Restoring authorship annotation for <heretic@yandex-team.ru>. Commit 1 of 2.

204 files changed, 11445 insertions, 11445 deletions

diff --git a/contrib/libs/grpc/src/core/lib/.yandex_meta/licenses.list.txt b/contrib/libs/grpc/src/core/lib/.yandex_meta/licenses.list.txt
index e5eda93675..0aab52b438 100644
--- a/contrib/libs/grpc/src/core/lib/.yandex_meta/licenses.list.txt
+++ b/contrib/libs/grpc/src/core/lib/.yandex_meta/licenses.list.txt
@@ -1,54 +1,54 @@
-====================Apache-2.0====================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-
-
-====================Apache-2.0====================
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-
-====================COPYRIGHT====================
- * Copyright 2015 gRPC authors.
-
-
-====================COPYRIGHT====================
- * Copyright 2015-2016 gRPC authors.
-
-
-====================COPYRIGHT====================
- * Copyright 2016 gRPC authors.
-
-
-====================COPYRIGHT====================
- * Copyright 2017 gRPC authors.
-
-
-====================COPYRIGHT====================
- * Copyright 2018 gRPC authors.
-
-
-====================COPYRIGHT====================
- * Copyright 2020 gRPC authors.
-
-
-====================COPYRIGHT====================
-# Copyright 2019 gRPC authors.
+====================Apache-2.0==================== 
+ * Licensed under the Apache License, Version 2.0 (the "License"); 
+ * you may not use this file except in compliance with the License. 
+ * You may obtain a copy of the License at 
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+ * See the License for the specific language governing permissions and 
+ * limitations under the License. 
+ 
+ 
+====================Apache-2.0==================== 
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License. 
+ 
+ 
+====================COPYRIGHT==================== 
+ * Copyright 2015 gRPC authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+ * Copyright 2015-2016 gRPC authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+ * Copyright 2016 gRPC authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+ * Copyright 2017 gRPC authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+ * Copyright 2018 gRPC authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+ * Copyright 2020 gRPC authors. 
+ 
+ 
+====================COPYRIGHT==================== 
+# Copyright 2019 gRPC authors. 
diff --git a/contrib/libs/grpc/src/core/lib/channel/channel_args.cc b/contrib/libs/grpc/src/core/lib/channel/channel_args.cc
index cb3d61fc4d..720345a745 100644
--- a/contrib/libs/grpc/src/core/lib/channel/channel_args.cc
+++ b/contrib/libs/grpc/src/core/lib/channel/channel_args.cc
@@ -21,11 +21,11 @@
 #include <limits.h>
 #include <string.h>
 
-#include <vector>
-
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/str_join.h"
-
+#include <vector> 
+ 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/str_join.h" 
+ 
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/impl/codegen/log.h>
@@ -341,28 +341,28 @@ grpc_arg grpc_channel_arg_pointer_create(
   return arg;
 }
 
-TString grpc_channel_args_string(const grpc_channel_args* args) {
-  if (args == nullptr) return "";
-  std::vector<TString> arg_strings;
+TString grpc_channel_args_string(const grpc_channel_args* args) { 
+  if (args == nullptr) return ""; 
+  std::vector<TString> arg_strings; 
   for (size_t i = 0; i < args->num_args; ++i) {
     const grpc_arg& arg = args->args[i];
-    TString arg_string;
+    TString arg_string; 
     switch (arg.type) {
       case GRPC_ARG_INTEGER:
-        arg_string = y_absl::StrFormat("%s=%d", arg.key, arg.value.integer);
+        arg_string = y_absl::StrFormat("%s=%d", arg.key, arg.value.integer); 
         break;
       case GRPC_ARG_STRING:
-        arg_string = y_absl::StrFormat("%s=%s", arg.key, arg.value.string);
+        arg_string = y_absl::StrFormat("%s=%s", arg.key, arg.value.string); 
         break;
       case GRPC_ARG_POINTER:
-        arg_string = y_absl::StrFormat("%s=%p", arg.key, arg.value.pointer.p);
+        arg_string = y_absl::StrFormat("%s=%p", arg.key, arg.value.pointer.p); 
         break;
       default:
-        arg_string = "arg with unknown type";
+        arg_string = "arg with unknown type"; 
     }
-    arg_strings.push_back(arg_string);
+    arg_strings.push_back(arg_string); 
   }
-  return y_absl::StrJoin(arg_strings, ", ");
+  return y_absl::StrJoin(arg_strings, ", "); 
 }
 
 namespace {
diff --git a/contrib/libs/grpc/src/core/lib/channel/channel_args.h b/contrib/libs/grpc/src/core/lib/channel/channel_args.h
index 6b973aa94d..19a14415a5 100644
--- a/contrib/libs/grpc/src/core/lib/channel/channel_args.h
+++ b/contrib/libs/grpc/src/core/lib/channel/channel_args.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 #include <grpc/grpc.h>
 
 #include "src/core/lib/surface/channel_stack_type.h"
@@ -117,7 +117,7 @@ grpc_arg grpc_channel_arg_pointer_create(char* name, void* value,
                                          const grpc_arg_pointer_vtable* vtable);
 
 // Returns a string representing channel args in human-readable form.
-TString grpc_channel_args_string(const grpc_channel_args* args);
+TString grpc_channel_args_string(const grpc_channel_args* args); 
 
 // Takes ownership of the old_args
 typedef grpc_channel_args* (*grpc_channel_args_client_channel_creation_mutator)(
diff --git a/contrib/libs/grpc/src/core/lib/channel/channel_stack.h b/contrib/libs/grpc/src/core/lib/channel/channel_stack.h
index e297df9488..0cd0a3b98b 100644
--- a/contrib/libs/grpc/src/core/lib/channel/channel_stack.h
+++ b/contrib/libs/grpc/src/core/lib/channel/channel_stack.h
@@ -31,19 +31,19 @@
    chains are linear, then channel stacks provide a mechanism to minimize
    allocations for that chain.
    Call stacks are created by channel stacks and represent the per-call data
-   for that stack.
-
-   Implementations should take care of the following details for a batch -
-   1. Synchronization is achieved with a CallCombiner. View
-   src/core/lib/iomgr/call_combiner.h for more details.
-   2. If the filter wants to inject an error on the way down, it needs to call
-   grpc_transport_stream_op_batch_finish_with_failure from within the call
-   combiner. This will cause any batch callbacks to be called with that error.
-   3. If the filter wants to inject an error on the way up (from a callback), it
-   should also inject that error in the recv_trailing_metadata callback so that
-   it can have an effect on the call status.
-*/
+   for that stack. 
 
+   Implementations should take care of the following details for a batch - 
+   1. Synchronization is achieved with a CallCombiner. View 
+   src/core/lib/iomgr/call_combiner.h for more details. 
+   2. If the filter wants to inject an error on the way down, it needs to call 
+   grpc_transport_stream_op_batch_finish_with_failure from within the call 
+   combiner. This will cause any batch callbacks to be called with that error. 
+   3. If the filter wants to inject an error on the way up (from a callback), it 
+   should also inject that error in the recv_trailing_metadata callback so that 
+   it can have an effect on the call status. 
+*/ 
+ 
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
diff --git a/contrib/libs/grpc/src/core/lib/channel/channel_trace.cc b/contrib/libs/grpc/src/core/lib/channel/channel_trace.cc
index dbc33af2d4..c0b833e410 100644
--- a/contrib/libs/grpc/src/core/lib/channel/channel_trace.cc
+++ b/contrib/libs/grpc/src/core/lib/channel/channel_trace.cc
@@ -144,46 +144,46 @@ const char* severity_string(ChannelTrace::Severity severity) {
 
 }  // anonymous namespace
 
-Json ChannelTrace::TraceEvent::RenderTraceEvent() const {
-  char* description = grpc_slice_to_c_string(data_);
-  Json::Object object = {
-      {"description", description},
-      {"severity", severity_string(severity_)},
-      {"timestamp", gpr_format_timespec(timestamp_)},
-  };
-  gpr_free(description);
+Json ChannelTrace::TraceEvent::RenderTraceEvent() const { 
+  char* description = grpc_slice_to_c_string(data_); 
+  Json::Object object = { 
+      {"description", description}, 
+      {"severity", severity_string(severity_)}, 
+      {"timestamp", gpr_format_timespec(timestamp_)}, 
+  }; 
+  gpr_free(description); 
   if (referenced_entity_ != nullptr) {
     const bool is_channel =
         (referenced_entity_->type() == BaseNode::EntityType::kTopLevelChannel ||
          referenced_entity_->type() == BaseNode::EntityType::kInternalChannel);
-    object[is_channel ? "channelRef" : "subchannelRef"] = Json::Object{
-        {(is_channel ? "channelId" : "subchannelId"),
-         ToString(referenced_entity_->uuid())},
-    };
+    object[is_channel ? "channelRef" : "subchannelRef"] = Json::Object{ 
+        {(is_channel ? "channelId" : "subchannelId"), 
+         ToString(referenced_entity_->uuid())}, 
+    }; 
   }
-  return object;
+  return object; 
 }
 
-Json ChannelTrace::RenderJson() const {
-  // Tracing is disabled if max_event_memory_ == 0.
-  if (max_event_memory_ == 0) {
-    return Json();  // JSON null
-  }
-  Json::Object object = {
-      {"creationTimestamp", gpr_format_timespec(time_created_)},
-  };
+Json ChannelTrace::RenderJson() const { 
+  // Tracing is disabled if max_event_memory_ == 0. 
+  if (max_event_memory_ == 0) { 
+    return Json();  // JSON null 
+  } 
+  Json::Object object = { 
+      {"creationTimestamp", gpr_format_timespec(time_created_)}, 
+  }; 
   if (num_events_logged_ > 0) {
-    object["numEventsLogged"] = ToString(num_events_logged_);
+    object["numEventsLogged"] = ToString(num_events_logged_); 
   }
-  // Only add in the event list if it is non-empty.
+  // Only add in the event list if it is non-empty. 
   if (head_trace_ != nullptr) {
-    Json::Array array;
-    for (TraceEvent* it = head_trace_; it != nullptr; it = it->next()) {
-      array.emplace_back(it->RenderTraceEvent());
+    Json::Array array; 
+    for (TraceEvent* it = head_trace_; it != nullptr; it = it->next()) { 
+      array.emplace_back(it->RenderTraceEvent()); 
     }
-    object["events"] = std::move(array);
+    object["events"] = std::move(array); 
   }
-  return object;
+  return object; 
 }
 
 }  // namespace channelz
diff --git a/contrib/libs/grpc/src/core/lib/channel/channel_trace.h b/contrib/libs/grpc/src/core/lib/channel/channel_trace.h
index c26e3016da..429aec254a 100644
--- a/contrib/libs/grpc/src/core/lib/channel/channel_trace.h
+++ b/contrib/libs/grpc/src/core/lib/channel/channel_trace.h
@@ -75,9 +75,9 @@ class ChannelTrace {
   void AddTraceEventWithReference(Severity severity, const grpc_slice& data,
                                   RefCountedPtr<BaseNode> referenced_entity);
 
-  // Creates and returns the raw Json object, so a parent channelz
+  // Creates and returns the raw Json object, so a parent channelz 
   // object may incorporate the json before rendering.
-  Json RenderJson() const;
+  Json RenderJson() const; 
 
  private:
   friend size_t testing::GetSizeofTraceEvent(void);
@@ -98,7 +98,7 @@ class ChannelTrace {
 
     // Renders the data inside of this TraceEvent into a json object. This is
     // used by the ChannelTrace, when it is rendering itself.
-    Json RenderTraceEvent() const;
+    Json RenderTraceEvent() const; 
 
     // set and get for the next_ pointer.
     TraceEvent* next() const { return next_; }
diff --git a/contrib/libs/grpc/src/core/lib/channel/channelz.cc b/contrib/libs/grpc/src/core/lib/channel/channelz.cc
index 16f505c053..1c2850f0d9 100644
--- a/contrib/libs/grpc/src/core/lib/channel/channelz.cc
+++ b/contrib/libs/grpc/src/core/lib/channel/channelz.cc
@@ -45,8 +45,8 @@
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/uri/uri_parser.h"
 
-#include <util/string/cast.h>
-
+#include <util/string/cast.h> 
+ 
 namespace grpc_core {
 namespace channelz {
 
@@ -54,7 +54,7 @@ namespace channelz {
 // BaseNode
 //
 
-BaseNode::BaseNode(EntityType type, TString name)
+BaseNode::BaseNode(EntityType type, TString name) 
     : type_(type), uuid_(-1), name_(std::move(name)) {
   // The registry will set uuid_ under its lock.
   ChannelzRegistry::Register(this);
@@ -62,9 +62,9 @@ BaseNode::BaseNode(EntityType type, TString name)
 
 BaseNode::~BaseNode() { ChannelzRegistry::Unregister(uuid_); }
 
-TString BaseNode::RenderJsonString() {
-  Json json = RenderJson();
-  return json.Dump();
+TString BaseNode::RenderJsonString() { 
+  Json json = RenderJson(); 
+  return json.Dump(); 
 }
 
 //
@@ -116,21 +116,21 @@ void CallCountingHelper::CollectData(CounterData* out) {
   }
 }
 
-void CallCountingHelper::PopulateCallCounts(Json::Object* object) {
+void CallCountingHelper::PopulateCallCounts(Json::Object* object) { 
   CounterData data;
   CollectData(&data);
   if (data.calls_started != 0) {
-    (*object)["callsStarted"] = ToString(data.calls_started);
-    gpr_timespec ts = gpr_convert_clock_type(
-        gpr_cycle_counter_to_time(data.last_call_started_cycle),
-        GPR_CLOCK_REALTIME);
-    (*object)["lastCallStartedTimestamp"] = gpr_format_timespec(ts);
+    (*object)["callsStarted"] = ToString(data.calls_started); 
+    gpr_timespec ts = gpr_convert_clock_type( 
+        gpr_cycle_counter_to_time(data.last_call_started_cycle), 
+        GPR_CLOCK_REALTIME); 
+    (*object)["lastCallStartedTimestamp"] = gpr_format_timespec(ts); 
   }
   if (data.calls_succeeded != 0) {
-    (*object)["callsSucceeded"] = ToString(data.calls_succeeded);
+    (*object)["callsSucceeded"] = ToString(data.calls_succeeded); 
   }
   if (data.calls_failed) {
-    (*object)["callsFailed"] = ToString(data.calls_failed);
+    (*object)["callsFailed"] = ToString(data.calls_failed); 
   }
 }
 
@@ -138,13 +138,13 @@ void CallCountingHelper::PopulateCallCounts(Json::Object* object) {
 // ChannelNode
 //
 
-ChannelNode::ChannelNode(TString target, size_t channel_tracer_max_nodes,
-                         bool is_internal_channel)
-    : BaseNode(is_internal_channel ? EntityType::kInternalChannel
-                                   : EntityType::kTopLevelChannel,
+ChannelNode::ChannelNode(TString target, size_t channel_tracer_max_nodes, 
+                         bool is_internal_channel) 
+    : BaseNode(is_internal_channel ? EntityType::kInternalChannel 
+                                   : EntityType::kTopLevelChannel, 
                target),
       target_(std::move(target)),
-      trace_(channel_tracer_max_nodes) {}
+      trace_(channel_tracer_max_nodes) {} 
 
 const char* ChannelNode::GetChannelConnectivityStateChangeString(
     grpc_connectivity_state state) {
@@ -163,60 +163,60 @@ const char* ChannelNode::GetChannelConnectivityStateChangeString(
   GPR_UNREACHABLE_CODE(return "UNKNOWN");
 }
 
-Json ChannelNode::RenderJson() {
-  Json::Object data = {
-      {"target", target_},
-  };
-  // Connectivity state.
+Json ChannelNode::RenderJson() { 
+  Json::Object data = { 
+      {"target", target_}, 
+  }; 
+  // Connectivity state. 
   // If low-order bit is on, then the field is set.
   int state_field = connectivity_state_.Load(MemoryOrder::RELAXED);
   if ((state_field & 1) != 0) {
     grpc_connectivity_state state =
         static_cast<grpc_connectivity_state>(state_field >> 1);
-    data["state"] = Json::Object{
-        {"state", ConnectivityStateName(state)},
-    };
+    data["state"] = Json::Object{ 
+        {"state", ConnectivityStateName(state)}, 
+    }; 
   }
-  // Fill in the channel trace if applicable.
-  Json trace_json = trace_.RenderJson();
-  if (trace_json.type() != Json::Type::JSON_NULL) {
-    data["trace"] = std::move(trace_json);
+  // Fill in the channel trace if applicable. 
+  Json trace_json = trace_.RenderJson(); 
+  if (trace_json.type() != Json::Type::JSON_NULL) { 
+    data["trace"] = std::move(trace_json); 
   }
-  // Ask CallCountingHelper to populate call count data.
-  call_counter_.PopulateCallCounts(&data);
-  // Construct outer object.
-  Json::Object json = {
-      {"ref",
-       Json::Object{
-           {"channelId", ToString(uuid())},
-       }},
-      {"data", std::move(data)},
-  };
-  // Template method. Child classes may override this to add their specific
+  // Ask CallCountingHelper to populate call count data. 
+  call_counter_.PopulateCallCounts(&data); 
+  // Construct outer object. 
+  Json::Object json = { 
+      {"ref", 
+       Json::Object{ 
+           {"channelId", ToString(uuid())}, 
+       }}, 
+      {"data", std::move(data)}, 
+  }; 
+  // Template method. Child classes may override this to add their specific 
   // functionality.
-  PopulateChildRefs(&json);
-  return json;
+  PopulateChildRefs(&json); 
+  return json; 
 }
 
-void ChannelNode::PopulateChildRefs(Json::Object* json) {
+void ChannelNode::PopulateChildRefs(Json::Object* json) { 
   MutexLock lock(&child_mu_);
   if (!child_subchannels_.empty()) {
-    Json::Array array;
-    for (intptr_t subchannel_uuid : child_subchannels_) {
-      array.emplace_back(Json::Object{
-          {"subchannelId", ToString(subchannel_uuid)},
-      });
+    Json::Array array; 
+    for (intptr_t subchannel_uuid : child_subchannels_) { 
+      array.emplace_back(Json::Object{ 
+          {"subchannelId", ToString(subchannel_uuid)}, 
+      }); 
     }
-    (*json)["subchannelRef"] = std::move(array);
+    (*json)["subchannelRef"] = std::move(array); 
   }
   if (!child_channels_.empty()) {
-    Json::Array array;
-    for (intptr_t channel_uuid : child_channels_) {
-      array.emplace_back(Json::Object{
-          {"channelId", ToString(channel_uuid)},
-      });
+    Json::Array array; 
+    for (intptr_t channel_uuid : child_channels_) { 
+      array.emplace_back(Json::Object{ 
+          {"channelId", ToString(channel_uuid)}, 
+      }); 
     }
-    (*json)["channelRef"] = std::move(array);
+    (*json)["channelRef"] = std::move(array); 
   }
 }
 
@@ -228,7 +228,7 @@ void ChannelNode::SetConnectivityState(grpc_connectivity_state state) {
 
 void ChannelNode::AddChildChannel(intptr_t child_uuid) {
   MutexLock lock(&child_mu_);
-  child_channels_.insert(child_uuid);
+  child_channels_.insert(child_uuid); 
 }
 
 void ChannelNode::RemoveChildChannel(intptr_t child_uuid) {
@@ -238,7 +238,7 @@ void ChannelNode::RemoveChildChannel(intptr_t child_uuid) {
 
 void ChannelNode::AddChildSubchannel(intptr_t child_uuid) {
   MutexLock lock(&child_mu_);
-  child_subchannels_.insert(child_uuid);
+  child_subchannels_.insert(child_uuid); 
 }
 
 void ChannelNode::RemoveChildSubchannel(intptr_t child_uuid) {
@@ -250,7 +250,7 @@ void ChannelNode::RemoveChildSubchannel(intptr_t child_uuid) {
 // ServerNode
 //
 
-ServerNode::ServerNode(size_t channel_tracer_max_nodes)
+ServerNode::ServerNode(size_t channel_tracer_max_nodes) 
     : BaseNode(EntityType::kServer, ""), trace_(channel_tracer_max_nodes) {}
 
 ServerNode::~ServerNode() {}
@@ -275,65 +275,65 @@ void ServerNode::RemoveChildListenSocket(intptr_t child_uuid) {
   child_listen_sockets_.erase(child_uuid);
 }
 
-TString ServerNode::RenderServerSockets(intptr_t start_socket_id,
-                                            intptr_t max_results) {
-  GPR_ASSERT(start_socket_id >= 0);
-  GPR_ASSERT(max_results >= 0);
+TString ServerNode::RenderServerSockets(intptr_t start_socket_id, 
+                                            intptr_t max_results) { 
+  GPR_ASSERT(start_socket_id >= 0); 
+  GPR_ASSERT(max_results >= 0); 
   // If user does not set max_results, we choose 500.
   size_t pagination_limit = max_results == 0 ? 500 : max_results;
-  Json::Object object;
-  {
-    MutexLock lock(&child_mu_);
-    size_t sockets_rendered = 0;
-    // Create list of socket refs.
-    Json::Array array;
-    auto it = child_sockets_.lower_bound(start_socket_id);
-    for (; it != child_sockets_.end() && sockets_rendered < pagination_limit;
-         ++it, ++sockets_rendered) {
-      array.emplace_back(Json::Object{
-          {"socketId", ToString(it->first)},
-          {"name", it->second->name()},
-      });
+  Json::Object object; 
+  { 
+    MutexLock lock(&child_mu_); 
+    size_t sockets_rendered = 0; 
+    // Create list of socket refs. 
+    Json::Array array; 
+    auto it = child_sockets_.lower_bound(start_socket_id); 
+    for (; it != child_sockets_.end() && sockets_rendered < pagination_limit; 
+         ++it, ++sockets_rendered) { 
+      array.emplace_back(Json::Object{ 
+          {"socketId", ToString(it->first)}, 
+          {"name", it->second->name()}, 
+      }); 
     }
-    object["socketRef"] = std::move(array);
-    if (it == child_sockets_.end()) object["end"] = true;
+    object["socketRef"] = std::move(array); 
+    if (it == child_sockets_.end()) object["end"] = true; 
   }
-  Json json = std::move(object);
-  return json.Dump();
+  Json json = std::move(object); 
+  return json.Dump(); 
 }
 
-Json ServerNode::RenderJson() {
-  Json::Object data;
-  // Fill in the channel trace if applicable.
-  Json trace_json = trace_.RenderJson();
-  if (trace_json.type() != Json::Type::JSON_NULL) {
-    data["trace"] = std::move(trace_json);
+Json ServerNode::RenderJson() { 
+  Json::Object data; 
+  // Fill in the channel trace if applicable. 
+  Json trace_json = trace_.RenderJson(); 
+  if (trace_json.type() != Json::Type::JSON_NULL) { 
+    data["trace"] = std::move(trace_json); 
   }
-  // Ask CallCountingHelper to populate call count data.
-  call_counter_.PopulateCallCounts(&data);
-  // Construct top-level object.
-  Json::Object object = {
-      {"ref",
-       Json::Object{
-           {"serverId", ToString(uuid())},
-       }},
-      {"data", std::move(data)},
-  };
-  // Render listen sockets.
-  {
-    MutexLock lock(&child_mu_);
-    if (!child_listen_sockets_.empty()) {
-      Json::Array array;
-      for (const auto& it : child_listen_sockets_) {
-        array.emplace_back(Json::Object{
-            {"socketId", ToString(it.first)},
-            {"name", it.second->name()},
-        });
-      }
-      object["listenSocket"] = std::move(array);
+  // Ask CallCountingHelper to populate call count data. 
+  call_counter_.PopulateCallCounts(&data); 
+  // Construct top-level object. 
+  Json::Object object = { 
+      {"ref", 
+       Json::Object{ 
+           {"serverId", ToString(uuid())}, 
+       }}, 
+      {"data", std::move(data)}, 
+  }; 
+  // Render listen sockets. 
+  { 
+    MutexLock lock(&child_mu_); 
+    if (!child_listen_sockets_.empty()) { 
+      Json::Array array; 
+      for (const auto& it : child_listen_sockets_) { 
+        array.emplace_back(Json::Object{ 
+            {"socketId", ToString(it.first)}, 
+            {"name", it.second->name()}, 
+        }); 
+      } 
+      object["listenSocket"] = std::move(array); 
     }
   }
-  return object;
+  return object; 
 }
 
 //
@@ -342,44 +342,44 @@ Json ServerNode::RenderJson() {
 
 namespace {
 
-void PopulateSocketAddressJson(Json::Object* json, const char* name,
+void PopulateSocketAddressJson(Json::Object* json, const char* name, 
                                const char* addr_str) {
   if (addr_str == nullptr) return;
-  Json::Object data;
+  Json::Object data; 
   grpc_uri* uri = grpc_uri_parse(addr_str, true);
   if ((uri != nullptr) && ((strcmp(uri->scheme, "ipv4") == 0) ||
                            (strcmp(uri->scheme, "ipv6") == 0))) {
     const char* host_port = uri->path;
     if (*host_port == '/') ++host_port;
-    TString host;
-    TString port;
+    TString host; 
+    TString port; 
     GPR_ASSERT(SplitHostPort(host_port, &host, &port));
     int port_num = -1;
-    if (!port.empty()) {
-      port_num = atoi(port.data());
+    if (!port.empty()) { 
+      port_num = atoi(port.data()); 
     }
-    char* b64_host = grpc_base64_encode(host.data(), host.size(), false, false);
-    data["tcpip_address"] = Json::Object{
-        {"port", port_num},
-        {"ip_address", b64_host},
-    };
-    gpr_free(b64_host);
+    char* b64_host = grpc_base64_encode(host.data(), host.size(), false, false); 
+    data["tcpip_address"] = Json::Object{ 
+        {"port", port_num}, 
+        {"ip_address", b64_host}, 
+    }; 
+    gpr_free(b64_host); 
   } else if (uri != nullptr && strcmp(uri->scheme, "unix") == 0) {
-    data["uds_address"] = Json::Object{
-        {"filename", uri->path},
-    };
+    data["uds_address"] = Json::Object{ 
+        {"filename", uri->path}, 
+    }; 
   } else {
-    data["other_address"] = Json::Object{
-        {"name", addr_str},
-    };
+    data["other_address"] = Json::Object{ 
+        {"name", addr_str}, 
+    }; 
   }
   grpc_uri_destroy(uri);
-  (*json)[name] = std::move(data);
+  (*json)[name] = std::move(data); 
 }
 
 }  // namespace
 
-SocketNode::SocketNode(TString local, TString remote, TString name)
+SocketNode::SocketNode(TString local, TString remote, TString name) 
     : BaseNode(EntityType::kSocket, std::move(name)),
       local_(std::move(local)),
       remote_(std::move(remote)) {}
@@ -407,20 +407,20 @@ void SocketNode::RecordMessageReceived() {
                                      MemoryOrder::RELAXED);
 }
 
-Json SocketNode::RenderJson() {
-  // Create and fill the data child.
-  Json::Object data;
+Json SocketNode::RenderJson() { 
+  // Create and fill the data child. 
+  Json::Object data; 
   gpr_timespec ts;
   int64_t streams_started = streams_started_.Load(MemoryOrder::RELAXED);
   if (streams_started != 0) {
-    data["streamsStarted"] = ToString(streams_started);
+    data["streamsStarted"] = ToString(streams_started); 
     gpr_cycle_counter last_local_stream_created_cycle =
         last_local_stream_created_cycle_.Load(MemoryOrder::RELAXED);
     if (last_local_stream_created_cycle != 0) {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_local_stream_created_cycle),
           GPR_CLOCK_REALTIME);
-      data["lastLocalStreamCreatedTimestamp"] = gpr_format_timespec(ts);
+      data["lastLocalStreamCreatedTimestamp"] = gpr_format_timespec(ts); 
     }
     gpr_cycle_counter last_remote_stream_created_cycle =
         last_remote_stream_created_cycle_.Load(MemoryOrder::RELAXED);
@@ -428,71 +428,71 @@ Json SocketNode::RenderJson() {
       ts = gpr_convert_clock_type(
           gpr_cycle_counter_to_time(last_remote_stream_created_cycle),
           GPR_CLOCK_REALTIME);
-      data["lastRemoteStreamCreatedTimestamp"] = gpr_format_timespec(ts);
+      data["lastRemoteStreamCreatedTimestamp"] = gpr_format_timespec(ts); 
     }
   }
   int64_t streams_succeeded = streams_succeeded_.Load(MemoryOrder::RELAXED);
   if (streams_succeeded != 0) {
-    data["streamsSucceeded"] = ToString(streams_succeeded);
+    data["streamsSucceeded"] = ToString(streams_succeeded); 
   }
   int64_t streams_failed = streams_failed_.Load(MemoryOrder::RELAXED);
-  if (streams_failed != 0) {
-    data["streamsFailed"] = ToString(streams_failed);
+  if (streams_failed != 0) { 
+    data["streamsFailed"] = ToString(streams_failed); 
   }
   int64_t messages_sent = messages_sent_.Load(MemoryOrder::RELAXED);
   if (messages_sent != 0) {
-    data["messagesSent"] = ToString(messages_sent);
+    data["messagesSent"] = ToString(messages_sent); 
     ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(
             last_message_sent_cycle_.Load(MemoryOrder::RELAXED)),
         GPR_CLOCK_REALTIME);
-    data["lastMessageSentTimestamp"] = gpr_format_timespec(ts);
+    data["lastMessageSentTimestamp"] = gpr_format_timespec(ts); 
   }
   int64_t messages_received = messages_received_.Load(MemoryOrder::RELAXED);
   if (messages_received != 0) {
-    data["messagesReceived"] = ToString(messages_received);
+    data["messagesReceived"] = ToString(messages_received); 
     ts = gpr_convert_clock_type(
         gpr_cycle_counter_to_time(
             last_message_received_cycle_.Load(MemoryOrder::RELAXED)),
         GPR_CLOCK_REALTIME);
-    data["lastMessageReceivedTimestamp"] = gpr_format_timespec(ts);
+    data["lastMessageReceivedTimestamp"] = gpr_format_timespec(ts); 
   }
   int64_t keepalives_sent = keepalives_sent_.Load(MemoryOrder::RELAXED);
   if (keepalives_sent != 0) {
-    data["keepAlivesSent"] = ToString(keepalives_sent);
+    data["keepAlivesSent"] = ToString(keepalives_sent); 
   }
-  // Create and fill the parent object.
-  Json::Object object = {
-      {"ref",
-       Json::Object{
-           {"socketId", ToString(uuid())},
-           {"name", name()},
-       }},
-      {"data", std::move(data)},
-  };
-  PopulateSocketAddressJson(&object, "remote", remote_.c_str());
-  PopulateSocketAddressJson(&object, "local", local_.c_str());
-  return object;
+  // Create and fill the parent object. 
+  Json::Object object = { 
+      {"ref", 
+       Json::Object{ 
+           {"socketId", ToString(uuid())}, 
+           {"name", name()}, 
+       }}, 
+      {"data", std::move(data)}, 
+  }; 
+  PopulateSocketAddressJson(&object, "remote", remote_.c_str()); 
+  PopulateSocketAddressJson(&object, "local", local_.c_str()); 
+  return object; 
 }
 
 //
 // ListenSocketNode
 //
 
-ListenSocketNode::ListenSocketNode(TString local_addr, TString name)
+ListenSocketNode::ListenSocketNode(TString local_addr, TString name) 
     : BaseNode(EntityType::kSocket, std::move(name)),
       local_addr_(std::move(local_addr)) {}
 
-Json ListenSocketNode::RenderJson() {
-  Json::Object object = {
-      {"ref",
-       Json::Object{
-           {"socketId", ToString(uuid())},
-           {"name", name()},
-       }},
-  };
-  PopulateSocketAddressJson(&object, "local", local_addr_.c_str());
-  return object;
+Json ListenSocketNode::RenderJson() { 
+  Json::Object object = { 
+      {"ref", 
+       Json::Object{ 
+           {"socketId", ToString(uuid())}, 
+           {"name", name()}, 
+       }}, 
+  }; 
+  PopulateSocketAddressJson(&object, "local", local_addr_.c_str()); 
+  return object; 
 }
 
 }  // namespace channelz
diff --git a/contrib/libs/grpc/src/core/lib/channel/channelz.h b/contrib/libs/grpc/src/core/lib/channel/channelz.h
index 596770ccdc..0356a6cdb1 100644
--- a/contrib/libs/grpc/src/core/lib/channel/channelz.h
+++ b/contrib/libs/grpc/src/core/lib/channel/channelz.h
@@ -23,11 +23,11 @@
 
 #include <grpc/grpc.h>
 
-#include <set>
-#include <util/generic/string.h>
-
-#include "y_absl/container/inlined_vector.h"
+#include <set> 
+#include <util/generic/string.h> 
 
+#include "y_absl/container/inlined_vector.h" 
+ 
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/atomic.h"
@@ -43,9 +43,9 @@
 // Channel arg key for channelz node.
 #define GRPC_ARG_CHANNELZ_CHANNEL_NODE "grpc.channelz_channel_node"
 
-// Channel arg key for indicating an internal channel.
-#define GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL \
-  "grpc.channelz_is_internal_channel"
+// Channel arg key for indicating an internal channel. 
+#define GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL \ 
+  "grpc.channelz_is_internal_channel" 
 
 /** This is the default value for whether or not to enable channelz. If
  * GRPC_ARG_ENABLE_CHANNELZ is set, it will override this default value. */
@@ -84,28 +84,28 @@ class BaseNode : public RefCounted<BaseNode> {
   };
 
  protected:
-  BaseNode(EntityType type, TString name);
+  BaseNode(EntityType type, TString name); 
 
  public:
   virtual ~BaseNode();
 
   // All children must implement this function.
-  virtual Json RenderJson() = 0;
+  virtual Json RenderJson() = 0; 
 
   // Renders the json and returns allocated string that must be freed by the
   // caller.
-  TString RenderJsonString();
+  TString RenderJsonString(); 
 
   EntityType type() const { return type_; }
   intptr_t uuid() const { return uuid_; }
-  const TString& name() const { return name_; }
+  const TString& name() const { return name_; } 
 
  private:
   // to allow the ChannelzRegistry to set uuid_ under its lock.
   friend class ChannelzRegistry;
   const EntityType type_;
   intptr_t uuid_;
-  TString name_;
+  TString name_; 
 };
 
 // This class is a helper class for channelz entities that deal with Channels,
@@ -123,7 +123,7 @@ class CallCountingHelper {
   void RecordCallSucceeded();
 
   // Common rendering of the call count data and last_call_started_timestamp.
-  void PopulateCallCounts(Json::Object* json);
+  void PopulateCallCounts(Json::Object* json); 
 
  private:
   // testing peer friend.
@@ -147,13 +147,13 @@ class CallCountingHelper {
     // Make sure the size is exactly one cache line.
     uint8_t padding[GPR_CACHELINE_SIZE - 3 * sizeof(Atomic<intptr_t>) -
                     sizeof(Atomic<gpr_cycle_counter>)];
-  };
-  // TODO(soheilhy,veblush): Revist this after abseil integration.
-  // This has a problem when using abseil inlined_vector because it
-  // carries an alignment attribute properly but our allocator doesn't
-  // respect this. To avoid UBSAN errors, this should be removed with
-  // abseil inlined_vector.
-  // GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
+  }; 
+  // TODO(soheilhy,veblush): Revist this after abseil integration. 
+  // This has a problem when using abseil inlined_vector because it 
+  // carries an alignment attribute properly but our allocator doesn't 
+  // respect this. To avoid UBSAN errors, this should be removed with 
+  // abseil inlined_vector. 
+  // GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE); 
 
   struct CounterData {
     int64_t calls_started = 0;
@@ -166,21 +166,21 @@ class CallCountingHelper {
   void CollectData(CounterData* out);
 
   // Really zero-sized, but 0-sized arrays are illegal on MSVC.
-  y_absl::InlinedVector<AtomicCounterData, 1> per_cpu_counter_data_storage_;
+  y_absl::InlinedVector<AtomicCounterData, 1> per_cpu_counter_data_storage_; 
   size_t num_cores_ = 0;
 };
 
 // Handles channelz bookkeeping for channels
 class ChannelNode : public BaseNode {
  public:
-  ChannelNode(TString target, size_t channel_tracer_max_nodes,
-              bool is_internal_channel);
+  ChannelNode(TString target, size_t channel_tracer_max_nodes, 
+              bool is_internal_channel); 
 
   // Returns the string description of the given connectivity state.
   static const char* GetChannelConnectivityStateChangeString(
       grpc_connectivity_state state);
 
-  Json RenderJson() override;
+  Json RenderJson() override; 
 
   // proxy methods to composed classes.
   void AddTraceEvent(ChannelTrace::Severity severity, const grpc_slice& data) {
@@ -209,12 +209,12 @@ class ChannelNode : public BaseNode {
   void RemoveChildSubchannel(intptr_t child_uuid);
 
  private:
-  // Allows the channel trace test to access trace_.
-  friend class testing::ChannelNodePeer;
-
-  void PopulateChildRefs(Json::Object* json);
+  // Allows the channel trace test to access trace_. 
+  friend class testing::ChannelNodePeer; 
+ 
+  void PopulateChildRefs(Json::Object* json); 
 
-  TString target_;
+  TString target_; 
   CallCountingHelper call_counter_;
   ChannelTrace trace_;
 
@@ -222,22 +222,22 @@ class ChannelNode : public BaseNode {
   // bits are a grpc_connectivity_state value.
   Atomic<int> connectivity_state_{0};
 
-  Mutex child_mu_;  // Guards sets below.
-  std::set<intptr_t> child_channels_;
-  std::set<intptr_t> child_subchannels_;
+  Mutex child_mu_;  // Guards sets below. 
+  std::set<intptr_t> child_channels_; 
+  std::set<intptr_t> child_subchannels_; 
 };
 
 // Handles channelz bookkeeping for servers
 class ServerNode : public BaseNode {
  public:
-  explicit ServerNode(size_t channel_tracer_max_nodes);
+  explicit ServerNode(size_t channel_tracer_max_nodes); 
 
   ~ServerNode() override;
 
-  Json RenderJson() override;
+  Json RenderJson() override; 
 
-  TString RenderServerSockets(intptr_t start_socket_id,
-                                  intptr_t max_results);
+  TString RenderServerSockets(intptr_t start_socket_id, 
+                                  intptr_t max_results); 
 
   void AddChildSocket(RefCountedPtr<SocketNode> node);
 
@@ -272,10 +272,10 @@ class ServerNode : public BaseNode {
 // Handles channelz bookkeeping for sockets
 class SocketNode : public BaseNode {
  public:
-  SocketNode(TString local, TString remote, TString name);
+  SocketNode(TString local, TString remote, TString name); 
   ~SocketNode() override {}
 
-  Json RenderJson() override;
+  Json RenderJson() override; 
 
   void RecordStreamStartedFromLocal();
   void RecordStreamStartedFromRemote();
@@ -291,7 +291,7 @@ class SocketNode : public BaseNode {
     keepalives_sent_.FetchAdd(1, MemoryOrder::RELAXED);
   }
 
-  const TString& remote() { return remote_; }
+  const TString& remote() { return remote_; } 
 
  private:
   Atomic<int64_t> streams_started_{0};
@@ -304,20 +304,20 @@ class SocketNode : public BaseNode {
   Atomic<gpr_cycle_counter> last_remote_stream_created_cycle_{0};
   Atomic<gpr_cycle_counter> last_message_sent_cycle_{0};
   Atomic<gpr_cycle_counter> last_message_received_cycle_{0};
-  TString local_;
-  TString remote_;
+  TString local_; 
+  TString remote_; 
 };
 
 // Handles channelz bookkeeping for listen sockets
 class ListenSocketNode : public BaseNode {
  public:
-  ListenSocketNode(TString local_addr, TString name);
+  ListenSocketNode(TString local_addr, TString name); 
   ~ListenSocketNode() override {}
 
-  Json RenderJson() override;
+  Json RenderJson() override; 
 
  private:
-  TString local_addr_;
+  TString local_addr_; 
 };
 
 }  // namespace channelz
diff --git a/contrib/libs/grpc/src/core/lib/channel/channelz_registry.cc b/contrib/libs/grpc/src/core/lib/channel/channelz_registry.cc
index 5a6e28ad78..89a7d5ad14 100644
--- a/contrib/libs/grpc/src/core/lib/channel/channelz_registry.cc
+++ b/contrib/libs/grpc/src/core/lib/channel/channelz_registry.cc
@@ -21,8 +21,8 @@
 #include <algorithm>
 #include <cstring>
 
-#include "y_absl/container/inlined_vector.h"
-
+#include "y_absl/container/inlined_vector.h" 
+ 
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/channelz_registry.h"
@@ -32,7 +32,7 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/string_util.h> 
 #include <grpc/support/sync.h>
 
 namespace grpc_core {
@@ -78,21 +78,21 @@ RefCountedPtr<BaseNode> ChannelzRegistry::InternalGet(intptr_t uuid) {
   // Found node.  Return only if its refcount is not zero (i.e., when we
   // know that there is no other thread about to destroy it).
   BaseNode* node = it->second;
-  return node->RefIfNonZero();
+  return node->RefIfNonZero(); 
 }
 
-TString ChannelzRegistry::InternalGetTopChannels(
-    intptr_t start_channel_id) {
-  y_absl::InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
+TString ChannelzRegistry::InternalGetTopChannels( 
+    intptr_t start_channel_id) { 
+  y_absl::InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels; 
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
     for (auto it = node_map_.lower_bound(start_channel_id);
          it != node_map_.end(); ++it) {
       BaseNode* node = it->second;
-      RefCountedPtr<BaseNode> node_ref;
+      RefCountedPtr<BaseNode> node_ref; 
       if (node->type() == BaseNode::EntityType::kTopLevelChannel &&
-          (node_ref = node->RefIfNonZero()) != nullptr) {
+          (node_ref = node->RefIfNonZero()) != nullptr) { 
         // Check if we are over pagination limit to determine if we need to set
         // the "end" element. If we don't go through this block, we know that
         // when the loop terminates, we have <= to kPaginationLimit.
@@ -100,38 +100,38 @@ TString ChannelzRegistry::InternalGetTopChannels(
         // refcount, we need to decrease it, but we can't unref while
         // holding the lock, because this may lead to a deadlock.
         if (top_level_channels.size() == kPaginationLimit) {
-          node_after_pagination_limit = std::move(node_ref);
+          node_after_pagination_limit = std::move(node_ref); 
           break;
         }
-        top_level_channels.emplace_back(std::move(node_ref));
+        top_level_channels.emplace_back(std::move(node_ref)); 
       }
     }
   }
-  Json::Object object;
+  Json::Object object; 
   if (!top_level_channels.empty()) {
-    // Create list of channels.
-    Json::Array array;
+    // Create list of channels. 
+    Json::Array array; 
     for (size_t i = 0; i < top_level_channels.size(); ++i) {
-      array.emplace_back(top_level_channels[i]->RenderJson());
+      array.emplace_back(top_level_channels[i]->RenderJson()); 
     }
-    object["channel"] = std::move(array);
+    object["channel"] = std::move(array); 
   }
-  if (node_after_pagination_limit == nullptr) object["end"] = true;
-  Json json(std::move(object));
-  return json.Dump();
+  if (node_after_pagination_limit == nullptr) object["end"] = true; 
+  Json json(std::move(object)); 
+  return json.Dump(); 
 }
 
-TString ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
-  y_absl::InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
+TString ChannelzRegistry::InternalGetServers(intptr_t start_server_id) { 
+  y_absl::InlinedVector<RefCountedPtr<BaseNode>, 10> servers; 
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
     for (auto it = node_map_.lower_bound(start_server_id);
          it != node_map_.end(); ++it) {
       BaseNode* node = it->second;
-      RefCountedPtr<BaseNode> node_ref;
+      RefCountedPtr<BaseNode> node_ref; 
       if (node->type() == BaseNode::EntityType::kServer &&
-          (node_ref = node->RefIfNonZero()) != nullptr) {
+          (node_ref = node->RefIfNonZero()) != nullptr) { 
         // Check if we are over pagination limit to determine if we need to set
         // the "end" element. If we don't go through this block, we know that
         // when the loop terminates, we have <= to kPaginationLimit.
@@ -139,41 +139,41 @@ TString ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
         // refcount, we need to decrease it, but we can't unref while
         // holding the lock, because this may lead to a deadlock.
         if (servers.size() == kPaginationLimit) {
-          node_after_pagination_limit = std::move(node_ref);
+          node_after_pagination_limit = std::move(node_ref); 
           break;
         }
-        servers.emplace_back(std::move(node_ref));
+        servers.emplace_back(std::move(node_ref)); 
       }
     }
   }
-  Json::Object object;
+  Json::Object object; 
   if (!servers.empty()) {
-    // Create list of servers.
-    Json::Array array;
+    // Create list of servers. 
+    Json::Array array; 
     for (size_t i = 0; i < servers.size(); ++i) {
-      array.emplace_back(servers[i]->RenderJson());
+      array.emplace_back(servers[i]->RenderJson()); 
     }
-    object["server"] = std::move(array);
+    object["server"] = std::move(array); 
   }
-  if (node_after_pagination_limit == nullptr) object["end"] = true;
-  Json json(std::move(object));
-  return json.Dump();
+  if (node_after_pagination_limit == nullptr) object["end"] = true; 
+  Json json(std::move(object)); 
+  return json.Dump(); 
 }
 
 void ChannelzRegistry::InternalLogAllEntities() {
-  y_absl::InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
+  y_absl::InlinedVector<RefCountedPtr<BaseNode>, 10> nodes; 
   {
     MutexLock lock(&mu_);
     for (auto& p : node_map_) {
-      RefCountedPtr<BaseNode> node = p.second->RefIfNonZero();
-      if (node != nullptr) {
-        nodes.emplace_back(std::move(node));
+      RefCountedPtr<BaseNode> node = p.second->RefIfNonZero(); 
+      if (node != nullptr) { 
+        nodes.emplace_back(std::move(node)); 
       }
     }
   }
   for (size_t i = 0; i < nodes.size(); ++i) {
-    TString json = nodes[i]->RenderJsonString();
-    gpr_log(GPR_INFO, "%s", json.c_str());
+    TString json = nodes[i]->RenderJsonString(); 
+    gpr_log(GPR_INFO, "%s", json.c_str()); 
   }
 }
 
@@ -181,15 +181,15 @@ void ChannelzRegistry::InternalLogAllEntities() {
 }  // namespace grpc_core
 
 char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
-  return gpr_strdup(
-      grpc_core::channelz::ChannelzRegistry::GetTopChannels(start_channel_id)
-          .c_str());
+  return gpr_strdup( 
+      grpc_core::channelz::ChannelzRegistry::GetTopChannels(start_channel_id) 
+          .c_str()); 
 }
 
 char* grpc_channelz_get_servers(intptr_t start_server_id) {
-  return gpr_strdup(
-      grpc_core::channelz::ChannelzRegistry::GetServers(start_server_id)
-          .c_str());
+  return gpr_strdup( 
+      grpc_core::channelz::ChannelzRegistry::GetServers(start_server_id) 
+          .c_str()); 
 }
 
 char* grpc_channelz_get_server(intptr_t server_id) {
@@ -200,29 +200,29 @@ char* grpc_channelz_get_server(intptr_t server_id) {
           grpc_core::channelz::BaseNode::EntityType::kServer) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
-      {"server", server_node->RenderJson()},
-  };
-  return gpr_strdup(json.Dump().c_str());
+  grpc_core::Json json = grpc_core::Json::Object{ 
+      {"server", server_node->RenderJson()}, 
+  }; 
+  return gpr_strdup(json.Dump().c_str()); 
 }
 
 char* grpc_channelz_get_server_sockets(intptr_t server_id,
                                        intptr_t start_socket_id,
                                        intptr_t max_results) {
-  // Validate inputs before handing them of to the renderer.
+  // Validate inputs before handing them of to the renderer. 
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> base_node =
       grpc_core::channelz::ChannelzRegistry::Get(server_id);
   if (base_node == nullptr ||
-      base_node->type() != grpc_core::channelz::BaseNode::EntityType::kServer ||
-      start_socket_id < 0 || max_results < 0) {
+      base_node->type() != grpc_core::channelz::BaseNode::EntityType::kServer || 
+      start_socket_id < 0 || max_results < 0) { 
     return nullptr;
   }
   // This cast is ok since we have just checked to make sure base_node is
-  // actually a server node.
+  // actually a server node. 
   grpc_core::channelz::ServerNode* server_node =
       static_cast<grpc_core::channelz::ServerNode*>(base_node.get());
-  return gpr_strdup(
-      server_node->RenderServerSockets(start_socket_id, max_results).c_str());
+  return gpr_strdup( 
+      server_node->RenderServerSockets(start_socket_id, max_results).c_str()); 
 }
 
 char* grpc_channelz_get_channel(intptr_t channel_id) {
@@ -235,10 +235,10 @@ char* grpc_channelz_get_channel(intptr_t channel_id) {
            grpc_core::channelz::BaseNode::EntityType::kInternalChannel)) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
-      {"channel", channel_node->RenderJson()},
-  };
-  return gpr_strdup(json.Dump().c_str());
+  grpc_core::Json json = grpc_core::Json::Object{ 
+      {"channel", channel_node->RenderJson()}, 
+  }; 
+  return gpr_strdup(json.Dump().c_str()); 
 }
 
 char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
@@ -249,10 +249,10 @@ char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
           grpc_core::channelz::BaseNode::EntityType::kSubchannel) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
-      {"subchannel", subchannel_node->RenderJson()},
-  };
-  return gpr_strdup(json.Dump().c_str());
+  grpc_core::Json json = grpc_core::Json::Object{ 
+      {"subchannel", subchannel_node->RenderJson()}, 
+  }; 
+  return gpr_strdup(json.Dump().c_str()); 
 }
 
 char* grpc_channelz_get_socket(intptr_t socket_id) {
@@ -263,8 +263,8 @@ char* grpc_channelz_get_socket(intptr_t socket_id) {
           grpc_core::channelz::BaseNode::EntityType::kSocket) {
     return nullptr;
   }
-  grpc_core::Json json = grpc_core::Json::Object{
-      {"socket", socket_node->RenderJson()},
-  };
-  return gpr_strdup(json.Dump().c_str());
+  grpc_core::Json json = grpc_core::Json::Object{ 
+      {"socket", socket_node->RenderJson()}, 
+  }; 
+  return gpr_strdup(json.Dump().c_str()); 
 }
diff --git a/contrib/libs/grpc/src/core/lib/channel/channelz_registry.h b/contrib/libs/grpc/src/core/lib/channel/channelz_registry.h
index 73a5e20fbd..54526e83bf 100644
--- a/contrib/libs/grpc/src/core/lib/channel/channelz_registry.h
+++ b/contrib/libs/grpc/src/core/lib/channel/channelz_registry.h
@@ -23,9 +23,9 @@
 
 #include <stdint.h>
 
-#include <map>
-#include <util/generic/string.h>
-
+#include <map> 
+#include <util/generic/string.h> 
+ 
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gprpp/map.h"
@@ -54,13 +54,13 @@ class ChannelzRegistry {
 
   // Returns the allocated JSON string that represents the proto
   // GetTopChannelsResponse as per channelz.proto.
-  static TString GetTopChannels(intptr_t start_channel_id) {
+  static TString GetTopChannels(intptr_t start_channel_id) { 
     return Default()->InternalGetTopChannels(start_channel_id);
   }
 
   // Returns the allocated JSON string that represents the proto
   // GetServersResponse as per channelz.proto.
-  static TString GetServers(intptr_t start_server_id) {
+  static TString GetServers(intptr_t start_server_id) { 
     return Default()->InternalGetServers(start_server_id);
   }
 
@@ -83,8 +83,8 @@ class ChannelzRegistry {
   // returns the void* associated with that uuid. Else returns nullptr.
   RefCountedPtr<BaseNode> InternalGet(intptr_t uuid);
 
-  TString InternalGetTopChannels(intptr_t start_channel_id);
-  TString InternalGetServers(intptr_t start_server_id);
+  TString InternalGetTopChannels(intptr_t start_channel_id); 
+  TString InternalGetServers(intptr_t start_server_id); 
 
   void InternalLogAllEntities();
 
diff --git a/contrib/libs/grpc/src/core/lib/channel/connected_channel.cc b/contrib/libs/grpc/src/core/lib/channel/connected_channel.cc
index be74d9e88b..22a1e9501e 100644
--- a/contrib/libs/grpc/src/core/lib/channel/connected_channel.cc
+++ b/contrib/libs/grpc/src/core/lib/channel/connected_channel.cc
@@ -90,12 +90,12 @@ static callback_state* get_state_for_batch(
 /* We perform a small hack to locate transport data alongside the connected
    channel data in call allocations, to allow everything to be pulled in minimal
    cache line requests */
-#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) \
-  ((grpc_stream*)(((char*)(calld)) +           \
-                  GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(call_data))))
+#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) \ 
+  ((grpc_stream*)(((char*)(calld)) +           \ 
+                  GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(call_data)))) 
 #define CALL_DATA_FROM_TRANSPORT_STREAM(transport_stream) \
-  ((call_data*)(((char*)(transport_stream)) -             \
-                GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(call_data))))
+  ((call_data*)(((char*)(transport_stream)) -             \ 
+                GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(call_data)))) 
 
 /* Intercept a call operation and either push it directly up or translate it
    into transport stream operations */
diff --git a/contrib/libs/grpc/src/core/lib/channel/context.h b/contrib/libs/grpc/src/core/lib/channel/context.h
index bd7fd495e4..7699609ef6 100644
--- a/contrib/libs/grpc/src/core/lib/channel/context.h
+++ b/contrib/libs/grpc/src/core/lib/channel/context.h
@@ -35,7 +35,7 @@ typedef enum {
   /// Reserved for traffic_class_context.
   GRPC_CONTEXT_TRAFFIC,
 
-  /// Holds a pointer to ServiceConfigCallData associated with this call.
+  /// Holds a pointer to ServiceConfigCallData associated with this call. 
   GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA,
 
   GRPC_CONTEXT_COUNT
diff --git a/contrib/libs/grpc/src/core/lib/channel/handshaker.cc b/contrib/libs/grpc/src/core/lib/channel/handshaker.cc
index 826be41cbb..cc36c26660 100644
--- a/contrib/libs/grpc/src/core/lib/channel/handshaker.cc
+++ b/contrib/libs/grpc/src/core/lib/channel/handshaker.cc
@@ -20,8 +20,8 @@
 
 #include <string.h>
 
-#include "y_absl/strings/str_format.h"
-
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/impl/codegen/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -39,16 +39,16 @@ TraceFlag grpc_handshaker_trace(false, "handshaker");
 
 namespace {
 
-TString HandshakerArgsString(HandshakerArgs* args) {
+TString HandshakerArgsString(HandshakerArgs* args) { 
   size_t num_args = args->args != nullptr ? args->args->num_args : 0;
   size_t read_buffer_length =
       args->read_buffer != nullptr ? args->read_buffer->length : 0;
-  return y_absl::StrFormat(
-      "{endpoint=%p, args=%p {size=%" PRIuPTR
-      ": %s}, read_buffer=%p (length=%" PRIuPTR "), exit_early=%d}",
-      args->endpoint, args->args, num_args,
-      grpc_channel_args_string(args->args), args->read_buffer,
-      read_buffer_length, args->exit_early);
+  return y_absl::StrFormat( 
+      "{endpoint=%p, args=%p {size=%" PRIuPTR 
+      ": %s}, read_buffer=%p (length=%" PRIuPTR "), exit_early=%d}", 
+      args->endpoint, args->args, num_args, 
+      grpc_channel_args_string(args->args), args->read_buffer, 
+      read_buffer_length, args->exit_early); 
 }
 
 }  // namespace
@@ -129,8 +129,8 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error* error) {
     gpr_log(GPR_INFO,
             "handshake_manager %p: error=%s shutdown=%d index=%" PRIuPTR
             ", args=%s",
-            this, grpc_error_string(error), is_shutdown_, index_,
-            HandshakerArgsString(&args_).c_str());
+            this, grpc_error_string(error), is_shutdown_, index_, 
+            HandshakerArgsString(&args_).c_str()); 
   }
   GPR_ASSERT(index_ <= handshakers_.size());
   // If we got an error or we've been shut down or we're exiting early or
diff --git a/contrib/libs/grpc/src/core/lib/channel/handshaker.h b/contrib/libs/grpc/src/core/lib/channel/handshaker.h
index cc8e9b2578..91e9d393fa 100644
--- a/contrib/libs/grpc/src/core/lib/channel/handshaker.h
+++ b/contrib/libs/grpc/src/core/lib/channel/handshaker.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "y_absl/container/inlined_vector.h"
-
+#include "y_absl/container/inlined_vector.h" 
+ 
 #include <grpc/support/string_util.h>
 
 #include <grpc/impl/codegen/grpc_types.h>
@@ -147,8 +147,8 @@ class HandshakeManager : public RefCounted<HandshakeManager> {
   gpr_mu mu_;
   bool is_shutdown_ = false;
   // An array of handshakers added via grpc_handshake_manager_add().
-  y_absl::InlinedVector<RefCountedPtr<Handshaker>, HANDSHAKERS_INIT_SIZE>
-      handshakers_;
+  y_absl::InlinedVector<RefCountedPtr<Handshaker>, HANDSHAKERS_INIT_SIZE> 
+      handshakers_; 
   // The index of the handshaker to invoke next and closure to invoke it.
   size_t index_ = 0;
   grpc_closure call_next_handshaker_;
diff --git a/contrib/libs/grpc/src/core/lib/channel/handshaker_registry.cc b/contrib/libs/grpc/src/core/lib/channel/handshaker_registry.cc
index 614531832d..be0a5edfb2 100644
--- a/contrib/libs/grpc/src/core/lib/channel/handshaker_registry.cc
+++ b/contrib/libs/grpc/src/core/lib/channel/handshaker_registry.cc
@@ -18,8 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "y_absl/container/inlined_vector.h"
-
+#include "y_absl/container/inlined_vector.h" 
+ 
 #include "src/core/lib/channel/handshaker_registry.h"
 #include "src/core/lib/gpr/alloc.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -45,7 +45,7 @@ class HandshakerFactoryList {
                       HandshakeManager* handshake_mgr);
 
  private:
-  y_absl::InlinedVector<std::unique_ptr<HandshakerFactory>, 2> factories_;
+  y_absl::InlinedVector<std::unique_ptr<HandshakerFactory>, 2> factories_; 
 };
 
 HandshakerFactoryList* g_handshaker_factory_lists = nullptr;
@@ -76,12 +76,12 @@ void HandshakerFactoryList::AddHandshakers(const grpc_channel_args* args,
 
 void HandshakerRegistry::Init() {
   GPR_ASSERT(g_handshaker_factory_lists == nullptr);
-  g_handshaker_factory_lists = new HandshakerFactoryList[NUM_HANDSHAKER_TYPES];
+  g_handshaker_factory_lists = new HandshakerFactoryList[NUM_HANDSHAKER_TYPES]; 
 }
 
 void HandshakerRegistry::Shutdown() {
   GPR_ASSERT(g_handshaker_factory_lists != nullptr);
-  delete[] g_handshaker_factory_lists;
+  delete[] g_handshaker_factory_lists; 
   g_handshaker_factory_lists = nullptr;
 }
 
diff --git a/contrib/libs/grpc/src/core/lib/compression/message_compress.cc b/contrib/libs/grpc/src/core/lib/compression/message_compress.cc
index 7c2a70bad4..26136828d6 100644
--- a/contrib/libs/grpc/src/core/lib/compression/message_compress.cc
+++ b/contrib/libs/grpc/src/core/lib/compression/message_compress.cc
@@ -34,7 +34,7 @@
 static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
                      grpc_slice_buffer* output,
                      int (*flate)(z_stream* zs, int flush)) {
-  int r = Z_STREAM_END; /* Do not fail on an empty input. */
+  int r = Z_STREAM_END; /* Do not fail on an empty input. */ 
   int flush;
   size_t i;
   grpc_slice outbuf = GRPC_SLICE_MALLOC(OUTPUT_BLOCK_SIZE);
@@ -68,10 +68,10 @@ static int zlib_body(z_stream* zs, grpc_slice_buffer* input,
       goto error;
     }
   }
-  if (r != Z_STREAM_END) {
-    gpr_log(GPR_INFO, "zlib: Data error");
-    goto error;
-  }
+  if (r != Z_STREAM_END) { 
+    gpr_log(GPR_INFO, "zlib: Data error"); 
+    goto error; 
+  } 
 
   GPR_ASSERT(outbuf.refcount);
   outbuf.data.refcounted.length -= zs->avail_out;
diff --git a/contrib/libs/grpc/src/core/lib/debug/stats.cc b/contrib/libs/grpc/src/core/lib/debug/stats.cc
index 1bcd1af25a..a0e70e21e0 100644
--- a/contrib/libs/grpc/src/core/lib/debug/stats.cc
+++ b/contrib/libs/grpc/src/core/lib/debug/stats.cc
@@ -23,11 +23,11 @@
 #include <inttypes.h>
 #include <string.h>
 
-#include <vector>
-
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/str_join.h"
-
+#include <vector> 
+ 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/str_join.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
@@ -145,28 +145,28 @@ double grpc_stats_histo_percentile(const grpc_stats_data* stats,
       static_cast<double>(count) * percentile / 100.0);
 }
 
-TString grpc_stats_data_as_json(const grpc_stats_data* data) {
-  std::vector<TString> parts;
-  parts.push_back("{");
+TString grpc_stats_data_as_json(const grpc_stats_data* data) { 
+  std::vector<TString> parts; 
+  parts.push_back("{"); 
   for (size_t i = 0; i < GRPC_STATS_COUNTER_COUNT; i++) {
-    parts.push_back(y_absl::StrFormat(
-        "\"%s\": %" PRIdPTR, grpc_stats_counter_name[i], data->counters[i]));
+    parts.push_back(y_absl::StrFormat( 
+        "\"%s\": %" PRIdPTR, grpc_stats_counter_name[i], data->counters[i])); 
   }
   for (size_t i = 0; i < GRPC_STATS_HISTOGRAM_COUNT; i++) {
-    parts.push_back(y_absl::StrFormat("\"%s\": [", grpc_stats_histogram_name[i]));
+    parts.push_back(y_absl::StrFormat("\"%s\": [", grpc_stats_histogram_name[i])); 
     for (int j = 0; j < grpc_stats_histo_buckets[i]; j++) {
-      parts.push_back(
-          y_absl::StrFormat("%s%" PRIdPTR, j == 0 ? "" : ",",
-                          data->histograms[grpc_stats_histo_start[i] + j]));
+      parts.push_back( 
+          y_absl::StrFormat("%s%" PRIdPTR, j == 0 ? "" : ",", 
+                          data->histograms[grpc_stats_histo_start[i] + j])); 
     }
-    parts.push_back(
-        y_absl::StrFormat("], \"%s_bkt\": [", grpc_stats_histogram_name[i]));
+    parts.push_back( 
+        y_absl::StrFormat("], \"%s_bkt\": [", grpc_stats_histogram_name[i])); 
     for (int j = 0; j < grpc_stats_histo_buckets[i]; j++) {
-      parts.push_back(y_absl::StrFormat(
-          "%s%d", j == 0 ? "" : ",", grpc_stats_histo_bucket_boundaries[i][j]));
+      parts.push_back(y_absl::StrFormat( 
+          "%s%d", j == 0 ? "" : ",", grpc_stats_histo_bucket_boundaries[i][j])); 
     }
-    parts.push_back("]");
+    parts.push_back("]"); 
   }
-  parts.push_back("}");
-  return y_absl::StrJoin(parts, "");
+  parts.push_back("}"); 
+  return y_absl::StrJoin(parts, ""); 
 }
diff --git a/contrib/libs/grpc/src/core/lib/debug/stats.h b/contrib/libs/grpc/src/core/lib/debug/stats.h
index c184fa7fc7..9498bf1fbf 100644
--- a/contrib/libs/grpc/src/core/lib/debug/stats.h
+++ b/contrib/libs/grpc/src/core/lib/debug/stats.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 #include <grpc/support/atm.h>
 #include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -58,7 +58,7 @@ void grpc_stats_collect(grpc_stats_data* output);
 // c = b-a
 void grpc_stats_diff(const grpc_stats_data* b, const grpc_stats_data* a,
                      grpc_stats_data* c);
-TString grpc_stats_data_as_json(const grpc_stats_data* data);
+TString grpc_stats_data_as_json(const grpc_stats_data* data); 
 int grpc_stats_histo_find_bucket_slow(int value, const int* table,
                                       int table_size);
 double grpc_stats_histo_percentile(const grpc_stats_data* data,
diff --git a/contrib/libs/grpc/src/core/lib/gpr/log_linux.cc b/contrib/libs/grpc/src/core/lib/gpr/log_linux.cc
index 7b098d4711..2e9891d95a 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/log_linux.cc
+++ b/contrib/libs/grpc/src/core/lib/gpr/log_linux.cc
@@ -38,8 +38,8 @@
 #include <sys/syscall.h>
 #include <time.h>
 #include <unistd.h>
-#include <util/generic/string.h>
-#include "y_absl/strings/str_format.h"
+#include <util/generic/string.h> 
+#include "y_absl/strings/str_format.h" 
 
 static long sys_gettid(void) { return syscall(__NR_gettid); }
 
@@ -86,10 +86,10 @@ void gpr_default_log(gpr_log_func_args* args) {
     strcpy(time_buffer, "error:strftime");
   }
 
-  TString prefix = y_absl::StrFormat(
-      "%s%s.%09" PRId32 " %7ld %s:%d]", gpr_log_severity_string(args->severity),
-      time_buffer, now.tv_nsec, tid, display_file, args->line);
-  fprintf(stderr, "%-60s %s\n", prefix.c_str(), args->message);
+  TString prefix = y_absl::StrFormat( 
+      "%s%s.%09" PRId32 " %7ld %s:%d]", gpr_log_severity_string(args->severity), 
+      time_buffer, now.tv_nsec, tid, display_file, args->line); 
+  fprintf(stderr, "%-60s %s\n", prefix.c_str(), args->message); 
 }
 
 #endif /* GPR_LINUX_LOG */
diff --git a/contrib/libs/grpc/src/core/lib/gpr/log_posix.cc b/contrib/libs/grpc/src/core/lib/gpr/log_posix.cc
index bc02118d94..5dd441f4e1 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/log_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/gpr/log_posix.cc
@@ -29,8 +29,8 @@
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
-#include <util/generic/string.h>
-#include "y_absl/strings/str_format.h"
+#include <util/generic/string.h> 
+#include "y_absl/strings/str_format.h" 
 
 static intptr_t sys_gettid(void) { return (intptr_t)pthread_self(); }
 
@@ -84,10 +84,10 @@ void gpr_default_log(gpr_log_func_args* args) {
     strcpy(time_buffer, "error:strftime");
   }
 
-  TString prefix = y_absl::StrFormat(
-      "%s%s.%09d %7" PRIdPTR " %s:%d]", gpr_log_severity_string(args->severity),
-      time_buffer, (int)(now.tv_nsec), sys_gettid(), display_file, args->line);
-  fprintf(stderr, "%-70s %s\n", prefix.c_str(), args->message);
+  TString prefix = y_absl::StrFormat( 
+      "%s%s.%09d %7" PRIdPTR " %s:%d]", gpr_log_severity_string(args->severity), 
+      time_buffer, (int)(now.tv_nsec), sys_gettid(), display_file, args->line); 
+  fprintf(stderr, "%-70s %s\n", prefix.c_str(), args->message); 
 }
 
 #endif /* defined(GPR_POSIX_LOG) */
diff --git a/contrib/libs/grpc/src/core/lib/gpr/string.cc b/contrib/libs/grpc/src/core/lib/gpr/string.cc
index 28f1ae437d..2785fa4afd 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/string.cc
+++ b/contrib/libs/grpc/src/core/lib/gpr/string.cc
@@ -28,8 +28,8 @@
 #include <string.h>
 #include <time.h>
 
-#include "y_absl/strings/str_cat.h"
-
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -52,7 +52,7 @@ char* gpr_strdup(const char* src) {
   return dst;
 }
 
-TString gpr_format_timespec(gpr_timespec tm) {
+TString gpr_format_timespec(gpr_timespec tm) { 
   char time_buffer[35];
   char ns_buffer[11];  // '.' + 9 digits of precision
   struct tm* tm_info = localtime((const time_t*)&tm.tv_sec);
@@ -73,15 +73,15 @@ TString gpr_format_timespec(gpr_timespec tm) {
       break;
     }
   }
-  return y_absl::StrCat(time_buffer, ns_buffer, "Z");
+  return y_absl::StrCat(time_buffer, ns_buffer, "Z"); 
 }
 
-struct dump_out {
-  size_t capacity;
-  size_t length;
-  char* data;
-};
-
+struct dump_out { 
+  size_t capacity; 
+  size_t length; 
+  char* data; 
+}; 
+ 
 static dump_out dump_out_create(void) {
   dump_out r = {0, 0, nullptr};
   return r;
diff --git a/contrib/libs/grpc/src/core/lib/gpr/string.h b/contrib/libs/grpc/src/core/lib/gpr/string.h
index 4b348198b8..d44f79d7fb 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/string.h
+++ b/contrib/libs/grpc/src/core/lib/gpr/string.h
@@ -26,8 +26,8 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 /* String utility functions */
 
 /* Flags for gpr_dump function. */
@@ -90,13 +90,13 @@ char* gpr_strjoin_sep(const char** strs, size_t nstrs, const char* sep,
 void gpr_string_split(const char* input, const char* sep, char*** strs,
                       size_t* nstrs);
 
-/* Returns a string that represents tm according to RFC-3339, and,
+/* Returns a string that represents tm according to RFC-3339, and, 
    more specifically, follows:
    https://developers.google.com/protocol-buffers/docs/proto3#json
 
    Uses RFC 3339, where generated output will always be Z-normalized and uses
    0, 3, 6 or 9 fractional digits. */
-TString gpr_format_timespec(gpr_timespec);
+TString gpr_format_timespec(gpr_timespec); 
 
 /** Case insensitive string comparison... return <0 if lower(a)<lower(b), ==0 if
     lower(a)==lower(b), >0 if lower(a)>lower(b) */
diff --git a/contrib/libs/grpc/src/core/lib/gpr/sync_abseil.cc b/contrib/libs/grpc/src/core/lib/gpr/sync_abseil.cc
index c224be2eee..09f8f592b6 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/sync_abseil.cc
+++ b/contrib/libs/grpc/src/core/lib/gpr/sync_abseil.cc
@@ -1,116 +1,116 @@
-/*
- *
- * 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#if defined(GPR_ABSEIL_SYNC) && !defined(GPR_CUSTOM_SYNC)
-
-#include <grpc/support/alloc.h>
-
-#include <errno.h>
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-#include <grpc/support/time.h>
-#include <time.h>
-#include "src/core/lib/profiling/timers.h"
-
-#include "y_absl/base/call_once.h"
-#include "y_absl/synchronization/mutex.h"
-#include "y_absl/time/clock.h"
-#include "y_absl/time/time.h"
-
-#ifdef GPR_LOW_LEVEL_COUNTERS
-gpr_atm gpr_mu_locks = 0;
-gpr_atm gpr_counter_atm_cas = 0;
-gpr_atm gpr_counter_atm_add = 0;
-#endif
-
-void gpr_mu_init(gpr_mu* mu) {
-  static_assert(sizeof(gpr_mu) == sizeof(y_absl::Mutex),
-                "gpr_mu and Mutex must be the same size");
-  new (mu) y_absl::Mutex;
-}
-
-void gpr_mu_destroy(gpr_mu* mu) {
-  reinterpret_cast<y_absl::Mutex*>(mu)->~Mutex();
-}
-
-void gpr_mu_lock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  GPR_TIMER_SCOPE("gpr_mu_lock", 0);
-  reinterpret_cast<y_absl::Mutex*>(mu)->Lock();
-}
-
-void gpr_mu_unlock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  GPR_TIMER_SCOPE("gpr_mu_unlock", 0);
-  reinterpret_cast<y_absl::Mutex*>(mu)->Unlock();
-}
-
-int gpr_mu_trylock(gpr_mu* mu) {
-  GPR_TIMER_SCOPE("gpr_mu_trylock", 0);
-  int ret = reinterpret_cast<y_absl::Mutex*>(mu)->TryLock() == true;
-  return ret;
-}
-
-/*----------------------------------------*/
-
-void gpr_cv_init(gpr_cv* cv) {
-  static_assert(sizeof(gpr_cv) == sizeof(y_absl::CondVar),
-                "gpr_cv and CondVar must be the same size");
-  new (cv) y_absl::CondVar;
-}
-
-void gpr_cv_destroy(gpr_cv* cv) {
-  reinterpret_cast<y_absl::CondVar*>(cv)->~CondVar();
-}
-
-int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
-  GPR_TIMER_SCOPE("gpr_cv_wait", 0);
-  if (gpr_time_cmp(abs_deadline, gpr_inf_future(abs_deadline.clock_type)) ==
-      0) {
-    reinterpret_cast<y_absl::CondVar*>(cv)->Wait(
-        reinterpret_cast<y_absl::Mutex*>(mu));
-    return 0;
-  }
-  abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME);
-  timespec ts = {static_cast<decltype(ts.tv_sec)>(abs_deadline.tv_sec),
-                 static_cast<decltype(ts.tv_nsec)>(abs_deadline.tv_nsec)};
-  int ret = reinterpret_cast<y_absl::CondVar*>(cv)->WaitWithDeadline(
-                reinterpret_cast<y_absl::Mutex*>(mu),
-                y_absl::TimeFromTimespec(ts)) == true;
-  return ret;
-}
-
-void gpr_cv_signal(gpr_cv* cv) {
-  GPR_TIMER_MARK("gpr_cv_signal", 0);
-  reinterpret_cast<y_absl::CondVar*>(cv)->Signal();
-}
-
-void gpr_cv_broadcast(gpr_cv* cv) {
-  GPR_TIMER_MARK("gpr_cv_broadcast", 0);
-  reinterpret_cast<y_absl::CondVar*>(cv)->SignalAll();
-}
-
-/*----------------------------------------*/
-
-void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
-  static_assert(sizeof(gpr_once) == sizeof(y_absl::once_flag),
-                "gpr_once and y_absl::once_flag must be the same size");
-  y_absl::call_once(*reinterpret_cast<y_absl::once_flag*>(once), init_function);
-}
-
-#endif /* defined(GPR_ABSEIL_SYNC) && !defined(GPR_CUSTOM_SYNC) */
+/* 
+ * 
+ * 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. 
+ * 
+ */ 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#if defined(GPR_ABSEIL_SYNC) && !defined(GPR_CUSTOM_SYNC) 
+ 
+#include <grpc/support/alloc.h> 
+ 
+#include <errno.h> 
+#include <grpc/support/log.h> 
+#include <grpc/support/sync.h> 
+#include <grpc/support/time.h> 
+#include <time.h> 
+#include "src/core/lib/profiling/timers.h" 
+ 
+#include "y_absl/base/call_once.h" 
+#include "y_absl/synchronization/mutex.h" 
+#include "y_absl/time/clock.h" 
+#include "y_absl/time/time.h" 
+ 
+#ifdef GPR_LOW_LEVEL_COUNTERS 
+gpr_atm gpr_mu_locks = 0; 
+gpr_atm gpr_counter_atm_cas = 0; 
+gpr_atm gpr_counter_atm_add = 0; 
+#endif 
+ 
+void gpr_mu_init(gpr_mu* mu) { 
+  static_assert(sizeof(gpr_mu) == sizeof(y_absl::Mutex), 
+                "gpr_mu and Mutex must be the same size"); 
+  new (mu) y_absl::Mutex; 
+} 
+ 
+void gpr_mu_destroy(gpr_mu* mu) { 
+  reinterpret_cast<y_absl::Mutex*>(mu)->~Mutex(); 
+} 
+ 
+void gpr_mu_lock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS { 
+  GPR_TIMER_SCOPE("gpr_mu_lock", 0); 
+  reinterpret_cast<y_absl::Mutex*>(mu)->Lock(); 
+} 
+ 
+void gpr_mu_unlock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS { 
+  GPR_TIMER_SCOPE("gpr_mu_unlock", 0); 
+  reinterpret_cast<y_absl::Mutex*>(mu)->Unlock(); 
+} 
+ 
+int gpr_mu_trylock(gpr_mu* mu) { 
+  GPR_TIMER_SCOPE("gpr_mu_trylock", 0); 
+  int ret = reinterpret_cast<y_absl::Mutex*>(mu)->TryLock() == true; 
+  return ret; 
+} 
+ 
+/*----------------------------------------*/ 
+ 
+void gpr_cv_init(gpr_cv* cv) { 
+  static_assert(sizeof(gpr_cv) == sizeof(y_absl::CondVar), 
+                "gpr_cv and CondVar must be the same size"); 
+  new (cv) y_absl::CondVar; 
+} 
+ 
+void gpr_cv_destroy(gpr_cv* cv) { 
+  reinterpret_cast<y_absl::CondVar*>(cv)->~CondVar(); 
+} 
+ 
+int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) { 
+  GPR_TIMER_SCOPE("gpr_cv_wait", 0); 
+  if (gpr_time_cmp(abs_deadline, gpr_inf_future(abs_deadline.clock_type)) == 
+      0) { 
+    reinterpret_cast<y_absl::CondVar*>(cv)->Wait( 
+        reinterpret_cast<y_absl::Mutex*>(mu)); 
+    return 0; 
+  } 
+  abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME); 
+  timespec ts = {static_cast<decltype(ts.tv_sec)>(abs_deadline.tv_sec), 
+                 static_cast<decltype(ts.tv_nsec)>(abs_deadline.tv_nsec)}; 
+  int ret = reinterpret_cast<y_absl::CondVar*>(cv)->WaitWithDeadline( 
+                reinterpret_cast<y_absl::Mutex*>(mu), 
+                y_absl::TimeFromTimespec(ts)) == true; 
+  return ret; 
+} 
+ 
+void gpr_cv_signal(gpr_cv* cv) { 
+  GPR_TIMER_MARK("gpr_cv_signal", 0); 
+  reinterpret_cast<y_absl::CondVar*>(cv)->Signal(); 
+} 
+ 
+void gpr_cv_broadcast(gpr_cv* cv) { 
+  GPR_TIMER_MARK("gpr_cv_broadcast", 0); 
+  reinterpret_cast<y_absl::CondVar*>(cv)->SignalAll(); 
+} 
+ 
+/*----------------------------------------*/ 
+ 
+void gpr_once_init(gpr_once* once, void (*init_function)(void)) { 
+  static_assert(sizeof(gpr_once) == sizeof(y_absl::once_flag), 
+                "gpr_once and y_absl::once_flag must be the same size"); 
+  y_absl::call_once(*reinterpret_cast<y_absl::once_flag*>(once), init_function); 
+} 
+ 
+#endif /* defined(GPR_ABSEIL_SYNC) && !defined(GPR_CUSTOM_SYNC) */ 
diff --git a/contrib/libs/grpc/src/core/lib/gpr/sync_posix.cc b/contrib/libs/grpc/src/core/lib/gpr/sync_posix.cc
index fdd278be23..faa0925d5e 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/sync_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/gpr/sync_posix.cc
@@ -18,17 +18,17 @@
 
 #include <grpc/support/port_platform.h>
 
-#if defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) && \
-    !defined(GPR_CUSTOM_SYNC)
-
+#if defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) && \ 
+    !defined(GPR_CUSTOM_SYNC) 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
-
-#include <errno.h>
+ 
+#include <errno.h> 
 #include <time.h>
-
+ 
 #include "src/core/lib/profiling/timers.h"
 
 #ifdef GPR_LOW_LEVEL_COUNTERS
@@ -128,9 +128,9 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
   } else {
     struct timespec abs_deadline_ts;
 #if GPR_LINUX
-    abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_MONOTONIC);
+    abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_MONOTONIC); 
 #else
-    abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME);
+    abs_deadline = gpr_convert_clock_type(abs_deadline, GPR_CLOCK_REALTIME); 
 #endif  // GPR_LINUX
     abs_deadline_ts.tv_sec = static_cast<time_t>(abs_deadline.tv_sec);
     abs_deadline_ts.tv_nsec = abs_deadline.tv_nsec;
@@ -166,5 +166,5 @@ void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
   GPR_ASSERT(pthread_once(once, init_function) == 0);
 }
 
-#endif /* defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) && \
-          !defined(GPR_CUSTOM_SYNC) */
+#endif /* defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) && \ 
+          !defined(GPR_CUSTOM_SYNC) */ 
diff --git a/contrib/libs/grpc/src/core/lib/gpr/sync_windows.cc b/contrib/libs/grpc/src/core/lib/gpr/sync_windows.cc
index 64eec7c2e1..1ffe06b095 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/sync_windows.cc
+++ b/contrib/libs/grpc/src/core/lib/gpr/sync_windows.cc
@@ -20,8 +20,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#if defined(GPR_WINDOWS) && !defined(GPR_ABSEIL_SYNC) && \
-    !defined(GPR_CUSTOM_SYNC)
+#if defined(GPR_WINDOWS) && !defined(GPR_ABSEIL_SYNC) && \ 
+    !defined(GPR_CUSTOM_SYNC) 
 
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -116,5 +116,5 @@ void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
   InitOnceExecuteOnce(once, run_once_func, &arg, &dummy);
 }
 
-#endif /* defined(GPR_WINDOWS) && !defined(GPR_ABSEIL_SYNC) && \
-          !defined(GPR_CUSTOM_SYNC) */
+#endif /* defined(GPR_WINDOWS) && !defined(GPR_ABSEIL_SYNC) && \ 
+          !defined(GPR_CUSTOM_SYNC) */ 
diff --git a/contrib/libs/grpc/src/core/lib/gpr/time.cc b/contrib/libs/grpc/src/core/lib/gpr/time.cc
index db5a7f64f7..2c96c5b2ba 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/time.cc
+++ b/contrib/libs/grpc/src/core/lib/gpr/time.cc
@@ -254,10 +254,10 @@ gpr_timespec gpr_convert_clock_type(gpr_timespec t, gpr_clock_type clock_type) {
     return gpr_time_add(gpr_now(clock_type), t);
   }
 
-  // If the given input hits this code, the same result is not guaranteed for
-  // the same input because it relies on `gpr_now` to calculate the difference
-  // between two different clocks. Please be careful when you want to use this
-  // function in unit tests. (e.g. https://github.com/grpc/grpc/pull/22655)
+  // If the given input hits this code, the same result is not guaranteed for 
+  // the same input because it relies on `gpr_now` to calculate the difference 
+  // between two different clocks. Please be careful when you want to use this 
+  // function in unit tests. (e.g. https://github.com/grpc/grpc/pull/22655) 
   return gpr_time_add(gpr_now(clock_type),
                       gpr_time_sub(t, gpr_now(t.clock_type)));
 }
diff --git a/contrib/libs/grpc/src/core/lib/gpr/time_posix.cc b/contrib/libs/grpc/src/core/lib/gpr/time_posix.cc
index 0a9e1158b3..61f5e0f14d 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/time_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/gpr/time_posix.cc
@@ -82,7 +82,7 @@ static gpr_timespec now_impl(gpr_clock_type clock_type) {
   }
 }
 #else
-/* For some reason Apple's OSes haven't implemented clock_gettime. */
+/* For some reason Apple's OSes haven't implemented clock_gettime. */ 
 
 #include <mach/mach.h>
 #include <mach/mach_time.h>
diff --git a/contrib/libs/grpc/src/core/lib/gpr/time_precise.cc b/contrib/libs/grpc/src/core/lib/gpr/time_precise.cc
index 4d1b64b8b2..20f27d84ec 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/time_precise.cc
+++ b/contrib/libs/grpc/src/core/lib/gpr/time_precise.cc
@@ -31,8 +31,8 @@
 
 #include "src/core/lib/gpr/time_precise.h"
 
-#ifndef GPR_CYCLE_COUNTER_CUSTOM
-#if GPR_CYCLE_COUNTER_RDTSC_32 || GPR_CYCLE_COUNTER_RDTSC_64
+#ifndef GPR_CYCLE_COUNTER_CUSTOM 
+#if GPR_CYCLE_COUNTER_RDTSC_32 || GPR_CYCLE_COUNTER_RDTSC_64 
 #if GPR_LINUX
 static bool read_freq_from_kernel(double* freq) {
   // Google production kernel export the frequency for us in kHz.
@@ -164,4 +164,4 @@ gpr_timespec gpr_cycle_counter_sub(gpr_cycle_counter a, gpr_cycle_counter b) {
                       gpr_cycle_counter_to_time(b));
 }
 #endif /* GPR_CYCLE_COUNTER_FALLBACK */
-#endif /* !GPR_CYCLE_COUNTER_CUSTOM */
+#endif /* !GPR_CYCLE_COUNTER_CUSTOM */ 
diff --git a/contrib/libs/grpc/src/core/lib/gpr/time_precise.h b/contrib/libs/grpc/src/core/lib/gpr/time_precise.h
index 1dcfa3b57e..a68ce28477 100644
--- a/contrib/libs/grpc/src/core/lib/gpr/time_precise.h
+++ b/contrib/libs/grpc/src/core/lib/gpr/time_precise.h
@@ -31,11 +31,11 @@
 // Using gpr_get_cycle_counter() is preferred to using ExecCtx::Get()->Now()
 // whenever possible.
 
-#if GPR_CYCLE_COUNTER_CUSTOM
-typedef int64_t gpr_cycle_counter;
-gpr_cycle_counter gpr_get_cycle_counter();
-#elif GPR_CYCLE_COUNTER_RDTSC_32
+#if GPR_CYCLE_COUNTER_CUSTOM 
 typedef int64_t gpr_cycle_counter;
+gpr_cycle_counter gpr_get_cycle_counter(); 
+#elif GPR_CYCLE_COUNTER_RDTSC_32 
+typedef int64_t gpr_cycle_counter; 
 inline gpr_cycle_counter gpr_get_cycle_counter() {
   int64_t ret;
   __asm__ volatile("rdtsc" : "=A"(ret));
@@ -57,8 +57,8 @@ gpr_cycle_counter gpr_get_cycle_counter();
 #else
 #error Must define exactly one of \
     GPR_CYCLE_COUNTER_RDTSC_32, \
-    GPR_CYCLE_COUNTER_RDTSC_64, \
-    GPR_CYCLE_COUNTER_CUSTOM, or \
+    GPR_CYCLE_COUNTER_RDTSC_64, \ 
+    GPR_CYCLE_COUNTER_CUSTOM, or \ 
     GPR_CYCLE_COUNTER_FALLBACK
 #endif
 
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/debug_location.h b/contrib/libs/grpc/src/core/lib/gprpp/debug_location.h
index a96e06e235..6b92b4e89a 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/debug_location.h
+++ b/contrib/libs/grpc/src/core/lib/gprpp/debug_location.h
@@ -26,7 +26,7 @@ namespace grpc_core {
 // Callers can use the DEBUG_LOCATION macro in either case.
 #ifndef NDEBUG
 // TODO(roth): See if there's a way to automatically populate this,
-// similarly to how y_absl::SourceLocation::current() works, so that
+// similarly to how y_absl::SourceLocation::current() works, so that 
 // callers don't need to explicitly pass DEBUG_LOCATION anywhere.
 class DebugLocation {
  public:
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/dual_ref_counted.h b/contrib/libs/grpc/src/core/lib/gprpp/dual_ref_counted.h
index 66935bbdea..fef7da530d 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/dual_ref_counted.h
+++ b/contrib/libs/grpc/src/core/lib/gprpp/dual_ref_counted.h
@@ -1,336 +1,336 @@
-//
-// 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_CORE_LIB_GPRPP_DUAL_REF_COUNTED_H
-#define GRPC_CORE_LIB_GPRPP_DUAL_REF_COUNTED_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/support/atm.h>
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-
-#include <atomic>
-#include <cassert>
-#include <cinttypes>
-
-#include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/atomic.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-
-namespace grpc_core {
-
-// DualRefCounted is an interface for reference-counted objects with two
-// classes of refs: strong refs (usually just called "refs") and weak refs.
-// This supports cases where an object needs to start shutting down when
-// all external callers are done with it (represented by strong refs) but
-// cannot be destroyed until all internal callbacks are complete
-// (represented by weak refs).
-//
-// Each class of refs can be incremented and decremented independently.
-// Objects start with 1 strong ref and 0 weak refs at instantiation.
-// When the strong refcount reaches 0, the object's Orphan() method is called.
-// When the weak refcount reaches 0, the object is destroyed.
-//
-// This will be used by CRTP (curiously-recurring template pattern), e.g.:
-//   class MyClass : public RefCounted<MyClass> { ... };
-template <typename Child>
-class DualRefCounted : public Orphanable {
- public:
-  virtual ~DualRefCounted() = default;
-
-  RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {
-    IncrementRefCount();
-    return RefCountedPtr<Child>(static_cast<Child*>(this));
-  }
-
-  RefCountedPtr<Child> Ref(const DebugLocation& location,
-                           const char* reason) GRPC_MUST_USE_RESULT {
-    IncrementRefCount(location, reason);
-    return RefCountedPtr<Child>(static_cast<Child*>(this));
-  }
-
-  void Unref() {
-    // Convert strong ref to weak ref.
-    const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(-1, 1), MemoryOrder::ACQ_REL);
-    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-#ifndef NDEBUG
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p unref %d -> %d, weak_ref %d -> %d",
-              trace_flag_->name(), this, strong_refs, strong_refs - 1,
-              weak_refs, weak_refs + 1);
-    }
-    GPR_ASSERT(strong_refs > 0);
-#endif
-    if (GPR_UNLIKELY(strong_refs == 1)) {
-      Orphan();
-    }
-    // Now drop the weak ref.
-    WeakUnref();
-  }
-  void Unref(const DebugLocation& location, const char* reason) {
-    const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(-1, 1), MemoryOrder::ACQ_REL);
-    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-#ifndef NDEBUG
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d unref %d -> %d, weak_ref %d -> %d) %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              strong_refs, strong_refs - 1, weak_refs, weak_refs + 1, reason);
-    }
-    GPR_ASSERT(strong_refs > 0);
-#else
-    // Avoid unused-parameter warnings for debug-only parameters
-    (void)location;
-    (void)reason;
-#endif
-    if (GPR_UNLIKELY(strong_refs == 1)) {
-      Orphan();
-    }
-    // Now drop the weak ref.
-    WeakUnref(location, reason);
-  }
-
-  RefCountedPtr<Child> RefIfNonZero() GRPC_MUST_USE_RESULT {
-    uint64_t prev_ref_pair = refs_.Load(MemoryOrder::ACQUIRE);
-    do {
-      const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-#ifndef NDEBUG
-      const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-      if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-        gpr_log(GPR_INFO, "%s:%p ref_if_non_zero %d -> %d (weak_refs=%d)",
-                trace_flag_->name(), this, strong_refs, strong_refs + 1,
-                weak_refs);
-      }
-#endif
-      if (strong_refs == 0) return nullptr;
-    } while (!refs_.CompareExchangeWeak(
-        &prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0), MemoryOrder::ACQ_REL,
-        MemoryOrder::ACQUIRE));
-    return RefCountedPtr<Child>(static_cast<Child*>(this));
-  }
-
-  RefCountedPtr<Child> RefIfNonZero(const DebugLocation& location,
-                                    const char* reason) GRPC_MUST_USE_RESULT {
-    uint64_t prev_ref_pair = refs_.Load(MemoryOrder::ACQUIRE);
-    do {
-      const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-#ifndef NDEBUG
-      const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-      if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-        gpr_log(GPR_INFO,
-                "%s:%p %s:%d ref_if_non_zero %d -> %d (weak_refs=%d) %s",
-                trace_flag_->name(), this, location.file(), location.line(),
-                strong_refs, strong_refs + 1, weak_refs, reason);
-      }
-#else
-      // Avoid unused-parameter warnings for debug-only parameters
-      (void)location;
-      (void)reason;
-#endif
-      if (strong_refs == 0) return nullptr;
-    } while (!refs_.CompareExchangeWeak(
-        &prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0), MemoryOrder::ACQ_REL,
-        MemoryOrder::ACQUIRE));
-    return RefCountedPtr<Child>(static_cast<Child*>(this));
-  }
-
-  WeakRefCountedPtr<Child> WeakRef() GRPC_MUST_USE_RESULT {
-    IncrementWeakRefCount();
-    return WeakRefCountedPtr<Child>(static_cast<Child*>(this));
-  }
-
-  WeakRefCountedPtr<Child> WeakRef(const DebugLocation& location,
-                                   const char* reason) GRPC_MUST_USE_RESULT {
-    IncrementWeakRefCount(location, reason);
-    return WeakRefCountedPtr<Child>(static_cast<Child*>(this));
-  }
-
-  void WeakUnref() {
-#ifndef NDEBUG
-    // Grab a copy of the trace flag before the atomic change, since we
-    // can't safely access it afterwards if we're going to be freed.
-    auto* trace_flag = trace_flag_;
-#endif
-    const uint64_t prev_ref_pair =
-        refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL);
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-#ifndef NDEBUG
-    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-    if (trace_flag != nullptr && trace_flag->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p weak_unref %d -> %d (refs=%d)",
-              trace_flag->name(), this, weak_refs, weak_refs - 1, strong_refs);
-    }
-    GPR_ASSERT(weak_refs > 0);
-#endif
-    if (GPR_UNLIKELY(prev_ref_pair == MakeRefPair(0, 1))) {
-      delete static_cast<Child*>(this);
-    }
-  }
-  void WeakUnref(const DebugLocation& location, const char* reason) {
-#ifndef NDEBUG
-    // Grab a copy of the trace flag before the atomic change, since we
-    // can't safely access it afterwards if we're going to be freed.
-    auto* trace_flag = trace_flag_;
-#endif
-    const uint64_t prev_ref_pair =
-        refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL);
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-#ifndef NDEBUG
-    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-    if (trace_flag != nullptr && trace_flag->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d weak_unref %d -> %d (refs=%d) %s",
-              trace_flag->name(), this, location.file(), location.line(),
-              weak_refs, weak_refs - 1, strong_refs, reason);
-    }
-    GPR_ASSERT(weak_refs > 0);
-#else
-    // Avoid unused-parameter warnings for debug-only parameters
-    (void)location;
-    (void)reason;
-#endif
-    if (GPR_UNLIKELY(prev_ref_pair == MakeRefPair(0, 1))) {
-      delete static_cast<Child*>(this);
-    }
-  }
-
-  // Not copyable nor movable.
-  DualRefCounted(const DualRefCounted&) = delete;
-  DualRefCounted& operator=(const DualRefCounted&) = delete;
-
- protected:
-  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
-  // Note: RefCount tracing is only enabled on debug builds, even when a
-  //       TraceFlag is used.
-  template <typename TraceFlagT = TraceFlag>
-  explicit DualRefCounted(
-      TraceFlagT*
-#ifndef NDEBUG
-          // Leave unnamed if NDEBUG to avoid unused parameter warning
-          trace_flag
-#endif
-      = nullptr,
-      int32_t initial_refcount = 1)
-      :
-#ifndef NDEBUG
-        trace_flag_(trace_flag),
-#endif
-        refs_(MakeRefPair(initial_refcount, 0)) {
-  }
-
- private:
-  // Allow RefCountedPtr<> to access IncrementRefCount().
-  template <typename T>
-  friend class RefCountedPtr;
-  // Allow WeakRefCountedPtr<> to access IncrementWeakRefCount().
-  template <typename T>
-  friend class WeakRefCountedPtr;
-
-  // First 32 bits are strong refs, next 32 bits are weak refs.
-  static uint64_t MakeRefPair(uint32_t strong, uint32_t weak) {
-    return (static_cast<uint64_t>(strong) << 32) + static_cast<int64_t>(weak);
-  }
-  static uint32_t GetStrongRefs(uint64_t ref_pair) {
-    return static_cast<uint32_t>(ref_pair >> 32);
-  }
-  static uint32_t GetWeakRefs(uint64_t ref_pair) {
-    return static_cast<uint32_t>(ref_pair & 0xffffffffu);
-  }
-
-  void IncrementRefCount() {
-#ifndef NDEBUG
-    const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
-    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    GPR_ASSERT(strong_refs != 0);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p ref %d -> %d; (weak_refs=%d)",
-              trace_flag_->name(), this, strong_refs, strong_refs + 1,
-              weak_refs);
-    }
-#else
-    refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
-#endif
-  }
-  void IncrementRefCount(const DebugLocation& location, const char* reason) {
-#ifndef NDEBUG
-    const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
-    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    GPR_ASSERT(strong_refs != 0);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d ref %d -> %d (weak_refs=%d) %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              strong_refs, strong_refs + 1, weak_refs, reason);
-    }
-#else
-    // Use conditionally-important parameters
-    (void)location;
-    (void)reason;
-    refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
-#endif
-  }
-
-  void IncrementWeakRefCount() {
-#ifndef NDEBUG
-    const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
-    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p weak_ref %d -> %d; (refs=%d)",
-              trace_flag_->name(), this, weak_refs, weak_refs + 1, strong_refs);
-    }
-#else
-    refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
-#endif
-  }
-  void IncrementWeakRefCount(const DebugLocation& location,
-                             const char* reason) {
-#ifndef NDEBUG
-    const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
-    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p %s:%d weak_ref %d -> %d (refs=%d) %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              weak_refs, weak_refs + 1, strong_refs, reason);
-    }
-#else
-    // Use conditionally-important parameters
-    (void)location;
-    (void)reason;
-    refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
-#endif
-  }
-
-#ifndef NDEBUG
-  TraceFlag* trace_flag_;
-#endif
-  Atomic<uint64_t> refs_;
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_GPRPP_DUAL_REF_COUNTED_H */
+// 
+// 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_CORE_LIB_GPRPP_DUAL_REF_COUNTED_H 
+#define GRPC_CORE_LIB_GPRPP_DUAL_REF_COUNTED_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <grpc/support/atm.h> 
+#include <grpc/support/log.h> 
+#include <grpc/support/sync.h> 
+ 
+#include <atomic> 
+#include <cassert> 
+#include <cinttypes> 
+ 
+#include "src/core/lib/debug/trace.h" 
+#include "src/core/lib/gprpp/atomic.h" 
+#include "src/core/lib/gprpp/debug_location.h" 
+#include "src/core/lib/gprpp/orphanable.h" 
+#include "src/core/lib/gprpp/ref_counted_ptr.h" 
+ 
+namespace grpc_core { 
+ 
+// DualRefCounted is an interface for reference-counted objects with two 
+// classes of refs: strong refs (usually just called "refs") and weak refs. 
+// This supports cases where an object needs to start shutting down when 
+// all external callers are done with it (represented by strong refs) but 
+// cannot be destroyed until all internal callbacks are complete 
+// (represented by weak refs). 
+// 
+// Each class of refs can be incremented and decremented independently. 
+// Objects start with 1 strong ref and 0 weak refs at instantiation. 
+// When the strong refcount reaches 0, the object's Orphan() method is called. 
+// When the weak refcount reaches 0, the object is destroyed. 
+// 
+// This will be used by CRTP (curiously-recurring template pattern), e.g.: 
+//   class MyClass : public RefCounted<MyClass> { ... }; 
+template <typename Child> 
+class DualRefCounted : public Orphanable { 
+ public: 
+  virtual ~DualRefCounted() = default; 
+ 
+  RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT { 
+    IncrementRefCount(); 
+    return RefCountedPtr<Child>(static_cast<Child*>(this)); 
+  } 
+ 
+  RefCountedPtr<Child> Ref(const DebugLocation& location, 
+                           const char* reason) GRPC_MUST_USE_RESULT { 
+    IncrementRefCount(location, reason); 
+    return RefCountedPtr<Child>(static_cast<Child*>(this)); 
+  } 
+ 
+  void Unref() { 
+    // Convert strong ref to weak ref. 
+    const uint64_t prev_ref_pair = 
+        refs_.FetchAdd(MakeRefPair(-1, 1), MemoryOrder::ACQ_REL); 
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair); 
+#ifndef NDEBUG 
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair); 
+    if (trace_flag_ != nullptr && trace_flag_->enabled()) { 
+      gpr_log(GPR_INFO, "%s:%p unref %d -> %d, weak_ref %d -> %d", 
+              trace_flag_->name(), this, strong_refs, strong_refs - 1, 
+              weak_refs, weak_refs + 1); 
+    } 
+    GPR_ASSERT(strong_refs > 0); 
+#endif 
+    if (GPR_UNLIKELY(strong_refs == 1)) { 
+      Orphan(); 
+    } 
+    // Now drop the weak ref. 
+    WeakUnref(); 
+  } 
+  void Unref(const DebugLocation& location, const char* reason) { 
+    const uint64_t prev_ref_pair = 
+        refs_.FetchAdd(MakeRefPair(-1, 1), MemoryOrder::ACQ_REL); 
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair); 
+#ifndef NDEBUG 
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair); 
+    if (trace_flag_ != nullptr && trace_flag_->enabled()) { 
+      gpr_log(GPR_INFO, "%s:%p %s:%d unref %d -> %d, weak_ref %d -> %d) %s", 
+              trace_flag_->name(), this, location.file(), location.line(), 
+              strong_refs, strong_refs - 1, weak_refs, weak_refs + 1, reason); 
+    } 
+    GPR_ASSERT(strong_refs > 0); 
+#else 
+    // Avoid unused-parameter warnings for debug-only parameters 
+    (void)location; 
+    (void)reason; 
+#endif 
+    if (GPR_UNLIKELY(strong_refs == 1)) { 
+      Orphan(); 
+    } 
+    // Now drop the weak ref. 
+    WeakUnref(location, reason); 
+  } 
+ 
+  RefCountedPtr<Child> RefIfNonZero() GRPC_MUST_USE_RESULT { 
+    uint64_t prev_ref_pair = refs_.Load(MemoryOrder::ACQUIRE); 
+    do { 
+      const uint32_t strong_refs = GetStrongRefs(prev_ref_pair); 
+#ifndef NDEBUG 
+      const uint32_t weak_refs = GetWeakRefs(prev_ref_pair); 
+      if (trace_flag_ != nullptr && trace_flag_->enabled()) { 
+        gpr_log(GPR_INFO, "%s:%p ref_if_non_zero %d -> %d (weak_refs=%d)", 
+                trace_flag_->name(), this, strong_refs, strong_refs + 1, 
+                weak_refs); 
+      } 
+#endif 
+      if (strong_refs == 0) return nullptr; 
+    } while (!refs_.CompareExchangeWeak( 
+        &prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0), MemoryOrder::ACQ_REL, 
+        MemoryOrder::ACQUIRE)); 
+    return RefCountedPtr<Child>(static_cast<Child*>(this)); 
+  } 
+ 
+  RefCountedPtr<Child> RefIfNonZero(const DebugLocation& location, 
+                                    const char* reason) GRPC_MUST_USE_RESULT { 
+    uint64_t prev_ref_pair = refs_.Load(MemoryOrder::ACQUIRE); 
+    do { 
+      const uint32_t strong_refs = GetStrongRefs(prev_ref_pair); 
+#ifndef NDEBUG 
+      const uint32_t weak_refs = GetWeakRefs(prev_ref_pair); 
+      if (trace_flag_ != nullptr && trace_flag_->enabled()) { 
+        gpr_log(GPR_INFO, 
+                "%s:%p %s:%d ref_if_non_zero %d -> %d (weak_refs=%d) %s", 
+                trace_flag_->name(), this, location.file(), location.line(), 
+                strong_refs, strong_refs + 1, weak_refs, reason); 
+      } 
+#else 
+      // Avoid unused-parameter warnings for debug-only parameters 
+      (void)location; 
+      (void)reason; 
+#endif 
+      if (strong_refs == 0) return nullptr; 
+    } while (!refs_.CompareExchangeWeak( 
+        &prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0), MemoryOrder::ACQ_REL, 
+        MemoryOrder::ACQUIRE)); 
+    return RefCountedPtr<Child>(static_cast<Child*>(this)); 
+  } 
+ 
+  WeakRefCountedPtr<Child> WeakRef() GRPC_MUST_USE_RESULT { 
+    IncrementWeakRefCount(); 
+    return WeakRefCountedPtr<Child>(static_cast<Child*>(this)); 
+  } 
+ 
+  WeakRefCountedPtr<Child> WeakRef(const DebugLocation& location, 
+                                   const char* reason) GRPC_MUST_USE_RESULT { 
+    IncrementWeakRefCount(location, reason); 
+    return WeakRefCountedPtr<Child>(static_cast<Child*>(this)); 
+  } 
+ 
+  void WeakUnref() { 
+#ifndef NDEBUG 
+    // Grab a copy of the trace flag before the atomic change, since we 
+    // can't safely access it afterwards if we're going to be freed. 
+    auto* trace_flag = trace_flag_; 
+#endif 
+    const uint64_t prev_ref_pair = 
+        refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL); 
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair); 
+#ifndef NDEBUG 
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair); 
+    if (trace_flag != nullptr && trace_flag->enabled()) { 
+      gpr_log(GPR_INFO, "%s:%p weak_unref %d -> %d (refs=%d)", 
+              trace_flag->name(), this, weak_refs, weak_refs - 1, strong_refs); 
+    } 
+    GPR_ASSERT(weak_refs > 0); 
+#endif 
+    if (GPR_UNLIKELY(prev_ref_pair == MakeRefPair(0, 1))) { 
+      delete static_cast<Child*>(this); 
+    } 
+  } 
+  void WeakUnref(const DebugLocation& location, const char* reason) { 
+#ifndef NDEBUG 
+    // Grab a copy of the trace flag before the atomic change, since we 
+    // can't safely access it afterwards if we're going to be freed. 
+    auto* trace_flag = trace_flag_; 
+#endif 
+    const uint64_t prev_ref_pair = 
+        refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL); 
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair); 
+#ifndef NDEBUG 
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair); 
+    if (trace_flag != nullptr && trace_flag->enabled()) { 
+      gpr_log(GPR_INFO, "%s:%p %s:%d weak_unref %d -> %d (refs=%d) %s", 
+              trace_flag->name(), this, location.file(), location.line(), 
+              weak_refs, weak_refs - 1, strong_refs, reason); 
+    } 
+    GPR_ASSERT(weak_refs > 0); 
+#else 
+    // Avoid unused-parameter warnings for debug-only parameters 
+    (void)location; 
+    (void)reason; 
+#endif 
+    if (GPR_UNLIKELY(prev_ref_pair == MakeRefPair(0, 1))) { 
+      delete static_cast<Child*>(this); 
+    } 
+  } 
+ 
+  // Not copyable nor movable. 
+  DualRefCounted(const DualRefCounted&) = delete; 
+  DualRefCounted& operator=(const DualRefCounted&) = delete; 
+ 
+ protected: 
+  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag. 
+  // Note: RefCount tracing is only enabled on debug builds, even when a 
+  //       TraceFlag is used. 
+  template <typename TraceFlagT = TraceFlag> 
+  explicit DualRefCounted( 
+      TraceFlagT* 
+#ifndef NDEBUG 
+          // Leave unnamed if NDEBUG to avoid unused parameter warning 
+          trace_flag 
+#endif 
+      = nullptr, 
+      int32_t initial_refcount = 1) 
+      : 
+#ifndef NDEBUG 
+        trace_flag_(trace_flag), 
+#endif 
+        refs_(MakeRefPair(initial_refcount, 0)) { 
+  } 
+ 
+ private: 
+  // Allow RefCountedPtr<> to access IncrementRefCount(). 
+  template <typename T> 
+  friend class RefCountedPtr; 
+  // Allow WeakRefCountedPtr<> to access IncrementWeakRefCount(). 
+  template <typename T> 
+  friend class WeakRefCountedPtr; 
+ 
+  // First 32 bits are strong refs, next 32 bits are weak refs. 
+  static uint64_t MakeRefPair(uint32_t strong, uint32_t weak) { 
+    return (static_cast<uint64_t>(strong) << 32) + static_cast<int64_t>(weak); 
+  } 
+  static uint32_t GetStrongRefs(uint64_t ref_pair) { 
+    return static_cast<uint32_t>(ref_pair >> 32); 
+  } 
+  static uint32_t GetWeakRefs(uint64_t ref_pair) { 
+    return static_cast<uint32_t>(ref_pair & 0xffffffffu); 
+  } 
+ 
+  void IncrementRefCount() { 
+#ifndef NDEBUG 
+    const uint64_t prev_ref_pair = 
+        refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED); 
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair); 
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair); 
+    GPR_ASSERT(strong_refs != 0); 
+    if (trace_flag_ != nullptr && trace_flag_->enabled()) { 
+      gpr_log(GPR_INFO, "%s:%p ref %d -> %d; (weak_refs=%d)", 
+              trace_flag_->name(), this, strong_refs, strong_refs + 1, 
+              weak_refs); 
+    } 
+#else 
+    refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED); 
+#endif 
+  } 
+  void IncrementRefCount(const DebugLocation& location, const char* reason) { 
+#ifndef NDEBUG 
+    const uint64_t prev_ref_pair = 
+        refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED); 
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair); 
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair); 
+    GPR_ASSERT(strong_refs != 0); 
+    if (trace_flag_ != nullptr && trace_flag_->enabled()) { 
+      gpr_log(GPR_INFO, "%s:%p %s:%d ref %d -> %d (weak_refs=%d) %s", 
+              trace_flag_->name(), this, location.file(), location.line(), 
+              strong_refs, strong_refs + 1, weak_refs, reason); 
+    } 
+#else 
+    // Use conditionally-important parameters 
+    (void)location; 
+    (void)reason; 
+    refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED); 
+#endif 
+  } 
+ 
+  void IncrementWeakRefCount() { 
+#ifndef NDEBUG 
+    const uint64_t prev_ref_pair = 
+        refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED); 
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair); 
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair); 
+    if (trace_flag_ != nullptr && trace_flag_->enabled()) { 
+      gpr_log(GPR_INFO, "%s:%p weak_ref %d -> %d; (refs=%d)", 
+              trace_flag_->name(), this, weak_refs, weak_refs + 1, strong_refs); 
+    } 
+#else 
+    refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED); 
+#endif 
+  } 
+  void IncrementWeakRefCount(const DebugLocation& location, 
+                             const char* reason) { 
+#ifndef NDEBUG 
+    const uint64_t prev_ref_pair = 
+        refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED); 
+    const uint32_t strong_refs = GetStrongRefs(prev_ref_pair); 
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair); 
+    if (trace_flag_ != nullptr && trace_flag_->enabled()) { 
+      gpr_log(GPR_INFO, "%s:%p %s:%d weak_ref %d -> %d (refs=%d) %s", 
+              trace_flag_->name(), this, location.file(), location.line(), 
+              weak_refs, weak_refs + 1, strong_refs, reason); 
+    } 
+#else 
+    // Use conditionally-important parameters 
+    (void)location; 
+    (void)reason; 
+    refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED); 
+#endif 
+  } 
+ 
+#ifndef NDEBUG 
+  TraceFlag* trace_flag_; 
+#endif 
+  Atomic<uint64_t> refs_; 
+}; 
+ 
+}  // namespace grpc_core 
+ 
+#endif /* GRPC_CORE_LIB_GPRPP_DUAL_REF_COUNTED_H */ 
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/fork.cc b/contrib/libs/grpc/src/core/lib/gprpp/fork.cc
index 51d1c80e67..cbee829806 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/fork.cc
+++ b/contrib/libs/grpc/src/core/lib/gprpp/fork.cc
@@ -164,7 +164,7 @@ class ThreadState {
   int count_;
 };
 
-}  // namespace internal
+}  // namespace internal 
 
 void Fork::GlobalInit() {
   if (!override_enabled_) {
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/global_config_env.cc b/contrib/libs/grpc/src/core/lib/gprpp/global_config_env.cc
index 72e3760661..f8f27b7bd0 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/global_config_env.cc
+++ b/contrib/libs/grpc/src/core/lib/gprpp/global_config_env.cc
@@ -30,10 +30,10 @@
 #include <ctype.h>
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_format.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_format.h" 
+ 
 namespace grpc_core {
 
 namespace {
@@ -46,10 +46,10 @@ GlobalConfigEnvErrorFunctionType g_global_config_env_error_func =
     DefaultGlobalConfigEnvErrorFunction;
 
 void LogParsingError(const char* name, const char* value) {
-  TString error_message = y_absl::StrFormat(
-      "Illegal value '%s' specified for environment variable '%s'", value,
-      name);
-  (*g_global_config_env_error_func)(error_message.c_str());
+  TString error_message = y_absl::StrFormat( 
+      "Illegal value '%s' specified for environment variable '%s'", value, 
+      name); 
+  (*g_global_config_env_error_func)(error_message.c_str()); 
 }
 
 }  // namespace
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/host_port.cc b/contrib/libs/grpc/src/core/lib/gprpp/host_port.cc
index e9db87f938..9355a71abf 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/host_port.cc
+++ b/contrib/libs/grpc/src/core/lib/gprpp/host_port.cc
@@ -20,36 +20,36 @@
 
 #include "src/core/lib/gprpp/host_port.h"
 
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/string_view.h"
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/string_view.h" 
 
 #include <grpc/support/log.h>
 
-namespace grpc_core {
+namespace grpc_core { 
 
-TString JoinHostPort(y_absl::string_view host, int port) {
-  if (!host.empty() && host[0] != '[' && host.rfind(':') != host.npos) {
-    // IPv6 literals must be enclosed in brackets.
-    return y_absl::StrFormat("[%s]:%d", host, port);
+TString JoinHostPort(y_absl::string_view host, int port) { 
+  if (!host.empty() && host[0] != '[' && host.rfind(':') != host.npos) { 
+    // IPv6 literals must be enclosed in brackets. 
+    return y_absl::StrFormat("[%s]:%d", host, port); 
   }
-  // Ordinary non-bracketed host:port.
-  return y_absl::StrFormat("%s:%d", host, port);
+  // Ordinary non-bracketed host:port. 
+  return y_absl::StrFormat("%s:%d", host, port); 
 }
 
 namespace {
-bool DoSplitHostPort(y_absl::string_view name, y_absl::string_view* host,
-                     y_absl::string_view* port, bool* has_port) {
+bool DoSplitHostPort(y_absl::string_view name, y_absl::string_view* host, 
+                     y_absl::string_view* port, bool* has_port) { 
   *has_port = false;
-  if (!name.empty() && name[0] == '[') {
+  if (!name.empty() && name[0] == '[') { 
     /* Parse a bracketed host, typically an IPv6 literal. */
     const size_t rbracket = name.find(']', 1);
-    if (rbracket == y_absl::string_view::npos) {
+    if (rbracket == y_absl::string_view::npos) { 
       /* Unmatched [ */
       return false;
     }
     if (rbracket == name.size() - 1) {
       /* ]<end> */
-      *port = y_absl::string_view();
+      *port = y_absl::string_view(); 
     } else if (name[rbracket + 1] == ':') {
       /* ]:<port?> */
       *port = name.substr(rbracket + 2, name.size() - rbracket - 2);
@@ -59,16 +59,16 @@ bool DoSplitHostPort(y_absl::string_view name, y_absl::string_view* host,
       return false;
     }
     *host = name.substr(1, rbracket - 1);
-    if (host->find(':') == y_absl::string_view::npos) {
+    if (host->find(':') == y_absl::string_view::npos) { 
       /* Require all bracketed hosts to contain a colon, because a hostname or
          IPv4 address should never use brackets. */
-      *host = y_absl::string_view();
+      *host = y_absl::string_view(); 
       return false;
     }
   } else {
     size_t colon = name.find(':');
-    if (colon != y_absl::string_view::npos &&
-        name.find(':', colon + 1) == y_absl::string_view::npos) {
+    if (colon != y_absl::string_view::npos && 
+        name.find(':', colon + 1) == y_absl::string_view::npos) { 
       /* Exactly 1 colon.  Split into host:port. */
       *host = name.substr(0, colon);
       *port = name.substr(colon + 1, name.size() - colon - 1);
@@ -76,37 +76,37 @@ bool DoSplitHostPort(y_absl::string_view name, y_absl::string_view* host,
     } else {
       /* 0 or 2+ colons.  Bare hostname or IPv6 litearal. */
       *host = name;
-      *port = y_absl::string_view();
+      *port = y_absl::string_view(); 
     }
   }
   return true;
 }
 }  // namespace
 
-bool SplitHostPort(y_absl::string_view name, y_absl::string_view* host,
-                   y_absl::string_view* port) {
+bool SplitHostPort(y_absl::string_view name, y_absl::string_view* host, 
+                   y_absl::string_view* port) { 
   bool unused;
   return DoSplitHostPort(name, host, port, &unused);
 }
 
-bool SplitHostPort(y_absl::string_view name, TString* host,
-                   TString* port) {
-  GPR_DEBUG_ASSERT(host != nullptr && host->empty());
-  GPR_DEBUG_ASSERT(port != nullptr && port->empty());
-  y_absl::string_view host_view;
-  y_absl::string_view port_view;
+bool SplitHostPort(y_absl::string_view name, TString* host, 
+                   TString* port) { 
+  GPR_DEBUG_ASSERT(host != nullptr && host->empty()); 
+  GPR_DEBUG_ASSERT(port != nullptr && port->empty()); 
+  y_absl::string_view host_view; 
+  y_absl::string_view port_view; 
   bool has_port;
   const bool ret = DoSplitHostPort(name, &host_view, &port_view, &has_port);
   if (ret) {
     // We always set the host, but port is set only when DoSplitHostPort find a
     // port in the string, to remain backward compatible with the old
     // gpr_split_host_port API.
-    *host = TString(host_view);
+    *host = TString(host_view); 
     if (has_port) {
-      *port = TString(port_view);
+      *port = TString(port_view); 
     }
   }
   return ret;
 }
-
+ 
 }  // namespace grpc_core
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/host_port.h b/contrib/libs/grpc/src/core/lib/gprpp/host_port.h
index 4591b85817..3f42cc7482 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/host_port.h
+++ b/contrib/libs/grpc/src/core/lib/gprpp/host_port.h
@@ -21,24 +21,24 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/string_view.h"
+#include <util/generic/string.h> 
 
+#include "y_absl/strings/string_view.h" 
+ 
 namespace grpc_core {
 
-// Given a host and port, creates a newly-allocated string of the form
-// "host:port" or "[ho:st]:port", depending on whether the host contains colons
-// like an IPv6 literal.  If the host is already bracketed, then additional
-// brackets will not be added.
-TString JoinHostPort(y_absl::string_view host, int port);
+// Given a host and port, creates a newly-allocated string of the form 
+// "host:port" or "[ho:st]:port", depending on whether the host contains colons 
+// like an IPv6 literal.  If the host is already bracketed, then additional 
+// brackets will not be added. 
+TString JoinHostPort(y_absl::string_view host, int port); 
 
 /** Given a name in the form "host:port" or "[ho:st]:port", split into hostname
    and port number.
 
    There are two variants of this method:
-   1) y_absl::string_view output: port and host are returned as views on name.
-   2) TString output: port and host are copied into newly allocated strings.
+   1) y_absl::string_view output: port and host are returned as views on name. 
+   2) TString output: port and host are copied into newly allocated strings. 
 
    Prefer variant (1) over (2), because no allocation or copy is performed in
    variant (1).  Use (2) only when interacting with C API that mandate
@@ -46,10 +46,10 @@ TString JoinHostPort(y_absl::string_view host, int port);
 
    Return true on success, false on failure. Guarantees *host and *port are
    cleared on failure. */
-bool SplitHostPort(y_absl::string_view name, y_absl::string_view* host,
-                   y_absl::string_view* port);
-bool SplitHostPort(y_absl::string_view name, TString* host,
-                   TString* port);
+bool SplitHostPort(y_absl::string_view name, y_absl::string_view* host, 
+                   y_absl::string_view* port); 
+bool SplitHostPort(y_absl::string_view name, TString* host, 
+                   TString* port); 
 
 }  // namespace grpc_core
 
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/map.h b/contrib/libs/grpc/src/core/lib/gprpp/map.h
index 741b0b1ed5..08124843a3 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/map.h
+++ b/contrib/libs/grpc/src/core/lib/gprpp/map.h
@@ -25,10 +25,10 @@
 
 #include <map>
 
-#include "y_absl/strings/string_view.h"
-
-#include "src/core/lib/gprpp/memory.h"
+#include "y_absl/strings/string_view.h" 
 
+#include "src/core/lib/gprpp/memory.h" 
+ 
 namespace grpc_core {
 
 struct StringLess {
@@ -39,8 +39,8 @@ struct StringLess {
                   const grpc_core::UniquePtr<char>& b) const {
     return strcmp(a.get(), b.get()) < 0;
   }
-  bool operator()(const y_absl::string_view& a,
-                  const y_absl::string_view& b) const {
+  bool operator()(const y_absl::string_view& a, 
+                  const y_absl::string_view& b) const { 
     const size_t min_size = std::min(a.size(), b.size());
     int c = strncmp(a.data(), b.data(), min_size);
     if (c != 0) return c < 0;
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/memory.h b/contrib/libs/grpc/src/core/lib/gprpp/memory.h
index becf273510..d16cbb9588 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/memory.h
+++ b/contrib/libs/grpc/src/core/lib/gprpp/memory.h
@@ -28,8 +28,8 @@
 #include <memory>
 #include <utility>
 
-#include "y_absl/memory/memory.h"
-
+#include "y_absl/memory/memory.h" 
+ 
 namespace grpc_core {
 
 class DefaultDeleteChar {
@@ -41,7 +41,7 @@ class DefaultDeleteChar {
 };
 
 // UniquePtr<T> is only allowed for char and UniquePtr<char> is deprecated
-// in favor of TString. UniquePtr<char> is equivalent std::unique_ptr
+// in favor of TString. UniquePtr<char> is equivalent std::unique_ptr 
 // except that it uses gpr_free for deleter.
 template <typename T>
 using UniquePtr = std::unique_ptr<T, DefaultDeleteChar>;
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/ref_counted.h b/contrib/libs/grpc/src/core/lib/gprpp/ref_counted.h
index d05ff6e44c..10306648db 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/ref_counted.h
+++ b/contrib/libs/grpc/src/core/lib/gprpp/ref_counted.h
@@ -204,46 +204,46 @@ class RefCount {
   Atomic<Value> value_;
 };
 
-// PolymorphicRefCount enforces polymorphic destruction of RefCounted.
-class PolymorphicRefCount {
- public:
-  virtual ~PolymorphicRefCount() = default;
-};
-
-// NonPolymorphicRefCount does not enforce polymorphic destruction of
-// RefCounted. Please refer to grpc_core::RefCounted for more details, and
-// when in doubt use PolymorphicRefCount.
-class NonPolymorphicRefCount {
- public:
-  ~NonPolymorphicRefCount() = default;
-};
-
-namespace internal {
-template <typename T, bool DoDelete>
-class Delete;
-template <typename T>
-class Delete<T, true> {
- public:
-  Delete(T* t) { delete t; }
-};
-template <typename T>
-class Delete<T, false> {
- public:
-  Delete(T* /*t*/) {}
-};
-}  // namespace internal
-
+// PolymorphicRefCount enforces polymorphic destruction of RefCounted. 
+class PolymorphicRefCount { 
+ public: 
+  virtual ~PolymorphicRefCount() = default; 
+}; 
+ 
+// NonPolymorphicRefCount does not enforce polymorphic destruction of 
+// RefCounted. Please refer to grpc_core::RefCounted for more details, and 
+// when in doubt use PolymorphicRefCount. 
+class NonPolymorphicRefCount { 
+ public: 
+  ~NonPolymorphicRefCount() = default; 
+}; 
+ 
+namespace internal { 
+template <typename T, bool DoDelete> 
+class Delete; 
+template <typename T> 
+class Delete<T, true> { 
+ public: 
+  Delete(T* t) { delete t; } 
+}; 
+template <typename T> 
+class Delete<T, false> { 
+ public: 
+  Delete(T* /*t*/) {} 
+}; 
+}  // namespace internal 
+ 
 // A base class for reference-counted objects.
-// New objects should be created via new and start with a refcount of 1.
-// When the refcount reaches 0, the object will be deleted via delete.
-//
-// If DeleteUponUnref is false, deletion will not occur when the ref
-// count reaches 0.  This is useful in cases where all existing objects
-// must be tracked in a registry but the object's entry in the registry
-// cannot be removed from the object's dtor due to synchronization issues.
-// In this case, the registry can be cleaned up later by identifying
-// entries for which RefIfNonZero() returns null.
+// New objects should be created via new and start with a refcount of 1. 
+// When the refcount reaches 0, the object will be deleted via delete. 
 //
+// If DeleteUponUnref is false, deletion will not occur when the ref 
+// count reaches 0.  This is useful in cases where all existing objects 
+// must be tracked in a registry but the object's entry in the registry 
+// cannot be removed from the object's dtor due to synchronization issues. 
+// In this case, the registry can be cleaned up later by identifying 
+// entries for which RefIfNonZero() returns null. 
+// 
 // This will commonly be used by CRTP (curiously-recurring template pattern)
 // e.g., class MyClass : public RefCounted<MyClass>
 //
@@ -266,8 +266,8 @@ class Delete<T, false> {
 //    Child* ch;
 //    ch->Unref();
 //
-template <typename Child, typename Impl = PolymorphicRefCount,
-          bool DeleteUponUnref = true>
+template <typename Child, typename Impl = PolymorphicRefCount, 
+          bool DeleteUponUnref = true> 
 class RefCounted : public Impl {
  public:
   // Note: Depending on the Impl used, this dtor can be implicitly virtual.
@@ -290,25 +290,25 @@ class RefCounted : public Impl {
   // friend of this class.
   void Unref() {
     if (GPR_UNLIKELY(refs_.Unref())) {
-      internal::Delete<Child, DeleteUponUnref>(static_cast<Child*>(this));
+      internal::Delete<Child, DeleteUponUnref>(static_cast<Child*>(this)); 
     }
   }
   void Unref(const DebugLocation& location, const char* reason) {
     if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      internal::Delete<Child, DeleteUponUnref>(static_cast<Child*>(this));
+      internal::Delete<Child, DeleteUponUnref>(static_cast<Child*>(this)); 
     }
   }
 
-  RefCountedPtr<Child> RefIfNonZero() GRPC_MUST_USE_RESULT {
-    return RefCountedPtr<Child>(refs_.RefIfNonZero() ? static_cast<Child*>(this)
-                                                     : nullptr);
-  }
-  RefCountedPtr<Child> RefIfNonZero(const DebugLocation& location,
-                                    const char* reason) GRPC_MUST_USE_RESULT {
-    return RefCountedPtr<Child>(refs_.RefIfNonZero(location, reason)
-                                    ? static_cast<Child*>(this)
-                                    : nullptr);
+  RefCountedPtr<Child> RefIfNonZero() GRPC_MUST_USE_RESULT { 
+    return RefCountedPtr<Child>(refs_.RefIfNonZero() ? static_cast<Child*>(this) 
+                                                     : nullptr); 
   }
+  RefCountedPtr<Child> RefIfNonZero(const DebugLocation& location, 
+                                    const char* reason) GRPC_MUST_USE_RESULT { 
+    return RefCountedPtr<Child>(refs_.RefIfNonZero(location, reason) 
+                                    ? static_cast<Child*>(this) 
+                                    : nullptr); 
+  } 
 
   // Not copyable nor movable.
   RefCounted(const RefCounted&) = delete;
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/ref_counted_ptr.h b/contrib/libs/grpc/src/core/lib/gprpp/ref_counted_ptr.h
index c28e762532..f178d393b1 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/ref_counted_ptr.h
+++ b/contrib/libs/grpc/src/core/lib/gprpp/ref_counted_ptr.h
@@ -177,169 +177,169 @@ class RefCountedPtr {
   T* value_ = nullptr;
 };
 
-// A smart pointer class for objects that provide IncrementWeakRefCount() and
-// WeakUnref() methods, such as those provided by the DualRefCounted base class.
-template <typename T>
-class WeakRefCountedPtr {
- public:
-  WeakRefCountedPtr() {}
-  WeakRefCountedPtr(std::nullptr_t) {}
-
-  // If value is non-null, we take ownership of a ref to it.
-  template <typename Y>
-  explicit WeakRefCountedPtr(Y* value) {
-    value_ = value;
-  }
-
-  // Move ctors.
-  WeakRefCountedPtr(WeakRefCountedPtr&& other) {
-    value_ = other.value_;
-    other.value_ = nullptr;
-  }
-  template <typename Y>
-  WeakRefCountedPtr(WeakRefCountedPtr<Y>&& other) {
-    value_ = static_cast<T*>(other.value_);
-    other.value_ = nullptr;
-  }
-
-  // Move assignment.
-  WeakRefCountedPtr& operator=(WeakRefCountedPtr&& other) {
-    reset(other.value_);
-    other.value_ = nullptr;
-    return *this;
-  }
-  template <typename Y>
-  WeakRefCountedPtr& operator=(WeakRefCountedPtr<Y>&& other) {
-    reset(other.value_);
-    other.value_ = nullptr;
-    return *this;
-  }
-
-  // Copy ctors.
-  WeakRefCountedPtr(const WeakRefCountedPtr& other) {
-    if (other.value_ != nullptr) other.value_->IncrementWeakRefCount();
-    value_ = other.value_;
-  }
-  template <typename Y>
-  WeakRefCountedPtr(const WeakRefCountedPtr<Y>& other) {
-    static_assert(std::has_virtual_destructor<T>::value,
-                  "T does not have a virtual dtor");
-    if (other.value_ != nullptr) other.value_->IncrementWeakRefCount();
-    value_ = static_cast<T*>(other.value_);
-  }
-
-  // Copy assignment.
-  WeakRefCountedPtr& operator=(const WeakRefCountedPtr& other) {
-    // Note: Order of reffing and unreffing is important here in case value_
-    // and other.value_ are the same object.
-    if (other.value_ != nullptr) other.value_->IncrementWeakRefCount();
-    reset(other.value_);
-    return *this;
-  }
-  template <typename Y>
-  WeakRefCountedPtr& operator=(const WeakRefCountedPtr<Y>& other) {
-    static_assert(std::has_virtual_destructor<T>::value,
-                  "T does not have a virtual dtor");
-    // Note: Order of reffing and unreffing is important here in case value_
-    // and other.value_ are the same object.
-    if (other.value_ != nullptr) other.value_->IncrementWeakRefCount();
-    reset(other.value_);
-    return *this;
-  }
-
-  ~WeakRefCountedPtr() {
-    if (value_ != nullptr) value_->WeakUnref();
-  }
-
-  void swap(WeakRefCountedPtr& other) { std::swap(value_, other.value_); }
-
-  // If value is non-null, we take ownership of a ref to it.
-  void reset(T* value = nullptr) {
-    if (value_ != nullptr) value_->WeakUnref();
-    value_ = value;
-  }
-  void reset(const DebugLocation& location, const char* reason,
-             T* value = nullptr) {
-    if (value_ != nullptr) value_->WeakUnref(location, reason);
-    value_ = value;
-  }
-  template <typename Y>
-  void reset(Y* value = nullptr) {
-    static_assert(std::has_virtual_destructor<T>::value,
-                  "T does not have a virtual dtor");
-    if (value_ != nullptr) value_->WeakUnref();
-    value_ = static_cast<T*>(value);
-  }
-  template <typename Y>
-  void reset(const DebugLocation& location, const char* reason,
-             Y* value = nullptr) {
-    static_assert(std::has_virtual_destructor<T>::value,
-                  "T does not have a virtual dtor");
-    if (value_ != nullptr) value_->WeakUnref(location, reason);
-    value_ = static_cast<T*>(value);
-  }
-
-  // TODO(roth): This method exists solely as a transition mechanism to allow
-  // us to pass a ref to idiomatic C code that does not use WeakRefCountedPtr<>.
-  // Once all of our code has been converted to idiomatic C++, this
-  // method should go away.
-  T* release() {
-    T* value = value_;
-    value_ = nullptr;
-    return value;
-  }
-
-  T* get() const { return value_; }
-
-  T& operator*() const { return *value_; }
-  T* operator->() const { return value_; }
-
-  template <typename Y>
-  bool operator==(const WeakRefCountedPtr<Y>& other) const {
-    return value_ == other.value_;
-  }
-
-  template <typename Y>
-  bool operator==(const Y* other) const {
-    return value_ == other;
-  }
-
-  bool operator==(std::nullptr_t) const { return value_ == nullptr; }
-
-  template <typename Y>
-  bool operator!=(const WeakRefCountedPtr<Y>& other) const {
-    return value_ != other.value_;
-  }
-
-  template <typename Y>
-  bool operator!=(const Y* other) const {
-    return value_ != other;
-  }
-
-  bool operator!=(std::nullptr_t) const { return value_ != nullptr; }
-
- private:
-  template <typename Y>
-  friend class WeakRefCountedPtr;
-
-  T* value_ = nullptr;
-};
-
+// A smart pointer class for objects that provide IncrementWeakRefCount() and 
+// WeakUnref() methods, such as those provided by the DualRefCounted base class. 
+template <typename T> 
+class WeakRefCountedPtr { 
+ public: 
+  WeakRefCountedPtr() {} 
+  WeakRefCountedPtr(std::nullptr_t) {} 
+ 
+  // If value is non-null, we take ownership of a ref to it. 
+  template <typename Y> 
+  explicit WeakRefCountedPtr(Y* value) { 
+    value_ = value; 
+  } 
+ 
+  // Move ctors. 
+  WeakRefCountedPtr(WeakRefCountedPtr&& other) { 
+    value_ = other.value_; 
+    other.value_ = nullptr; 
+  } 
+  template <typename Y> 
+  WeakRefCountedPtr(WeakRefCountedPtr<Y>&& other) { 
+    value_ = static_cast<T*>(other.value_); 
+    other.value_ = nullptr; 
+  } 
+ 
+  // Move assignment. 
+  WeakRefCountedPtr& operator=(WeakRefCountedPtr&& other) { 
+    reset(other.value_); 
+    other.value_ = nullptr; 
+    return *this; 
+  } 
+  template <typename Y> 
+  WeakRefCountedPtr& operator=(WeakRefCountedPtr<Y>&& other) { 
+    reset(other.value_); 
+    other.value_ = nullptr; 
+    return *this; 
+  } 
+ 
+  // Copy ctors. 
+  WeakRefCountedPtr(const WeakRefCountedPtr& other) { 
+    if (other.value_ != nullptr) other.value_->IncrementWeakRefCount(); 
+    value_ = other.value_; 
+  } 
+  template <typename Y> 
+  WeakRefCountedPtr(const WeakRefCountedPtr<Y>& other) { 
+    static_assert(std::has_virtual_destructor<T>::value, 
+                  "T does not have a virtual dtor"); 
+    if (other.value_ != nullptr) other.value_->IncrementWeakRefCount(); 
+    value_ = static_cast<T*>(other.value_); 
+  } 
+ 
+  // Copy assignment. 
+  WeakRefCountedPtr& operator=(const WeakRefCountedPtr& other) { 
+    // Note: Order of reffing and unreffing is important here in case value_ 
+    // and other.value_ are the same object. 
+    if (other.value_ != nullptr) other.value_->IncrementWeakRefCount(); 
+    reset(other.value_); 
+    return *this; 
+  } 
+  template <typename Y> 
+  WeakRefCountedPtr& operator=(const WeakRefCountedPtr<Y>& other) { 
+    static_assert(std::has_virtual_destructor<T>::value, 
+                  "T does not have a virtual dtor"); 
+    // Note: Order of reffing and unreffing is important here in case value_ 
+    // and other.value_ are the same object. 
+    if (other.value_ != nullptr) other.value_->IncrementWeakRefCount(); 
+    reset(other.value_); 
+    return *this; 
+  } 
+ 
+  ~WeakRefCountedPtr() { 
+    if (value_ != nullptr) value_->WeakUnref(); 
+  } 
+ 
+  void swap(WeakRefCountedPtr& other) { std::swap(value_, other.value_); } 
+ 
+  // If value is non-null, we take ownership of a ref to it. 
+  void reset(T* value = nullptr) { 
+    if (value_ != nullptr) value_->WeakUnref(); 
+    value_ = value; 
+  } 
+  void reset(const DebugLocation& location, const char* reason, 
+             T* value = nullptr) { 
+    if (value_ != nullptr) value_->WeakUnref(location, reason); 
+    value_ = value; 
+  } 
+  template <typename Y> 
+  void reset(Y* value = nullptr) { 
+    static_assert(std::has_virtual_destructor<T>::value, 
+                  "T does not have a virtual dtor"); 
+    if (value_ != nullptr) value_->WeakUnref(); 
+    value_ = static_cast<T*>(value); 
+  } 
+  template <typename Y> 
+  void reset(const DebugLocation& location, const char* reason, 
+             Y* value = nullptr) { 
+    static_assert(std::has_virtual_destructor<T>::value, 
+                  "T does not have a virtual dtor"); 
+    if (value_ != nullptr) value_->WeakUnref(location, reason); 
+    value_ = static_cast<T*>(value); 
+  } 
+ 
+  // TODO(roth): This method exists solely as a transition mechanism to allow 
+  // us to pass a ref to idiomatic C code that does not use WeakRefCountedPtr<>. 
+  // Once all of our code has been converted to idiomatic C++, this 
+  // method should go away. 
+  T* release() { 
+    T* value = value_; 
+    value_ = nullptr; 
+    return value; 
+  } 
+ 
+  T* get() const { return value_; } 
+ 
+  T& operator*() const { return *value_; } 
+  T* operator->() const { return value_; } 
+ 
+  template <typename Y> 
+  bool operator==(const WeakRefCountedPtr<Y>& other) const { 
+    return value_ == other.value_; 
+  } 
+ 
+  template <typename Y> 
+  bool operator==(const Y* other) const { 
+    return value_ == other; 
+  } 
+ 
+  bool operator==(std::nullptr_t) const { return value_ == nullptr; } 
+ 
+  template <typename Y> 
+  bool operator!=(const WeakRefCountedPtr<Y>& other) const { 
+    return value_ != other.value_; 
+  } 
+ 
+  template <typename Y> 
+  bool operator!=(const Y* other) const { 
+    return value_ != other; 
+  } 
+ 
+  bool operator!=(std::nullptr_t) const { return value_ != nullptr; } 
+ 
+ private: 
+  template <typename Y> 
+  friend class WeakRefCountedPtr; 
+ 
+  T* value_ = nullptr; 
+}; 
+ 
 template <typename T, typename... Args>
 inline RefCountedPtr<T> MakeRefCounted(Args&&... args) {
   return RefCountedPtr<T>(new T(std::forward<Args>(args)...));
 }
 
-template <typename T>
-bool operator<(const RefCountedPtr<T>& p1, const RefCountedPtr<T>& p2) {
-  return p1.get() < p2.get();
-}
-
-template <typename T>
-bool operator<(const WeakRefCountedPtr<T>& p1, const WeakRefCountedPtr<T>& p2) {
-  return p1.get() < p2.get();
-}
-
+template <typename T> 
+bool operator<(const RefCountedPtr<T>& p1, const RefCountedPtr<T>& p2) { 
+  return p1.get() < p2.get(); 
+} 
+ 
+template <typename T> 
+bool operator<(const WeakRefCountedPtr<T>& p1, const WeakRefCountedPtr<T>& p2) { 
+  return p1.get() < p2.get(); 
+} 
+ 
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_REF_COUNTED_PTR_H */
diff --git a/contrib/libs/grpc/src/core/lib/gprpp/sync.h b/contrib/libs/grpc/src/core/lib/gprpp/sync.h
index 0a911b1cd2..bca408a582 100644
--- a/contrib/libs/grpc/src/core/lib/gprpp/sync.h
+++ b/contrib/libs/grpc/src/core/lib/gprpp/sync.h
@@ -117,15 +117,15 @@ class CondVar {
     }
   }
 
-  // Returns true iff we timed-out
-  template <typename Predicate>
-  bool WaitUntil(Mutex* mu, Predicate pred, const gpr_timespec& deadline) {
-    while (!pred()) {
-      if (Wait(mu, deadline)) return true;
-    }
-    return false;
-  }
-
+  // Returns true iff we timed-out 
+  template <typename Predicate> 
+  bool WaitUntil(Mutex* mu, Predicate pred, const gpr_timespec& deadline) { 
+    while (!pred()) { 
+      if (Wait(mu, deadline)) return true; 
+    } 
+    return false; 
+  } 
+ 
  private:
   gpr_cv cv_;
 };
diff --git a/contrib/libs/grpc/src/core/lib/http/format_request.cc b/contrib/libs/grpc/src/core/lib/http/format_request.cc
index d9294324bd..3dface847e 100644
--- a/contrib/libs/grpc/src/core/lib/http/format_request.cc
+++ b/contrib/libs/grpc/src/core/lib/http/format_request.cc
@@ -24,80 +24,80 @@
 #include <stdio.h>
 #include <string.h>
 
-#include <vector>
-
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/str_join.h"
-
+#include <vector> 
+ 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/str_join.h" 
+ 
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 #include "src/core/lib/gpr/string.h"
 
 static void fill_common_header(const grpc_httpcli_request* request,
-                               bool connection_close,
-                               std::vector<TString>* buf) {
-  buf->push_back(request->http.path);
-  buf->push_back(" HTTP/1.0\r\n");
+                               bool connection_close, 
+                               std::vector<TString>* buf) { 
+  buf->push_back(request->http.path); 
+  buf->push_back(" HTTP/1.0\r\n"); 
   /* just in case some crazy server really expects HTTP/1.1 */
-  buf->push_back("Host: ");
-  buf->push_back(request->host);
-  buf->push_back("\r\n");
-  if (connection_close) buf->push_back("Connection: close\r\n");
-  buf->push_back("User-Agent: " GRPC_HTTPCLI_USER_AGENT "\r\n");
+  buf->push_back("Host: "); 
+  buf->push_back(request->host); 
+  buf->push_back("\r\n"); 
+  if (connection_close) buf->push_back("Connection: close\r\n"); 
+  buf->push_back("User-Agent: " GRPC_HTTPCLI_USER_AGENT "\r\n"); 
   /* user supplied headers */
-  for (size_t i = 0; i < request->http.hdr_count; i++) {
-    buf->push_back(request->http.hdrs[i].key);
-    buf->push_back(": ");
-    buf->push_back(request->http.hdrs[i].value);
-    buf->push_back("\r\n");
+  for (size_t i = 0; i < request->http.hdr_count; i++) { 
+    buf->push_back(request->http.hdrs[i].key); 
+    buf->push_back(": "); 
+    buf->push_back(request->http.hdrs[i].value); 
+    buf->push_back("\r\n"); 
   }
 }
 
 grpc_slice grpc_httpcli_format_get_request(
     const grpc_httpcli_request* request) {
-  std::vector<TString> out;
-  out.push_back("GET ");
-  fill_common_header(request, true, &out);
-  out.push_back("\r\n");
-  TString req = y_absl::StrJoin(out, "");
-  return grpc_slice_from_copied_buffer(req.data(), req.size());
+  std::vector<TString> out; 
+  out.push_back("GET "); 
+  fill_common_header(request, true, &out); 
+  out.push_back("\r\n"); 
+  TString req = y_absl::StrJoin(out, ""); 
+  return grpc_slice_from_copied_buffer(req.data(), req.size()); 
 }
 
 grpc_slice grpc_httpcli_format_post_request(const grpc_httpcli_request* request,
                                             const char* body_bytes,
                                             size_t body_size) {
-  std::vector<TString> out;
-  out.push_back("POST ");
-  fill_common_header(request, true, &out);
-  if (body_bytes != nullptr) {
-    bool has_content_type = false;
-    for (size_t i = 0; i < request->http.hdr_count; i++) {
+  std::vector<TString> out; 
+  out.push_back("POST "); 
+  fill_common_header(request, true, &out); 
+  if (body_bytes != nullptr) { 
+    bool has_content_type = false; 
+    for (size_t i = 0; i < request->http.hdr_count; i++) { 
       if (strcmp(request->http.hdrs[i].key, "Content-Type") == 0) {
-        has_content_type = true;
+        has_content_type = true; 
         break;
       }
     }
     if (!has_content_type) {
-      out.push_back("Content-Type: text/plain\r\n");
+      out.push_back("Content-Type: text/plain\r\n"); 
     }
-    out.push_back(y_absl::StrFormat("Content-Length: %lu\r\n",
-                                  static_cast<unsigned long>(body_size)));
+    out.push_back(y_absl::StrFormat("Content-Length: %lu\r\n", 
+                                  static_cast<unsigned long>(body_size))); 
   }
-  out.push_back("\r\n");
-  TString req = y_absl::StrJoin(out, "");
-  if (body_bytes != nullptr) {
-    y_absl::StrAppend(&req, y_absl::string_view(body_bytes, body_size));
+  out.push_back("\r\n"); 
+  TString req = y_absl::StrJoin(out, ""); 
+  if (body_bytes != nullptr) { 
+    y_absl::StrAppend(&req, y_absl::string_view(body_bytes, body_size)); 
   }
-  return grpc_slice_from_copied_buffer(req.data(), req.size());
+  return grpc_slice_from_copied_buffer(req.data(), req.size()); 
 }
 
 grpc_slice grpc_httpcli_format_connect_request(
     const grpc_httpcli_request* request) {
-  std::vector<TString> out;
-  out.push_back("CONNECT ");
-  fill_common_header(request, false, &out);
-  out.push_back("\r\n");
-  TString req = y_absl::StrJoin(out, "");
-  return grpc_slice_from_copied_buffer(req.data(), req.size());
+  std::vector<TString> out; 
+  out.push_back("CONNECT "); 
+  fill_common_header(request, false, &out); 
+  out.push_back("\r\n"); 
+  TString req = y_absl::StrJoin(out, ""); 
+  return grpc_slice_from_copied_buffer(req.data(), req.size()); 
 }
diff --git a/contrib/libs/grpc/src/core/lib/http/httpcli.cc b/contrib/libs/grpc/src/core/lib/http/httpcli.cc
index c196a8faac..f6741d5264 100644
--- a/contrib/libs/grpc/src/core/lib/http/httpcli.cc
+++ b/contrib/libs/grpc/src/core/lib/http/httpcli.cc
@@ -22,10 +22,10 @@
 
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_format.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -116,11 +116,11 @@ static void append_error(internal_request* req, grpc_error* error) {
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
   }
   grpc_resolved_address* addr = &req->addresses->addrs[req->next_address - 1];
-  TString addr_text = grpc_sockaddr_to_uri(addr);
+  TString addr_text = grpc_sockaddr_to_uri(addr); 
   req->overall_error = grpc_error_add_child(
       req->overall_error,
       grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
-                         grpc_slice_from_cpp_string(std::move(addr_text))));
+                         grpc_slice_from_cpp_string(std::move(addr_text)))); 
 }
 
 static void do_read(internal_request* req) {
@@ -273,10 +273,10 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
   if (g_get_override && g_get_override(request, deadline, on_done, response)) {
     return;
   }
-  TString name =
-      y_absl::StrFormat("HTTP:GET:%s:%s", request->host, request->http.path);
+  TString name = 
+      y_absl::StrFormat("HTTP:GET:%s:%s", request->host, request->http.path); 
   internal_request_begin(context, pollent, resource_quota, request, deadline,
-                         on_done, response, name.c_str(),
+                         on_done, response, name.c_str(), 
                          grpc_httpcli_format_get_request(request));
 }
 
@@ -291,12 +291,12 @@ void grpc_httpcli_post(grpc_httpcli_context* context,
                                          deadline, on_done, response)) {
     return;
   }
-  TString name =
-      y_absl::StrFormat("HTTP:POST:%s:%s", request->host, request->http.path);
+  TString name = 
+      y_absl::StrFormat("HTTP:POST:%s:%s", request->host, request->http.path); 
   internal_request_begin(
       context, pollent, resource_quota, request, deadline, on_done, response,
-      name.c_str(),
-      grpc_httpcli_format_post_request(request, body_bytes, body_size));
+      name.c_str(), 
+      grpc_httpcli_format_post_request(request, body_bytes, body_size)); 
 }
 
 void grpc_httpcli_set_override(grpc_httpcli_get_override get,
diff --git a/contrib/libs/grpc/src/core/lib/http/httpcli_security_connector.cc b/contrib/libs/grpc/src/core/lib/http/httpcli_security_connector.cc
index 62643186ad..c495619bc7 100644
--- a/contrib/libs/grpc/src/core/lib/http/httpcli_security_connector.cc
+++ b/contrib/libs/grpc/src/core/lib/http/httpcli_security_connector.cc
@@ -22,9 +22,9 @@
 
 #include <string.h>
 
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/string_view.h"
-
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/string_view.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -96,10 +96,10 @@ class grpc_httpcli_ssl_channel_security_connector final
     /* Check the peer name. */
     if (secure_peer_name_ != nullptr &&
         !tsi_ssl_peer_matches_name(&peer, secure_peer_name_)) {
-      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          y_absl::StrCat("Peer name ", secure_peer_name_,
-                       " is not in peer certificate")
-              .c_str());
+      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+          y_absl::StrCat("Peer name ", secure_peer_name_, 
+                       " is not in peer certificate") 
+              .c_str()); 
     }
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
     tsi_peer_destruct(&peer);
@@ -112,7 +112,7 @@ class grpc_httpcli_ssl_channel_security_connector final
     return strcmp(secure_peer_name_, other->secure_peer_name_);
   }
 
-  bool check_call_host(y_absl::string_view /*host*/,
+  bool check_call_host(y_absl::string_view /*host*/, 
                        grpc_auth_context* /*auth_context*/,
                        grpc_closure* /*on_call_host_checked*/,
                        grpc_error** error) override {
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/buffer_list.cc b/contrib/libs/grpc/src/core/lib/iomgr/buffer_list.cc
index e1b87da4d0..a525815e17 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/buffer_list.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/buffer_list.cc
@@ -66,27 +66,27 @@ void extract_opt_stats_from_tcp_info(ConnectionMetrics* metrics,
     return;
   }
   if (info->length > offsetof(grpc_core::tcp_info, tcpi_sndbuf_limited)) {
-    metrics->recurring_retrans.emplace(info->tcpi_retransmits);
-    metrics->is_delivery_rate_app_limited.emplace(
+    metrics->recurring_retrans.emplace(info->tcpi_retransmits); 
+    metrics->is_delivery_rate_app_limited.emplace( 
         info->tcpi_delivery_rate_app_limited);
-    metrics->congestion_window.emplace(info->tcpi_snd_cwnd);
-    metrics->reordering.emplace(info->tcpi_reordering);
-    metrics->packet_retx.emplace(info->tcpi_total_retrans);
-    metrics->pacing_rate.emplace(info->tcpi_pacing_rate);
-    metrics->data_notsent.emplace(info->tcpi_notsent_bytes);
+    metrics->congestion_window.emplace(info->tcpi_snd_cwnd); 
+    metrics->reordering.emplace(info->tcpi_reordering); 
+    metrics->packet_retx.emplace(info->tcpi_total_retrans); 
+    metrics->pacing_rate.emplace(info->tcpi_pacing_rate); 
+    metrics->data_notsent.emplace(info->tcpi_notsent_bytes); 
     if (info->tcpi_min_rtt != UINT32_MAX) {
-      metrics->min_rtt.emplace(info->tcpi_min_rtt);
+      metrics->min_rtt.emplace(info->tcpi_min_rtt); 
     }
-    metrics->packet_sent.emplace(info->tcpi_data_segs_out);
-    metrics->delivery_rate.emplace(info->tcpi_delivery_rate);
-    metrics->busy_usec.emplace(info->tcpi_busy_time);
-    metrics->rwnd_limited_usec.emplace(info->tcpi_rwnd_limited);
-    metrics->sndbuf_limited_usec.emplace(info->tcpi_sndbuf_limited);
+    metrics->packet_sent.emplace(info->tcpi_data_segs_out); 
+    metrics->delivery_rate.emplace(info->tcpi_delivery_rate); 
+    metrics->busy_usec.emplace(info->tcpi_busy_time); 
+    metrics->rwnd_limited_usec.emplace(info->tcpi_rwnd_limited); 
+    metrics->sndbuf_limited_usec.emplace(info->tcpi_sndbuf_limited); 
   }
   if (info->length > offsetof(grpc_core::tcp_info, tcpi_dsack_dups)) {
-    metrics->data_sent.emplace(info->tcpi_bytes_sent);
-    metrics->data_retx.emplace(info->tcpi_bytes_retrans);
-    metrics->packet_spurious_retx.emplace(info->tcpi_dsack_dups);
+    metrics->data_sent.emplace(info->tcpi_bytes_sent); 
+    metrics->data_retx.emplace(info->tcpi_bytes_retrans); 
+    metrics->packet_spurious_retx.emplace(info->tcpi_dsack_dups); 
   }
 }
 
@@ -107,80 +107,80 @@ void extract_opt_stats_from_cmsg(ConnectionMetrics* metrics,
     const void* val = data + offset + NLA_HDRLEN;
     switch (attr->nla_type) {
       case TCP_NLA_BUSY: {
-        metrics->busy_usec.emplace(read_unaligned<uint64_t>(val));
+        metrics->busy_usec.emplace(read_unaligned<uint64_t>(val)); 
         break;
       }
       case TCP_NLA_RWND_LIMITED: {
-        metrics->rwnd_limited_usec.emplace(read_unaligned<uint64_t>(val));
+        metrics->rwnd_limited_usec.emplace(read_unaligned<uint64_t>(val)); 
         break;
       }
       case TCP_NLA_SNDBUF_LIMITED: {
-        metrics->sndbuf_limited_usec.emplace(read_unaligned<uint64_t>(val));
+        metrics->sndbuf_limited_usec.emplace(read_unaligned<uint64_t>(val)); 
         break;
       }
       case TCP_NLA_PACING_RATE: {
-        metrics->pacing_rate.emplace(read_unaligned<uint64_t>(val));
+        metrics->pacing_rate.emplace(read_unaligned<uint64_t>(val)); 
         break;
       }
       case TCP_NLA_DELIVERY_RATE: {
-        metrics->delivery_rate.emplace(read_unaligned<uint64_t>(val));
+        metrics->delivery_rate.emplace(read_unaligned<uint64_t>(val)); 
         break;
       }
       case TCP_NLA_DELIVERY_RATE_APP_LMT: {
-        metrics->is_delivery_rate_app_limited.emplace(
-            read_unaligned<uint8_t>(val));
+        metrics->is_delivery_rate_app_limited.emplace( 
+            read_unaligned<uint8_t>(val)); 
         break;
       }
       case TCP_NLA_SND_CWND: {
-        metrics->congestion_window.emplace(read_unaligned<uint32_t>(val));
+        metrics->congestion_window.emplace(read_unaligned<uint32_t>(val)); 
         break;
       }
       case TCP_NLA_MIN_RTT: {
-        metrics->min_rtt.emplace(read_unaligned<uint32_t>(val));
+        metrics->min_rtt.emplace(read_unaligned<uint32_t>(val)); 
         break;
       }
       case TCP_NLA_SRTT: {
-        metrics->srtt.emplace(read_unaligned<uint32_t>(val));
+        metrics->srtt.emplace(read_unaligned<uint32_t>(val)); 
         break;
       }
       case TCP_NLA_RECUR_RETRANS: {
-        metrics->recurring_retrans.emplace(read_unaligned<uint8_t>(val));
+        metrics->recurring_retrans.emplace(read_unaligned<uint8_t>(val)); 
         break;
       }
       case TCP_NLA_BYTES_SENT: {
-        metrics->data_sent.emplace(read_unaligned<uint64_t>(val));
+        metrics->data_sent.emplace(read_unaligned<uint64_t>(val)); 
         break;
       }
       case TCP_NLA_DATA_SEGS_OUT: {
-        metrics->packet_sent.emplace(read_unaligned<uint64_t>(val));
+        metrics->packet_sent.emplace(read_unaligned<uint64_t>(val)); 
         break;
       }
       case TCP_NLA_TOTAL_RETRANS: {
-        metrics->packet_retx.emplace(read_unaligned<uint64_t>(val));
+        metrics->packet_retx.emplace(read_unaligned<uint64_t>(val)); 
         break;
       }
       case TCP_NLA_DELIVERED: {
-        metrics->packet_delivered.emplace(read_unaligned<uint32_t>(val));
+        metrics->packet_delivered.emplace(read_unaligned<uint32_t>(val)); 
         break;
       }
       case TCP_NLA_DELIVERED_CE: {
-        metrics->packet_delivered_ce.emplace(read_unaligned<uint32_t>(val));
+        metrics->packet_delivered_ce.emplace(read_unaligned<uint32_t>(val)); 
         break;
       }
       case TCP_NLA_BYTES_RETRANS: {
-        metrics->data_retx.emplace(read_unaligned<uint64_t>(val));
+        metrics->data_retx.emplace(read_unaligned<uint64_t>(val)); 
         break;
       }
       case TCP_NLA_DSACK_DUPS: {
-        metrics->packet_spurious_retx.emplace(read_unaligned<uint32_t>(val));
+        metrics->packet_spurious_retx.emplace(read_unaligned<uint32_t>(val)); 
         break;
       }
       case TCP_NLA_REORDERING: {
-        metrics->reordering.emplace(read_unaligned<uint32_t>(val));
+        metrics->reordering.emplace(read_unaligned<uint32_t>(val)); 
         break;
       }
       case TCP_NLA_SND_SSTHRESH: {
-        metrics->snd_ssthresh.emplace(read_unaligned<uint32_t>(val));
+        metrics->snd_ssthresh.emplace(read_unaligned<uint32_t>(val)); 
         break;
       }
     }
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/buffer_list.h b/contrib/libs/grpc/src/core/lib/iomgr/buffer_list.h
index 54a2dc748f..e38bd1dcde 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/buffer_list.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/buffer_list.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "y_absl/types/optional.h"
-
+#include "y_absl/types/optional.h" 
+ 
 #include "src/core/lib/iomgr/port.h"
 
 #include <grpc/support/time.h>
@@ -35,52 +35,52 @@ namespace grpc_core {
 
 struct ConnectionMetrics {
   /* Delivery rate in Bytes/s. */
-  y_absl::optional<uint64_t> delivery_rate;
+  y_absl::optional<uint64_t> delivery_rate; 
   /* If the delivery rate is limited by the application, this is set to true. */
-  y_absl::optional<bool> is_delivery_rate_app_limited;
+  y_absl::optional<bool> is_delivery_rate_app_limited; 
   /* Total packets retransmitted. */
-  y_absl::optional<uint32_t> packet_retx;
+  y_absl::optional<uint32_t> packet_retx; 
   /* Total packets retransmitted spuriously. This metric is smaller than or
   equal to packet_retx. */
-  y_absl::optional<uint32_t> packet_spurious_retx;
+  y_absl::optional<uint32_t> packet_spurious_retx; 
   /* Total packets sent. */
-  y_absl::optional<uint32_t> packet_sent;
+  y_absl::optional<uint32_t> packet_sent; 
   /* Total packets delivered. */
-  y_absl::optional<uint32_t> packet_delivered;
+  y_absl::optional<uint32_t> packet_delivered; 
   /* Total packets delivered with ECE marked. This metric is smaller than or
   equal to packet_delivered. */
-  y_absl::optional<uint32_t> packet_delivered_ce;
+  y_absl::optional<uint32_t> packet_delivered_ce; 
   /* Total bytes lost so far. */
-  y_absl::optional<uint64_t> data_retx;
+  y_absl::optional<uint64_t> data_retx; 
   /* Total bytes sent so far. */
-  y_absl::optional<uint64_t> data_sent;
+  y_absl::optional<uint64_t> data_sent; 
   /* Total bytes in write queue but not sent. */
-  y_absl::optional<uint64_t> data_notsent;
+  y_absl::optional<uint64_t> data_notsent; 
   /* Pacing rate of the connection in Bps */
-  y_absl::optional<uint64_t> pacing_rate;
+  y_absl::optional<uint64_t> pacing_rate; 
   /* Minimum RTT observed in usec. */
-  y_absl::optional<uint32_t> min_rtt;
+  y_absl::optional<uint32_t> min_rtt; 
   /* Smoothed RTT in usec */
-  y_absl::optional<uint32_t> srtt;
+  y_absl::optional<uint32_t> srtt; 
   /* Send congestion window. */
-  y_absl::optional<uint32_t> congestion_window;
+  y_absl::optional<uint32_t> congestion_window; 
   /* Slow start threshold in packets. */
-  y_absl::optional<uint32_t> snd_ssthresh;
+  y_absl::optional<uint32_t> snd_ssthresh; 
   /* Maximum degree of reordering (i.e., maximum number of packets reodered)
    on the connection. */
-  y_absl::optional<uint32_t> reordering;
+  y_absl::optional<uint32_t> reordering; 
   /* Represents the number of recurring retransmissions of the first sequence
   that is not acknowledged yet. */
-  y_absl::optional<uint8_t> recurring_retrans;
+  y_absl::optional<uint8_t> recurring_retrans; 
   /* The cumulative time (in usec) that the transport protocol was busy
    sending data. */
-  y_absl::optional<uint64_t> busy_usec;
+  y_absl::optional<uint64_t> busy_usec; 
   /* The cumulative time (in usec) that the transport protocol was limited by
    the receive window size. */
-  y_absl::optional<uint64_t> rwnd_limited_usec;
+  y_absl::optional<uint64_t> rwnd_limited_usec; 
   /* The cumulative time (in usec) that the transport protocol was limited by
    the send buffer size. */
-  y_absl::optional<uint64_t> sndbuf_limited_usec;
+  y_absl::optional<uint64_t> sndbuf_limited_usec; 
 };
 
 struct Timestamp {
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/call_combiner.h b/contrib/libs/grpc/src/core/lib/iomgr/call_combiner.h
index aed847c972..ffe79b3534 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/call_combiner.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/call_combiner.h
@@ -23,8 +23,8 @@
 
 #include <stddef.h>
 
-#include "y_absl/container/inlined_vector.h"
-
+#include "y_absl/container/inlined_vector.h" 
+ 
 #include <grpc/support/atm.h>
 
 #include "src/core/lib/gprpp/mpscq.h"
@@ -209,7 +209,7 @@ class CallCombinerClosureList {
 
   // There are generally a maximum of 6 closures to run in the call
   // combiner, one for each pending op.
-  y_absl::InlinedVector<CallCombinerClosure, 6> closures_;
+  y_absl::InlinedVector<CallCombinerClosure, 6> closures_; 
 };
 
 }  // namespace grpc_core
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/cfstream_handle.cc b/contrib/libs/grpc/src/core/lib/iomgr/cfstream_handle.cc
index 46914e5175..e8ff3a54d0 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/cfstream_handle.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/cfstream_handle.cc
@@ -32,7 +32,7 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
-#include "src/core/lib/iomgr/ev_apple.h"
+#include "src/core/lib/iomgr/ev_apple.h" 
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
@@ -148,15 +148,15 @@ CFStreamHandle::CFStreamHandle(CFReadStreamRef read_stream,
       kCFStreamEventOpenCompleted | kCFStreamEventCanAcceptBytes |
           kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered,
       CFStreamHandle::WriteCallback, &ctx);
-  grpc_apple_register_read_stream(read_stream, dispatch_queue_);
-  grpc_apple_register_write_stream(write_stream, dispatch_queue_);
+  grpc_apple_register_read_stream(read_stream, dispatch_queue_); 
+  grpc_apple_register_write_stream(write_stream, dispatch_queue_); 
 }
 
 CFStreamHandle::~CFStreamHandle() {
   open_event_.DestroyEvent();
   read_event_.DestroyEvent();
   write_event_.DestroyEvent();
-  dispatch_release(dispatch_queue_);
+  dispatch_release(dispatch_queue_); 
 }
 
 void CFStreamHandle::NotifyOnOpen(grpc_closure* closure) {
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/dualstack_socket_posix.cc b/contrib/libs/grpc/src/core/lib/iomgr/dualstack_socket_posix.cc
index dc0eafebf9..2d58d97799 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/dualstack_socket_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/dualstack_socket_posix.cc
@@ -1,47 +1,47 @@
-/*
- *
- * 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
-
-#include <netinet/in.h>
-#include "src/core/lib/iomgr/socket_utils_posix.h"
-
-#ifndef GRPC_SET_SOCKET_DUALSTACK_CUSTOM
-
-/* This should be 0 in production, but it may be enabled for testing or
-   debugging purposes, to simulate an environment where IPv6 sockets can't
-   also speak IPv4. */
-int grpc_forbid_dualstack_sockets_for_testing = 0;
-
-int grpc_set_socket_dualstack(int fd) {
-  if (!grpc_forbid_dualstack_sockets_for_testing) {
-    const int off = 0;
-    return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
-  } else {
-    /* Force an IPv6-only socket, for testing purposes. */
-    const int on = 1;
-    setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on));
-    return 0;
-  }
-}
-#endif  // GRPC_SET_SOCKET_DUALSTACK_CUSTOM
-#endif  // GRPC_POSIX_SOCKET_UTILS_COMMON
+/* 
+ * 
+ * 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. 
+ * 
+ */ 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/iomgr/port.h" 
+ 
+#ifdef GRPC_POSIX_SOCKET_UTILS_COMMON 
+ 
+#include <netinet/in.h> 
+#include "src/core/lib/iomgr/socket_utils_posix.h" 
+ 
+#ifndef GRPC_SET_SOCKET_DUALSTACK_CUSTOM 
+ 
+/* This should be 0 in production, but it may be enabled for testing or 
+   debugging purposes, to simulate an environment where IPv6 sockets can't 
+   also speak IPv4. */ 
+int grpc_forbid_dualstack_sockets_for_testing = 0; 
+ 
+int grpc_set_socket_dualstack(int fd) { 
+  if (!grpc_forbid_dualstack_sockets_for_testing) { 
+    const int off = 0; 
+    return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off)); 
+  } else { 
+    /* Force an IPv6-only socket, for testing purposes. */ 
+    const int on = 1; 
+    setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)); 
+    return 0; 
+  } 
+} 
+#endif  // GRPC_SET_SOCKET_DUALSTACK_CUSTOM 
+#endif  // GRPC_POSIX_SOCKET_UTILS_COMMON 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/endpoint.cc b/contrib/libs/grpc/src/core/lib/iomgr/endpoint.cc
index 37e0400102..5a5d2620ad 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/endpoint.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/endpoint.cc
@@ -52,14 +52,14 @@ void grpc_endpoint_shutdown(grpc_endpoint* ep, grpc_error* why) {
 
 void grpc_endpoint_destroy(grpc_endpoint* ep) { ep->vtable->destroy(ep); }
 
-y_absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep) {
+y_absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep) { 
   return ep->vtable->get_peer(ep);
 }
 
-y_absl::string_view grpc_endpoint_get_local_address(grpc_endpoint* ep) {
-  return ep->vtable->get_local_address(ep);
-}
-
+y_absl::string_view grpc_endpoint_get_local_address(grpc_endpoint* ep) { 
+  return ep->vtable->get_local_address(ep); 
+} 
+ 
 int grpc_endpoint_get_fd(grpc_endpoint* ep) { return ep->vtable->get_fd(ep); }
 
 grpc_resource_user* grpc_endpoint_get_resource_user(grpc_endpoint* ep) {
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/endpoint.h b/contrib/libs/grpc/src/core/lib/iomgr/endpoint.h
index e704c3be49..15b2107fa9 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/endpoint.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/endpoint.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "y_absl/strings/string_view.h"
-
+#include "y_absl/strings/string_view.h" 
+ 
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/time.h>
@@ -47,8 +47,8 @@ struct grpc_endpoint_vtable {
   void (*shutdown)(grpc_endpoint* ep, grpc_error* why);
   void (*destroy)(grpc_endpoint* ep);
   grpc_resource_user* (*get_resource_user)(grpc_endpoint* ep);
-  y_absl::string_view (*get_peer)(grpc_endpoint* ep);
-  y_absl::string_view (*get_local_address)(grpc_endpoint* ep);
+  y_absl::string_view (*get_peer)(grpc_endpoint* ep); 
+  y_absl::string_view (*get_local_address)(grpc_endpoint* ep); 
   int (*get_fd)(grpc_endpoint* ep);
   bool (*can_track_err)(grpc_endpoint* ep);
 };
@@ -61,10 +61,10 @@ struct grpc_endpoint_vtable {
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
                         grpc_closure* cb, bool urgent);
 
-y_absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep);
-
-y_absl::string_view grpc_endpoint_get_local_address(grpc_endpoint* ep);
+y_absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep); 
 
+y_absl::string_view grpc_endpoint_get_local_address(grpc_endpoint* ep); 
+ 
 /* Get the file descriptor used by \a ep. Return -1 if \a ep is not using an fd.
  */
 int grpc_endpoint_get_fd(grpc_endpoint* ep);
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/endpoint_cfstream.cc b/contrib/libs/grpc/src/core/lib/iomgr/endpoint_cfstream.cc
index d3a9c9b200..aac574c60a 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/endpoint_cfstream.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/endpoint_cfstream.cc
@@ -34,8 +34,8 @@
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
-#include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
+#include "src/core/lib/iomgr/sockaddr.h" 
+#include "src/core/lib/iomgr/sockaddr_utils.h" 
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
@@ -57,8 +57,8 @@ struct CFStreamEndpoint {
   grpc_closure read_action;
   grpc_closure write_action;
 
-  TString peer_string;
-  TString local_address;
+  TString peer_string; 
+  TString local_address; 
   grpc_resource_user* resource_user;
   grpc_resource_user_slice_allocator slice_allocator;
 };
@@ -67,7 +67,7 @@ static void CFStreamFree(CFStreamEndpoint* ep) {
   CFRelease(ep->read_stream);
   CFRelease(ep->write_stream);
   CFSTREAM_HANDLE_UNREF(ep->stream_sync, "free");
-  delete ep;
+  delete ep; 
 }
 
 #ifndef NDEBUG
@@ -112,7 +112,7 @@ static grpc_error* CFStreamAnnotateError(grpc_error* src_error,
       grpc_error_set_int(src_error, GRPC_ERROR_INT_GRPC_STATUS,
                          GRPC_STATUS_UNAVAILABLE),
       GRPC_ERROR_STR_TARGET_ADDRESS,
-      grpc_slice_from_copied_string(ep->peer_string.c_str()));
+      grpc_slice_from_copied_string(ep->peer_string.c_str())); 
 }
 
 static void CallReadCb(CFStreamEndpoint* ep, grpc_error* error) {
@@ -126,8 +126,8 @@ static void CallReadCb(CFStreamEndpoint* ep, grpc_error* error) {
     for (i = 0; i < ep->read_slices->count; i++) {
       char* dump = grpc_dump_slice(ep->read_slices->slices[i],
                                    GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_DEBUG, "READ %p (peer=%s): %s", ep, ep->peer_string.c_str(),
-              dump);
+      gpr_log(GPR_DEBUG, "READ %p (peer=%s): %s", ep, ep->peer_string.c_str(), 
+              dump); 
       gpr_free(dump);
     }
   }
@@ -233,8 +233,8 @@ static void WriteAction(void* arg, grpc_error* error) {
     if (grpc_tcp_trace.enabled()) {
       grpc_slice trace_slice = grpc_slice_sub(slice, 0, write_size);
       char* dump = grpc_dump_slice(trace_slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", ep, ep->peer_string.c_str(),
-              dump);
+      gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", ep, ep->peer_string.c_str(), 
+              dump); 
       gpr_free(dump);
       grpc_slice_unref_internal(trace_slice);
     }
@@ -313,16 +313,16 @@ grpc_resource_user* CFStreamGetResourceUser(grpc_endpoint* ep) {
   return ep_impl->resource_user;
 }
 
-y_absl::string_view CFStreamGetPeer(grpc_endpoint* ep) {
+y_absl::string_view CFStreamGetPeer(grpc_endpoint* ep) { 
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
-  return ep_impl->peer_string;
-}
-
-y_absl::string_view CFStreamGetLocalAddress(grpc_endpoint* ep) {
-  CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
-  return ep_impl->local_address;
+  return ep_impl->peer_string; 
 }
 
+y_absl::string_view CFStreamGetLocalAddress(grpc_endpoint* ep) { 
+  CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep); 
+  return ep_impl->local_address; 
+} 
+ 
 int CFStreamGetFD(grpc_endpoint* ep) { return 0; }
 
 bool CFStreamCanTrackErr(grpc_endpoint* ep) { return false; }
@@ -341,7 +341,7 @@ static const grpc_endpoint_vtable vtable = {CFStreamRead,
                                             CFStreamDestroy,
                                             CFStreamGetResourceUser,
                                             CFStreamGetPeer,
-                                            CFStreamGetLocalAddress,
+                                            CFStreamGetLocalAddress, 
                                             CFStreamGetFD,
                                             CFStreamCanTrackErr};
 
@@ -349,7 +349,7 @@ grpc_endpoint* grpc_cfstream_endpoint_create(
     CFReadStreamRef read_stream, CFWriteStreamRef write_stream,
     const char* peer_string, grpc_resource_quota* resource_quota,
     CFStreamHandle* stream_sync) {
-  CFStreamEndpoint* ep_impl = new CFStreamEndpoint;
+  CFStreamEndpoint* ep_impl = new CFStreamEndpoint; 
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG,
             "CFStream endpoint:%p create readStream:%p writeStream: %p",
@@ -364,23 +364,23 @@ grpc_endpoint* grpc_cfstream_endpoint_create(
   ep_impl->stream_sync = stream_sync;
   CFSTREAM_HANDLE_REF(ep_impl->stream_sync, "endpoint create");
 
-  ep_impl->peer_string = peer_string;
-  grpc_resolved_address resolved_local_addr;
-  resolved_local_addr.len = sizeof(resolved_local_addr.addr);
-  CFDataRef native_handle = static_cast<CFDataRef>(CFReadStreamCopyProperty(
-      ep_impl->read_stream, kCFStreamPropertySocketNativeHandle));
-  CFSocketNativeHandle sockfd;
-  CFDataGetBytes(native_handle, CFRangeMake(0, sizeof(CFSocketNativeHandle)),
-                 (UInt8*)&sockfd);
-  if (native_handle) {
-    CFRelease(native_handle);
-  }
-  if (getsockname(sockfd, reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-                  &resolved_local_addr.len) < 0) {
-    ep_impl->local_address = "";
-  } else {
-    ep_impl->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
-  }
+  ep_impl->peer_string = peer_string; 
+  grpc_resolved_address resolved_local_addr; 
+  resolved_local_addr.len = sizeof(resolved_local_addr.addr); 
+  CFDataRef native_handle = static_cast<CFDataRef>(CFReadStreamCopyProperty( 
+      ep_impl->read_stream, kCFStreamPropertySocketNativeHandle)); 
+  CFSocketNativeHandle sockfd; 
+  CFDataGetBytes(native_handle, CFRangeMake(0, sizeof(CFSocketNativeHandle)), 
+                 (UInt8*)&sockfd); 
+  if (native_handle) { 
+    CFRelease(native_handle); 
+  } 
+  if (getsockname(sockfd, reinterpret_cast<sockaddr*>(resolved_local_addr.addr), 
+                  &resolved_local_addr.len) < 0) { 
+    ep_impl->local_address = ""; 
+  } else { 
+    ep_impl->local_address = grpc_sockaddr_to_uri(&resolved_local_addr); 
+  } 
   ep_impl->read_cb = nil;
   ep_impl->write_cb = nil;
   ep_impl->read_slices = nil;
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/endpoint_pair_posix.cc b/contrib/libs/grpc/src/core/lib/iomgr/endpoint_pair_posix.cc
index 7f95da7365..ad4d0fda1c 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/endpoint_pair_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/endpoint_pair_posix.cc
@@ -32,10 +32,10 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include "src/core/lib/gpr/string.h"
@@ -60,12 +60,12 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
 
   grpc_core::ExecCtx exec_ctx;
 
-  TString final_name = y_absl::StrCat(name, ":client");
-  p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
-                             args, "socketpair-server");
-  final_name = y_absl::StrCat(name, ":server");
-  p.server = grpc_tcp_create(grpc_fd_create(sv[0], final_name.c_str(), false),
-                             args, "socketpair-client");
+  TString final_name = y_absl::StrCat(name, ":client"); 
+  p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false), 
+                             args, "socketpair-server"); 
+  final_name = y_absl::StrCat(name, ":server"); 
+  p.server = grpc_tcp_create(grpc_fd_create(sv[0], final_name.c_str(), false), 
+                             args, "socketpair-client"); 
 
   return p;
 }
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/error.h b/contrib/libs/grpc/src/core/lib/iomgr/error.h
index ac3ff87628..a1075d36a1 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/error.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/error.h
@@ -200,10 +200,10 @@ inline void grpc_error_unref(grpc_error* err) {
 
 // Consumes all the errors in the vector and forms a referencing error from
 // them. If the vector is empty, return GRPC_ERROR_NONE.
-template <typename VectorType>
-static grpc_error* grpc_error_create_from_vector(const char* file, int line,
-                                                 const char* desc,
-                                                 VectorType* error_list) {
+template <typename VectorType> 
+static grpc_error* grpc_error_create_from_vector(const char* file, int line, 
+                                                 const char* desc, 
+                                                 VectorType* error_list) { 
   grpc_error* error = GRPC_ERROR_NONE;
   if (error_list->size() != 0) {
     error = grpc_error_create(file, line, grpc_slice_from_static_string(desc),
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/error_cfstream.cc b/contrib/libs/grpc/src/core/lib/iomgr/error_cfstream.cc
index 62f6bc1d40..6c6e89fc9e 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/error_cfstream.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/error_cfstream.cc
@@ -19,10 +19,10 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GRPC_CFSTREAM
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_format.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_format.h" 
+ 
 #include <CoreFoundation/CoreFoundation.h>
 
 #include <grpc/support/alloc.h>
@@ -43,11 +43,11 @@ grpc_error* grpc_error_create_from_cferror(const char* file, int line,
                      kCFStringEncodingUTF8);
   CFStringGetCString(desc, buf_desc, MAX_ERROR_DESCRIPTION,
                      kCFStringEncodingUTF8);
-  TString error_msg =
-      y_absl::StrFormat("%s (error domain:%s, code:%ld, description:%s)",
-                      custom_desc, buf_domain, code, buf_desc);
+  TString error_msg = 
+      y_absl::StrFormat("%s (error domain:%s, code:%ld, description:%s)", 
+                      custom_desc, buf_domain, code, buf_desc); 
   CFRelease(desc);
-  return grpc_error_create(
-      file, line, grpc_slice_from_copied_string(error_msg.c_str()), NULL, 0);
+  return grpc_error_create( 
+      file, line, grpc_slice_from_copied_string(error_msg.c_str()), NULL, 0); 
 }
 #endif /* GRPC_CFSTREAM */
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/ev_apple.cc b/contrib/libs/grpc/src/core/lib/iomgr/ev_apple.cc
index d152582886..b0a352524b 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/ev_apple.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/ev_apple.cc
@@ -1,356 +1,356 @@
-/*
- *
- * 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.
- *
- */
-
-/// Event engine based on Apple's CFRunLoop API family. If the CFRunLoop engine
-/// is enabled (see iomgr_posix_cfstream.cc), a global thread is started to
-/// handle and trigger all the CFStream events. The CFStream streams register
-/// themselves with the run loop with functions grpc_apple_register_read_stream
-/// and grpc_apple_register_read_stream. Pollsets are dummy and block on a
-/// condition variable in pollset_work().
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_APPLE_EV
-
-#include <CoreFoundation/CoreFoundation.h>
-
-#include <list>
-
-#include "src/core/lib/gprpp/thd.h"
-#include "src/core/lib/iomgr/ev_apple.h"
-
-grpc_core::DebugOnlyTraceFlag grpc_apple_polling_trace(false, "apple_polling");
-
-#ifndef NDEBUG
-#define GRPC_POLLING_TRACE(format, ...)                    \
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_apple_polling_trace)) { \
-    gpr_log(GPR_DEBUG, "(polling) " format, __VA_ARGS__);  \
-  }
-#else
-#define GRPC_POLLING_TRACE(...)
-#endif  // NDEBUG
-
-#define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker*)1)
-
-struct GlobalRunLoopContext {
-  grpc_core::CondVar init_cv;
-  grpc_core::CondVar input_source_cv;
-
-  grpc_core::Mutex mu;
-
-  // Whether an input source registration is pending. Protected by mu.
-  bool input_source_registered = false;
-
-  // The reference to the global run loop object. Protected by mu.
-  CFRunLoopRef run_loop;
-
-  // Whether the pollset has been globally shut down. Protected by mu.
-  bool is_shutdown = false;
-};
-
-struct GrpcAppleWorker {
-  // The condition varible to kick the worker. Works with the pollset's lock
-  // (GrpcApplePollset.mu).
-  grpc_core::CondVar cv;
-
-  // Whether the worker is kicked. Protected by the pollset's lock
-  // (GrpcApplePollset.mu).
-  bool kicked = false;
-};
-
-struct GrpcApplePollset {
-  grpc_core::Mutex mu;
-
-  // Tracks the current workers in the pollset. Protected by mu.
-  std::list<GrpcAppleWorker*> workers;
-
-  // Whether the pollset is shut down. Protected by mu.
-  bool is_shutdown = false;
-
-  // Closure to call when shutdown is done. Protected by mu.
-  grpc_closure* shutdown_closure;
-
-  // Whether there's an outstanding kick that was not processed. Protected by
-  // mu.
-  bool kicked_without_poller = false;
-};
-
-static GlobalRunLoopContext* gGlobalRunLoopContext = nullptr;
-static grpc_core::Thread* gGlobalRunLoopThread = nullptr;
-
-/// Register the stream with the dispatch queue. Callbacks of the stream will be
-/// issued to the dispatch queue when a network event happens and will be
-/// managed by Grand Central Dispatch.
-static void grpc_apple_register_read_stream_queue(
-    CFReadStreamRef read_stream, dispatch_queue_t dispatch_queue) {
-  CFReadStreamSetDispatchQueue(read_stream, dispatch_queue);
-}
-
-/// Register the stream with the dispatch queue. Callbacks of the stream will be
-/// issued to the dispatch queue when a network event happens and will be
-/// managed by Grand Central Dispatch.
-static void grpc_apple_register_write_stream_queue(
-    CFWriteStreamRef write_stream, dispatch_queue_t dispatch_queue) {
-  CFWriteStreamSetDispatchQueue(write_stream, dispatch_queue);
-}
-
-/// Register the stream with the global run loop. Callbacks of the stream will
-/// be issued to the run loop when a network event happens and will be driven by
-/// the global run loop thread gGlobalRunLoopThread.
-static void grpc_apple_register_read_stream_run_loop(
-    CFReadStreamRef read_stream, dispatch_queue_t dispatch_queue) {
-  GRPC_POLLING_TRACE("Register read stream: %p", read_stream);
-  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
-  CFReadStreamScheduleWithRunLoop(read_stream, gGlobalRunLoopContext->run_loop,
-                                  kCFRunLoopDefaultMode);
-  gGlobalRunLoopContext->input_source_registered = true;
-  gGlobalRunLoopContext->input_source_cv.Signal();
-}
-
-/// Register the stream with the global run loop. Callbacks of the stream will
-/// be issued to the run loop when a network event happens, and will be driven
-/// by the global run loop thread gGlobalRunLoopThread.
-static void grpc_apple_register_write_stream_run_loop(
-    CFWriteStreamRef write_stream, dispatch_queue_t dispatch_queue) {
-  GRPC_POLLING_TRACE("Register write stream: %p", write_stream);
-  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
-  CFWriteStreamScheduleWithRunLoop(
-      write_stream, gGlobalRunLoopContext->run_loop, kCFRunLoopDefaultMode);
-  gGlobalRunLoopContext->input_source_registered = true;
-  gGlobalRunLoopContext->input_source_cv.Signal();
-}
-
-/// The default implementation of stream registration is to register the stream
-/// to a dispatch queue. However, if the CFRunLoop based pollset is enabled (by
-/// macro and environment variable, see docs in iomgr_posix_cfstream.cc), the
-/// CFStream streams are registered with the global run loop instead (see
-/// pollset_global_init below).
-static void (*grpc_apple_register_read_stream_impl)(
-    CFReadStreamRef, dispatch_queue_t) = grpc_apple_register_read_stream_queue;
-static void (*grpc_apple_register_write_stream_impl)(CFWriteStreamRef,
-                                                     dispatch_queue_t) =
-    grpc_apple_register_write_stream_queue;
-
-void grpc_apple_register_read_stream(CFReadStreamRef read_stream,
-                                     dispatch_queue_t dispatch_queue) {
-  grpc_apple_register_read_stream_impl(read_stream, dispatch_queue);
-}
-
-void grpc_apple_register_write_stream(CFWriteStreamRef write_stream,
-                                      dispatch_queue_t dispatch_queue) {
-  grpc_apple_register_write_stream_impl(write_stream, dispatch_queue);
-}
-
-/// Drive the run loop in a global singleton thread until the global run loop is
-/// shutdown.
-static void GlobalRunLoopFunc(void* arg) {
-  grpc_core::ReleasableMutexLock lock(&gGlobalRunLoopContext->mu);
-  gGlobalRunLoopContext->run_loop = CFRunLoopGetCurrent();
-  gGlobalRunLoopContext->init_cv.Signal();
-
-  while (!gGlobalRunLoopContext->is_shutdown) {
-    // CFRunLoopRun() will return immediately if no stream is registered on it.
-    // So we wait on a conditional variable until a stream is registered;
-    // otherwise we'll be running a spinning loop.
-    while (!gGlobalRunLoopContext->input_source_registered) {
-      gGlobalRunLoopContext->input_source_cv.Wait(&gGlobalRunLoopContext->mu);
-    }
-    gGlobalRunLoopContext->input_source_registered = false;
-    lock.Unlock();
-    CFRunLoopRun();
-    lock.Lock();
-  }
-  lock.Unlock();
-}
-
-// pollset implementation
-
-static void pollset_global_init(void) {
-  gGlobalRunLoopContext = new GlobalRunLoopContext;
-
-  grpc_apple_register_read_stream_impl =
-      grpc_apple_register_read_stream_run_loop;
-  grpc_apple_register_write_stream_impl =
-      grpc_apple_register_write_stream_run_loop;
-
-  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
-  gGlobalRunLoopThread =
-      new grpc_core::Thread("apple_ev", GlobalRunLoopFunc, nullptr);
-  gGlobalRunLoopThread->Start();
-  while (gGlobalRunLoopContext->run_loop == NULL)
-    gGlobalRunLoopContext->init_cv.Wait(&gGlobalRunLoopContext->mu);
-}
-
-static void pollset_global_shutdown(void) {
-  {
-    grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu);
-    gGlobalRunLoopContext->is_shutdown = true;
-    CFRunLoopStop(gGlobalRunLoopContext->run_loop);
-  }
-  gGlobalRunLoopThread->Join();
-  delete gGlobalRunLoopThread;
-  delete gGlobalRunLoopContext;
-}
-
-/// The caller must acquire the lock GrpcApplePollset.mu before calling this
-/// function. The lock may be temporarily released when waiting on the condition
-/// variable but will be re-acquired before the function returns.
-///
-/// The Apple pollset simply waits on a condition variable until it is kicked.
-/// The network events are handled in the global run loop thread. Processing of
-/// these events will eventually trigger the kick.
-static grpc_error* pollset_work(grpc_pollset* pollset,
-                                grpc_pollset_worker** worker,
-                                grpc_millis deadline) {
-  GRPC_POLLING_TRACE("pollset work: %p, worker: %p, deadline: %" PRIu64,
-                     pollset, worker, deadline);
-  GrpcApplePollset* apple_pollset =
-      reinterpret_cast<GrpcApplePollset*>(pollset);
-  GrpcAppleWorker actual_worker;
-  if (worker) {
-    *worker = reinterpret_cast<grpc_pollset_worker*>(&actual_worker);
-  }
-
-  if (apple_pollset->kicked_without_poller) {
-    // Process the outstanding kick and reset the flag. Do not block.
-    apple_pollset->kicked_without_poller = false;
-  } else {
-    // Block until kicked, timed out, or the pollset shuts down.
-    apple_pollset->workers.push_front(&actual_worker);
-    auto it = apple_pollset->workers.begin();
-
-    while (!actual_worker.kicked && !apple_pollset->is_shutdown) {
-      if (actual_worker.cv.Wait(
-              &apple_pollset->mu,
-              grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME))) {
-        // timed out
-        break;
-      }
-    }
-
-    apple_pollset->workers.erase(it);
-
-    // If the pollset is shut down asynchronously and this is the last pending
-    // worker, the shutdown process is complete at this moment and the shutdown
-    // callback will be called.
-    if (apple_pollset->is_shutdown && apple_pollset->workers.empty()) {
-      grpc_core::ExecCtx::Run(DEBUG_LOCATION, apple_pollset->shutdown_closure,
-                              GRPC_ERROR_NONE);
-    }
-  }
-
-  return GRPC_ERROR_NONE;
-}
-
-/// Kick a specific worker. The caller must acquire the lock GrpcApplePollset.mu
-/// before calling this function.
-static void kick_worker(GrpcAppleWorker* worker) {
-  worker->kicked = true;
-  worker->cv.Signal();
-}
-
-/// The caller must acquire the lock GrpcApplePollset.mu before calling this
-/// function. The kick action simply signals the condition variable of the
-/// worker.
-static grpc_error* pollset_kick(grpc_pollset* pollset,
-                                grpc_pollset_worker* specific_worker) {
-  GrpcApplePollset* apple_pollset =
-      reinterpret_cast<GrpcApplePollset*>(pollset);
-
-  GRPC_POLLING_TRACE("pollset kick: %p, worker:%p", pollset, specific_worker);
-
-  if (specific_worker == nullptr) {
-    if (apple_pollset->workers.empty()) {
-      apple_pollset->kicked_without_poller = true;
-    } else {
-      GrpcAppleWorker* actual_worker = apple_pollset->workers.front();
-      kick_worker(actual_worker);
-    }
-  } else if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
-    for (auto& actual_worker : apple_pollset->workers) {
-      kick_worker(actual_worker);
-    }
-  } else {
-    GrpcAppleWorker* actual_worker =
-        reinterpret_cast<GrpcAppleWorker*>(specific_worker);
-    kick_worker(actual_worker);
-  }
-
-  return GRPC_ERROR_NONE;
-}
-
-static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
-  GRPC_POLLING_TRACE("pollset init: %p", pollset);
-  GrpcApplePollset* apple_pollset = new (pollset) GrpcApplePollset();
-  *mu = apple_pollset->mu.get();
-}
-
-/// The caller must acquire the lock GrpcApplePollset.mu before calling this
-/// function.
-static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
-  GRPC_POLLING_TRACE("pollset shutdown: %p", pollset);
-
-  GrpcApplePollset* apple_pollset =
-      reinterpret_cast<GrpcApplePollset*>(pollset);
-  apple_pollset->is_shutdown = true;
-  pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
-
-  // If there is any worker blocked, shutdown will be done asynchronously.
-  if (apple_pollset->workers.empty()) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
-  } else {
-    apple_pollset->shutdown_closure = closure;
-  }
-}
-
-static void pollset_destroy(grpc_pollset* pollset) {
-  GRPC_POLLING_TRACE("pollset destroy: %p", pollset);
-  GrpcApplePollset* apple_pollset =
-      reinterpret_cast<GrpcApplePollset*>(pollset);
-  apple_pollset->~GrpcApplePollset();
-}
-
-size_t pollset_size(void) { return sizeof(GrpcApplePollset); }
-
-grpc_pollset_vtable grpc_apple_pollset_vtable = {
-    pollset_global_init, pollset_global_shutdown,
-    pollset_init,        pollset_shutdown,
-    pollset_destroy,     pollset_work,
-    pollset_kick,        pollset_size};
-
-// pollset_set implementation
-
-grpc_pollset_set* pollset_set_create(void) { return nullptr; }
-void pollset_set_destroy(grpc_pollset_set* pollset_set) {}
-void pollset_set_add_pollset(grpc_pollset_set* pollset_set,
-                             grpc_pollset* pollset) {}
-void pollset_set_del_pollset(grpc_pollset_set* pollset_set,
-                             grpc_pollset* pollset) {}
-void pollset_set_add_pollset_set(grpc_pollset_set* bag,
-                                 grpc_pollset_set* item) {}
-void pollset_set_del_pollset_set(grpc_pollset_set* bag,
-                                 grpc_pollset_set* item) {}
-
-grpc_pollset_set_vtable grpc_apple_pollset_set_vtable = {
-    pollset_set_create,          pollset_set_destroy,
-    pollset_set_add_pollset,     pollset_set_del_pollset,
-    pollset_set_add_pollset_set, pollset_set_del_pollset_set};
-
-#endif
+/* 
+ * 
+ * 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. 
+ * 
+ */ 
+ 
+/// Event engine based on Apple's CFRunLoop API family. If the CFRunLoop engine 
+/// is enabled (see iomgr_posix_cfstream.cc), a global thread is started to 
+/// handle and trigger all the CFStream events. The CFStream streams register 
+/// themselves with the run loop with functions grpc_apple_register_read_stream 
+/// and grpc_apple_register_read_stream. Pollsets are dummy and block on a 
+/// condition variable in pollset_work(). 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/iomgr/port.h" 
+ 
+#ifdef GRPC_APPLE_EV 
+ 
+#include <CoreFoundation/CoreFoundation.h> 
+ 
+#include <list> 
+ 
+#include "src/core/lib/gprpp/thd.h" 
+#include "src/core/lib/iomgr/ev_apple.h" 
+ 
+grpc_core::DebugOnlyTraceFlag grpc_apple_polling_trace(false, "apple_polling"); 
+ 
+#ifndef NDEBUG 
+#define GRPC_POLLING_TRACE(format, ...)                    \ 
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_apple_polling_trace)) { \ 
+    gpr_log(GPR_DEBUG, "(polling) " format, __VA_ARGS__);  \ 
+  } 
+#else 
+#define GRPC_POLLING_TRACE(...) 
+#endif  // NDEBUG 
+ 
+#define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker*)1) 
+ 
+struct GlobalRunLoopContext { 
+  grpc_core::CondVar init_cv; 
+  grpc_core::CondVar input_source_cv; 
+ 
+  grpc_core::Mutex mu; 
+ 
+  // Whether an input source registration is pending. Protected by mu. 
+  bool input_source_registered = false; 
+ 
+  // The reference to the global run loop object. Protected by mu. 
+  CFRunLoopRef run_loop; 
+ 
+  // Whether the pollset has been globally shut down. Protected by mu. 
+  bool is_shutdown = false; 
+}; 
+ 
+struct GrpcAppleWorker { 
+  // The condition varible to kick the worker. Works with the pollset's lock 
+  // (GrpcApplePollset.mu). 
+  grpc_core::CondVar cv; 
+ 
+  // Whether the worker is kicked. Protected by the pollset's lock 
+  // (GrpcApplePollset.mu). 
+  bool kicked = false; 
+}; 
+ 
+struct GrpcApplePollset { 
+  grpc_core::Mutex mu; 
+ 
+  // Tracks the current workers in the pollset. Protected by mu. 
+  std::list<GrpcAppleWorker*> workers; 
+ 
+  // Whether the pollset is shut down. Protected by mu. 
+  bool is_shutdown = false; 
+ 
+  // Closure to call when shutdown is done. Protected by mu. 
+  grpc_closure* shutdown_closure; 
+ 
+  // Whether there's an outstanding kick that was not processed. Protected by 
+  // mu. 
+  bool kicked_without_poller = false; 
+}; 
+ 
+static GlobalRunLoopContext* gGlobalRunLoopContext = nullptr; 
+static grpc_core::Thread* gGlobalRunLoopThread = nullptr; 
+ 
+/// Register the stream with the dispatch queue. Callbacks of the stream will be 
+/// issued to the dispatch queue when a network event happens and will be 
+/// managed by Grand Central Dispatch. 
+static void grpc_apple_register_read_stream_queue( 
+    CFReadStreamRef read_stream, dispatch_queue_t dispatch_queue) { 
+  CFReadStreamSetDispatchQueue(read_stream, dispatch_queue); 
+} 
+ 
+/// Register the stream with the dispatch queue. Callbacks of the stream will be 
+/// issued to the dispatch queue when a network event happens and will be 
+/// managed by Grand Central Dispatch. 
+static void grpc_apple_register_write_stream_queue( 
+    CFWriteStreamRef write_stream, dispatch_queue_t dispatch_queue) { 
+  CFWriteStreamSetDispatchQueue(write_stream, dispatch_queue); 
+} 
+ 
+/// Register the stream with the global run loop. Callbacks of the stream will 
+/// be issued to the run loop when a network event happens and will be driven by 
+/// the global run loop thread gGlobalRunLoopThread. 
+static void grpc_apple_register_read_stream_run_loop( 
+    CFReadStreamRef read_stream, dispatch_queue_t dispatch_queue) { 
+  GRPC_POLLING_TRACE("Register read stream: %p", read_stream); 
+  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu); 
+  CFReadStreamScheduleWithRunLoop(read_stream, gGlobalRunLoopContext->run_loop, 
+                                  kCFRunLoopDefaultMode); 
+  gGlobalRunLoopContext->input_source_registered = true; 
+  gGlobalRunLoopContext->input_source_cv.Signal(); 
+} 
+ 
+/// Register the stream with the global run loop. Callbacks of the stream will 
+/// be issued to the run loop when a network event happens, and will be driven 
+/// by the global run loop thread gGlobalRunLoopThread. 
+static void grpc_apple_register_write_stream_run_loop( 
+    CFWriteStreamRef write_stream, dispatch_queue_t dispatch_queue) { 
+  GRPC_POLLING_TRACE("Register write stream: %p", write_stream); 
+  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu); 
+  CFWriteStreamScheduleWithRunLoop( 
+      write_stream, gGlobalRunLoopContext->run_loop, kCFRunLoopDefaultMode); 
+  gGlobalRunLoopContext->input_source_registered = true; 
+  gGlobalRunLoopContext->input_source_cv.Signal(); 
+} 
+ 
+/// The default implementation of stream registration is to register the stream 
+/// to a dispatch queue. However, if the CFRunLoop based pollset is enabled (by 
+/// macro and environment variable, see docs in iomgr_posix_cfstream.cc), the 
+/// CFStream streams are registered with the global run loop instead (see 
+/// pollset_global_init below). 
+static void (*grpc_apple_register_read_stream_impl)( 
+    CFReadStreamRef, dispatch_queue_t) = grpc_apple_register_read_stream_queue; 
+static void (*grpc_apple_register_write_stream_impl)(CFWriteStreamRef, 
+                                                     dispatch_queue_t) = 
+    grpc_apple_register_write_stream_queue; 
+ 
+void grpc_apple_register_read_stream(CFReadStreamRef read_stream, 
+                                     dispatch_queue_t dispatch_queue) { 
+  grpc_apple_register_read_stream_impl(read_stream, dispatch_queue); 
+} 
+ 
+void grpc_apple_register_write_stream(CFWriteStreamRef write_stream, 
+                                      dispatch_queue_t dispatch_queue) { 
+  grpc_apple_register_write_stream_impl(write_stream, dispatch_queue); 
+} 
+ 
+/// Drive the run loop in a global singleton thread until the global run loop is 
+/// shutdown. 
+static void GlobalRunLoopFunc(void* arg) { 
+  grpc_core::ReleasableMutexLock lock(&gGlobalRunLoopContext->mu); 
+  gGlobalRunLoopContext->run_loop = CFRunLoopGetCurrent(); 
+  gGlobalRunLoopContext->init_cv.Signal(); 
+ 
+  while (!gGlobalRunLoopContext->is_shutdown) { 
+    // CFRunLoopRun() will return immediately if no stream is registered on it. 
+    // So we wait on a conditional variable until a stream is registered; 
+    // otherwise we'll be running a spinning loop. 
+    while (!gGlobalRunLoopContext->input_source_registered) { 
+      gGlobalRunLoopContext->input_source_cv.Wait(&gGlobalRunLoopContext->mu); 
+    } 
+    gGlobalRunLoopContext->input_source_registered = false; 
+    lock.Unlock(); 
+    CFRunLoopRun(); 
+    lock.Lock(); 
+  } 
+  lock.Unlock(); 
+} 
+ 
+// pollset implementation 
+ 
+static void pollset_global_init(void) { 
+  gGlobalRunLoopContext = new GlobalRunLoopContext; 
+ 
+  grpc_apple_register_read_stream_impl = 
+      grpc_apple_register_read_stream_run_loop; 
+  grpc_apple_register_write_stream_impl = 
+      grpc_apple_register_write_stream_run_loop; 
+ 
+  grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu); 
+  gGlobalRunLoopThread = 
+      new grpc_core::Thread("apple_ev", GlobalRunLoopFunc, nullptr); 
+  gGlobalRunLoopThread->Start(); 
+  while (gGlobalRunLoopContext->run_loop == NULL) 
+    gGlobalRunLoopContext->init_cv.Wait(&gGlobalRunLoopContext->mu); 
+} 
+ 
+static void pollset_global_shutdown(void) { 
+  { 
+    grpc_core::MutexLock lock(&gGlobalRunLoopContext->mu); 
+    gGlobalRunLoopContext->is_shutdown = true; 
+    CFRunLoopStop(gGlobalRunLoopContext->run_loop); 
+  } 
+  gGlobalRunLoopThread->Join(); 
+  delete gGlobalRunLoopThread; 
+  delete gGlobalRunLoopContext; 
+} 
+ 
+/// The caller must acquire the lock GrpcApplePollset.mu before calling this 
+/// function. The lock may be temporarily released when waiting on the condition 
+/// variable but will be re-acquired before the function returns. 
+/// 
+/// The Apple pollset simply waits on a condition variable until it is kicked. 
+/// The network events are handled in the global run loop thread. Processing of 
+/// these events will eventually trigger the kick. 
+static grpc_error* pollset_work(grpc_pollset* pollset, 
+                                grpc_pollset_worker** worker, 
+                                grpc_millis deadline) { 
+  GRPC_POLLING_TRACE("pollset work: %p, worker: %p, deadline: %" PRIu64, 
+                     pollset, worker, deadline); 
+  GrpcApplePollset* apple_pollset = 
+      reinterpret_cast<GrpcApplePollset*>(pollset); 
+  GrpcAppleWorker actual_worker; 
+  if (worker) { 
+    *worker = reinterpret_cast<grpc_pollset_worker*>(&actual_worker); 
+  } 
+ 
+  if (apple_pollset->kicked_without_poller) { 
+    // Process the outstanding kick and reset the flag. Do not block. 
+    apple_pollset->kicked_without_poller = false; 
+  } else { 
+    // Block until kicked, timed out, or the pollset shuts down. 
+    apple_pollset->workers.push_front(&actual_worker); 
+    auto it = apple_pollset->workers.begin(); 
+ 
+    while (!actual_worker.kicked && !apple_pollset->is_shutdown) { 
+      if (actual_worker.cv.Wait( 
+              &apple_pollset->mu, 
+              grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME))) { 
+        // timed out 
+        break; 
+      } 
+    } 
+ 
+    apple_pollset->workers.erase(it); 
+ 
+    // If the pollset is shut down asynchronously and this is the last pending 
+    // worker, the shutdown process is complete at this moment and the shutdown 
+    // callback will be called. 
+    if (apple_pollset->is_shutdown && apple_pollset->workers.empty()) { 
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, apple_pollset->shutdown_closure, 
+                              GRPC_ERROR_NONE); 
+    } 
+  } 
+ 
+  return GRPC_ERROR_NONE; 
+} 
+ 
+/// Kick a specific worker. The caller must acquire the lock GrpcApplePollset.mu 
+/// before calling this function. 
+static void kick_worker(GrpcAppleWorker* worker) { 
+  worker->kicked = true; 
+  worker->cv.Signal(); 
+} 
+ 
+/// The caller must acquire the lock GrpcApplePollset.mu before calling this 
+/// function. The kick action simply signals the condition variable of the 
+/// worker. 
+static grpc_error* pollset_kick(grpc_pollset* pollset, 
+                                grpc_pollset_worker* specific_worker) { 
+  GrpcApplePollset* apple_pollset = 
+      reinterpret_cast<GrpcApplePollset*>(pollset); 
+ 
+  GRPC_POLLING_TRACE("pollset kick: %p, worker:%p", pollset, specific_worker); 
+ 
+  if (specific_worker == nullptr) { 
+    if (apple_pollset->workers.empty()) { 
+      apple_pollset->kicked_without_poller = true; 
+    } else { 
+      GrpcAppleWorker* actual_worker = apple_pollset->workers.front(); 
+      kick_worker(actual_worker); 
+    } 
+  } else if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) { 
+    for (auto& actual_worker : apple_pollset->workers) { 
+      kick_worker(actual_worker); 
+    } 
+  } else { 
+    GrpcAppleWorker* actual_worker = 
+        reinterpret_cast<GrpcAppleWorker*>(specific_worker); 
+    kick_worker(actual_worker); 
+  } 
+ 
+  return GRPC_ERROR_NONE; 
+} 
+ 
+static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) { 
+  GRPC_POLLING_TRACE("pollset init: %p", pollset); 
+  GrpcApplePollset* apple_pollset = new (pollset) GrpcApplePollset(); 
+  *mu = apple_pollset->mu.get(); 
+} 
+ 
+/// The caller must acquire the lock GrpcApplePollset.mu before calling this 
+/// function. 
+static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) { 
+  GRPC_POLLING_TRACE("pollset shutdown: %p", pollset); 
+ 
+  GrpcApplePollset* apple_pollset = 
+      reinterpret_cast<GrpcApplePollset*>(pollset); 
+  apple_pollset->is_shutdown = true; 
+  pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST); 
+ 
+  // If there is any worker blocked, shutdown will be done asynchronously. 
+  if (apple_pollset->workers.empty()) { 
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE); 
+  } else { 
+    apple_pollset->shutdown_closure = closure; 
+  } 
+} 
+ 
+static void pollset_destroy(grpc_pollset* pollset) { 
+  GRPC_POLLING_TRACE("pollset destroy: %p", pollset); 
+  GrpcApplePollset* apple_pollset = 
+      reinterpret_cast<GrpcApplePollset*>(pollset); 
+  apple_pollset->~GrpcApplePollset(); 
+} 
+ 
+size_t pollset_size(void) { return sizeof(GrpcApplePollset); } 
+ 
+grpc_pollset_vtable grpc_apple_pollset_vtable = { 
+    pollset_global_init, pollset_global_shutdown, 
+    pollset_init,        pollset_shutdown, 
+    pollset_destroy,     pollset_work, 
+    pollset_kick,        pollset_size}; 
+ 
+// pollset_set implementation 
+ 
+grpc_pollset_set* pollset_set_create(void) { return nullptr; } 
+void pollset_set_destroy(grpc_pollset_set* pollset_set) {} 
+void pollset_set_add_pollset(grpc_pollset_set* pollset_set, 
+                             grpc_pollset* pollset) {} 
+void pollset_set_del_pollset(grpc_pollset_set* pollset_set, 
+                             grpc_pollset* pollset) {} 
+void pollset_set_add_pollset_set(grpc_pollset_set* bag, 
+                                 grpc_pollset_set* item) {} 
+void pollset_set_del_pollset_set(grpc_pollset_set* bag, 
+                                 grpc_pollset_set* item) {} 
+ 
+grpc_pollset_set_vtable grpc_apple_pollset_set_vtable = { 
+    pollset_set_create,          pollset_set_destroy, 
+    pollset_set_add_pollset,     pollset_set_del_pollset, 
+    pollset_set_add_pollset_set, pollset_set_del_pollset_set}; 
+ 
+#endif 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/ev_apple.h b/contrib/libs/grpc/src/core/lib/iomgr/ev_apple.h
index a05f91ce15..74692077fb 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/ev_apple.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/ev_apple.h
@@ -1,43 +1,43 @@
-/*
- *
- * 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_CORE_LIB_IOMGR_EV_APPLE_H
-#define GRPC_CORE_LIB_IOMGR_EV_APPLE_H
-
-#include <grpc/support/port_platform.h>
-
-#ifdef GRPC_APPLE_EV
-
-#include <CoreFoundation/CoreFoundation.h>
-
-#include "src/core/lib/iomgr/pollset.h"
-#include "src/core/lib/iomgr/pollset_set.h"
-
-void grpc_apple_register_read_stream(CFReadStreamRef read_stream,
-                                     dispatch_queue_t dispatch_queue);
-
-void grpc_apple_register_write_stream(CFWriteStreamRef write_stream,
-                                      dispatch_queue_t dispatch_queue);
-
-extern grpc_pollset_vtable grpc_apple_pollset_vtable;
-
-extern grpc_pollset_set_vtable grpc_apple_pollset_set_vtable;
-
-#endif
-
-#endif
+/* 
+ * 
+ * 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_CORE_LIB_IOMGR_EV_APPLE_H 
+#define GRPC_CORE_LIB_IOMGR_EV_APPLE_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#ifdef GRPC_APPLE_EV 
+ 
+#include <CoreFoundation/CoreFoundation.h> 
+ 
+#include "src/core/lib/iomgr/pollset.h" 
+#include "src/core/lib/iomgr/pollset_set.h" 
+ 
+void grpc_apple_register_read_stream(CFReadStreamRef read_stream, 
+                                     dispatch_queue_t dispatch_queue); 
+ 
+void grpc_apple_register_write_stream(CFWriteStreamRef write_stream, 
+                                      dispatch_queue_t dispatch_queue); 
+ 
+extern grpc_pollset_vtable grpc_apple_pollset_vtable; 
+ 
+extern grpc_pollset_set_vtable grpc_apple_pollset_set_vtable; 
+ 
+#endif 
+ 
+#endif 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/ev_epoll1_linux.cc b/contrib/libs/grpc/src/core/lib/iomgr/ev_epoll1_linux.cc
index f09dcee0c0..bebd39665b 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/ev_epoll1_linux.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/ev_epoll1_linux.cc
@@ -38,13 +38,13 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
-#include <util/generic/string.h>
-#include <vector>
-
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/str_join.h"
-
+#include <util/generic/string.h> 
+#include <vector> 
+ 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/str_join.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
 
@@ -352,12 +352,12 @@ static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
 
   new_fd->freelist_next = nullptr;
 
-  TString fd_name = y_absl::StrCat(name, " fd=", fd);
-  grpc_iomgr_register_object(&new_fd->iomgr_object, fd_name.c_str());
+  TString fd_name = y_absl::StrCat(name, " fd=", fd); 
+  grpc_iomgr_register_object(&new_fd->iomgr_object, fd_name.c_str()); 
   fork_fd_list_add_grpc_fd(new_fd);
 #ifndef NDEBUG
   if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fd_refcount)) {
-    gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, new_fd, fd_name.c_str());
+    gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, new_fd, fd_name.c_str()); 
   }
 #endif
 
@@ -1068,23 +1068,23 @@ static grpc_error* pollset_kick(grpc_pollset* pollset,
   GRPC_STATS_INC_POLLSET_KICK();
   grpc_error* ret_err = GRPC_ERROR_NONE;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-    std::vector<TString> log;
-    log.push_back(y_absl::StrFormat(
-        "PS:%p KICK:%p curps=%p curworker=%p root=%p", pollset, specific_worker,
-        (void*)gpr_tls_get(&g_current_thread_pollset),
-        (void*)gpr_tls_get(&g_current_thread_worker), pollset->root_worker));
+    std::vector<TString> log; 
+    log.push_back(y_absl::StrFormat( 
+        "PS:%p KICK:%p curps=%p curworker=%p root=%p", pollset, specific_worker, 
+        (void*)gpr_tls_get(&g_current_thread_pollset), 
+        (void*)gpr_tls_get(&g_current_thread_worker), pollset->root_worker)); 
     if (pollset->root_worker != nullptr) {
-      log.push_back(y_absl::StrFormat(
-          " {kick_state=%s next=%p {kick_state=%s}}",
-          kick_state_string(pollset->root_worker->state),
-          pollset->root_worker->next,
-          kick_state_string(pollset->root_worker->next->state)));
+      log.push_back(y_absl::StrFormat( 
+          " {kick_state=%s next=%p {kick_state=%s}}", 
+          kick_state_string(pollset->root_worker->state), 
+          pollset->root_worker->next, 
+          kick_state_string(pollset->root_worker->next->state))); 
     }
     if (specific_worker != nullptr) {
-      log.push_back(y_absl::StrFormat(" worker_kick_state=%s",
-                                    kick_state_string(specific_worker->state)));
+      log.push_back(y_absl::StrFormat(" worker_kick_state=%s", 
+                                    kick_state_string(specific_worker->state))); 
     }
-    gpr_log(GPR_DEBUG, "%s", y_absl::StrJoin(log, "").c_str());
+    gpr_log(GPR_DEBUG, "%s", y_absl::StrJoin(log, "").c_str()); 
   }
 
   if (specific_worker == nullptr) {
@@ -1113,8 +1113,8 @@ static grpc_error* pollset_kick(grpc_pollset* pollset,
         }
         SET_KICK_STATE(next_worker, KICKED);
         goto done;
-      } else if (root_worker == next_worker &&  // only try and wake up a poller
-                                                // if there is no next worker
+      } else if (root_worker == next_worker &&  // only try and wake up a poller 
+                                                // if there is no next worker 
                  root_worker == (grpc_pollset_worker*)gpr_atm_no_barrier_load(
                                     &g_active_poller)) {
         GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD();
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/ev_epollex_linux.cc b/contrib/libs/grpc/src/core/lib/iomgr/ev_epollex_linux.cc
index 2dd9bbdffd..94033e7ca7 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/ev_epollex_linux.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/ev_epollex_linux.cc
@@ -38,12 +38,12 @@
 #include <sys/syscall.h>
 #include <unistd.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/container/inlined_vector.h"
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_format.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/container/inlined_vector.h" 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/support/alloc.h>
 
 #include "src/core/lib/debug/stats.h"
@@ -124,10 +124,10 @@ static const char* pollable_type_string(pollable_type t) {
   return "<invalid>";
 }
 
-static TString pollable_desc(pollable* p) {
-  return y_absl::StrFormat("type=%s epfd=%d wakeup=%d",
-                         pollable_type_string(p->type), p->epfd,
-                         p->wakeup.read_fd);
+static TString pollable_desc(pollable* p) { 
+  return y_absl::StrFormat("type=%s epfd=%d wakeup=%d", 
+                         pollable_type_string(p->type), p->epfd, 
+                         p->wakeup.read_fd); 
 }
 
 /// Shared empty pollable - used by pollset to poll on until the first fd is
@@ -169,11 +169,11 @@ struct grpc_fd {
     write_closure.InitEvent();
     error_closure.InitEvent();
 
-    TString fd_name = y_absl::StrCat(name, " fd=", fd);
-    grpc_iomgr_register_object(&iomgr_object, fd_name.c_str());
+    TString fd_name = y_absl::StrCat(name, " fd=", fd); 
+    grpc_iomgr_register_object(&iomgr_object, fd_name.c_str()); 
 #ifndef NDEBUG
     if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_fd_refcount)) {
-      gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, this, fd_name.c_str());
+      gpr_log(GPR_DEBUG, "FD %d %p create %s", fd, this, fd_name.c_str()); 
     }
 #endif
   }
@@ -187,15 +187,15 @@ struct grpc_fd {
     grpc_iomgr_unregister_object(&iomgr_object);
 
     POLLABLE_UNREF(pollable_obj, "fd_pollable");
-
-    // To clear out the allocations of pollset_fds, we need to swap its
-    // contents with a newly-constructed (and soon to be destructed) local
-    // variable of its same type. This is because InlinedVector::clear is _not_
-    // guaranteed to actually free up allocations and this is important since
-    // this object doesn't have a conventional destructor.
-    y_absl::InlinedVector<int, 1> pollset_fds_tmp;
-    pollset_fds_tmp.swap(pollset_fds);
-
+ 
+    // To clear out the allocations of pollset_fds, we need to swap its 
+    // contents with a newly-constructed (and soon to be destructed) local 
+    // variable of its same type. This is because InlinedVector::clear is _not_ 
+    // guaranteed to actually free up allocations and this is important since 
+    // this object doesn't have a conventional destructor. 
+    y_absl::InlinedVector<int, 1> pollset_fds_tmp; 
+    pollset_fds_tmp.swap(pollset_fds); 
+ 
     gpr_mu_destroy(&pollable_mu);
     gpr_mu_destroy(&orphan_mu);
 
@@ -237,8 +237,8 @@ struct grpc_fd {
 
   // Protects pollable_obj and pollset_fds.
   gpr_mu pollable_mu;
-  y_absl::InlinedVector<int, 1> pollset_fds;  // Used in PO_MULTI.
-  pollable* pollable_obj = nullptr;         // Used in PO_FD.
+  y_absl::InlinedVector<int, 1> pollset_fds;  // Used in PO_MULTI. 
+  pollable* pollable_obj = nullptr;         // Used in PO_FD. 
 
   grpc_core::LockfreeEvent read_closure;
   grpc_core::LockfreeEvent write_closure;
@@ -929,8 +929,8 @@ static grpc_error* pollable_epoll(pollable* p, grpc_millis deadline) {
   int timeout = poll_deadline_to_millis_timeout(deadline);
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
-    gpr_log(GPR_INFO, "POLLABLE:%p[%s] poll for %dms", p,
-            pollable_desc(p).c_str(), timeout);
+    gpr_log(GPR_INFO, "POLLABLE:%p[%s] poll for %dms", p, 
+            pollable_desc(p).c_str(), timeout); 
   }
 
   if (timeout != 0) {
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/ev_poll_posix.cc b/contrib/libs/grpc/src/core/lib/iomgr/ev_poll_posix.cc
index a46ab7ea0d..3c296e2418 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/ev_poll_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/ev_poll_posix.cc
@@ -32,10 +32,10 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -310,9 +310,9 @@ static void fork_fd_list_add_wakeup_fd(grpc_cached_wakeup_fd* fd) {
   }
 }
 
-/*******************************************************************************
- * fd_posix.c
- */
+/******************************************************************************* 
+ * fd_posix.c 
+ */ 
 
 #ifndef NDEBUG
 #define REF_BY(fd, n, reason) ref_by(fd, n, reason, __FILE__, __LINE__)
@@ -384,8 +384,8 @@ static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
   r->released = 0;
   gpr_atm_no_barrier_store(&r->pollhup, 0);
 
-  TString name2 = y_absl::StrCat(name, " fd=", fd);
-  grpc_iomgr_register_object(&r->iomgr_object, name2.c_str());
+  TString name2 = y_absl::StrCat(name, " fd=", fd); 
+  grpc_iomgr_register_object(&r->iomgr_object, name2.c_str()); 
   fork_fd_list_add_grpc_fd(r);
   return r;
 }
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/exec_ctx.h b/contrib/libs/grpc/src/core/lib/iomgr/exec_ctx.h
index 6b4e184cad..f66910c4f1 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/exec_ctx.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/exec_ctx.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <limits>
-
+#include <limits> 
+ 
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
@@ -134,12 +134,12 @@ class ExecCtx {
   ExecCtx(const ExecCtx&) = delete;
   ExecCtx& operator=(const ExecCtx&) = delete;
 
-  unsigned starting_cpu() {
-    if (starting_cpu_ == std::numeric_limits<unsigned>::max()) {
-      starting_cpu_ = gpr_cpu_current_cpu();
-    }
-    return starting_cpu_;
-  }
+  unsigned starting_cpu() { 
+    if (starting_cpu_ == std::numeric_limits<unsigned>::max()) { 
+      starting_cpu_ = gpr_cpu_current_cpu(); 
+    } 
+    return starting_cpu_; 
+  } 
 
   struct CombinerData {
     /* currently active combiner: updated only via combiner.c */
@@ -246,7 +246,7 @@ class ExecCtx {
   CombinerData combiner_data_ = {nullptr, nullptr};
   uintptr_t flags_;
 
-  unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
+  unsigned starting_cpu_ = std::numeric_limits<unsigned>::max(); 
 
   bool now_is_valid_ = false;
   grpc_millis now_ = 0;
@@ -331,15 +331,15 @@ class ApplicationCallbackExecCtx {
     }
   }
 
-  uintptr_t Flags() { return flags_; }
-
-  static ApplicationCallbackExecCtx* Get() {
-    return reinterpret_cast<ApplicationCallbackExecCtx*>(
-        gpr_tls_get(&callback_exec_ctx_));
-  }
-
+  uintptr_t Flags() { return flags_; } 
+ 
+  static ApplicationCallbackExecCtx* Get() { 
+    return reinterpret_cast<ApplicationCallbackExecCtx*>( 
+        gpr_tls_get(&callback_exec_ctx_)); 
+  } 
+ 
   static void Set(ApplicationCallbackExecCtx* exec_ctx, uintptr_t flags) {
-    if (Get() == nullptr) {
+    if (Get() == nullptr) { 
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags)) {
         grpc_core::Fork::IncExecCtxCount();
       }
@@ -352,7 +352,7 @@ class ApplicationCallbackExecCtx {
     functor->internal_success = is_success;
     functor->internal_next = nullptr;
 
-    ApplicationCallbackExecCtx* ctx = Get();
+    ApplicationCallbackExecCtx* ctx = Get(); 
 
     if (ctx->head_ == nullptr) {
       ctx->head_ = functor;
@@ -369,8 +369,8 @@ class ApplicationCallbackExecCtx {
   /** Global shutdown for ApplicationCallbackExecCtx. Called by init. */
   static void GlobalShutdown(void) { gpr_tls_destroy(&callback_exec_ctx_); }
 
-  static bool Available() { return Get() != nullptr; }
-
+  static bool Available() { return Get() != nullptr; } 
+ 
  private:
   uintptr_t flags_{0u};
   grpc_experimental_completion_queue_functor* head_{nullptr};
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/executor.cc b/contrib/libs/grpc/src/core/lib/iomgr/executor.cc
index 10b2f948ec..e0b8581992 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/executor.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/executor.cc
@@ -154,7 +154,7 @@ void Executor::SetThreading(bool threading) {
 
   if (threading) {
     if (curr_num_threads > 0) {
-      EXECUTOR_TRACE("(%s) SetThreading(true). curr_num_threads > 0", name_);
+      EXECUTOR_TRACE("(%s) SetThreading(true). curr_num_threads > 0", name_); 
       return;
     }
 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/fork_posix.cc b/contrib/libs/grpc/src/core/lib/iomgr/fork_posix.cc
index 82654b5a88..fec48ccb3f 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/fork_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/fork_posix.cc
@@ -22,10 +22,10 @@
 
 #ifdef GRPC_POSIX_FORK
 
-#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK
-#include <pthread.h>
-#endif
-
+#ifdef GRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK 
+#include <pthread.h> 
+#endif 
+ 
 #include <string.h>
 
 #include <grpc/fork.h>
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/iomgr_posix_cfstream.cc b/contrib/libs/grpc/src/core/lib/iomgr/iomgr_posix_cfstream.cc
index 30c44edb5d..feae0996ba 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/iomgr_posix_cfstream.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/iomgr_posix_cfstream.cc
@@ -16,20 +16,20 @@
  *
  */
 
-/// CFStream is build-enabled on iOS by default and disabled by default on other
-/// platforms (see port_platform.h). To enable CFStream build on another
-/// platform, the users need to define macro "GRPC_CFSTREAM=1" when building
-/// gRPC.
-///
-/// When CFStream is to be built (either by default on iOS or by macro on other
-/// platforms), the users can disable CFStream with environment variable
-/// "grpc_cfstream=0". This will let gRPC to fallback to use POSIX sockets. In
-/// addition, the users may choose to use an alternative CFRunLoop based pollset
-/// "ev_apple" by setting environment variable "GRPC_CFSTREAM_RUN_LOOP=1". This
-/// pollset resolves a bug from Apple when CFStream streams dispatch events to
-/// dispatch queues. The caveat of this pollset is that users may not be able to
-/// run a gRPC server in the same process.
-
+/// CFStream is build-enabled on iOS by default and disabled by default on other 
+/// platforms (see port_platform.h). To enable CFStream build on another 
+/// platform, the users need to define macro "GRPC_CFSTREAM=1" when building 
+/// gRPC. 
+/// 
+/// When CFStream is to be built (either by default on iOS or by macro on other 
+/// platforms), the users can disable CFStream with environment variable 
+/// "grpc_cfstream=0". This will let gRPC to fallback to use POSIX sockets. In 
+/// addition, the users may choose to use an alternative CFRunLoop based pollset 
+/// "ev_apple" by setting environment variable "GRPC_CFSTREAM_RUN_LOOP=1". This 
+/// pollset resolves a bug from Apple when CFStream streams dispatch events to 
+/// dispatch queues. The caveat of this pollset is that users may not be able to 
+/// run a gRPC server in the same process. 
+ 
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/port.h"
@@ -37,7 +37,7 @@
 #ifdef GRPC_CFSTREAM_IOMGR
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/iomgr/ev_apple.h"
+#include "src/core/lib/iomgr/ev_apple.h" 
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/iomgr_posix.h"
@@ -48,7 +48,7 @@
 #include "src/core/lib/iomgr/timer.h"
 
 static const char* grpc_cfstream_env_var = "grpc_cfstream";
-static const char* grpc_cfstream_run_loop_env_var = "GRPC_CFSTREAM_RUN_LOOP";
+static const char* grpc_cfstream_run_loop_env_var = "GRPC_CFSTREAM_RUN_LOOP"; 
 
 extern grpc_tcp_server_vtable grpc_posix_tcp_server_vtable;
 extern grpc_tcp_client_vtable grpc_posix_tcp_client_vtable;
@@ -58,33 +58,33 @@ extern grpc_pollset_vtable grpc_posix_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_posix_pollset_set_vtable;
 extern grpc_address_resolver_vtable grpc_posix_resolver_vtable;
 
-static void apple_iomgr_platform_init(void) { grpc_pollset_global_init(); }
-
-static void apple_iomgr_platform_flush(void) {}
-
-static void apple_iomgr_platform_shutdown(void) {
-  grpc_pollset_global_shutdown();
-}
-
-static void apple_iomgr_platform_shutdown_background_closure(void) {}
-
-static bool apple_iomgr_platform_is_any_background_poller_thread(void) {
-  return false;
-}
-
-static bool apple_iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* closure, grpc_error* error) {
-  return false;
-}
-
-static grpc_iomgr_platform_vtable apple_vtable = {
-    apple_iomgr_platform_init,
-    apple_iomgr_platform_flush,
-    apple_iomgr_platform_shutdown,
-    apple_iomgr_platform_shutdown_background_closure,
-    apple_iomgr_platform_is_any_background_poller_thread,
-    apple_iomgr_platform_add_closure_to_background_poller};
-
+static void apple_iomgr_platform_init(void) { grpc_pollset_global_init(); } 
+ 
+static void apple_iomgr_platform_flush(void) {} 
+ 
+static void apple_iomgr_platform_shutdown(void) { 
+  grpc_pollset_global_shutdown(); 
+} 
+ 
+static void apple_iomgr_platform_shutdown_background_closure(void) {} 
+ 
+static bool apple_iomgr_platform_is_any_background_poller_thread(void) { 
+  return false; 
+} 
+ 
+static bool apple_iomgr_platform_add_closure_to_background_poller( 
+    grpc_closure* closure, grpc_error* error) { 
+  return false; 
+} 
+ 
+static grpc_iomgr_platform_vtable apple_vtable = { 
+    apple_iomgr_platform_init, 
+    apple_iomgr_platform_flush, 
+    apple_iomgr_platform_shutdown, 
+    apple_iomgr_platform_shutdown_background_closure, 
+    apple_iomgr_platform_is_any_background_poller_thread, 
+    apple_iomgr_platform_add_closure_to_background_poller}; 
+ 
 static void iomgr_platform_init(void) {
   grpc_wakeup_fd_global_init();
   grpc_event_engine_init();
@@ -119,53 +119,53 @@ static grpc_iomgr_platform_vtable vtable = {
     iomgr_platform_add_closure_to_background_poller};
 
 void grpc_set_default_iomgr_platform() {
-  char* enable_cfstream_str = getenv(grpc_cfstream_env_var);
-  bool enable_cfstream =
-      enable_cfstream_str == nullptr || enable_cfstream_str[0] != '0';
-  char* enable_cfstream_run_loop_str = getenv(grpc_cfstream_run_loop_env_var);
-  // CFStream run-loop is disabled by default. The user has to enable it
-  // explicitly with environment variable.
-  bool enable_cfstream_run_loop = enable_cfstream_run_loop_str != nullptr &&
-                                  enable_cfstream_run_loop_str[0] == '1';
-  if (!enable_cfstream) {
-    // Use POSIX sockets for both client and server
-    grpc_set_tcp_client_impl(&grpc_posix_tcp_client_vtable);
-    grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);
-    grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
-    grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
-    grpc_set_iomgr_platform_vtable(&vtable);
-  } else if (enable_cfstream && !enable_cfstream_run_loop) {
-    // Use CFStream with dispatch queue for client; use POSIX sockets for server
-    grpc_set_tcp_client_impl(&grpc_cfstream_client_vtable);
-    grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable);
-    grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
-    grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
-    grpc_set_iomgr_platform_vtable(&vtable);
-  } else {
-    // Use CFStream with CFRunLoop for client; server not supported
-    grpc_set_tcp_client_impl(&grpc_cfstream_client_vtable);
-    grpc_set_pollset_vtable(&grpc_apple_pollset_vtable);
-    grpc_set_pollset_set_vtable(&grpc_apple_pollset_set_vtable);
-    grpc_set_iomgr_platform_vtable(&apple_vtable);
+  char* enable_cfstream_str = getenv(grpc_cfstream_env_var); 
+  bool enable_cfstream = 
+      enable_cfstream_str == nullptr || enable_cfstream_str[0] != '0'; 
+  char* enable_cfstream_run_loop_str = getenv(grpc_cfstream_run_loop_env_var); 
+  // CFStream run-loop is disabled by default. The user has to enable it 
+  // explicitly with environment variable. 
+  bool enable_cfstream_run_loop = enable_cfstream_run_loop_str != nullptr && 
+                                  enable_cfstream_run_loop_str[0] == '1'; 
+  if (!enable_cfstream) { 
+    // Use POSIX sockets for both client and server 
+    grpc_set_tcp_client_impl(&grpc_posix_tcp_client_vtable); 
+    grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable); 
+    grpc_set_pollset_vtable(&grpc_posix_pollset_vtable); 
+    grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable); 
+    grpc_set_iomgr_platform_vtable(&vtable); 
+  } else if (enable_cfstream && !enable_cfstream_run_loop) { 
+    // Use CFStream with dispatch queue for client; use POSIX sockets for server 
+    grpc_set_tcp_client_impl(&grpc_cfstream_client_vtable); 
+    grpc_set_tcp_server_impl(&grpc_posix_tcp_server_vtable); 
+    grpc_set_pollset_vtable(&grpc_posix_pollset_vtable); 
+    grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable); 
+    grpc_set_iomgr_platform_vtable(&vtable); 
+  } else { 
+    // Use CFStream with CFRunLoop for client; server not supported 
+    grpc_set_tcp_client_impl(&grpc_cfstream_client_vtable); 
+    grpc_set_pollset_vtable(&grpc_apple_pollset_vtable); 
+    grpc_set_pollset_set_vtable(&grpc_apple_pollset_set_vtable); 
+    grpc_set_iomgr_platform_vtable(&apple_vtable); 
   }
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
   grpc_set_resolver_impl(&grpc_posix_resolver_vtable);
 }
 
 bool grpc_iomgr_run_in_background() {
-  char* enable_cfstream_str = getenv(grpc_cfstream_env_var);
-  bool enable_cfstream =
-      enable_cfstream_str == nullptr || enable_cfstream_str[0] != '0';
-  char* enable_cfstream_run_loop_str = getenv(grpc_cfstream_run_loop_env_var);
-  // CFStream run-loop is disabled by default. The user has to enable it
-  // explicitly with environment variable.
-  bool enable_cfstream_run_loop = enable_cfstream_run_loop_str != nullptr &&
-                                  enable_cfstream_run_loop_str[0] == '1';
-  if (enable_cfstream && enable_cfstream_run_loop) {
-    return false;
-  } else {
-    return grpc_event_engine_run_in_background();
-  }
+  char* enable_cfstream_str = getenv(grpc_cfstream_env_var); 
+  bool enable_cfstream = 
+      enable_cfstream_str == nullptr || enable_cfstream_str[0] != '0'; 
+  char* enable_cfstream_run_loop_str = getenv(grpc_cfstream_run_loop_env_var); 
+  // CFStream run-loop is disabled by default. The user has to enable it 
+  // explicitly with environment variable. 
+  bool enable_cfstream_run_loop = enable_cfstream_run_loop_str != nullptr && 
+                                  enable_cfstream_run_loop_str[0] == '1'; 
+  if (enable_cfstream && enable_cfstream_run_loop) { 
+    return false; 
+  } else { 
+    return grpc_event_engine_run_in_background(); 
+  } 
 }
 
 #endif /* GRPC_CFSTREAM_IOMGR */
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/is_epollexclusive_available.cc b/contrib/libs/grpc/src/core/lib/iomgr/is_epollexclusive_available.cc
index abc901efbe..b9daf1f79c 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/is_epollexclusive_available.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/is_epollexclusive_available.cc
@@ -93,20 +93,20 @@ bool grpc_is_epollexclusive_available(void) {
     close(evfd);
     return false;
   }
-  // Check that EPOLLEXCLUSIVE is supported at all.
-  ev.events = static_cast<uint32_t>(EPOLLET | EPOLLIN | EPOLLEXCLUSIVE);
-  if (epoll_ctl(fd, EPOLL_CTL_ADD, evfd, &ev) != 0) {
-    if (!logged_why_not) {
-      gpr_log(GPR_DEBUG,
-              "epoll_ctl with EPOLLEXCLUSIVE failed with error: "
-              "%d. Not using epollex polling engine.",
-              errno);
-      logged_why_not = true;
-    }
-    close(fd);
-    close(evfd);
-    return false;
-  }
+  // Check that EPOLLEXCLUSIVE is supported at all. 
+  ev.events = static_cast<uint32_t>(EPOLLET | EPOLLIN | EPOLLEXCLUSIVE); 
+  if (epoll_ctl(fd, EPOLL_CTL_ADD, evfd, &ev) != 0) { 
+    if (!logged_why_not) { 
+      gpr_log(GPR_DEBUG, 
+              "epoll_ctl with EPOLLEXCLUSIVE failed with error: " 
+              "%d. Not using epollex polling engine.", 
+              errno); 
+      logged_why_not = true; 
+    } 
+    close(fd); 
+    close(evfd); 
+    return false; 
+  } 
   close(evfd);
   close(fd);
   return true;
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/load_file.cc b/contrib/libs/grpc/src/core/lib/iomgr/load_file.cc
index 4bed6275dc..ed193b56cb 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/load_file.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/load_file.cc
@@ -53,7 +53,7 @@ grpc_error* grpc_load_file(const char* filename, int add_null_terminator,
       gpr_malloc(contents_size + (add_null_terminator ? 1 : 0)));
   bytes_read = fread(contents, 1, contents_size, file);
   if (bytes_read < contents_size) {
-    gpr_free(contents);
+    gpr_free(contents); 
     error = GRPC_OS_ERROR(errno, "fread");
     GPR_ASSERT(ferror(file));
     goto end;
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/parse_address.cc b/contrib/libs/grpc/src/core/lib/iomgr/parse_address.cc
index af514c81cd..a1bbacd8f5 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/parse_address.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/parse_address.cc
@@ -1,238 +1,238 @@
-/*
- *
- * 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
-#include "src/core/lib/iomgr/parse_address.h"
-#include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/socket_utils.h"
-
-#include <stdio.h>
-#include <string.h>
-#ifdef GRPC_HAVE_UNIX_SOCKET
-#include <sys/un.h>
-#endif
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/host_port.h"
-
-#ifdef GRPC_POSIX_SOCKET
-#include <errno.h>
-#include <net/if.h>
-#endif
-
-#ifdef GRPC_HAVE_UNIX_SOCKET
-
-bool grpc_parse_unix(const grpc_uri* uri,
-                     grpc_resolved_address* resolved_addr) {
-  if (strcmp("unix", uri->scheme) != 0) {
-    gpr_log(GPR_ERROR, "Expected 'unix' scheme, got '%s'", uri->scheme);
-    return false;
-  }
-  struct sockaddr_un* un =
-      reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
-  const size_t maxlen = sizeof(un->sun_path);
-  const size_t path_len = strnlen(uri->path, maxlen);
-  if (path_len == maxlen) return false;
-  un->sun_family = AF_UNIX;
-  strcpy(un->sun_path, uri->path);
-  resolved_addr->len = static_cast<socklen_t>(sizeof(*un));
-  return true;
-}
-
-#else /* GRPC_HAVE_UNIX_SOCKET */
-
-bool grpc_parse_unix(const grpc_uri* uri,
-                     grpc_resolved_address* resolved_addr) {
-  abort();
-}
-
-#endif /* GRPC_HAVE_UNIX_SOCKET */
-
-bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr,
-                              bool log_errors) {
-  bool success = false;
-  // Split host and port.
-  TString host;
-  TString port;
-  if (!grpc_core::SplitHostPort(hostport, &host, &port)) {
-    if (log_errors) {
-      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)", hostport);
-    }
-    return false;
-  }
-  // Parse IP address.
-  memset(addr, 0, sizeof(*addr));
-  addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
-  grpc_sockaddr_in* in = reinterpret_cast<grpc_sockaddr_in*>(addr->addr);
-  in->sin_family = GRPC_AF_INET;
-  if (grpc_inet_pton(GRPC_AF_INET, host.c_str(), &in->sin_addr) == 0) {
-    if (log_errors) {
-      gpr_log(GPR_ERROR, "invalid ipv4 address: '%s'", host.c_str());
-    }
-    goto done;
-  }
-  // Parse port.
-  if (port.empty()) {
-    if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv4 scheme");
-    goto done;
-  }
-  int port_num;
-  if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 ||
-      port_num > 65535) {
-    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv4 port: '%s'", port.c_str());
-    goto done;
-  }
-  in->sin_port = grpc_htons(static_cast<uint16_t>(port_num));
-  success = true;
-done:
-  return success;
-}
-
-bool grpc_parse_ipv4(const grpc_uri* uri,
-                     grpc_resolved_address* resolved_addr) {
-  if (strcmp("ipv4", uri->scheme) != 0) {
-    gpr_log(GPR_ERROR, "Expected 'ipv4' scheme, got '%s'", uri->scheme);
-    return false;
-  }
-  const char* host_port = uri->path;
-  if (*host_port == '/') ++host_port;
-  return grpc_parse_ipv4_hostport(host_port, resolved_addr,
-                                  true /* log_errors */);
-}
-
-bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
-                              bool log_errors) {
-  bool success = false;
-  // Split host and port.
-  TString host;
-  TString port;
-  if (!grpc_core::SplitHostPort(hostport, &host, &port)) {
-    if (log_errors) {
-      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)", hostport);
-    }
-    return false;
-  }
-  // Parse IP address.
-  memset(addr, 0, sizeof(*addr));
-  addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
-  grpc_sockaddr_in6* in6 = reinterpret_cast<grpc_sockaddr_in6*>(addr->addr);
-  in6->sin6_family = GRPC_AF_INET6;
-  // Handle the RFC6874 syntax for IPv6 zone identifiers.
-  char* host_end =
-      static_cast<char*>(gpr_memrchr(host.c_str(), '%', host.size()));
-  if (host_end != nullptr) {
-    GPR_ASSERT(host_end >= host.c_str());
-    char host_without_scope[GRPC_INET6_ADDRSTRLEN + 1];
-    size_t host_without_scope_len =
-        static_cast<size_t>(host_end - host.c_str());
-    uint32_t sin6_scope_id = 0;
-    if (host_without_scope_len > GRPC_INET6_ADDRSTRLEN) {
-      if (log_errors) {
-        gpr_log(
-            GPR_ERROR,
-            "invalid ipv6 address length %zu. Length cannot be greater than "
-            "GRPC_INET6_ADDRSTRLEN i.e %d)",
-            host_without_scope_len, GRPC_INET6_ADDRSTRLEN);
-      }
-      goto done;
-    }
-    strncpy(host_without_scope, host.c_str(), host_without_scope_len);
-    host_without_scope[host_without_scope_len] = '\0';
-    if (grpc_inet_pton(GRPC_AF_INET6, host_without_scope, &in6->sin6_addr) ==
-        0) {
-      if (log_errors) {
-        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host_without_scope);
-      }
-      goto done;
-    }
-    if (gpr_parse_bytes_to_uint32(host_end + 1,
-                                  host.size() - host_without_scope_len - 1,
-                                  &sin6_scope_id) == 0) {
-      if ((sin6_scope_id = grpc_if_nametoindex(host_end + 1)) == 0) {
-        gpr_log(GPR_ERROR,
-                "Invalid interface name: '%s'. "
-                "Non-numeric and failed if_nametoindex.",
-                host_end + 1);
-        goto done;
-      }
-    }
-    // Handle "sin6_scope_id" being type "u_long". See grpc issue #10027.
-    in6->sin6_scope_id = sin6_scope_id;
-  } else {
-    if (grpc_inet_pton(GRPC_AF_INET6, host.c_str(), &in6->sin6_addr) == 0) {
-      if (log_errors) {
-        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host.c_str());
-      }
-      goto done;
-    }
-  }
-  // Parse port.
-  if (port.empty()) {
-    if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv6 scheme");
-    goto done;
-  }
-  int port_num;
-  if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 ||
-      port_num > 65535) {
-    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv6 port: '%s'", port.c_str());
-    goto done;
-  }
-  in6->sin6_port = grpc_htons(static_cast<uint16_t>(port_num));
-  success = true;
-done:
-  return success;
-}
-
-bool grpc_parse_ipv6(const grpc_uri* uri,
-                     grpc_resolved_address* resolved_addr) {
-  if (strcmp("ipv6", uri->scheme) != 0) {
-    gpr_log(GPR_ERROR, "Expected 'ipv6' scheme, got '%s'", uri->scheme);
-    return false;
-  }
-  const char* host_port = uri->path;
-  if (*host_port == '/') ++host_port;
-  return grpc_parse_ipv6_hostport(host_port, resolved_addr,
-                                  true /* log_errors */);
-}
-
-bool grpc_parse_uri(const grpc_uri* uri, grpc_resolved_address* resolved_addr) {
-  if (strcmp("unix", uri->scheme) == 0) {
-    return grpc_parse_unix(uri, resolved_addr);
-  } else if (strcmp("ipv4", uri->scheme) == 0) {
-    return grpc_parse_ipv4(uri, resolved_addr);
-  } else if (strcmp("ipv6", uri->scheme) == 0) {
-    return grpc_parse_ipv6(uri, resolved_addr);
-  }
-  gpr_log(GPR_ERROR, "Can't parse scheme '%s'", uri->scheme);
-  return false;
-}
-
-uint16_t grpc_strhtons(const char* port) {
-  if (strcmp(port, "http") == 0) {
-    return htons(80);
-  } else if (strcmp(port, "https") == 0) {
-    return htons(443);
-  }
-  return htons(static_cast<unsigned short>(atoi(port)));
-}
+/* 
+ * 
+ * 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. 
+ * 
+ */ 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/iomgr/grpc_if_nametoindex.h" 
+#include "src/core/lib/iomgr/parse_address.h" 
+#include "src/core/lib/iomgr/sockaddr.h" 
+#include "src/core/lib/iomgr/socket_utils.h" 
+ 
+#include <stdio.h> 
+#include <string.h> 
+#ifdef GRPC_HAVE_UNIX_SOCKET 
+#include <sys/un.h> 
+#endif 
+ 
+#include <grpc/support/alloc.h> 
+#include <grpc/support/log.h> 
+#include <grpc/support/string_util.h> 
+ 
+#include "src/core/lib/gpr/string.h" 
+#include "src/core/lib/gprpp/host_port.h" 
+ 
+#ifdef GRPC_POSIX_SOCKET 
+#include <errno.h> 
+#include <net/if.h> 
+#endif 
+ 
+#ifdef GRPC_HAVE_UNIX_SOCKET 
+ 
+bool grpc_parse_unix(const grpc_uri* uri, 
+                     grpc_resolved_address* resolved_addr) { 
+  if (strcmp("unix", uri->scheme) != 0) { 
+    gpr_log(GPR_ERROR, "Expected 'unix' scheme, got '%s'", uri->scheme); 
+    return false; 
+  } 
+  struct sockaddr_un* un = 
+      reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr); 
+  const size_t maxlen = sizeof(un->sun_path); 
+  const size_t path_len = strnlen(uri->path, maxlen); 
+  if (path_len == maxlen) return false; 
+  un->sun_family = AF_UNIX; 
+  strcpy(un->sun_path, uri->path); 
+  resolved_addr->len = static_cast<socklen_t>(sizeof(*un)); 
+  return true; 
+} 
+ 
+#else /* GRPC_HAVE_UNIX_SOCKET */ 
+ 
+bool grpc_parse_unix(const grpc_uri* uri, 
+                     grpc_resolved_address* resolved_addr) { 
+  abort(); 
+} 
+ 
+#endif /* GRPC_HAVE_UNIX_SOCKET */ 
+ 
+bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr, 
+                              bool log_errors) { 
+  bool success = false; 
+  // Split host and port. 
+  TString host; 
+  TString port; 
+  if (!grpc_core::SplitHostPort(hostport, &host, &port)) { 
+    if (log_errors) { 
+      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)", hostport); 
+    } 
+    return false; 
+  } 
+  // Parse IP address. 
+  memset(addr, 0, sizeof(*addr)); 
+  addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in)); 
+  grpc_sockaddr_in* in = reinterpret_cast<grpc_sockaddr_in*>(addr->addr); 
+  in->sin_family = GRPC_AF_INET; 
+  if (grpc_inet_pton(GRPC_AF_INET, host.c_str(), &in->sin_addr) == 0) { 
+    if (log_errors) { 
+      gpr_log(GPR_ERROR, "invalid ipv4 address: '%s'", host.c_str()); 
+    } 
+    goto done; 
+  } 
+  // Parse port. 
+  if (port.empty()) { 
+    if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv4 scheme"); 
+    goto done; 
+  } 
+  int port_num; 
+  if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 || 
+      port_num > 65535) { 
+    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv4 port: '%s'", port.c_str()); 
+    goto done; 
+  } 
+  in->sin_port = grpc_htons(static_cast<uint16_t>(port_num)); 
+  success = true; 
+done: 
+  return success; 
+} 
+ 
+bool grpc_parse_ipv4(const grpc_uri* uri, 
+                     grpc_resolved_address* resolved_addr) { 
+  if (strcmp("ipv4", uri->scheme) != 0) { 
+    gpr_log(GPR_ERROR, "Expected 'ipv4' scheme, got '%s'", uri->scheme); 
+    return false; 
+  } 
+  const char* host_port = uri->path; 
+  if (*host_port == '/') ++host_port; 
+  return grpc_parse_ipv4_hostport(host_port, resolved_addr, 
+                                  true /* log_errors */); 
+} 
+ 
+bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr, 
+                              bool log_errors) { 
+  bool success = false; 
+  // Split host and port. 
+  TString host; 
+  TString port; 
+  if (!grpc_core::SplitHostPort(hostport, &host, &port)) { 
+    if (log_errors) { 
+      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)", hostport); 
+    } 
+    return false; 
+  } 
+  // Parse IP address. 
+  memset(addr, 0, sizeof(*addr)); 
+  addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6)); 
+  grpc_sockaddr_in6* in6 = reinterpret_cast<grpc_sockaddr_in6*>(addr->addr); 
+  in6->sin6_family = GRPC_AF_INET6; 
+  // Handle the RFC6874 syntax for IPv6 zone identifiers. 
+  char* host_end = 
+      static_cast<char*>(gpr_memrchr(host.c_str(), '%', host.size())); 
+  if (host_end != nullptr) { 
+    GPR_ASSERT(host_end >= host.c_str()); 
+    char host_without_scope[GRPC_INET6_ADDRSTRLEN + 1]; 
+    size_t host_without_scope_len = 
+        static_cast<size_t>(host_end - host.c_str()); 
+    uint32_t sin6_scope_id = 0; 
+    if (host_without_scope_len > GRPC_INET6_ADDRSTRLEN) { 
+      if (log_errors) { 
+        gpr_log( 
+            GPR_ERROR, 
+            "invalid ipv6 address length %zu. Length cannot be greater than " 
+            "GRPC_INET6_ADDRSTRLEN i.e %d)", 
+            host_without_scope_len, GRPC_INET6_ADDRSTRLEN); 
+      } 
+      goto done; 
+    } 
+    strncpy(host_without_scope, host.c_str(), host_without_scope_len); 
+    host_without_scope[host_without_scope_len] = '\0'; 
+    if (grpc_inet_pton(GRPC_AF_INET6, host_without_scope, &in6->sin6_addr) == 
+        0) { 
+      if (log_errors) { 
+        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host_without_scope); 
+      } 
+      goto done; 
+    } 
+    if (gpr_parse_bytes_to_uint32(host_end + 1, 
+                                  host.size() - host_without_scope_len - 1, 
+                                  &sin6_scope_id) == 0) { 
+      if ((sin6_scope_id = grpc_if_nametoindex(host_end + 1)) == 0) { 
+        gpr_log(GPR_ERROR, 
+                "Invalid interface name: '%s'. " 
+                "Non-numeric and failed if_nametoindex.", 
+                host_end + 1); 
+        goto done; 
+      } 
+    } 
+    // Handle "sin6_scope_id" being type "u_long". See grpc issue #10027. 
+    in6->sin6_scope_id = sin6_scope_id; 
+  } else { 
+    if (grpc_inet_pton(GRPC_AF_INET6, host.c_str(), &in6->sin6_addr) == 0) { 
+      if (log_errors) { 
+        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host.c_str()); 
+      } 
+      goto done; 
+    } 
+  } 
+  // Parse port. 
+  if (port.empty()) { 
+    if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv6 scheme"); 
+    goto done; 
+  } 
+  int port_num; 
+  if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 || 
+      port_num > 65535) { 
+    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv6 port: '%s'", port.c_str()); 
+    goto done; 
+  } 
+  in6->sin6_port = grpc_htons(static_cast<uint16_t>(port_num)); 
+  success = true; 
+done: 
+  return success; 
+} 
+ 
+bool grpc_parse_ipv6(const grpc_uri* uri, 
+                     grpc_resolved_address* resolved_addr) { 
+  if (strcmp("ipv6", uri->scheme) != 0) { 
+    gpr_log(GPR_ERROR, "Expected 'ipv6' scheme, got '%s'", uri->scheme); 
+    return false; 
+  } 
+  const char* host_port = uri->path; 
+  if (*host_port == '/') ++host_port; 
+  return grpc_parse_ipv6_hostport(host_port, resolved_addr, 
+                                  true /* log_errors */); 
+} 
+ 
+bool grpc_parse_uri(const grpc_uri* uri, grpc_resolved_address* resolved_addr) { 
+  if (strcmp("unix", uri->scheme) == 0) { 
+    return grpc_parse_unix(uri, resolved_addr); 
+  } else if (strcmp("ipv4", uri->scheme) == 0) { 
+    return grpc_parse_ipv4(uri, resolved_addr); 
+  } else if (strcmp("ipv6", uri->scheme) == 0) { 
+    return grpc_parse_ipv6(uri, resolved_addr); 
+  } 
+  gpr_log(GPR_ERROR, "Can't parse scheme '%s'", uri->scheme); 
+  return false; 
+} 
+ 
+uint16_t grpc_strhtons(const char* port) { 
+  if (strcmp(port, "http") == 0) { 
+    return htons(80); 
+  } else if (strcmp(port, "https") == 0) { 
+    return htons(443); 
+  } 
+  return htons(static_cast<unsigned short>(atoi(port))); 
+} 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/parse_address.h b/contrib/libs/grpc/src/core/lib/iomgr/parse_address.h
index d42daac46a..5795fd7889 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/parse_address.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/parse_address.h
@@ -1,53 +1,53 @@
-/*
- *
- * 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_CORE_LIB_IOMGR_PARSE_ADDRESS_H
-#define GRPC_CORE_LIB_IOMGR_PARSE_ADDRESS_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stddef.h>
-
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/uri/uri_parser.h"
-
-/** Populate \a resolved_addr from \a uri, whose path is expected to contain a
- * unix socket path. Returns true upon success. */
-bool grpc_parse_unix(const grpc_uri* uri, grpc_resolved_address* resolved_addr);
-
-/** Populate \a resolved_addr from \a uri, whose path is expected to contain an
- * IPv4 host:port pair. Returns true upon success. */
-bool grpc_parse_ipv4(const grpc_uri* uri, grpc_resolved_address* resolved_addr);
-
-/** Populate \a resolved_addr from \a uri, whose path is expected to contain an
- * IPv6 host:port pair. Returns true upon success. */
-bool grpc_parse_ipv6(const grpc_uri* uri, grpc_resolved_address* resolved_addr);
-
-/** Populate \a resolved_addr from \a uri. Returns true upon success. */
-bool grpc_parse_uri(const grpc_uri* uri, grpc_resolved_address* resolved_addr);
-
-/** Parse bare IPv4 or IPv6 "IP:port" strings. */
-bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr,
-                              bool log_errors);
-bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
-                              bool log_errors);
-
-/* Converts named or numeric port to a uint16 suitable for use in a sockaddr. */
-uint16_t grpc_strhtons(const char* port);
-
-#endif /* GRPC_CORE_LIB_IOMGR_PARSE_ADDRESS_H */
+/* 
+ * 
+ * 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_CORE_LIB_IOMGR_PARSE_ADDRESS_H 
+#define GRPC_CORE_LIB_IOMGR_PARSE_ADDRESS_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <stddef.h> 
+ 
+#include "src/core/lib/iomgr/resolve_address.h" 
+#include "src/core/lib/uri/uri_parser.h" 
+ 
+/** Populate \a resolved_addr from \a uri, whose path is expected to contain a 
+ * unix socket path. Returns true upon success. */ 
+bool grpc_parse_unix(const grpc_uri* uri, grpc_resolved_address* resolved_addr); 
+ 
+/** Populate \a resolved_addr from \a uri, whose path is expected to contain an 
+ * IPv4 host:port pair. Returns true upon success. */ 
+bool grpc_parse_ipv4(const grpc_uri* uri, grpc_resolved_address* resolved_addr); 
+ 
+/** Populate \a resolved_addr from \a uri, whose path is expected to contain an 
+ * IPv6 host:port pair. Returns true upon success. */ 
+bool grpc_parse_ipv6(const grpc_uri* uri, grpc_resolved_address* resolved_addr); 
+ 
+/** Populate \a resolved_addr from \a uri. Returns true upon success. */ 
+bool grpc_parse_uri(const grpc_uri* uri, grpc_resolved_address* resolved_addr); 
+ 
+/** Parse bare IPv4 or IPv6 "IP:port" strings. */ 
+bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr, 
+                              bool log_errors); 
+bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr, 
+                              bool log_errors); 
+ 
+/* Converts named or numeric port to a uint16 suitable for use in a sockaddr. */ 
+uint16_t grpc_strhtons(const char* port); 
+ 
+#endif /* GRPC_CORE_LIB_IOMGR_PARSE_ADDRESS_H */ 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/poller/eventmanager_libuv.cc b/contrib/libs/grpc/src/core/lib/iomgr/poller/eventmanager_libuv.cc
index e7045df585..992d532ab7 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/poller/eventmanager_libuv.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/poller/eventmanager_libuv.cc
@@ -1,87 +1,87 @@
-/*
- *
- * 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/poller/eventmanager_libuv.h"
-
-#include <grpc/support/time.h>
-
-grpc::experimental::LibuvEventManager::Options::Options() : num_workers_(-1) {}
-grpc::experimental::LibuvEventManager::Options::Options(int num_workers)
-    : num_workers_(num_workers) {}
-
-grpc::experimental::LibuvEventManager::LibuvEventManager(const Options& options)
-    : options_(options) {
-  int num_workers = options_.num_workers();
-  // Number of workers can't be 0 if we do not accept thread donation.
-  // TODO(guantaol): replaces the hard-coded number with a flag.
-  if (num_workers <= 0) num_workers = 32;
-
-  for (int i = 0; i < num_workers; i++) {
-    workers_.emplace_back(
-        options_.thread_name_prefix().c_str(),
-        [](void* em) { static_cast<LibuvEventManager*>(em)->RunWorkerLoop(); },
-        this);
-    workers_.back().Start();
-  }
-}
-
-grpc::experimental::LibuvEventManager::~LibuvEventManager() {
-  Shutdown();
-  for (auto& th : workers_) {
-    th.Join();
-  }
-}
-
-void grpc::experimental::LibuvEventManager::RunWorkerLoop() {
-  while (true) {
-    // TODO(guantaol): extend the worker loop with real work.
-    if (ShouldStop()) return;
-    gpr_sleep_until(gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
-                                 gpr_time_from_micros(10, GPR_TIMESPAN)));
-  }
-}
-
-bool grpc::experimental::LibuvEventManager::ShouldStop() {
-  return should_stop_.Load(grpc_core::MemoryOrder::ACQUIRE) != 0;
-}
-
-void grpc::experimental::LibuvEventManager::Shutdown() {
-  if (should_stop_.Load(grpc_core::MemoryOrder::ACQUIRE))
-    return;  // Already shut down.
-
-  {
-    grpc_core::MutexLock lock(&shutdown_mu_);
-    while (shutdown_refcount_.Load(grpc_core::MemoryOrder::ACQUIRE) > 0) {
-      shutdown_cv_.Wait(&shutdown_mu_);
-    }
-  }
-  should_stop_.Store(true, grpc_core::MemoryOrder::RELEASE);
-}
-
-void grpc::experimental::LibuvEventManager::ShutdownRef() {
-  shutdown_refcount_.FetchAdd(1, grpc_core::MemoryOrder::RELAXED);
-}
-
-void grpc::experimental::LibuvEventManager::ShutdownUnref() {
-  if (shutdown_refcount_.FetchSub(1, grpc_core::MemoryOrder::ACQ_REL) == 1) {
-    grpc_core::MutexLock lock(&shutdown_mu_);
-    shutdown_cv_.Signal();
-  }
-}
+/* 
+ * 
+ * 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. 
+ * 
+ */ 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/iomgr/poller/eventmanager_libuv.h" 
+ 
+#include <grpc/support/time.h> 
+ 
+grpc::experimental::LibuvEventManager::Options::Options() : num_workers_(-1) {} 
+grpc::experimental::LibuvEventManager::Options::Options(int num_workers) 
+    : num_workers_(num_workers) {} 
+ 
+grpc::experimental::LibuvEventManager::LibuvEventManager(const Options& options) 
+    : options_(options) { 
+  int num_workers = options_.num_workers(); 
+  // Number of workers can't be 0 if we do not accept thread donation. 
+  // TODO(guantaol): replaces the hard-coded number with a flag. 
+  if (num_workers <= 0) num_workers = 32; 
+ 
+  for (int i = 0; i < num_workers; i++) { 
+    workers_.emplace_back( 
+        options_.thread_name_prefix().c_str(), 
+        [](void* em) { static_cast<LibuvEventManager*>(em)->RunWorkerLoop(); }, 
+        this); 
+    workers_.back().Start(); 
+  } 
+} 
+ 
+grpc::experimental::LibuvEventManager::~LibuvEventManager() { 
+  Shutdown(); 
+  for (auto& th : workers_) { 
+    th.Join(); 
+  } 
+} 
+ 
+void grpc::experimental::LibuvEventManager::RunWorkerLoop() { 
+  while (true) { 
+    // TODO(guantaol): extend the worker loop with real work. 
+    if (ShouldStop()) return; 
+    gpr_sleep_until(gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), 
+                                 gpr_time_from_micros(10, GPR_TIMESPAN))); 
+  } 
+} 
+ 
+bool grpc::experimental::LibuvEventManager::ShouldStop() { 
+  return should_stop_.Load(grpc_core::MemoryOrder::ACQUIRE) != 0; 
+} 
+ 
+void grpc::experimental::LibuvEventManager::Shutdown() { 
+  if (should_stop_.Load(grpc_core::MemoryOrder::ACQUIRE)) 
+    return;  // Already shut down. 
+ 
+  { 
+    grpc_core::MutexLock lock(&shutdown_mu_); 
+    while (shutdown_refcount_.Load(grpc_core::MemoryOrder::ACQUIRE) > 0) { 
+      shutdown_cv_.Wait(&shutdown_mu_); 
+    } 
+  } 
+  should_stop_.Store(true, grpc_core::MemoryOrder::RELEASE); 
+} 
+ 
+void grpc::experimental::LibuvEventManager::ShutdownRef() { 
+  shutdown_refcount_.FetchAdd(1, grpc_core::MemoryOrder::RELAXED); 
+} 
+ 
+void grpc::experimental::LibuvEventManager::ShutdownUnref() { 
+  if (shutdown_refcount_.FetchSub(1, grpc_core::MemoryOrder::ACQ_REL) == 1) { 
+    grpc_core::MutexLock lock(&shutdown_mu_); 
+    shutdown_cv_.Signal(); 
+  } 
+} 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/poller/eventmanager_libuv.h b/contrib/libs/grpc/src/core/lib/iomgr/poller/eventmanager_libuv.h
index 88988a1890..ee6f8037d8 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/poller/eventmanager_libuv.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/poller/eventmanager_libuv.h
@@ -1,88 +1,88 @@
-/*
- *
- * 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 GRPC_CORE_LIB_IOMGR_POLLER_EVENTMANAGER_LIBUV_H
-#define GRPC_CORE_LIB_IOMGR_POLLER_EVENTMANAGER_LIBUV_H
-
-#include <grpc/support/port_platform.h>
-
-#include <util/generic/string.h>
-#include <vector>
-
-#include "src/core/lib/gprpp/atomic.h"
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/gprpp/thd.h"
-
-namespace grpc {
-namespace experimental {
-
-class LibuvEventManager {
- public:
-  class Options {
-   public:
-    Options();
-    Options(int num_workers);
-
-    int num_workers() const { return num_workers_; }
-    void set_num_workers(int num) { num_workers_ = num; }
-
-    const TString& thread_name_prefix() const {
-      return thread_name_prefix_;
-    }
-    void set_thread_name_prefix(const TString& name) {
-      thread_name_prefix_ = name;
-    }
-
-   private:
-    // Number of worker threads to create at startup. If less than 0, uses the
-    // default value of 32.
-    int num_workers_;
-    // Name prefix used for worker.
-    TString thread_name_prefix_;
-  };
-
-  explicit LibuvEventManager(const Options& options);
-  virtual ~LibuvEventManager();
-
-  void Shutdown();
-  void ShutdownRef();
-  void ShutdownUnref();
-
- private:
-  // Function run by the worker threads.
-  void RunWorkerLoop();
-
-  // Whether the EventManager has been shut down.
-  bool ShouldStop();
-
-  const Options options_;
-  // Whether the EventManager workers should be stopped.
-  grpc_core::Atomic<bool> should_stop_{false};
-  // A refcount preventing the EventManager from shutdown.
-  grpc_core::Atomic<int> shutdown_refcount_{0};
-  // Worker threads of the EventManager.
-  std::vector<grpc_core::Thread> workers_;
-  // Mutex and condition variable used for shutdown.
-  grpc_core::Mutex shutdown_mu_;
-  grpc_core::CondVar shutdown_cv_;
-};
-
-}  // namespace experimental
-}  // namespace grpc
-
-#endif /* GRPC_CORE_LIB_IOMGR_POLLER_EVENTMANAGER_LIBUV_H */
+/* 
+ * 
+ * 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 GRPC_CORE_LIB_IOMGR_POLLER_EVENTMANAGER_LIBUV_H 
+#define GRPC_CORE_LIB_IOMGR_POLLER_EVENTMANAGER_LIBUV_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <util/generic/string.h> 
+#include <vector> 
+ 
+#include "src/core/lib/gprpp/atomic.h" 
+#include "src/core/lib/gprpp/sync.h" 
+#include "src/core/lib/gprpp/thd.h" 
+ 
+namespace grpc { 
+namespace experimental { 
+ 
+class LibuvEventManager { 
+ public: 
+  class Options { 
+   public: 
+    Options(); 
+    Options(int num_workers); 
+ 
+    int num_workers() const { return num_workers_; } 
+    void set_num_workers(int num) { num_workers_ = num; } 
+ 
+    const TString& thread_name_prefix() const { 
+      return thread_name_prefix_; 
+    } 
+    void set_thread_name_prefix(const TString& name) { 
+      thread_name_prefix_ = name; 
+    } 
+ 
+   private: 
+    // Number of worker threads to create at startup. If less than 0, uses the 
+    // default value of 32. 
+    int num_workers_; 
+    // Name prefix used for worker. 
+    TString thread_name_prefix_; 
+  }; 
+ 
+  explicit LibuvEventManager(const Options& options); 
+  virtual ~LibuvEventManager(); 
+ 
+  void Shutdown(); 
+  void ShutdownRef(); 
+  void ShutdownUnref(); 
+ 
+ private: 
+  // Function run by the worker threads. 
+  void RunWorkerLoop(); 
+ 
+  // Whether the EventManager has been shut down. 
+  bool ShouldStop(); 
+ 
+  const Options options_; 
+  // Whether the EventManager workers should be stopped. 
+  grpc_core::Atomic<bool> should_stop_{false}; 
+  // A refcount preventing the EventManager from shutdown. 
+  grpc_core::Atomic<int> shutdown_refcount_{0}; 
+  // Worker threads of the EventManager. 
+  std::vector<grpc_core::Thread> workers_; 
+  // Mutex and condition variable used for shutdown. 
+  grpc_core::Mutex shutdown_mu_; 
+  grpc_core::CondVar shutdown_cv_; 
+}; 
+ 
+}  // namespace experimental 
+}  // namespace grpc 
+ 
+#endif /* GRPC_CORE_LIB_IOMGR_POLLER_EVENTMANAGER_LIBUV_H */ 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/pollset_set_custom.cc b/contrib/libs/grpc/src/core/lib/iomgr/pollset_set_custom.cc
index 2c1df60819..6ef086b1a9 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/pollset_set_custom.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/pollset_set_custom.cc
@@ -22,23 +22,23 @@
 
 #include "src/core/lib/iomgr/pollset_set.h"
 
-static grpc_pollset_set* pollset_set_create(void) {
+static grpc_pollset_set* pollset_set_create(void) { 
   return (grpc_pollset_set*)((intptr_t)0xdeafbeef);
 }
 
-static void pollset_set_destroy(grpc_pollset_set* /*pollset_set*/) {}
+static void pollset_set_destroy(grpc_pollset_set* /*pollset_set*/) {} 
 
-static void pollset_set_add_pollset(grpc_pollset_set* /*pollset_set*/,
-                                    grpc_pollset* /*pollset*/) {}
+static void pollset_set_add_pollset(grpc_pollset_set* /*pollset_set*/, 
+                                    grpc_pollset* /*pollset*/) {} 
 
-static void pollset_set_del_pollset(grpc_pollset_set* /*pollset_set*/,
-                                    grpc_pollset* /*pollset*/) {}
+static void pollset_set_del_pollset(grpc_pollset_set* /*pollset_set*/, 
+                                    grpc_pollset* /*pollset*/) {} 
 
-static void pollset_set_add_pollset_set(grpc_pollset_set* /*bag*/,
-                                        grpc_pollset_set* /*item*/) {}
+static void pollset_set_add_pollset_set(grpc_pollset_set* /*bag*/, 
+                                        grpc_pollset_set* /*item*/) {} 
 
-static void pollset_set_del_pollset_set(grpc_pollset_set* /*bag*/,
-                                        grpc_pollset_set* /*item*/) {}
+static void pollset_set_del_pollset_set(grpc_pollset_set* /*bag*/, 
+                                        grpc_pollset_set* /*item*/) {} 
 
 static grpc_pollset_set_vtable vtable = {
     pollset_set_create,          pollset_set_destroy,
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/port.h b/contrib/libs/grpc/src/core/lib/iomgr/port.h
index 2a8d67b261..ea7d92b1ed 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/port.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/port.h
@@ -84,7 +84,7 @@
  */
 #define GRPC_LINUX_TCP_H 1
 #endif /* __GLIBC_PREREQ(2, 17) */
-#endif
+#endif 
 #ifndef __GLIBC__
 #define GRPC_LINUX_EPOLL 1
 #define GRPC_LINUX_EPOLL_CREATE1 1
@@ -109,7 +109,7 @@
 #define GRPC_CFSTREAM_IOMGR 1
 #define GRPC_CFSTREAM_CLIENT 1
 #define GRPC_CFSTREAM_ENDPOINT 1
-#define GRPC_APPLE_EV 1
+#define GRPC_APPLE_EV 1 
 #define GRPC_POSIX_SOCKET_ARES_EV_DRIVER 1
 #define GRPC_POSIX_SOCKET_EV 1
 #define GRPC_POSIX_SOCKET_EV_EPOLL1 1
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_custom.cc b/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_custom.cc
index 69b4382b2b..06d00f005f 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_custom.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_custom.cc
@@ -18,30 +18,30 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/resolve_address_custom.h"
-
-#include <string.h>
-
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_format.h"
-
+#include "src/core/lib/iomgr/resolve_address_custom.h" 
+
+#include <string.h> 
+ 
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
+#include <grpc/support/log.h> 
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
-#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/port.h" 
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 
-struct grpc_custom_resolver {
-  grpc_closure* on_done = nullptr;
-  grpc_resolved_addresses** addresses = nullptr;
-  TString host;
-  TString port;
-};
+struct grpc_custom_resolver { 
+  grpc_closure* on_done = nullptr; 
+  grpc_resolved_addresses** addresses = nullptr; 
+  TString host; 
+  TString port; 
+}; 
 
 static grpc_custom_resolver_vtable* resolve_address_vtable = nullptr;
 
@@ -50,18 +50,18 @@ static int retry_named_port_failure(grpc_custom_resolver* r,
   // This loop is copied from resolve_address_posix.c
   const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
   for (size_t i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
-    if (r->port == svc[i][0]) {
-      r->port = svc[i][1];
+    if (r->port == svc[i][0]) { 
+      r->port = svc[i][1]; 
       if (res) {
-        grpc_error* error = resolve_address_vtable->resolve(
-            r->host.c_str(), r->port.c_str(), res);
+        grpc_error* error = resolve_address_vtable->resolve( 
+            r->host.c_str(), r->port.c_str(), res); 
         if (error != GRPC_ERROR_NONE) {
           GRPC_ERROR_UNREF(error);
           return 0;
         }
       } else {
-        resolve_address_vtable->resolve_async(r, r->host.c_str(),
-                                              r->port.c_str());
+        resolve_address_vtable->resolve_async(r, r->host.c_str(), 
+                                              r->port.c_str()); 
       }
       return 1;
     }
@@ -83,25 +83,25 @@ void grpc_custom_resolve_callback(grpc_custom_resolver* r,
   if (r->on_done) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
   }
-  delete r;
+  delete r; 
 }
 
 static grpc_error* try_split_host_port(const char* name,
                                        const char* default_port,
-                                       TString* host, TString* port) {
+                                       TString* host, TString* port) { 
   /* parse name, splitting it into host and port parts */
   grpc_core::SplitHostPort(name, host, port);
-  if (host->empty()) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrFormat("unparseable host:port: '%s'", name).c_str());
+  if (host->empty()) { 
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrFormat("unparseable host:port: '%s'", name).c_str()); 
   }
-  if (port->empty()) {
+  if (port->empty()) { 
     // TODO(murgatroid99): add tests for this case
     if (default_port == nullptr) {
-      return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          y_absl::StrFormat("no port in name '%s'", name).c_str());
+      return GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+          y_absl::StrFormat("no port in name '%s'", name).c_str()); 
     }
-    *port = default_port;
+    *port = default_port; 
   }
   return GRPC_ERROR_NONE;
 }
@@ -111,9 +111,9 @@ static grpc_error* blocking_resolve_address_impl(
     grpc_resolved_addresses** addresses) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
 
-  grpc_custom_resolver resolver;
-  grpc_error* err =
-      try_split_host_port(name, default_port, &resolver.host, &resolver.port);
+  grpc_custom_resolver resolver; 
+  grpc_error* err = 
+      try_split_host_port(name, default_port, &resolver.host, &resolver.port); 
   if (err != GRPC_ERROR_NONE) {
     return err;
   }
@@ -122,8 +122,8 @@ static grpc_error* blocking_resolve_address_impl(
   grpc_resolved_addresses* addrs;
   grpc_core::ExecCtx* curr = grpc_core::ExecCtx::Get();
   grpc_core::ExecCtx::Set(nullptr);
-  err = resolve_address_vtable->resolve(resolver.host.c_str(),
-                                        resolver.port.c_str(), &addrs);
+  err = resolve_address_vtable->resolve(resolver.host.c_str(), 
+                                        resolver.port.c_str(), &addrs); 
   if (err != GRPC_ERROR_NONE) {
     if (retry_named_port_failure(&resolver, &addrs)) {
       GRPC_ERROR_UNREF(err);
@@ -142,21 +142,21 @@ static void resolve_address_impl(const char* name, const char* default_port,
                                  grpc_closure* on_done,
                                  grpc_resolved_addresses** addrs) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
-  TString host;
-  TString port;
-  grpc_error* err = try_split_host_port(name, default_port, &host, &port);
+  TString host; 
+  TString port; 
+  grpc_error* err = try_split_host_port(name, default_port, &host, &port); 
   if (err != GRPC_ERROR_NONE) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done, err);
     return;
   }
-  grpc_custom_resolver* r = new grpc_custom_resolver();
+  grpc_custom_resolver* r = new grpc_custom_resolver(); 
   r->on_done = on_done;
   r->addresses = addrs;
-  r->host = std::move(host);
-  r->port = std::move(port);
+  r->host = std::move(host); 
+  r->port = std::move(port); 
 
   /* Call getaddrinfo */
-  resolve_address_vtable->resolve_async(r, r->host.c_str(), r->port.c_str());
+  resolve_address_vtable->resolve_async(r, r->host.c_str(), r->port.c_str()); 
 }
 
 static grpc_address_resolver_vtable custom_resolver_vtable = {
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_custom.h b/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_custom.h
index f5f68ca32d..48a7bb7604 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_custom.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_custom.h
@@ -29,10 +29,10 @@
 typedef struct grpc_custom_resolver grpc_custom_resolver;
 
 typedef struct grpc_custom_resolver_vtable {
-  grpc_error* (*resolve)(const char* host, const char* port,
-                         grpc_resolved_addresses** res);
-  void (*resolve_async)(grpc_custom_resolver* resolver, const char* host,
-                        const char* port);
+  grpc_error* (*resolve)(const char* host, const char* port, 
+                         grpc_resolved_addresses** res); 
+  void (*resolve_async)(grpc_custom_resolver* resolver, const char* host, 
+                        const char* port); 
 } grpc_custom_resolver_vtable;
 
 void grpc_custom_resolve_callback(grpc_custom_resolver* resolver,
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_posix.cc b/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_posix.cc
index 4f29087391..0bfba602d2 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_posix.cc
@@ -57,24 +57,24 @@ static grpc_error* posix_blocking_resolve_address(
     return grpc_resolve_unix_domain_address(name + 5, addresses);
   }
 
-  TString host;
-  TString port;
+  TString host; 
+  TString port; 
   /* parse name, splitting it into host and port parts */
   grpc_core::SplitHostPort(name, &host, &port);
-  if (host.empty()) {
+  if (host.empty()) { 
     err = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
         GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
     goto done;
   }
-  if (port.empty()) {
+  if (port.empty()) { 
     if (default_port == nullptr) {
       err = grpc_error_set_str(
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
           GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
       goto done;
     }
-    port = default_port;
+    port = default_port; 
   }
 
   /* Call getaddrinfo */
@@ -84,16 +84,16 @@ static grpc_error* posix_blocking_resolve_address(
   hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
-  s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
+  s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result); 
   GRPC_SCHEDULING_END_BLOCKING_REGION;
 
   if (s != 0) {
     /* Retry if well-known service name is recognized */
     const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
     for (i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
-      if (port == svc[i][0]) {
+      if (port == svc[i][0]) { 
         GRPC_SCHEDULING_START_BLOCKING_REGION;
-        s = getaddrinfo(host.c_str(), svc[i][1], &hints, &result);
+        s = getaddrinfo(host.c_str(), svc[i][1], &hints, &result); 
         GRPC_SCHEDULING_END_BLOCKING_REGION;
         break;
       }
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_windows.cc b/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_windows.cc
index 9922b88065..6d7bbf1b96 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_windows.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/resolve_address_windows.cc
@@ -29,10 +29,10 @@
 #include <string.h>
 #include <sys/types.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_format.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
@@ -65,21 +65,21 @@ static grpc_error* windows_blocking_resolve_address(
   grpc_error* error = GRPC_ERROR_NONE;
 
   /* parse name, splitting it into host and port parts */
-  TString host;
-  TString port;
+  TString host; 
+  TString port; 
   grpc_core::SplitHostPort(name, &host, &port);
-  if (host.empty()) {
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrFormat("unparseable host:port: '%s'", name).c_str());
+  if (host.empty()) { 
+    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrFormat("unparseable host:port: '%s'", name).c_str()); 
     goto done;
   }
-  if (port.empty()) {
+  if (port.empty()) { 
     if (default_port == NULL) {
-      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          y_absl::StrFormat("no port in name '%s'", name).c_str());
+      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+          y_absl::StrFormat("no port in name '%s'", name).c_str()); 
       goto done;
     }
-    port = default_port;
+    port = default_port; 
   }
 
   /* Call getaddrinfo */
@@ -89,7 +89,7 @@ static grpc_error* windows_blocking_resolve_address(
   hints.ai_flags = AI_PASSIVE;     /* for wildcard IP address */
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
-  s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result);
+  s = getaddrinfo(host.c_str(), port.c_str(), &hints, &result); 
   GRPC_SCHEDULING_END_BLOCKING_REGION;
   if (s != 0) {
     error = GRPC_WSA_ERROR(WSAGetLastError(), "getaddrinfo");
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/resource_quota.cc b/contrib/libs/grpc/src/core/lib/iomgr/resource_quota.cc
index f416e096f4..724357ee15 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/resource_quota.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/resource_quota.cc
@@ -25,10 +25,10 @@
 #include <stdint.h>
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -121,7 +121,7 @@ struct grpc_resource_user {
   grpc_resource_user_link links[GRPC_RULIST_COUNT];
 
   /* The name of this resource user, for debugging/tracing */
-  TString name;
+  TString name; 
 };
 
 struct grpc_resource_quota {
@@ -184,7 +184,7 @@ struct grpc_resource_quota {
   /* Roots of all resource user lists */
   grpc_resource_user* roots[GRPC_RULIST_COUNT];
 
-  TString name;
+  TString name; 
 };
 
 static void ru_unref_by(grpc_resource_user* resource_user, gpr_atm amount);
@@ -323,9 +323,9 @@ static bool rq_alloc(grpc_resource_quota* resource_quota) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
       gpr_log(GPR_INFO,
               "RQ: check allocation for user %p shutdown=%" PRIdPTR
-              " free_pool=%" PRId64 " outstanding_allocations=%" PRId64,
+              " free_pool=%" PRId64 " outstanding_allocations=%" PRId64, 
               resource_user, gpr_atm_no_barrier_load(&resource_user->shutdown),
-              resource_user->free_pool, resource_user->outstanding_allocations);
+              resource_user->free_pool, resource_user->outstanding_allocations); 
     }
     if (gpr_atm_no_barrier_load(&resource_user->shutdown)) {
       resource_user->allocating = false;
@@ -337,9 +337,9 @@ static bool rq_alloc(grpc_resource_quota* resource_quota) {
       resource_user->free_pool += aborted_allocations;
       grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &resource_user->on_allocated);
       gpr_mu_unlock(&resource_user->mu);
-      if (aborted_allocations > 0) {
-        ru_unref_by(resource_user, static_cast<gpr_atm>(aborted_allocations));
-      }
+      if (aborted_allocations > 0) { 
+        ru_unref_by(resource_user, static_cast<gpr_atm>(aborted_allocations)); 
+      } 
       continue;
     }
     if (resource_user->free_pool < 0 &&
@@ -352,13 +352,13 @@ static bool rq_alloc(grpc_resource_quota* resource_quota) {
         gpr_log(GPR_INFO,
                 "RQ %s %s: grant alloc %" PRId64
                 " bytes; rq_free_pool -> %" PRId64,
-                resource_quota->name.c_str(), resource_user->name.c_str(), amt,
+                resource_quota->name.c_str(), resource_user->name.c_str(), amt, 
                 resource_quota->free_pool);
       }
     } else if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace) &&
                resource_user->free_pool >= 0) {
       gpr_log(GPR_INFO, "RQ %s %s: discard already satisfied alloc request",
-              resource_quota->name.c_str(), resource_user->name.c_str());
+              resource_quota->name.c_str(), resource_user->name.c_str()); 
     }
     if (resource_user->free_pool >= 0) {
       resource_user->allocating = false;
@@ -391,7 +391,7 @@ static bool rq_reclaim_from_per_user_free_pool(
         gpr_log(GPR_INFO,
                 "RQ %s %s: reclaim_from_per_user_free_pool %" PRId64
                 " bytes; rq_free_pool -> %" PRId64,
-                resource_quota->name.c_str(), resource_user->name.c_str(), amt,
+                resource_quota->name.c_str(), resource_user->name.c_str(), amt, 
                 resource_quota->free_pool);
       }
       gpr_mu_unlock(&resource_user->mu);
@@ -401,7 +401,7 @@ static bool rq_reclaim_from_per_user_free_pool(
         gpr_log(GPR_INFO,
                 "RQ %s %s: failed to reclaim_from_per_user_free_pool; "
                 "free_pool = %" PRId64 "; rq_free_pool = %" PRId64,
-                resource_quota->name.c_str(), resource_user->name.c_str(),
+                resource_quota->name.c_str(), resource_user->name.c_str(), 
                 resource_user->free_pool, resource_quota->free_pool);
       }
       gpr_mu_unlock(&resource_user->mu);
@@ -418,9 +418,9 @@ static bool rq_reclaim(grpc_resource_quota* resource_quota, bool destructive) {
   grpc_resource_user* resource_user = rulist_pop_head(resource_quota, list);
   if (resource_user == nullptr) return false;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
-    gpr_log(GPR_INFO, "RQ %s %s: initiate %s reclamation",
-            resource_quota->name.c_str(), resource_user->name.c_str(),
-            destructive ? "destructive" : "benign");
+    gpr_log(GPR_INFO, "RQ %s %s: initiate %s reclamation", 
+            resource_quota->name.c_str(), resource_user->name.c_str(), 
+            destructive ? "destructive" : "benign"); 
   }
   resource_quota->reclaiming = true;
   grpc_resource_quota_ref_internal(resource_quota);
@@ -589,7 +589,7 @@ static void ru_destroy(void* ru, grpc_error* /*error*/) {
   }
   grpc_resource_quota_unref_internal(resource_user->resource_quota);
   gpr_mu_destroy(&resource_user->mu);
-  delete resource_user;
+  delete resource_user; 
 }
 
 static void ru_alloc_slices(
@@ -643,7 +643,7 @@ static void rq_reclamation_done(void* rq, grpc_error* /*error*/) {
 
 /* Public API */
 grpc_resource_quota* grpc_resource_quota_create(const char* name) {
-  grpc_resource_quota* resource_quota = new grpc_resource_quota;
+  grpc_resource_quota* resource_quota = new grpc_resource_quota; 
   gpr_ref_init(&resource_quota->refs, 1);
   resource_quota->combiner = grpc_combiner_create();
   resource_quota->free_pool = INT64_MAX;
@@ -657,10 +657,10 @@ grpc_resource_quota* grpc_resource_quota_create(const char* name) {
   resource_quota->reclaiming = false;
   gpr_atm_no_barrier_store(&resource_quota->memory_usage_estimation, 0);
   if (name != nullptr) {
-    resource_quota->name = name;
+    resource_quota->name = name; 
   } else {
-    resource_quota->name =
-        y_absl::StrCat("anonymous_pool_", (intptr_t)resource_quota);
+    resource_quota->name = 
+        y_absl::StrCat("anonymous_pool_", (intptr_t)resource_quota); 
   }
   GRPC_CLOSURE_INIT(&resource_quota->rq_step_closure, rq_step, resource_quota,
                     nullptr);
@@ -678,7 +678,7 @@ void grpc_resource_quota_unref_internal(grpc_resource_quota* resource_quota) {
     GPR_ASSERT(resource_quota->num_threads_allocated == 0);
     GRPC_COMBINER_UNREF(resource_quota->combiner, "resource_quota");
     gpr_mu_destroy(&resource_quota->thread_count_mu);
-    delete resource_quota;
+    delete resource_quota; 
   }
 }
 
@@ -775,7 +775,7 @@ const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable(void) {
 
 grpc_resource_user* grpc_resource_user_create(
     grpc_resource_quota* resource_quota, const char* name) {
-  grpc_resource_user* resource_user = new grpc_resource_user;
+  grpc_resource_user* resource_user = new grpc_resource_user; 
   resource_user->resource_quota =
       grpc_resource_quota_ref_internal(resource_quota);
   GRPC_CLOSURE_INIT(&resource_user->allocate_closure, &ru_allocate,
@@ -805,10 +805,10 @@ grpc_resource_user* grpc_resource_user_create(
     resource_user->links[i].next = resource_user->links[i].prev = nullptr;
   }
   if (name != nullptr) {
-    resource_user->name = name;
+    resource_user->name = name; 
   } else {
-    resource_user->name =
-        y_absl::StrCat("anonymous_resource_user_", (intptr_t)resource_user);
+    resource_user->name = 
+        y_absl::StrCat("anonymous_resource_user_", (intptr_t)resource_user); 
   }
   return resource_user;
 }
@@ -890,8 +890,8 @@ static bool resource_user_alloc_locked(grpc_resource_user* resource_user,
   resource_user->free_pool -= static_cast<int64_t>(size);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
     gpr_log(GPR_INFO, "RQ %s %s: alloc %" PRIdPTR "; free_pool -> %" PRId64,
-            resource_user->resource_quota->name.c_str(),
-            resource_user->name.c_str(), size, resource_user->free_pool);
+            resource_user->resource_quota->name.c_str(), 
+            resource_user->name.c_str(), size, resource_user->free_pool); 
   }
   if (GPR_LIKELY(resource_user->free_pool >= 0)) return true;
   // Slow path: We need to wait for the free pool to refill.
@@ -951,8 +951,8 @@ void grpc_resource_user_free(grpc_resource_user* resource_user, size_t size) {
   resource_user->free_pool += static_cast<int64_t>(size);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
     gpr_log(GPR_INFO, "RQ %s %s: free %" PRIdPTR "; free_pool -> %" PRId64,
-            resource_user->resource_quota->name.c_str(),
-            resource_user->name.c_str(), size, resource_user->free_pool);
+            resource_user->resource_quota->name.c_str(), 
+            resource_user->name.c_str(), size, resource_user->free_pool); 
   }
   bool is_bigger_than_zero = resource_user->free_pool > 0;
   if (is_bigger_than_zero && was_zero_or_negative &&
@@ -977,8 +977,8 @@ void grpc_resource_user_post_reclaimer(grpc_resource_user* resource_user,
 void grpc_resource_user_finish_reclamation(grpc_resource_user* resource_user) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
     gpr_log(GPR_INFO, "RQ %s %s: reclamation complete",
-            resource_user->resource_quota->name.c_str(),
-            resource_user->name.c_str());
+            resource_user->resource_quota->name.c_str(), 
+            resource_user->name.c_str()); 
   }
   resource_user->resource_quota->combiner->Run(
       &resource_user->resource_quota->rq_reclamation_done_closure,
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/sockaddr_utils.cc b/contrib/libs/grpc/src/core/lib/iomgr/sockaddr_utils.cc
index b43dbc9923..8b3c2dc965 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/sockaddr_utils.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/sockaddr_utils.cc
@@ -24,11 +24,11 @@
 #include <inttypes.h>
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_format.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -154,15 +154,15 @@ void grpc_sockaddr_make_wildcard6(int port,
   resolved_wild_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
 }
 
-TString grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
-                                    bool normalize) {
+TString grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr, 
+                                    bool normalize) { 
   const int save_errno = errno;
   grpc_resolved_address addr_normalized;
-  if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
-    resolved_addr = &addr_normalized;
-  }
-  const grpc_sockaddr* addr =
-      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) { 
+    resolved_addr = &addr_normalized; 
+  } 
+  const grpc_sockaddr* addr = 
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr); 
   const void* ip = nullptr;
   int port = 0;
   uint32_t sin6_scope_id = 0;
@@ -178,28 +178,28 @@ TString grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
     port = grpc_ntohs(addr6->sin6_port);
     sin6_scope_id = addr6->sin6_scope_id;
   }
-  char ntop_buf[GRPC_INET6_ADDRSTRLEN];
-  TString out;
+  char ntop_buf[GRPC_INET6_ADDRSTRLEN]; 
+  TString out; 
   if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
                                       sizeof(ntop_buf)) != nullptr) {
     if (sin6_scope_id != 0) {
-      // Enclose sin6_scope_id with the format defined in RFC 6784 section 2.
-      TString host_with_scope =
-          y_absl::StrFormat("%s%%25%" PRIu32, ntop_buf, sin6_scope_id);
-      out = grpc_core::JoinHostPort(host_with_scope, port);
+      // Enclose sin6_scope_id with the format defined in RFC 6784 section 2. 
+      TString host_with_scope = 
+          y_absl::StrFormat("%s%%25%" PRIu32, ntop_buf, sin6_scope_id); 
+      out = grpc_core::JoinHostPort(host_with_scope, port); 
     } else {
-      out = grpc_core::JoinHostPort(ntop_buf, port);
+      out = grpc_core::JoinHostPort(ntop_buf, port); 
     }
   } else {
-    out = y_absl::StrFormat("(sockaddr family=%d)", addr->sa_family);
+    out = y_absl::StrFormat("(sockaddr family=%d)", addr->sa_family); 
   }
   /* This is probably redundant, but we wouldn't want to log the wrong error. */
   errno = save_errno;
-  return out;
+  return out; 
 }
 
-void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr,
-                             int port) {
+void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr, 
+                             int port) { 
   memset(out, 0, sizeof(grpc_resolved_address));
   grpc_sockaddr_in6* addr6 = (grpc_sockaddr_in6*)out->addr;
   grpc_sockaddr_in* addr4 = (grpc_sockaddr_in*)out->addr;
@@ -215,8 +215,8 @@ void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr,
   grpc_sockaddr_set_port(out, port);
 }
 
-TString grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
-  if (resolved_addr->len == 0) return "";
+TString grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) { 
+  if (resolved_addr->len == 0) return ""; 
   grpc_resolved_address addr_normalized;
   if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
     resolved_addr = &addr_normalized;
@@ -225,13 +225,13 @@ TString grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   if (scheme == nullptr || strcmp("unix", scheme) == 0) {
     return grpc_sockaddr_to_uri_unix_if_possible(resolved_addr);
   }
-  TString path =
-      grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
-  TString uri_str;
-  if (scheme != nullptr) {
-    uri_str = y_absl::StrCat(scheme, ":", path);
+  TString path = 
+      grpc_sockaddr_to_string(resolved_addr, false /* normalize */); 
+  TString uri_str; 
+  if (scheme != nullptr) { 
+    uri_str = y_absl::StrCat(scheme, ":", path); 
   }
-  return uri_str;
+  return uri_str; 
 }
 
 const char* grpc_sockaddr_get_uri_scheme(
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/sockaddr_utils.h b/contrib/libs/grpc/src/core/lib/iomgr/sockaddr_utils.h
index eeedeeb90c..7d9fe64239 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/sockaddr_utils.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/sockaddr_utils.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 #include "src/core/lib/iomgr/resolve_address.h"
 
 /* Returns true if addr is an IPv4-mapped IPv6 address within the
@@ -58,19 +58,19 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* addr);
 /* Set IP port number of a sockaddr */
 int grpc_sockaddr_set_port(const grpc_resolved_address* addr, int port);
 
-// Converts a sockaddr into a newly-allocated human-readable string.
-//
-// Currently, only the AF_INET and AF_INET6 families are recognized.
-// If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
-// displayed as plain IPv4.
-TString grpc_sockaddr_to_string(const grpc_resolved_address* addr,
-                                    bool normalize);
+// Converts a sockaddr into a newly-allocated human-readable string. 
+// 
+// Currently, only the AF_INET and AF_INET6 families are recognized. 
+// If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are 
+// displayed as plain IPv4. 
+TString grpc_sockaddr_to_string(const grpc_resolved_address* addr, 
+                                    bool normalize); 
 
-void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr,
-                             int port);
+void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr, 
+                             int port); 
 
 /* Returns the URI string corresponding to \a addr */
-TString grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
+TString grpc_sockaddr_to_uri(const grpc_resolved_address* addr); 
 
 /* Returns the URI scheme corresponding to \a addr */
 const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/socket_utils_common_posix.cc b/contrib/libs/grpc/src/core/lib/iomgr/socket_utils_common_posix.cc
index 8a8d4d3a22..2d099db85d 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/socket_utils_common_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/socket_utils_common_posix.cc
@@ -41,8 +41,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -63,19 +63,19 @@ extern "C" bool IsReusePortAvailable();
 #define TCP_USER_TIMEOUT 18 /* How long for loss retry before timeout */
 #endif
 
-/* set a socket to use zerocopy */
-grpc_error* grpc_set_socket_zerocopy(int fd) {
-#ifdef GRPC_LINUX_ERRQUEUE
-  const int enable = 1;
-  auto err = setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &enable, sizeof(enable));
-  if (err != 0) {
-    return GRPC_OS_ERROR(errno, "setsockopt(SO_ZEROCOPY)");
-  }
-  return GRPC_ERROR_NONE;
-#else
-  return GRPC_OS_ERROR(ENOSYS, "setsockopt(SO_ZEROCOPY)");
-#endif
-}
+/* set a socket to use zerocopy */ 
+grpc_error* grpc_set_socket_zerocopy(int fd) { 
+#ifdef GRPC_LINUX_ERRQUEUE 
+  const int enable = 1; 
+  auto err = setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &enable, sizeof(enable)); 
+  if (err != 0) { 
+    return GRPC_OS_ERROR(errno, "setsockopt(SO_ZEROCOPY)"); 
+  } 
+  return GRPC_ERROR_NONE; 
+#else 
+  return GRPC_OS_ERROR(ENOSYS, "setsockopt(SO_ZEROCOPY)"); 
+#endif 
+} 
 
 /* set a socket to non blocking mode */
 grpc_error* grpc_set_socket_nonblocking(int fd, int non_blocking) {
@@ -270,27 +270,27 @@ static int g_default_server_tcp_user_timeout_ms =
 static bool g_default_client_tcp_user_timeout_enabled = false;
 static bool g_default_server_tcp_user_timeout_enabled = true;
 
-#if GPR_LINUX == 1
-// For Linux, it will be detected to support TCP_USER_TIMEOUT
-#ifndef TCP_USER_TIMEOUT
-#define TCP_USER_TIMEOUT 18
-#endif
-#define SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT 0
-#else
-// For non-Linux, TCP_USER_TIMEOUT will be used if TCP_USER_TIMEOUT is defined.
-#ifdef TCP_USER_TIMEOUT
-#define SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT 0
-#else
-#define TCP_USER_TIMEOUT 0
-#define SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT -1
-#endif  // TCP_USER_TIMEOUT
-#endif  // GPR_LINUX == 1
-
-// Whether the socket supports TCP_USER_TIMEOUT option.
-// (0: don't know, 1: support, -1: not support)
-static std::atomic<int> g_socket_supports_tcp_user_timeout(
-    SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT);
-
+#if GPR_LINUX == 1 
+// For Linux, it will be detected to support TCP_USER_TIMEOUT 
+#ifndef TCP_USER_TIMEOUT 
+#define TCP_USER_TIMEOUT 18 
+#endif 
+#define SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT 0 
+#else 
+// For non-Linux, TCP_USER_TIMEOUT will be used if TCP_USER_TIMEOUT is defined. 
+#ifdef TCP_USER_TIMEOUT 
+#define SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT 0 
+#else 
+#define TCP_USER_TIMEOUT 0 
+#define SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT -1 
+#endif  // TCP_USER_TIMEOUT 
+#endif  // GPR_LINUX == 1 
+ 
+// Whether the socket supports TCP_USER_TIMEOUT option. 
+// (0: don't know, 1: support, -1: not support) 
+static std::atomic<int> g_socket_supports_tcp_user_timeout( 
+    SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT); 
+ 
 void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client) {
   if (is_client) {
     g_default_client_tcp_user_timeout_enabled = enable;
@@ -312,85 +312,85 @@ grpc_error* grpc_set_socket_tcp_user_timeout(
   (void)fd;
   (void)channel_args;
   (void)is_client;
-  extern grpc_core::TraceFlag grpc_tcp_trace;
-  if (g_socket_supports_tcp_user_timeout.load() >= 0) {
-    bool enable;
-    int timeout;
-    if (is_client) {
-      enable = g_default_client_tcp_user_timeout_enabled;
-      timeout = g_default_client_tcp_user_timeout_ms;
-    } else {
-      enable = g_default_server_tcp_user_timeout_enabled;
-      timeout = g_default_server_tcp_user_timeout_ms;
-    }
-    if (channel_args) {
-      for (unsigned int i = 0; i < channel_args->num_args; i++) {
-        if (0 ==
-            strcmp(channel_args->args[i].key, GRPC_ARG_KEEPALIVE_TIME_MS)) {
-          const int value = grpc_channel_arg_get_integer(
-              &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
-          /* Continue using default if value is 0 */
-          if (value == 0) {
-            continue;
-          }
-          /* Disable if value is INT_MAX */
-          enable = value != INT_MAX;
-        } else if (0 == strcmp(channel_args->args[i].key,
-                               GRPC_ARG_KEEPALIVE_TIMEOUT_MS)) {
-          const int value = grpc_channel_arg_get_integer(
-              &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
-          /* Continue using default if value is 0 */
-          if (value == 0) {
-            continue;
-          }
-          timeout = value;
+  extern grpc_core::TraceFlag grpc_tcp_trace; 
+  if (g_socket_supports_tcp_user_timeout.load() >= 0) { 
+    bool enable; 
+    int timeout; 
+    if (is_client) { 
+      enable = g_default_client_tcp_user_timeout_enabled; 
+      timeout = g_default_client_tcp_user_timeout_ms; 
+    } else { 
+      enable = g_default_server_tcp_user_timeout_enabled; 
+      timeout = g_default_server_tcp_user_timeout_ms; 
+    } 
+    if (channel_args) { 
+      for (unsigned int i = 0; i < channel_args->num_args; i++) { 
+        if (0 == 
+            strcmp(channel_args->args[i].key, GRPC_ARG_KEEPALIVE_TIME_MS)) { 
+          const int value = grpc_channel_arg_get_integer( 
+              &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX}); 
+          /* Continue using default if value is 0 */ 
+          if (value == 0) { 
+            continue; 
+          } 
+          /* Disable if value is INT_MAX */ 
+          enable = value != INT_MAX; 
+        } else if (0 == strcmp(channel_args->args[i].key, 
+                               GRPC_ARG_KEEPALIVE_TIMEOUT_MS)) { 
+          const int value = grpc_channel_arg_get_integer( 
+              &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX}); 
+          /* Continue using default if value is 0 */ 
+          if (value == 0) { 
+            continue; 
+          } 
+          timeout = value; 
         }
-      }
-    }
-    if (enable) {
-      int newval;
-      socklen_t len = sizeof(newval);
-      // If this is the first time to use TCP_USER_TIMEOUT, try to check
-      // if it is available.
-      if (g_socket_supports_tcp_user_timeout.load() == 0) {
-        if (0 != getsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) {
-          gpr_log(GPR_INFO,
-                  "TCP_USER_TIMEOUT is not available. TCP_USER_TIMEOUT won't "
-                  "be used thereafter");
-          g_socket_supports_tcp_user_timeout.store(-1);
-        } else {
-          gpr_log(GPR_INFO,
-                  "TCP_USER_TIMEOUT is available. TCP_USER_TIMEOUT will be "
-                  "used thereafter");
-          g_socket_supports_tcp_user_timeout.store(1);
-        }
-      }
-      if (g_socket_supports_tcp_user_timeout.load() > 0) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-          gpr_log(GPR_INFO, "Enabling TCP_USER_TIMEOUT with a timeout of %d ms",
-                  timeout);
-        }
-        if (0 != setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout,
-                            sizeof(timeout))) {
-          gpr_log(GPR_ERROR, "setsockopt(TCP_USER_TIMEOUT) %s",
-                  strerror(errno));
-          return GRPC_ERROR_NONE;
-        }
-        if (0 != getsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) {
-          gpr_log(GPR_ERROR, "getsockopt(TCP_USER_TIMEOUT) %s",
-                  strerror(errno));
-          return GRPC_ERROR_NONE;
-        }
-        if (newval != timeout) {
-          /* Do not fail on failing to set TCP_USER_TIMEOUT for now. */
-          gpr_log(GPR_ERROR, "Failed to set TCP_USER_TIMEOUT");
-          return GRPC_ERROR_NONE;
+      } 
+    } 
+    if (enable) { 
+      int newval; 
+      socklen_t len = sizeof(newval); 
+      // If this is the first time to use TCP_USER_TIMEOUT, try to check 
+      // if it is available. 
+      if (g_socket_supports_tcp_user_timeout.load() == 0) { 
+        if (0 != getsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) { 
+          gpr_log(GPR_INFO, 
+                  "TCP_USER_TIMEOUT is not available. TCP_USER_TIMEOUT won't " 
+                  "be used thereafter"); 
+          g_socket_supports_tcp_user_timeout.store(-1); 
+        } else { 
+          gpr_log(GPR_INFO, 
+                  "TCP_USER_TIMEOUT is available. TCP_USER_TIMEOUT will be " 
+                  "used thereafter"); 
+          g_socket_supports_tcp_user_timeout.store(1); 
         }
       }
+      if (g_socket_supports_tcp_user_timeout.load() > 0) { 
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) { 
+          gpr_log(GPR_INFO, "Enabling TCP_USER_TIMEOUT with a timeout of %d ms", 
+                  timeout); 
+        } 
+        if (0 != setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout, 
+                            sizeof(timeout))) { 
+          gpr_log(GPR_ERROR, "setsockopt(TCP_USER_TIMEOUT) %s", 
+                  strerror(errno)); 
+          return GRPC_ERROR_NONE; 
+        } 
+        if (0 != getsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) { 
+          gpr_log(GPR_ERROR, "getsockopt(TCP_USER_TIMEOUT) %s", 
+                  strerror(errno)); 
+          return GRPC_ERROR_NONE; 
+        } 
+        if (newval != timeout) { 
+          /* Do not fail on failing to set TCP_USER_TIMEOUT for now. */ 
+          gpr_log(GPR_ERROR, "Failed to set TCP_USER_TIMEOUT"); 
+          return GRPC_ERROR_NONE; 
+        } 
+      } 
     }
-  } else {
+  } else { 
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-      gpr_log(GPR_INFO, "TCP_USER_TIMEOUT not supported for this platform");
+      gpr_log(GPR_INFO, "TCP_USER_TIMEOUT not supported for this platform"); 
     }
   }
   return GRPC_ERROR_NONE;
@@ -448,10 +448,10 @@ int grpc_ipv6_loopback_available(void) {
 
 static grpc_error* error_for_fd(int fd, const grpc_resolved_address* addr) {
   if (fd >= 0) return GRPC_ERROR_NONE;
-  TString addr_str = grpc_sockaddr_to_string(addr, false);
-  grpc_error* err = grpc_error_set_str(
-      GRPC_OS_ERROR(errno, "socket"), GRPC_ERROR_STR_TARGET_ADDRESS,
-      grpc_slice_from_copied_string(addr_str.c_str()));
+  TString addr_str = grpc_sockaddr_to_string(addr, false); 
+  grpc_error* err = grpc_error_set_str( 
+      GRPC_OS_ERROR(errno, "socket"), GRPC_ERROR_STR_TARGET_ADDRESS, 
+      grpc_slice_from_copied_string(addr_str.c_str())); 
   return err;
 }
 
@@ -483,7 +483,7 @@ grpc_error* grpc_create_dualstack_socket_using_factory(
       errno = EAFNOSUPPORT;
     }
     /* Check if we've got a valid dualstack socket. */
-    if (*newfd >= 0 && grpc_set_socket_dualstack(*newfd)) {
+    if (*newfd >= 0 && grpc_set_socket_dualstack(*newfd)) { 
       *dsmode = GRPC_DSMODE_DUALSTACK;
       return GRPC_ERROR_NONE;
     }
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/socket_utils_posix.h b/contrib/libs/grpc/src/core/lib/iomgr/socket_utils_posix.h
index b4dc909d1e..59cde06ac6 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/socket_utils_posix.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/socket_utils_posix.h
@@ -31,22 +31,22 @@
 #include "src/core/lib/iomgr/socket_factory_posix.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 
-#ifdef GRPC_LINUX_ERRQUEUE
-#ifndef SO_ZEROCOPY
-#define SO_ZEROCOPY 60
-#endif
-#ifndef SO_EE_ORIGIN_ZEROCOPY
-#define SO_EE_ORIGIN_ZEROCOPY 5
-#endif
-#endif /* ifdef GRPC_LINUX_ERRQUEUE */
-
+#ifdef GRPC_LINUX_ERRQUEUE 
+#ifndef SO_ZEROCOPY 
+#define SO_ZEROCOPY 60 
+#endif 
+#ifndef SO_EE_ORIGIN_ZEROCOPY 
+#define SO_EE_ORIGIN_ZEROCOPY 5 
+#endif 
+#endif /* ifdef GRPC_LINUX_ERRQUEUE */ 
+ 
 /* a wrapper for accept or accept4 */
 int grpc_accept4(int sockfd, grpc_resolved_address* resolved_addr, int nonblock,
                  int cloexec);
 
-/* set a socket to use zerocopy */
-grpc_error* grpc_set_socket_zerocopy(int fd);
-
+/* set a socket to use zerocopy */ 
+grpc_error* grpc_set_socket_zerocopy(int fd); 
+ 
 /* set a socket to non blocking mode */
 grpc_error* grpc_set_socket_nonblocking(int fd, int non_blocking);
 
@@ -126,9 +126,9 @@ typedef enum grpc_dualstack_mode {
 /* Only tests should use this flag. */
 extern int grpc_forbid_dualstack_sockets_for_testing;
 
-/* Tries to set the socket to dualstack. Returns 1 on success. */
-int grpc_set_socket_dualstack(int fd);
-
+/* Tries to set the socket to dualstack. Returns 1 on success. */ 
+int grpc_set_socket_dualstack(int fd); 
+ 
 /* Creates a new socket for connecting to (or listening on) an address.
 
    If addr is AF_INET6, this creates an IPv6 socket first.  If that fails,
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/socket_windows.cc b/contrib/libs/grpc/src/core/lib/iomgr/socket_windows.cc
index f117653c49..04d266d725 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/socket_windows.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/socket_windows.cc
@@ -31,8 +31,8 @@
 
 #undef OPTIONAL
 
-#include "y_absl/strings/str_format.h"
-
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
@@ -51,8 +51,8 @@ grpc_winsocket* grpc_winsocket_create(SOCKET socket, const char* name) {
   memset(r, 0, sizeof(grpc_winsocket));
   r->socket = socket;
   gpr_mu_init(&r->state_mu);
-  grpc_iomgr_register_object(
-      &r->iomgr_object, y_absl::StrFormat("%s:socket=0x%p", name, r).c_str());
+  grpc_iomgr_register_object( 
+      &r->iomgr_object, y_absl::StrFormat("%s:socket=0x%p", name, r).c_str()); 
   grpc_iocp_add_socket(r);
   return r;
 }
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_cfstream.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_cfstream.cc
index eafa885e2c..7ba74ba535 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_cfstream.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_cfstream.cc
@@ -46,7 +46,7 @@
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
 
-struct CFStreamConnect {
+struct CFStreamConnect { 
   gpr_mu mu;
   gpr_refcount refcount;
 
@@ -65,9 +65,9 @@ struct CFStreamConnect {
   grpc_closure* closure;
   grpc_endpoint** endpoint;
   int refs;
-  TString addr_name;
+  TString addr_name; 
   grpc_resource_quota* resource_quota;
-};
+}; 
 
 static void CFStreamConnectCleanup(CFStreamConnect* connect) {
   grpc_resource_quota_unref_internal(connect->resource_quota);
@@ -75,7 +75,7 @@ static void CFStreamConnectCleanup(CFStreamConnect* connect) {
   CFRelease(connect->read_stream);
   CFRelease(connect->write_stream);
   gpr_mu_destroy(&connect->mu);
-  delete connect;
+  delete connect; 
 }
 
 static void OnAlarm(void* arg, grpc_error* error) {
@@ -129,9 +129,9 @@ static void OnOpen(void* arg, grpc_error* error) {
       }
       if (error == GRPC_ERROR_NONE) {
         *endpoint = grpc_cfstream_endpoint_create(
-            connect->read_stream, connect->write_stream,
-            connect->addr_name.c_str(), connect->resource_quota,
-            connect->stream_handle);
+            connect->read_stream, connect->write_stream, 
+            connect->addr_name.c_str(), connect->resource_quota, 
+            connect->stream_handle); 
       }
     } else {
       GRPC_ERROR_REF(error);
@@ -143,12 +143,12 @@ static void OnOpen(void* arg, grpc_error* error) {
 
 static void ParseResolvedAddress(const grpc_resolved_address* addr,
                                  CFStringRef* host, int* port) {
-  TString host_port = grpc_sockaddr_to_string(addr, true);
-  TString host_string;
-  TString port_string;
+  TString host_port = grpc_sockaddr_to_string(addr, true); 
+  TString host_string; 
+  TString port_string; 
   grpc_core::SplitHostPort(host_port, &host_string, &port_string);
-  *host = CFStringCreateWithCString(NULL, host_string.c_str(),
-                                    kCFStringEncodingUTF8);
+  *host = CFStringCreateWithCString(NULL, host_string.c_str(), 
+                                    kCFStringEncodingUTF8); 
   *port = grpc_sockaddr_get_port(addr);
 }
 
@@ -157,7 +157,7 @@ static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
                                   const grpc_channel_args* channel_args,
                                   const grpc_resolved_address* resolved_addr,
                                   grpc_millis deadline) {
-  CFStreamConnect* connect = new CFStreamConnect();
+  CFStreamConnect* connect = new CFStreamConnect(); 
   connect->closure = closure;
   connect->endpoint = ep;
   connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
@@ -168,7 +168,7 @@ static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
 
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CLIENT_CONNECT: %p, %s: asynchronously connecting",
-            connect, connect->addr_name.c_str());
+            connect, connect->addr_name.c_str()); 
   }
 
   grpc_resource_quota* resource_quota = grpc_resource_quota_create(NULL);
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_custom.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_custom.cc
index dbcf62c94f..1b63a5c23b 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_custom.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_custom.cc
@@ -42,14 +42,14 @@ struct grpc_custom_tcp_connect {
   grpc_closure* closure;
   grpc_endpoint** endpoint;
   int refs;
-  TString addr_name;
+  TString addr_name; 
   grpc_resource_quota* resource_quota;
 };
 
 static void custom_tcp_connect_cleanup(grpc_custom_tcp_connect* connect) {
   grpc_custom_socket* socket = connect->socket;
   grpc_resource_quota_unref_internal(connect->resource_quota);
-  delete connect;
+  delete connect; 
   socket->refs--;
   if (socket->refs == 0) {
     grpc_custom_socket_vtable->destroy(socket);
@@ -66,7 +66,7 @@ static void on_alarm(void* acp, grpc_error* error) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     const char* str = grpc_error_string(error);
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_alarm: error=%s",
-            connect->addr_name.c_str(), str);
+            connect->addr_name.c_str(), str); 
   }
   if (error == GRPC_ERROR_NONE) {
     /* error == NONE implies that the timer ran out, and wasn't cancelled. If
@@ -88,7 +88,7 @@ static void custom_connect_callback_internal(grpc_custom_socket* socket,
   grpc_timer_cancel(&connect->alarm);
   if (error == GRPC_ERROR_NONE) {
     *connect->endpoint = custom_tcp_endpoint_create(
-        socket, connect->resource_quota, connect->addr_name.c_str());
+        socket, connect->resource_quota, connect->addr_name.c_str()); 
   }
   done = (--connect->refs == 0);
   if (done) {
@@ -133,7 +133,7 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
       (grpc_custom_socket*)gpr_malloc(sizeof(grpc_custom_socket));
   socket->refs = 2;
   grpc_custom_socket_vtable->init(socket, GRPC_AF_UNSPEC);
-  grpc_custom_tcp_connect* connect = new grpc_custom_tcp_connect();
+  grpc_custom_tcp_connect* connect = new grpc_custom_tcp_connect(); 
   connect->closure = closure;
   connect->endpoint = ep;
   connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
@@ -146,7 +146,7 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %p %s: asynchronously connecting",
-            socket, connect->addr_name.c_str());
+            socket, connect->addr_name.c_str()); 
   }
 
   GRPC_CLOSURE_INIT(&connect->on_alarm, on_alarm, socket,
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_posix.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_posix.cc
index 401ddd2f68..0d4aa82794 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_posix.cc
@@ -29,8 +29,8 @@
 #include <string.h>
 #include <unistd.h>
 
-#include "y_absl/strings/str_cat.h"
-
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
@@ -58,12 +58,12 @@ struct async_connect {
   int refs;
   grpc_closure write_closure;
   grpc_pollset_set* interested_parties;
-  TString addr_str;
+  TString addr_str; 
   grpc_endpoint** ep;
   grpc_closure* closure;
   grpc_channel_args* channel_args;
 };
-
+ 
 static grpc_error* prepare_socket(const grpc_resolved_address* addr, int fd,
                                   const grpc_channel_args* channel_args) {
   grpc_error* err = GRPC_ERROR_NONE;
@@ -104,8 +104,8 @@ static void tc_on_alarm(void* acp, grpc_error* error) {
   async_connect* ac = static_cast<async_connect*>(acp);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     const char* str = grpc_error_string(error);
-    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_alarm: error=%s",
-            ac->addr_str.c_str(), str);
+    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_alarm: error=%s", 
+            ac->addr_str.c_str(), str); 
   }
   gpr_mu_lock(&ac->mu);
   if (ac->fd != nullptr) {
@@ -117,7 +117,7 @@ static void tc_on_alarm(void* acp, grpc_error* error) {
   if (done) {
     gpr_mu_destroy(&ac->mu);
     grpc_channel_args_destroy(ac->channel_args);
-    delete ac;
+    delete ac; 
   }
 }
 
@@ -140,8 +140,8 @@ static void on_writable(void* acp, grpc_error* error) {
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     const char* str = grpc_error_string(error);
-    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_writable: error=%s",
-            ac->addr_str.c_str(), str);
+    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_writable: error=%s", 
+            ac->addr_str.c_str(), str); 
   }
 
   gpr_mu_lock(&ac->mu);
@@ -173,8 +173,8 @@ static void on_writable(void* acp, grpc_error* error) {
   switch (so_error) {
     case 0:
       grpc_pollset_set_del_fd(ac->interested_parties, fd);
-      *ep = grpc_tcp_client_create_from_fd(fd, ac->channel_args,
-                                           ac->addr_str.c_str());
+      *ep = grpc_tcp_client_create_from_fd(fd, ac->channel_args, 
+                                           ac->addr_str.c_str()); 
       fd = nullptr;
       break;
     case ENOBUFS:
@@ -216,17 +216,17 @@ finish:
   done = (--ac->refs == 0);
   // Create a copy of the data from "ac" to be accessed after the unlock, as
   // "ac" and its contents may be deallocated by the time they are read.
-  const grpc_slice addr_str_slice = grpc_slice_from_cpp_string(ac->addr_str);
+  const grpc_slice addr_str_slice = grpc_slice_from_cpp_string(ac->addr_str); 
   gpr_mu_unlock(&ac->mu);
   if (error != GRPC_ERROR_NONE) {
     grpc_slice str;
     bool ret = grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION, &str);
     GPR_ASSERT(ret);
-    TString description = y_absl::StrCat("Failed to connect to remote host: ",
-                                           grpc_core::StringViewFromSlice(str));
-    error =
-        grpc_error_set_str(error, GRPC_ERROR_STR_DESCRIPTION,
-                           grpc_slice_from_cpp_string(std::move(description)));
+    TString description = y_absl::StrCat("Failed to connect to remote host: ", 
+                                           grpc_core::StringViewFromSlice(str)); 
+    error = 
+        grpc_error_set_str(error, GRPC_ERROR_STR_DESCRIPTION, 
+                           grpc_slice_from_cpp_string(std::move(description))); 
     error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
                                addr_str_slice /* takes ownership */);
   } else {
@@ -237,7 +237,7 @@ finish:
     // populated *inside* the lock.
     gpr_mu_destroy(&ac->mu);
     grpc_channel_args_destroy(ac->channel_args);
-    delete ac;
+    delete ac; 
   }
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
 }
@@ -245,10 +245,10 @@ finish:
 grpc_error* grpc_tcp_client_prepare_fd(const grpc_channel_args* channel_args,
                                        const grpc_resolved_address* addr,
                                        grpc_resolved_address* mapped_addr,
-                                       int* fd) {
+                                       int* fd) { 
   grpc_dualstack_mode dsmode;
   grpc_error* error;
-  *fd = -1;
+  *fd = -1; 
   /* Use dualstack sockets where available. Set mapped to v6 or v4 mapped to
      v6. */
   if (!grpc_sockaddr_to_v4mapped(addr, mapped_addr)) {
@@ -256,7 +256,7 @@ grpc_error* grpc_tcp_client_prepare_fd(const grpc_channel_args* channel_args,
     memcpy(mapped_addr, addr, sizeof(*mapped_addr));
   }
   error =
-      grpc_create_dualstack_socket(mapped_addr, SOCK_STREAM, 0, &dsmode, fd);
+      grpc_create_dualstack_socket(mapped_addr, SOCK_STREAM, 0, &dsmode, fd); 
   if (error != GRPC_ERROR_NONE) {
     return error;
   }
@@ -266,7 +266,7 @@ grpc_error* grpc_tcp_client_prepare_fd(const grpc_channel_args* channel_args,
       memcpy(mapped_addr, addr, sizeof(*mapped_addr));
     }
   }
-  if ((error = prepare_socket(mapped_addr, *fd, channel_args)) !=
+  if ((error = prepare_socket(mapped_addr, *fd, channel_args)) != 
       GRPC_ERROR_NONE) {
     return error;
   }
@@ -274,7 +274,7 @@ grpc_error* grpc_tcp_client_prepare_fd(const grpc_channel_args* channel_args,
 }
 
 void grpc_tcp_client_create_from_prepared_fd(
-    grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
+    grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd, 
     const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
     grpc_millis deadline, grpc_endpoint** ep) {
   int err;
@@ -282,29 +282,29 @@ void grpc_tcp_client_create_from_prepared_fd(
     err = connect(fd, reinterpret_cast<const grpc_sockaddr*>(addr->addr),
                   addr->len);
   } while (err < 0 && errno == EINTR);
-
-  TString name = y_absl::StrCat("tcp-client:", grpc_sockaddr_to_uri(addr));
-  grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
-
+ 
+  TString name = y_absl::StrCat("tcp-client:", grpc_sockaddr_to_uri(addr)); 
+  grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true); 
+ 
   if (err >= 0) {
-    *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args,
-                                         grpc_sockaddr_to_uri(addr).c_str());
+    *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args, 
+                                         grpc_sockaddr_to_uri(addr).c_str()); 
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
     return;
   }
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
-    grpc_error* error = GRPC_OS_ERROR(errno, "connect");
-    error = grpc_error_set_str(
-        error, GRPC_ERROR_STR_TARGET_ADDRESS,
-        grpc_slice_from_cpp_string(grpc_sockaddr_to_uri(addr)));
+    grpc_error* error = GRPC_OS_ERROR(errno, "connect"); 
+    error = grpc_error_set_str( 
+        error, GRPC_ERROR_STR_TARGET_ADDRESS, 
+        grpc_slice_from_cpp_string(grpc_sockaddr_to_uri(addr))); 
     grpc_fd_orphan(fdobj, nullptr, nullptr, "tcp_client_connect_error");
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error); 
     return;
   }
 
   grpc_pollset_set_add_fd(interested_parties, fdobj);
 
-  async_connect* ac = new async_connect();
+  async_connect* ac = new async_connect(); 
   ac->closure = closure;
   ac->ep = ep;
   ac->fd = fdobj;
@@ -318,7 +318,7 @@ void grpc_tcp_client_create_from_prepared_fd(
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: asynchronously connecting fd %p",
-            ac->addr_str.c_str(), fdobj);
+            ac->addr_str.c_str(), fdobj); 
   }
 
   gpr_mu_lock(&ac->mu);
@@ -334,15 +334,15 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
                         const grpc_resolved_address* addr,
                         grpc_millis deadline) {
   grpc_resolved_address mapped_addr;
-  int fd = -1;
+  int fd = -1; 
   grpc_error* error;
   *ep = nullptr;
   if ((error = grpc_tcp_client_prepare_fd(channel_args, addr, &mapped_addr,
-                                          &fd)) != GRPC_ERROR_NONE) {
+                                          &fd)) != GRPC_ERROR_NONE) { 
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return;
   }
-  grpc_tcp_client_create_from_prepared_fd(interested_parties, closure, fd,
+  grpc_tcp_client_create_from_prepared_fd(interested_parties, closure, fd, 
                                           channel_args, &mapped_addr, deadline,
                                           ep);
 }
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_posix.h b/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_posix.h
index 6f61866fc4..e27d8225e8 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_posix.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_posix.h
@@ -35,33 +35,33 @@
 grpc_endpoint* grpc_tcp_client_create_from_fd(
     grpc_fd* fd, const grpc_channel_args* channel_args, const char* addr_str);
 
-/* Return a configured, unbound, unconnected TCP client fd.
+/* Return a configured, unbound, unconnected TCP client fd. 
 
    channel_args: may contain custom settings for the fd
    addr: the destination address
    mapped_addr: out parameter. addr mapped to an address appropriate to the
      type of socket FD created. For example, if addr is IPv4 and dual stack
      sockets are available, mapped_addr will be an IPv4-mapped IPv6 address
-   fd: out parameter. The new FD
+   fd: out parameter. The new FD 
    Returns: error, if any. Out parameters are not set on error
 */
 grpc_error* grpc_tcp_client_prepare_fd(const grpc_channel_args* channel_args,
                                        const grpc_resolved_address* addr,
                                        grpc_resolved_address* mapped_addr,
-                                       int* fd);
+                                       int* fd); 
 
-/* Connect a configured TCP client fd.
+/* Connect a configured TCP client fd. 
 
    interested_parties: a set of pollsets that would be interested in this
      connection being established (in order to continue their work
    closure: called when complete. On success, *ep will be set.
-   fd: an FD returned from grpc_tcp_client_prepare_fd().
+   fd: an FD returned from grpc_tcp_client_prepare_fd(). 
    channel_args: may contain custom settings for the endpoint
    deadline: connection deadline
    ep: out parameter. Set before closure is called if successful
 */
 void grpc_tcp_client_create_from_prepared_fd(
-    grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
+    grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd, 
     const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
     grpc_millis deadline, grpc_endpoint** ep);
 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_windows.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_windows.cc
index a57e7539f2..18c6e427b2 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_windows.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_client_windows.cc
@@ -39,7 +39,7 @@
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
 #include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_internal.h" 
 
 struct async_connect {
   grpc_closure* on_done;
@@ -47,13 +47,13 @@ struct async_connect {
   grpc_winsocket* socket;
   grpc_timer alarm;
   grpc_closure on_alarm;
-  TString addr_name;
+  TString addr_name; 
   int refs;
   grpc_closure on_connect;
   grpc_endpoint** endpoint;
   grpc_channel_args* channel_args;
 };
-
+ 
 static void async_connect_unlock_and_cleanup(async_connect* ac,
                                              grpc_winsocket* socket) {
   int done = (--ac->refs == 0);
@@ -61,7 +61,7 @@ static void async_connect_unlock_and_cleanup(async_connect* ac,
   if (done) {
     grpc_channel_args_destroy(ac->channel_args);
     gpr_mu_destroy(&ac->mu);
-    delete ac;
+    delete ac; 
   }
   if (socket != NULL) grpc_winsocket_destroy(socket);
 }
@@ -106,7 +106,7 @@ static void on_connect(void* acp, grpc_error* error) {
         error = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx");
         closesocket(socket->socket);
       } else {
-        *ep = grpc_tcp_create(socket, ac->channel_args, ac->addr_name.c_str());
+        *ep = grpc_tcp_create(socket, ac->channel_args, ac->addr_name.c_str()); 
         socket = NULL;
       }
     } else {
@@ -138,7 +138,7 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   DWORD ioctl_num_bytes;
   grpc_winsocket_callback_info* info;
   grpc_error* error = GRPC_ERROR_NONE;
-  async_connect* ac = NULL;
+  async_connect* ac = NULL; 
 
   *endpoint = NULL;
 
@@ -195,7 +195,7 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
     }
   }
 
-  ac = new async_connect();
+  ac = new async_connect(); 
   ac->on_done = on_done;
   ac->socket = socket;
   gpr_mu_init(&ac->mu);
@@ -212,12 +212,12 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
 
 failure:
   GPR_ASSERT(error != GRPC_ERROR_NONE);
-  TString target_uri = grpc_sockaddr_to_uri(addr);
+  TString target_uri = grpc_sockaddr_to_uri(addr); 
   grpc_error* final_error =
       grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                              "Failed to connect", &error, 1),
                          GRPC_ERROR_STR_TARGET_ADDRESS,
-                         grpc_slice_from_cpp_string(std::move(target_uri)));
+                         grpc_slice_from_cpp_string(std::move(target_uri))); 
   GRPC_ERROR_UNREF(error);
   if (socket != NULL) {
     grpc_winsocket_destroy(socket);
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_custom.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_custom.cc
index 3e562da508..d2de7bc717 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_custom.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_custom.cc
@@ -32,7 +32,7 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
 #include "src/core/lib/iomgr/resource_quota.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
+#include "src/core/lib/iomgr/sockaddr_utils.h" 
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_custom.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -58,24 +58,24 @@ struct custom_tcp_endpoint {
   gpr_refcount refcount;
   grpc_custom_socket* socket;
 
-  grpc_closure* read_cb = nullptr;
-  grpc_closure* write_cb = nullptr;
+  grpc_closure* read_cb = nullptr; 
+  grpc_closure* write_cb = nullptr; 
 
-  grpc_slice_buffer* read_slices = nullptr;
-  grpc_slice_buffer* write_slices = nullptr;
+  grpc_slice_buffer* read_slices = nullptr; 
+  grpc_slice_buffer* write_slices = nullptr; 
 
   grpc_resource_user* resource_user;
   grpc_resource_user_slice_allocator slice_allocator;
 
   bool shutting_down;
 
-  TString peer_string;
-  TString local_address;
+  TString peer_string; 
+  TString local_address; 
 };
 static void tcp_free(grpc_custom_socket* s) {
   custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)s->endpoint;
   grpc_resource_user_unref(tcp->resource_user);
-  delete tcp;
+  delete tcp; 
   s->refs--;
   if (s->refs == 0) {
     grpc_custom_socket_vtable->destroy(s);
@@ -133,8 +133,8 @@ static void call_read_cb(custom_tcp_endpoint* tcp, grpc_error* error) {
     for (i = 0; i < tcp->read_slices->count; i++) {
       char* dump = grpc_dump_slice(tcp->read_slices->slices[i],
                                    GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_INFO, "READ %p (peer=%s): %s", tcp, tcp->peer_string.c_str(),
-              dump);
+      gpr_log(GPR_INFO, "READ %p (peer=%s): %s", tcp, tcp->peer_string.c_str(), 
+              dump); 
       gpr_free(dump);
     }
   }
@@ -235,8 +235,8 @@ static void endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* write_slices,
     for (j = 0; j < write_slices->count; j++) {
       char* data = grpc_dump_slice(write_slices->slices[j],
                                    GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_INFO, "WRITE %p (peer=%s): %s", tcp->socket,
-              tcp->peer_string.c_str(), data);
+      gpr_log(GPR_INFO, "WRITE %p (peer=%s): %s", tcp->socket, 
+              tcp->peer_string.c_str(), data); 
       gpr_free(data);
     }
   }
@@ -319,16 +319,16 @@ static void endpoint_destroy(grpc_endpoint* ep) {
   grpc_custom_socket_vtable->close(tcp->socket, custom_close_callback);
 }
 
-static y_absl::string_view endpoint_get_peer(grpc_endpoint* ep) {
+static y_absl::string_view endpoint_get_peer(grpc_endpoint* ep) { 
   custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
-  return tcp->peer_string;
-}
-
-static y_absl::string_view endpoint_get_local_address(grpc_endpoint* ep) {
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
-  return tcp->local_address;
+  return tcp->peer_string; 
 }
 
+static y_absl::string_view endpoint_get_local_address(grpc_endpoint* ep) { 
+  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep; 
+  return tcp->local_address; 
+} 
+ 
 static grpc_resource_user* endpoint_get_resource_user(grpc_endpoint* ep) {
   custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
   return tcp->resource_user;
@@ -347,14 +347,14 @@ static grpc_endpoint_vtable vtable = {endpoint_read,
                                       endpoint_destroy,
                                       endpoint_get_resource_user,
                                       endpoint_get_peer,
-                                      endpoint_get_local_address,
+                                      endpoint_get_local_address, 
                                       endpoint_get_fd,
                                       endpoint_can_track_err};
 
 grpc_endpoint* custom_tcp_endpoint_create(grpc_custom_socket* socket,
                                           grpc_resource_quota* resource_quota,
-                                          const char* peer_string) {
-  custom_tcp_endpoint* tcp = new custom_tcp_endpoint;
+                                          const char* peer_string) { 
+  custom_tcp_endpoint* tcp = new custom_tcp_endpoint; 
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
 
@@ -366,17 +366,17 @@ grpc_endpoint* custom_tcp_endpoint_create(grpc_custom_socket* socket,
   tcp->socket = socket;
   tcp->base.vtable = &vtable;
   gpr_ref_init(&tcp->refcount, 1);
-  tcp->peer_string = peer_string;
-  grpc_resolved_address resolved_local_addr;
-  resolved_local_addr.len = sizeof(resolved_local_addr.addr);
-  if (grpc_custom_socket_vtable->getsockname(
-          socket, reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-          reinterpret_cast<int*>(&resolved_local_addr.len)) !=
-      GRPC_ERROR_NONE) {
-    tcp->local_address = "";
-  } else {
-    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
-  }
+  tcp->peer_string = peer_string; 
+  grpc_resolved_address resolved_local_addr; 
+  resolved_local_addr.len = sizeof(resolved_local_addr.addr); 
+  if (grpc_custom_socket_vtable->getsockname( 
+          socket, reinterpret_cast<sockaddr*>(resolved_local_addr.addr), 
+          reinterpret_cast<int*>(&resolved_local_addr.len)) != 
+      GRPC_ERROR_NONE) { 
+    tcp->local_address = ""; 
+  } else { 
+    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr); 
+  } 
   tcp->shutting_down = false;
   tcp->resource_user = grpc_resource_user_create(resource_quota, peer_string);
   grpc_resource_user_slice_allocator_init(
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_custom.h b/contrib/libs/grpc/src/core/lib/iomgr/tcp_custom.h
index d32ed2b4b6..c7b08adee1 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_custom.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_custom.h
@@ -24,9 +24,9 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 
-// Same number as the micro of SO_REUSEPORT in kernel
-#define GRPC_CUSTOM_SOCKET_OPT_SO_REUSEPORT (0x00000200u)
-
+// Same number as the micro of SO_REUSEPORT in kernel 
+#define GRPC_CUSTOM_SOCKET_OPT_SO_REUSEPORT (0x00000200u) 
+ 
 typedef struct grpc_tcp_listener grpc_tcp_listener;
 typedef struct grpc_custom_tcp_connect grpc_custom_tcp_connect;
 
@@ -79,6 +79,6 @@ void grpc_custom_close_server_callback(grpc_tcp_listener* listener);
 
 grpc_endpoint* custom_tcp_endpoint_create(grpc_custom_socket* socket,
                                           grpc_resource_quota* resource_quota,
-                                          const char* peer_string);
+                                          const char* peer_string); 
 
 #endif /* GRPC_CORE_LIB_IOMGR_TCP_CUSTOM_H */
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_posix.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_posix.cc
index b1cd892964..b6b4501702 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_posix.cc
@@ -36,7 +36,7 @@
 #include <sys/types.h>
 #include <unistd.h>
 #include <algorithm>
-#include <unordered_map>
+#include <unordered_map> 
 
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
@@ -50,12 +50,12 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/sync.h" 
 #include "src/core/lib/iomgr/buffer_list.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
-#include "src/core/lib/iomgr/socket_utils_posix.h"
+#include "src/core/lib/iomgr/sockaddr_utils.h" 
+#include "src/core/lib/iomgr/socket_utils_posix.h" 
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
@@ -75,15 +75,15 @@
 #define SENDMSG_FLAGS 0
 #endif
 
-// TCP zero copy sendmsg flag.
-// NB: We define this here as a fallback in case we're using an older set of
-// library headers that has not defined MSG_ZEROCOPY. Since this constant is
-// part of the kernel, we are guaranteed it will never change/disagree so
-// defining it here is safe.
-#ifndef MSG_ZEROCOPY
-#define MSG_ZEROCOPY 0x4000000
-#endif
-
+// TCP zero copy sendmsg flag. 
+// NB: We define this here as a fallback in case we're using an older set of 
+// library headers that has not defined MSG_ZEROCOPY. Since this constant is 
+// part of the kernel, we are guaranteed it will never change/disagree so 
+// defining it here is safe. 
+#ifndef MSG_ZEROCOPY 
+#define MSG_ZEROCOPY 0x4000000 
+#endif 
+ 
 #ifdef GRPC_MSG_IOVLEN_TYPE
 typedef GRPC_MSG_IOVLEN_TYPE msg_iovlen_type;
 #else
@@ -92,268 +92,268 @@ typedef size_t msg_iovlen_type;
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
 
-namespace grpc_core {
-
-class TcpZerocopySendRecord {
- public:
-  TcpZerocopySendRecord() { grpc_slice_buffer_init(&buf_); }
-
-  ~TcpZerocopySendRecord() {
-    AssertEmpty();
-    grpc_slice_buffer_destroy_internal(&buf_);
-  }
-
-  // Given the slices that we wish to send, and the current offset into the
-  //   slice buffer (indicating which have already been sent), populate an iovec
-  //   array that will be used for a zerocopy enabled sendmsg().
-  msg_iovlen_type PopulateIovs(size_t* unwind_slice_idx,
-                               size_t* unwind_byte_idx, size_t* sending_length,
-                               iovec* iov);
-
-  // A sendmsg() may not be able to send the bytes that we requested at this
-  // time, returning EAGAIN (possibly due to backpressure). In this case,
-  // unwind the offset into the slice buffer so we retry sending these bytes.
-  void UnwindIfThrottled(size_t unwind_slice_idx, size_t unwind_byte_idx) {
-    out_offset_.byte_idx = unwind_byte_idx;
-    out_offset_.slice_idx = unwind_slice_idx;
-  }
-
-  // Update the offset into the slice buffer based on how much we wanted to sent
-  // vs. what sendmsg() actually sent (which may be lower, possibly due to
-  // backpressure).
-  void UpdateOffsetForBytesSent(size_t sending_length, size_t actually_sent);
-
-  // Indicates whether all underlying data has been sent or not.
-  bool AllSlicesSent() { return out_offset_.slice_idx == buf_.count; }
-
-  // Reset this structure for a new tcp_write() with zerocopy.
-  void PrepareForSends(grpc_slice_buffer* slices_to_send) {
-    AssertEmpty();
-    out_offset_.slice_idx = 0;
-    out_offset_.byte_idx = 0;
-    grpc_slice_buffer_swap(slices_to_send, &buf_);
-    Ref();
-  }
-
-  // References: 1 reference per sendmsg(), and 1 for the tcp_write().
-  void Ref() { ref_.FetchAdd(1, MemoryOrder::RELAXED); }
-
-  // Unref: called when we get an error queue notification for a sendmsg(), if a
-  //  sendmsg() failed or when tcp_write() is done.
-  bool Unref() {
-    const intptr_t prior = ref_.FetchSub(1, MemoryOrder::ACQ_REL);
-    GPR_DEBUG_ASSERT(prior > 0);
-    if (prior == 1) {
-      AllSendsComplete();
-      return true;
-    }
-    return false;
-  }
-
- private:
-  struct OutgoingOffset {
-    size_t slice_idx = 0;
-    size_t byte_idx = 0;
-  };
-
-  void AssertEmpty() {
-    GPR_DEBUG_ASSERT(buf_.count == 0);
-    GPR_DEBUG_ASSERT(buf_.length == 0);
-    GPR_DEBUG_ASSERT(ref_.Load(MemoryOrder::RELAXED) == 0);
-  }
-
-  // When all sendmsg() calls associated with this tcp_write() have been
-  // completed (ie. we have received the notifications for each sequence number
-  // for each sendmsg()) and all reference counts have been dropped, drop our
-  // reference to the underlying data since we no longer need it.
-  void AllSendsComplete() {
-    GPR_DEBUG_ASSERT(ref_.Load(MemoryOrder::RELAXED) == 0);
-    grpc_slice_buffer_reset_and_unref_internal(&buf_);
-  }
-
-  grpc_slice_buffer buf_;
-  Atomic<intptr_t> ref_;
-  OutgoingOffset out_offset_;
-};
-
-class TcpZerocopySendCtx {
- public:
-  static constexpr int kDefaultMaxSends = 4;
-  static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;  // 16KB
-
-  TcpZerocopySendCtx(int max_sends = kDefaultMaxSends,
-                     size_t send_bytes_threshold = kDefaultSendBytesThreshold)
-      : max_sends_(max_sends),
-        free_send_records_size_(max_sends),
-        threshold_bytes_(send_bytes_threshold) {
-    send_records_ = static_cast<TcpZerocopySendRecord*>(
-        gpr_malloc(max_sends * sizeof(*send_records_)));
-    free_send_records_ = static_cast<TcpZerocopySendRecord**>(
-        gpr_malloc(max_sends * sizeof(*free_send_records_)));
-    if (send_records_ == nullptr || free_send_records_ == nullptr) {
-      gpr_free(send_records_);
-      gpr_free(free_send_records_);
-      gpr_log(GPR_INFO, "Disabling TCP TX zerocopy due to memory pressure.\n");
-      memory_limited_ = true;
-    } else {
-      for (int idx = 0; idx < max_sends_; ++idx) {
-        new (send_records_ + idx) TcpZerocopySendRecord();
-        free_send_records_[idx] = send_records_ + idx;
-      }
-    }
-  }
-
-  ~TcpZerocopySendCtx() {
-    if (send_records_ != nullptr) {
-      for (int idx = 0; idx < max_sends_; ++idx) {
-        send_records_[idx].~TcpZerocopySendRecord();
-      }
-    }
-    gpr_free(send_records_);
-    gpr_free(free_send_records_);
-  }
-
-  // True if we were unable to allocate the various bookkeeping structures at
-  // transport initialization time. If memory limited, we do not zerocopy.
-  bool memory_limited() const { return memory_limited_; }
-
-  // TCP send zerocopy maintains an implicit sequence number for every
-  // successful sendmsg() with zerocopy enabled; the kernel later gives us an
-  // error queue notification with this sequence number indicating that the
-  // underlying data buffers that we sent can now be released. Once that
-  // notification is received, we can release the buffers associated with this
-  // zerocopy send record. Here, we associate the sequence number with the data
-  // buffers that were sent with the corresponding call to sendmsg().
-  void NoteSend(TcpZerocopySendRecord* record) {
-    record->Ref();
-    AssociateSeqWithSendRecord(last_send_, record);
-    ++last_send_;
-  }
-
-  // If sendmsg() actually failed, though, we need to revert the sequence number
-  // that we speculatively bumped before calling sendmsg(). Note that we bump
-  // this sequence number and perform relevant bookkeeping (see: NoteSend())
-  // *before* calling sendmsg() since, if we called it *after* sendmsg(), then
-  // there is a possible race with the release notification which could occur on
-  // another thread before we do the necessary bookkeeping. Hence, calling
-  // NoteSend() *before* sendmsg() and implementing an undo function is needed.
-  void UndoSend() {
-    --last_send_;
-    if (ReleaseSendRecord(last_send_)->Unref()) {
-      // We should still be holding the ref taken by tcp_write().
-      GPR_DEBUG_ASSERT(0);
-    }
-  }
-
-  // Simply associate this send record (and the underlying sent data buffers)
-  // with the implicit sequence number for this zerocopy sendmsg().
-  void AssociateSeqWithSendRecord(uint32_t seq, TcpZerocopySendRecord* record) {
-    MutexLock guard(&lock_);
-    ctx_lookup_.emplace(seq, record);
-  }
-
-  // Get a send record for a send that we wish to do with zerocopy.
-  TcpZerocopySendRecord* GetSendRecord() {
-    MutexLock guard(&lock_);
-    return TryGetSendRecordLocked();
-  }
-
-  // A given send record corresponds to a single tcp_write() with zerocopy
-  // enabled. This can result in several sendmsg() calls to flush all of the
-  // data to wire. Each sendmsg() takes a reference on the
-  // TcpZerocopySendRecord, and corresponds to a single sequence number.
-  // ReleaseSendRecord releases a reference on TcpZerocopySendRecord for a
-  // single sequence number. This is called either when we receive the relevant
-  // error queue notification (saying that we can discard the underlying
-  // buffers for this sendmsg()) is received from the kernel - or, in case
-  // sendmsg() was unsuccessful to begin with.
-  TcpZerocopySendRecord* ReleaseSendRecord(uint32_t seq) {
-    MutexLock guard(&lock_);
-    return ReleaseSendRecordLocked(seq);
-  }
-
-  // After all the references to a TcpZerocopySendRecord are released, we can
-  // add it back to the pool (of size max_sends_). Note that we can only have
-  // max_sends_ tcp_write() instances with zerocopy enabled in flight at the
-  // same time.
-  void PutSendRecord(TcpZerocopySendRecord* record) {
-    GPR_DEBUG_ASSERT(record >= send_records_ &&
-                     record < send_records_ + max_sends_);
-    MutexLock guard(&lock_);
-    PutSendRecordLocked(record);
-  }
-
-  // Indicate that we are disposing of this zerocopy context. This indicator
-  // will prevent new zerocopy writes from being issued.
-  void Shutdown() { shutdown_.Store(true, MemoryOrder::RELEASE); }
-
-  // Indicates that there are no inflight tcp_write() instances with zerocopy
-  // enabled.
-  bool AllSendRecordsEmpty() {
-    MutexLock guard(&lock_);
-    return free_send_records_size_ == max_sends_;
-  }
-
-  bool enabled() const { return enabled_; }
-
-  void set_enabled(bool enabled) {
-    GPR_DEBUG_ASSERT(!enabled || !memory_limited());
-    enabled_ = enabled;
-  }
-
-  // Only use zerocopy if we are sending at least this many bytes. The
-  // additional overhead of reading the error queue for notifications means that
-  // zerocopy is not useful for small transfers.
-  size_t threshold_bytes() const { return threshold_bytes_; }
-
- private:
-  TcpZerocopySendRecord* ReleaseSendRecordLocked(uint32_t seq) {
-    auto iter = ctx_lookup_.find(seq);
-    GPR_DEBUG_ASSERT(iter != ctx_lookup_.end());
-    TcpZerocopySendRecord* record = iter->second;
-    ctx_lookup_.erase(iter);
-    return record;
-  }
-
-  TcpZerocopySendRecord* TryGetSendRecordLocked() {
-    if (shutdown_.Load(MemoryOrder::ACQUIRE)) {
-      return nullptr;
-    }
-    if (free_send_records_size_ == 0) {
-      return nullptr;
-    }
-    free_send_records_size_--;
-    return free_send_records_[free_send_records_size_];
-  }
-
-  void PutSendRecordLocked(TcpZerocopySendRecord* record) {
-    GPR_DEBUG_ASSERT(free_send_records_size_ < max_sends_);
-    free_send_records_[free_send_records_size_] = record;
-    free_send_records_size_++;
-  }
-
-  TcpZerocopySendRecord* send_records_;
-  TcpZerocopySendRecord** free_send_records_;
-  int max_sends_;
-  int free_send_records_size_;
-  Mutex lock_;
-  uint32_t last_send_ = 0;
-  Atomic<bool> shutdown_;
-  bool enabled_ = false;
-  size_t threshold_bytes_ = kDefaultSendBytesThreshold;
-  std::unordered_map<uint32_t, TcpZerocopySendRecord*> ctx_lookup_;
-  bool memory_limited_ = false;
-};
-
-}  // namespace grpc_core
-
-using grpc_core::TcpZerocopySendCtx;
-using grpc_core::TcpZerocopySendRecord;
-
+namespace grpc_core { 
+ 
+class TcpZerocopySendRecord { 
+ public: 
+  TcpZerocopySendRecord() { grpc_slice_buffer_init(&buf_); } 
+ 
+  ~TcpZerocopySendRecord() { 
+    AssertEmpty(); 
+    grpc_slice_buffer_destroy_internal(&buf_); 
+  } 
+ 
+  // Given the slices that we wish to send, and the current offset into the 
+  //   slice buffer (indicating which have already been sent), populate an iovec 
+  //   array that will be used for a zerocopy enabled sendmsg(). 
+  msg_iovlen_type PopulateIovs(size_t* unwind_slice_idx, 
+                               size_t* unwind_byte_idx, size_t* sending_length, 
+                               iovec* iov); 
+ 
+  // A sendmsg() may not be able to send the bytes that we requested at this 
+  // time, returning EAGAIN (possibly due to backpressure). In this case, 
+  // unwind the offset into the slice buffer so we retry sending these bytes. 
+  void UnwindIfThrottled(size_t unwind_slice_idx, size_t unwind_byte_idx) { 
+    out_offset_.byte_idx = unwind_byte_idx; 
+    out_offset_.slice_idx = unwind_slice_idx; 
+  } 
+ 
+  // Update the offset into the slice buffer based on how much we wanted to sent 
+  // vs. what sendmsg() actually sent (which may be lower, possibly due to 
+  // backpressure). 
+  void UpdateOffsetForBytesSent(size_t sending_length, size_t actually_sent); 
+ 
+  // Indicates whether all underlying data has been sent or not. 
+  bool AllSlicesSent() { return out_offset_.slice_idx == buf_.count; } 
+ 
+  // Reset this structure for a new tcp_write() with zerocopy. 
+  void PrepareForSends(grpc_slice_buffer* slices_to_send) { 
+    AssertEmpty(); 
+    out_offset_.slice_idx = 0; 
+    out_offset_.byte_idx = 0; 
+    grpc_slice_buffer_swap(slices_to_send, &buf_); 
+    Ref(); 
+  } 
+ 
+  // References: 1 reference per sendmsg(), and 1 for the tcp_write(). 
+  void Ref() { ref_.FetchAdd(1, MemoryOrder::RELAXED); } 
+ 
+  // Unref: called when we get an error queue notification for a sendmsg(), if a 
+  //  sendmsg() failed or when tcp_write() is done. 
+  bool Unref() { 
+    const intptr_t prior = ref_.FetchSub(1, MemoryOrder::ACQ_REL); 
+    GPR_DEBUG_ASSERT(prior > 0); 
+    if (prior == 1) { 
+      AllSendsComplete(); 
+      return true; 
+    } 
+    return false; 
+  } 
+ 
+ private: 
+  struct OutgoingOffset { 
+    size_t slice_idx = 0; 
+    size_t byte_idx = 0; 
+  }; 
+ 
+  void AssertEmpty() { 
+    GPR_DEBUG_ASSERT(buf_.count == 0); 
+    GPR_DEBUG_ASSERT(buf_.length == 0); 
+    GPR_DEBUG_ASSERT(ref_.Load(MemoryOrder::RELAXED) == 0); 
+  } 
+ 
+  // When all sendmsg() calls associated with this tcp_write() have been 
+  // completed (ie. we have received the notifications for each sequence number 
+  // for each sendmsg()) and all reference counts have been dropped, drop our 
+  // reference to the underlying data since we no longer need it. 
+  void AllSendsComplete() { 
+    GPR_DEBUG_ASSERT(ref_.Load(MemoryOrder::RELAXED) == 0); 
+    grpc_slice_buffer_reset_and_unref_internal(&buf_); 
+  } 
+ 
+  grpc_slice_buffer buf_; 
+  Atomic<intptr_t> ref_; 
+  OutgoingOffset out_offset_; 
+}; 
+ 
+class TcpZerocopySendCtx { 
+ public: 
+  static constexpr int kDefaultMaxSends = 4; 
+  static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;  // 16KB 
+ 
+  TcpZerocopySendCtx(int max_sends = kDefaultMaxSends, 
+                     size_t send_bytes_threshold = kDefaultSendBytesThreshold) 
+      : max_sends_(max_sends), 
+        free_send_records_size_(max_sends), 
+        threshold_bytes_(send_bytes_threshold) { 
+    send_records_ = static_cast<TcpZerocopySendRecord*>( 
+        gpr_malloc(max_sends * sizeof(*send_records_))); 
+    free_send_records_ = static_cast<TcpZerocopySendRecord**>( 
+        gpr_malloc(max_sends * sizeof(*free_send_records_))); 
+    if (send_records_ == nullptr || free_send_records_ == nullptr) { 
+      gpr_free(send_records_); 
+      gpr_free(free_send_records_); 
+      gpr_log(GPR_INFO, "Disabling TCP TX zerocopy due to memory pressure.\n"); 
+      memory_limited_ = true; 
+    } else { 
+      for (int idx = 0; idx < max_sends_; ++idx) { 
+        new (send_records_ + idx) TcpZerocopySendRecord(); 
+        free_send_records_[idx] = send_records_ + idx; 
+      } 
+    } 
+  } 
+ 
+  ~TcpZerocopySendCtx() { 
+    if (send_records_ != nullptr) { 
+      for (int idx = 0; idx < max_sends_; ++idx) { 
+        send_records_[idx].~TcpZerocopySendRecord(); 
+      } 
+    } 
+    gpr_free(send_records_); 
+    gpr_free(free_send_records_); 
+  } 
+ 
+  // True if we were unable to allocate the various bookkeeping structures at 
+  // transport initialization time. If memory limited, we do not zerocopy. 
+  bool memory_limited() const { return memory_limited_; } 
+ 
+  // TCP send zerocopy maintains an implicit sequence number for every 
+  // successful sendmsg() with zerocopy enabled; the kernel later gives us an 
+  // error queue notification with this sequence number indicating that the 
+  // underlying data buffers that we sent can now be released. Once that 
+  // notification is received, we can release the buffers associated with this 
+  // zerocopy send record. Here, we associate the sequence number with the data 
+  // buffers that were sent with the corresponding call to sendmsg(). 
+  void NoteSend(TcpZerocopySendRecord* record) { 
+    record->Ref(); 
+    AssociateSeqWithSendRecord(last_send_, record); 
+    ++last_send_; 
+  } 
+ 
+  // If sendmsg() actually failed, though, we need to revert the sequence number 
+  // that we speculatively bumped before calling sendmsg(). Note that we bump 
+  // this sequence number and perform relevant bookkeeping (see: NoteSend()) 
+  // *before* calling sendmsg() since, if we called it *after* sendmsg(), then 
+  // there is a possible race with the release notification which could occur on 
+  // another thread before we do the necessary bookkeeping. Hence, calling 
+  // NoteSend() *before* sendmsg() and implementing an undo function is needed. 
+  void UndoSend() { 
+    --last_send_; 
+    if (ReleaseSendRecord(last_send_)->Unref()) { 
+      // We should still be holding the ref taken by tcp_write(). 
+      GPR_DEBUG_ASSERT(0); 
+    } 
+  } 
+ 
+  // Simply associate this send record (and the underlying sent data buffers) 
+  // with the implicit sequence number for this zerocopy sendmsg(). 
+  void AssociateSeqWithSendRecord(uint32_t seq, TcpZerocopySendRecord* record) { 
+    MutexLock guard(&lock_); 
+    ctx_lookup_.emplace(seq, record); 
+  } 
+ 
+  // Get a send record for a send that we wish to do with zerocopy. 
+  TcpZerocopySendRecord* GetSendRecord() { 
+    MutexLock guard(&lock_); 
+    return TryGetSendRecordLocked(); 
+  } 
+ 
+  // A given send record corresponds to a single tcp_write() with zerocopy 
+  // enabled. This can result in several sendmsg() calls to flush all of the 
+  // data to wire. Each sendmsg() takes a reference on the 
+  // TcpZerocopySendRecord, and corresponds to a single sequence number. 
+  // ReleaseSendRecord releases a reference on TcpZerocopySendRecord for a 
+  // single sequence number. This is called either when we receive the relevant 
+  // error queue notification (saying that we can discard the underlying 
+  // buffers for this sendmsg()) is received from the kernel - or, in case 
+  // sendmsg() was unsuccessful to begin with. 
+  TcpZerocopySendRecord* ReleaseSendRecord(uint32_t seq) { 
+    MutexLock guard(&lock_); 
+    return ReleaseSendRecordLocked(seq); 
+  } 
+ 
+  // After all the references to a TcpZerocopySendRecord are released, we can 
+  // add it back to the pool (of size max_sends_). Note that we can only have 
+  // max_sends_ tcp_write() instances with zerocopy enabled in flight at the 
+  // same time. 
+  void PutSendRecord(TcpZerocopySendRecord* record) { 
+    GPR_DEBUG_ASSERT(record >= send_records_ && 
+                     record < send_records_ + max_sends_); 
+    MutexLock guard(&lock_); 
+    PutSendRecordLocked(record); 
+  } 
+ 
+  // Indicate that we are disposing of this zerocopy context. This indicator 
+  // will prevent new zerocopy writes from being issued. 
+  void Shutdown() { shutdown_.Store(true, MemoryOrder::RELEASE); } 
+ 
+  // Indicates that there are no inflight tcp_write() instances with zerocopy 
+  // enabled. 
+  bool AllSendRecordsEmpty() { 
+    MutexLock guard(&lock_); 
+    return free_send_records_size_ == max_sends_; 
+  } 
+ 
+  bool enabled() const { return enabled_; } 
+ 
+  void set_enabled(bool enabled) { 
+    GPR_DEBUG_ASSERT(!enabled || !memory_limited()); 
+    enabled_ = enabled; 
+  } 
+ 
+  // Only use zerocopy if we are sending at least this many bytes. The 
+  // additional overhead of reading the error queue for notifications means that 
+  // zerocopy is not useful for small transfers. 
+  size_t threshold_bytes() const { return threshold_bytes_; } 
+ 
+ private: 
+  TcpZerocopySendRecord* ReleaseSendRecordLocked(uint32_t seq) { 
+    auto iter = ctx_lookup_.find(seq); 
+    GPR_DEBUG_ASSERT(iter != ctx_lookup_.end()); 
+    TcpZerocopySendRecord* record = iter->second; 
+    ctx_lookup_.erase(iter); 
+    return record; 
+  } 
+ 
+  TcpZerocopySendRecord* TryGetSendRecordLocked() { 
+    if (shutdown_.Load(MemoryOrder::ACQUIRE)) { 
+      return nullptr; 
+    } 
+    if (free_send_records_size_ == 0) { 
+      return nullptr; 
+    } 
+    free_send_records_size_--; 
+    return free_send_records_[free_send_records_size_]; 
+  } 
+ 
+  void PutSendRecordLocked(TcpZerocopySendRecord* record) { 
+    GPR_DEBUG_ASSERT(free_send_records_size_ < max_sends_); 
+    free_send_records_[free_send_records_size_] = record; 
+    free_send_records_size_++; 
+  } 
+ 
+  TcpZerocopySendRecord* send_records_; 
+  TcpZerocopySendRecord** free_send_records_; 
+  int max_sends_; 
+  int free_send_records_size_; 
+  Mutex lock_; 
+  uint32_t last_send_ = 0; 
+  Atomic<bool> shutdown_; 
+  bool enabled_ = false; 
+  size_t threshold_bytes_ = kDefaultSendBytesThreshold; 
+  std::unordered_map<uint32_t, TcpZerocopySendRecord*> ctx_lookup_; 
+  bool memory_limited_ = false; 
+}; 
+ 
+}  // namespace grpc_core 
+ 
+using grpc_core::TcpZerocopySendCtx; 
+using grpc_core::TcpZerocopySendRecord; 
+ 
 namespace {
 struct grpc_tcp {
-  grpc_tcp(int max_sends, size_t send_bytes_threshold)
-      : tcp_zerocopy_send_ctx(max_sends, send_bytes_threshold) {}
+  grpc_tcp(int max_sends, size_t send_bytes_threshold) 
+      : tcp_zerocopy_send_ctx(max_sends, send_bytes_threshold) {} 
   grpc_endpoint base;
   grpc_fd* em_fd;
   int fd;
@@ -388,8 +388,8 @@ struct grpc_tcp {
   grpc_closure write_done_closure;
   grpc_closure error_closure;
 
-  TString peer_string;
-  TString local_address;
+  TString peer_string; 
+  TString local_address; 
 
   grpc_resource_user* resource_user;
   grpc_resource_user_slice_allocator slice_allocator;
@@ -416,8 +416,8 @@ struct grpc_tcp {
   bool ts_capable;        /* Cache whether we can set timestamping options */
   gpr_atm stop_error_notification; /* Set to 1 if we do not want to be notified
                                       on errors anymore */
-  TcpZerocopySendCtx tcp_zerocopy_send_ctx;
-  TcpZerocopySendRecord* current_zerocopy_send = nullptr;
+  TcpZerocopySendCtx tcp_zerocopy_send_ctx; 
+  TcpZerocopySendRecord* current_zerocopy_send = nullptr; 
 };
 
 struct backup_poller {
@@ -427,8 +427,8 @@ struct backup_poller {
 
 }  // namespace
 
-static void ZerocopyDisableAndWaitForRemaining(grpc_tcp* tcp);
-
+static void ZerocopyDisableAndWaitForRemaining(grpc_tcp* tcp); 
+ 
 #define BACKUP_POLLER_POLLSET(b) ((grpc_pollset*)((b) + 1))
 
 static gpr_atm g_uncovered_notifications_pending;
@@ -609,7 +609,7 @@ static grpc_error* tcp_annotate_error(grpc_error* src_error, grpc_tcp* tcp) {
            * choose to retry. */
           GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE),
       GRPC_ERROR_STR_TARGET_ADDRESS,
-      grpc_slice_from_copied_string(tcp->peer_string.c_str()));
+      grpc_slice_from_copied_string(tcp->peer_string.c_str())); 
 }
 
 static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error* error);
@@ -617,7 +617,7 @@ static void tcp_handle_write(void* arg /* grpc_tcp */, grpc_error* error);
 
 static void tcp_shutdown(grpc_endpoint* ep, grpc_error* why) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
-  ZerocopyDisableAndWaitForRemaining(tcp);
+  ZerocopyDisableAndWaitForRemaining(tcp); 
   grpc_fd_shutdown(tcp->em_fd, why);
   grpc_resource_user_shutdown(tcp->resource_user);
 }
@@ -635,7 +635,7 @@ static void tcp_free(grpc_tcp* tcp) {
   gpr_mu_unlock(&tcp->tb_mu);
   tcp->outgoing_buffer_arg = nullptr;
   gpr_mu_destroy(&tcp->tb_mu);
-  delete tcp;
+  delete tcp; 
 }
 
 #ifndef NDEBUG
@@ -668,7 +668,7 @@ static void tcp_destroy(grpc_endpoint* ep) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
   grpc_slice_buffer_reset_and_unref_internal(&tcp->last_read_buffer);
   if (grpc_event_engine_can_track_errors()) {
-    ZerocopyDisableAndWaitForRemaining(tcp);
+    ZerocopyDisableAndWaitForRemaining(tcp); 
     gpr_atm_no_barrier_store(&tcp->stop_error_notification, true);
     grpc_fd_set_error(tcp->em_fd);
   }
@@ -682,8 +682,8 @@ static void call_read_cb(grpc_tcp* tcp, grpc_error* error) {
     gpr_log(GPR_INFO, "TCP:%p call_cb %p %p:%p", tcp, cb, cb->cb, cb->cb_arg);
     size_t i;
     const char* str = grpc_error_string(error);
-    gpr_log(GPR_INFO, "READ %p (peer=%s) error=%s", tcp,
-            tcp->peer_string.c_str(), str);
+    gpr_log(GPR_INFO, "READ %p (peer=%s) error=%s", tcp, 
+            tcp->peer_string.c_str(), str); 
 
     if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
       for (i = 0; i < tcp->incoming_buffer->count; i++) {
@@ -932,13 +932,13 @@ static void tcp_read(grpc_endpoint* ep, grpc_slice_buffer* incoming_buffer,
 
 /* A wrapper around sendmsg. It sends \a msg over \a fd and returns the number
  * of bytes sent. */
-ssize_t tcp_send(int fd, const struct msghdr* msg, int additional_flags = 0) {
+ssize_t tcp_send(int fd, const struct msghdr* msg, int additional_flags = 0) { 
   GPR_TIMER_SCOPE("sendmsg", 1);
   ssize_t sent_length;
   do {
     /* TODO(klempner): Cork if this is a partial write */
     GRPC_STATS_INC_SYSCALL_WRITE();
-    sent_length = sendmsg(fd, msg, SENDMSG_FLAGS | additional_flags);
+    sent_length = sendmsg(fd, msg, SENDMSG_FLAGS | additional_flags); 
   } while (sent_length < 0 && errno == EINTR);
   return sent_length;
 }
@@ -951,52 +951,52 @@ ssize_t tcp_send(int fd, const struct msghdr* msg, int additional_flags = 0) {
  */
 static bool tcp_write_with_timestamps(grpc_tcp* tcp, struct msghdr* msg,
                                       size_t sending_length,
-                                      ssize_t* sent_length,
-                                      int additional_flags = 0);
+                                      ssize_t* sent_length, 
+                                      int additional_flags = 0); 
 
 /** The callback function to be invoked when we get an error on the socket. */
 static void tcp_handle_error(void* arg /* grpc_tcp */, grpc_error* error);
 
-static TcpZerocopySendRecord* tcp_get_send_zerocopy_record(
-    grpc_tcp* tcp, grpc_slice_buffer* buf);
-
+static TcpZerocopySendRecord* tcp_get_send_zerocopy_record( 
+    grpc_tcp* tcp, grpc_slice_buffer* buf); 
+ 
 #ifdef GRPC_LINUX_ERRQUEUE
-static bool process_errors(grpc_tcp* tcp);
-
-static TcpZerocopySendRecord* tcp_get_send_zerocopy_record(
-    grpc_tcp* tcp, grpc_slice_buffer* buf) {
-  TcpZerocopySendRecord* zerocopy_send_record = nullptr;
-  const bool use_zerocopy =
-      tcp->tcp_zerocopy_send_ctx.enabled() &&
-      tcp->tcp_zerocopy_send_ctx.threshold_bytes() < buf->length;
-  if (use_zerocopy) {
-    zerocopy_send_record = tcp->tcp_zerocopy_send_ctx.GetSendRecord();
-    if (zerocopy_send_record == nullptr) {
-      process_errors(tcp);
-      zerocopy_send_record = tcp->tcp_zerocopy_send_ctx.GetSendRecord();
-    }
-    if (zerocopy_send_record != nullptr) {
-      zerocopy_send_record->PrepareForSends(buf);
-      GPR_DEBUG_ASSERT(buf->count == 0);
-      GPR_DEBUG_ASSERT(buf->length == 0);
-      tcp->outgoing_byte_idx = 0;
-      tcp->outgoing_buffer = nullptr;
-    }
-  }
-  return zerocopy_send_record;
-}
-
-static void ZerocopyDisableAndWaitForRemaining(grpc_tcp* tcp) {
-  tcp->tcp_zerocopy_send_ctx.Shutdown();
-  while (!tcp->tcp_zerocopy_send_ctx.AllSendRecordsEmpty()) {
-    process_errors(tcp);
-  }
-}
-
+static bool process_errors(grpc_tcp* tcp); 
+
+static TcpZerocopySendRecord* tcp_get_send_zerocopy_record( 
+    grpc_tcp* tcp, grpc_slice_buffer* buf) { 
+  TcpZerocopySendRecord* zerocopy_send_record = nullptr; 
+  const bool use_zerocopy = 
+      tcp->tcp_zerocopy_send_ctx.enabled() && 
+      tcp->tcp_zerocopy_send_ctx.threshold_bytes() < buf->length; 
+  if (use_zerocopy) { 
+    zerocopy_send_record = tcp->tcp_zerocopy_send_ctx.GetSendRecord(); 
+    if (zerocopy_send_record == nullptr) { 
+      process_errors(tcp); 
+      zerocopy_send_record = tcp->tcp_zerocopy_send_ctx.GetSendRecord(); 
+    } 
+    if (zerocopy_send_record != nullptr) { 
+      zerocopy_send_record->PrepareForSends(buf); 
+      GPR_DEBUG_ASSERT(buf->count == 0); 
+      GPR_DEBUG_ASSERT(buf->length == 0); 
+      tcp->outgoing_byte_idx = 0; 
+      tcp->outgoing_buffer = nullptr; 
+    } 
+  } 
+  return zerocopy_send_record; 
+} 
+ 
+static void ZerocopyDisableAndWaitForRemaining(grpc_tcp* tcp) { 
+  tcp->tcp_zerocopy_send_ctx.Shutdown(); 
+  while (!tcp->tcp_zerocopy_send_ctx.AllSendRecordsEmpty()) { 
+    process_errors(tcp); 
+  } 
+} 
+ 
 static bool tcp_write_with_timestamps(grpc_tcp* tcp, struct msghdr* msg,
                                       size_t sending_length,
-                                      ssize_t* sent_length,
-                                      int additional_flags) {
+                                      ssize_t* sent_length, 
+                                      int additional_flags) { 
   if (!tcp->socket_ts_enabled) {
     uint32_t opt = grpc_core::kTimestampingSocketOptions;
     if (setsockopt(tcp->fd, SOL_SOCKET, SO_TIMESTAMPING,
@@ -1024,7 +1024,7 @@ static bool tcp_write_with_timestamps(grpc_tcp* tcp, struct msghdr* msg,
   msg->msg_controllen = CMSG_SPACE(sizeof(uint32_t));
 
   /* If there was an error on sendmsg the logic in tcp_flush will handle it. */
-  ssize_t length = tcp_send(tcp->fd, msg, additional_flags);
+  ssize_t length = tcp_send(tcp->fd, msg, additional_flags); 
   *sent_length = length;
   /* Only save timestamps if all the bytes were taken by sendmsg. */
   if (sending_length == static_cast<size_t>(length)) {
@@ -1038,43 +1038,43 @@ static bool tcp_write_with_timestamps(grpc_tcp* tcp, struct msghdr* msg,
   return true;
 }
 
-static void UnrefMaybePutZerocopySendRecord(grpc_tcp* tcp,
-                                            TcpZerocopySendRecord* record,
-                                            uint32_t seq, const char* tag);
-// Reads \a cmsg to process zerocopy control messages.
-static void process_zerocopy(grpc_tcp* tcp, struct cmsghdr* cmsg) {
-  GPR_DEBUG_ASSERT(cmsg);
-  auto serr = reinterpret_cast<struct sock_extended_err*>(CMSG_DATA(cmsg));
-  GPR_DEBUG_ASSERT(serr->ee_errno == 0);
-  GPR_DEBUG_ASSERT(serr->ee_origin == SO_EE_ORIGIN_ZEROCOPY);
-  const uint32_t lo = serr->ee_info;
-  const uint32_t hi = serr->ee_data;
-  for (uint32_t seq = lo; seq <= hi; ++seq) {
-    // TODO(arjunroy): It's likely that lo and hi refer to zerocopy sequence
-    // numbers that are generated by a single call to grpc_endpoint_write; ie.
-    // we can batch the unref operation. So, check if record is the same for
-    // both; if so, batch the unref/put.
-    TcpZerocopySendRecord* record =
-        tcp->tcp_zerocopy_send_ctx.ReleaseSendRecord(seq);
-    GPR_DEBUG_ASSERT(record);
-    UnrefMaybePutZerocopySendRecord(tcp, record, seq, "CALLBACK RCVD");
-  }
-}
-
-// Whether the cmsg received from error queue is of the IPv4 or IPv6 levels.
-static bool CmsgIsIpLevel(const cmsghdr& cmsg) {
-  return (cmsg.cmsg_level == SOL_IPV6 && cmsg.cmsg_type == IPV6_RECVERR) ||
-         (cmsg.cmsg_level == SOL_IP && cmsg.cmsg_type == IP_RECVERR);
-}
-
-static bool CmsgIsZeroCopy(const cmsghdr& cmsg) {
-  if (!CmsgIsIpLevel(cmsg)) {
-    return false;
-  }
-  auto serr = reinterpret_cast<const sock_extended_err*> CMSG_DATA(&cmsg);
-  return serr->ee_errno == 0 && serr->ee_origin == SO_EE_ORIGIN_ZEROCOPY;
-}
-
+static void UnrefMaybePutZerocopySendRecord(grpc_tcp* tcp, 
+                                            TcpZerocopySendRecord* record, 
+                                            uint32_t seq, const char* tag); 
+// Reads \a cmsg to process zerocopy control messages. 
+static void process_zerocopy(grpc_tcp* tcp, struct cmsghdr* cmsg) { 
+  GPR_DEBUG_ASSERT(cmsg); 
+  auto serr = reinterpret_cast<struct sock_extended_err*>(CMSG_DATA(cmsg)); 
+  GPR_DEBUG_ASSERT(serr->ee_errno == 0); 
+  GPR_DEBUG_ASSERT(serr->ee_origin == SO_EE_ORIGIN_ZEROCOPY); 
+  const uint32_t lo = serr->ee_info; 
+  const uint32_t hi = serr->ee_data; 
+  for (uint32_t seq = lo; seq <= hi; ++seq) { 
+    // TODO(arjunroy): It's likely that lo and hi refer to zerocopy sequence 
+    // numbers that are generated by a single call to grpc_endpoint_write; ie. 
+    // we can batch the unref operation. So, check if record is the same for 
+    // both; if so, batch the unref/put. 
+    TcpZerocopySendRecord* record = 
+        tcp->tcp_zerocopy_send_ctx.ReleaseSendRecord(seq); 
+    GPR_DEBUG_ASSERT(record); 
+    UnrefMaybePutZerocopySendRecord(tcp, record, seq, "CALLBACK RCVD"); 
+  } 
+} 
+ 
+// Whether the cmsg received from error queue is of the IPv4 or IPv6 levels. 
+static bool CmsgIsIpLevel(const cmsghdr& cmsg) { 
+  return (cmsg.cmsg_level == SOL_IPV6 && cmsg.cmsg_type == IPV6_RECVERR) || 
+         (cmsg.cmsg_level == SOL_IP && cmsg.cmsg_type == IP_RECVERR); 
+} 
+ 
+static bool CmsgIsZeroCopy(const cmsghdr& cmsg) { 
+  if (!CmsgIsIpLevel(cmsg)) { 
+    return false; 
+  } 
+  auto serr = reinterpret_cast<const sock_extended_err*> CMSG_DATA(&cmsg); 
+  return serr->ee_errno == 0 && serr->ee_origin == SO_EE_ORIGIN_ZEROCOPY; 
+} 
+ 
 /** Reads \a cmsg to derive timestamps from the control messages. If a valid
  * timestamp is found, the traced buffer list is updated with this timestamp.
  * The caller of this function should be looping on the control messages found
@@ -1136,31 +1136,31 @@ struct cmsghdr* process_timestamp(grpc_tcp* tcp, msghdr* msg,
 /** For linux platforms, reads the socket's error queue and processes error
  * messages from the queue.
  */
-static bool process_errors(grpc_tcp* tcp) {
-  bool processed_err = false;
-  struct iovec iov;
-  iov.iov_base = nullptr;
-  iov.iov_len = 0;
-  struct msghdr msg;
-  msg.msg_name = nullptr;
-  msg.msg_namelen = 0;
-  msg.msg_iov = &iov;
-  msg.msg_iovlen = 0;
-  msg.msg_flags = 0;
-  /* Allocate enough space so we don't need to keep increasing this as size
-   * of OPT_STATS increase */
-  constexpr size_t cmsg_alloc_space =
-      CMSG_SPACE(sizeof(grpc_core::scm_timestamping)) +
-      CMSG_SPACE(sizeof(sock_extended_err) + sizeof(sockaddr_in)) +
-      CMSG_SPACE(32 * NLA_ALIGN(NLA_HDRLEN + sizeof(uint64_t)));
-  /* Allocate aligned space for cmsgs received along with timestamps */
-  union {
-    char rbuf[cmsg_alloc_space];
-    struct cmsghdr align;
-  } aligned_buf;
-  msg.msg_control = aligned_buf.rbuf;
-  msg.msg_controllen = sizeof(aligned_buf.rbuf);
-  int r, saved_errno;
+static bool process_errors(grpc_tcp* tcp) { 
+  bool processed_err = false; 
+  struct iovec iov; 
+  iov.iov_base = nullptr; 
+  iov.iov_len = 0; 
+  struct msghdr msg; 
+  msg.msg_name = nullptr; 
+  msg.msg_namelen = 0; 
+  msg.msg_iov = &iov; 
+  msg.msg_iovlen = 0; 
+  msg.msg_flags = 0; 
+  /* Allocate enough space so we don't need to keep increasing this as size 
+   * of OPT_STATS increase */ 
+  constexpr size_t cmsg_alloc_space = 
+      CMSG_SPACE(sizeof(grpc_core::scm_timestamping)) + 
+      CMSG_SPACE(sizeof(sock_extended_err) + sizeof(sockaddr_in)) + 
+      CMSG_SPACE(32 * NLA_ALIGN(NLA_HDRLEN + sizeof(uint64_t))); 
+  /* Allocate aligned space for cmsgs received along with timestamps */ 
+  union { 
+    char rbuf[cmsg_alloc_space]; 
+    struct cmsghdr align; 
+  } aligned_buf; 
+  msg.msg_control = aligned_buf.rbuf; 
+  msg.msg_controllen = sizeof(aligned_buf.rbuf); 
+  int r, saved_errno; 
   while (true) {
     do {
       r = recvmsg(tcp->fd, &msg, MSG_ERRQUEUE);
@@ -1168,44 +1168,44 @@ static bool process_errors(grpc_tcp* tcp) {
     } while (r < 0 && saved_errno == EINTR);
 
     if (r == -1 && saved_errno == EAGAIN) {
-      return processed_err; /* No more errors to process */
+      return processed_err; /* No more errors to process */ 
     }
     if (r == -1) {
-      return processed_err;
+      return processed_err; 
     }
-    if (GPR_UNLIKELY((msg.msg_flags & MSG_CTRUNC) != 0)) {
+    if (GPR_UNLIKELY((msg.msg_flags & MSG_CTRUNC) != 0)) { 
       gpr_log(GPR_ERROR, "Error message was truncated.");
     }
 
     if (msg.msg_controllen == 0) {
       /* There was no control message found. It was probably spurious. */
-      return processed_err;
+      return processed_err; 
     }
     bool seen = false;
     for (auto cmsg = CMSG_FIRSTHDR(&msg); cmsg && cmsg->cmsg_len;
          cmsg = CMSG_NXTHDR(&msg, cmsg)) {
-      if (CmsgIsZeroCopy(*cmsg)) {
-        process_zerocopy(tcp, cmsg);
-        seen = true;
-        processed_err = true;
-      } else if (cmsg->cmsg_level == SOL_SOCKET &&
-                 cmsg->cmsg_type == SCM_TIMESTAMPING) {
-        cmsg = process_timestamp(tcp, &msg, cmsg);
-        seen = true;
-        processed_err = true;
-      } else {
-        /* Got a control message that is not a timestamp or zerocopy. Don't know
-         * how to handle this. */
+      if (CmsgIsZeroCopy(*cmsg)) { 
+        process_zerocopy(tcp, cmsg); 
+        seen = true; 
+        processed_err = true; 
+      } else if (cmsg->cmsg_level == SOL_SOCKET && 
+                 cmsg->cmsg_type == SCM_TIMESTAMPING) { 
+        cmsg = process_timestamp(tcp, &msg, cmsg); 
+        seen = true; 
+        processed_err = true; 
+      } else { 
+        /* Got a control message that is not a timestamp or zerocopy. Don't know 
+         * how to handle this. */ 
         if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
           gpr_log(GPR_INFO,
                   "unknown control message cmsg_level:%d cmsg_type:%d",
                   cmsg->cmsg_level, cmsg->cmsg_type);
         }
-        return processed_err;
+        return processed_err; 
       }
     }
     if (!seen) {
-      return processed_err;
+      return processed_err; 
     }
   }
 }
@@ -1226,28 +1226,28 @@ static void tcp_handle_error(void* arg /* grpc_tcp */, grpc_error* error) {
 
   /* We are still interested in collecting timestamps, so let's try reading
    * them. */
-  bool processed = process_errors(tcp);
+  bool processed = process_errors(tcp); 
   /* This might not a timestamps error. Set the read and write closures to be
    * ready. */
-  if (!processed) {
-    grpc_fd_set_readable(tcp->em_fd);
-    grpc_fd_set_writable(tcp->em_fd);
-  }
+  if (!processed) { 
+    grpc_fd_set_readable(tcp->em_fd); 
+    grpc_fd_set_writable(tcp->em_fd); 
+  } 
   grpc_fd_notify_on_error(tcp->em_fd, &tcp->error_closure);
 }
 
 #else  /* GRPC_LINUX_ERRQUEUE */
-static TcpZerocopySendRecord* tcp_get_send_zerocopy_record(
-    grpc_tcp* tcp, grpc_slice_buffer* buf) {
-  return nullptr;
-}
-
-static void ZerocopyDisableAndWaitForRemaining(grpc_tcp* tcp) {}
-
+static TcpZerocopySendRecord* tcp_get_send_zerocopy_record( 
+    grpc_tcp* tcp, grpc_slice_buffer* buf) { 
+  return nullptr; 
+} 
+ 
+static void ZerocopyDisableAndWaitForRemaining(grpc_tcp* tcp) {} 
+ 
 static bool tcp_write_with_timestamps(grpc_tcp* /*tcp*/, struct msghdr* /*msg*/,
                                       size_t /*sending_length*/,
-                                      ssize_t* /*sent_length*/,
-                                      int /*additional_flags*/) {
+                                      ssize_t* /*sent_length*/, 
+                                      int /*additional_flags*/) { 
   gpr_log(GPR_ERROR, "Write with timestamps not supported for this platform");
   GPR_ASSERT(0);
   return false;
@@ -1278,134 +1278,134 @@ void tcp_shutdown_buffer_list(grpc_tcp* tcp) {
 #else
 #define MAX_WRITE_IOVEC 1000
 #endif
-msg_iovlen_type TcpZerocopySendRecord::PopulateIovs(size_t* unwind_slice_idx,
-                                                    size_t* unwind_byte_idx,
-                                                    size_t* sending_length,
-                                                    iovec* iov) {
-  msg_iovlen_type iov_size;
-  *unwind_slice_idx = out_offset_.slice_idx;
-  *unwind_byte_idx = out_offset_.byte_idx;
-  for (iov_size = 0;
-       out_offset_.slice_idx != buf_.count && iov_size != MAX_WRITE_IOVEC;
-       iov_size++) {
-    iov[iov_size].iov_base =
-        GRPC_SLICE_START_PTR(buf_.slices[out_offset_.slice_idx]) +
-        out_offset_.byte_idx;
-    iov[iov_size].iov_len =
-        GRPC_SLICE_LENGTH(buf_.slices[out_offset_.slice_idx]) -
-        out_offset_.byte_idx;
-    *sending_length += iov[iov_size].iov_len;
-    ++(out_offset_.slice_idx);
-    out_offset_.byte_idx = 0;
-  }
-  GPR_DEBUG_ASSERT(iov_size > 0);
-  return iov_size;
-}
-
-void TcpZerocopySendRecord::UpdateOffsetForBytesSent(size_t sending_length,
-                                                     size_t actually_sent) {
-  size_t trailing = sending_length - actually_sent;
-  while (trailing > 0) {
-    size_t slice_length;
-    out_offset_.slice_idx--;
-    slice_length = GRPC_SLICE_LENGTH(buf_.slices[out_offset_.slice_idx]);
-    if (slice_length > trailing) {
-      out_offset_.byte_idx = slice_length - trailing;
-      break;
-    } else {
-      trailing -= slice_length;
-    }
-  }
-}
-
-// returns true if done, false if pending; if returning true, *error is set
-static bool do_tcp_flush_zerocopy(grpc_tcp* tcp, TcpZerocopySendRecord* record,
-                                  grpc_error** error) {
-  struct msghdr msg;
-  struct iovec iov[MAX_WRITE_IOVEC];
-  msg_iovlen_type iov_size;
-  ssize_t sent_length = 0;
-  size_t sending_length;
-  size_t unwind_slice_idx;
-  size_t unwind_byte_idx;
-  while (true) {
-    sending_length = 0;
-    iov_size = record->PopulateIovs(&unwind_slice_idx, &unwind_byte_idx,
-                                    &sending_length, iov);
-    msg.msg_name = nullptr;
-    msg.msg_namelen = 0;
-    msg.msg_iov = iov;
-    msg.msg_iovlen = iov_size;
-    msg.msg_flags = 0;
-    bool tried_sending_message = false;
-    // Before calling sendmsg (with or without timestamps): we
-    // take a single ref on the zerocopy send record.
-    tcp->tcp_zerocopy_send_ctx.NoteSend(record);
-    if (tcp->outgoing_buffer_arg != nullptr) {
-      if (!tcp->ts_capable ||
-          !tcp_write_with_timestamps(tcp, &msg, sending_length, &sent_length,
-                                     MSG_ZEROCOPY)) {
-        /* We could not set socket options to collect Fathom timestamps.
-         * Fallback on writing without timestamps. */
-        tcp->ts_capable = false;
-        tcp_shutdown_buffer_list(tcp);
-      } else {
-        tried_sending_message = true;
-      }
-    }
-    if (!tried_sending_message) {
-      msg.msg_control = nullptr;
-      msg.msg_controllen = 0;
-      GRPC_STATS_INC_TCP_WRITE_SIZE(sending_length);
-      GRPC_STATS_INC_TCP_WRITE_IOV_SIZE(iov_size);
-      sent_length = tcp_send(tcp->fd, &msg, MSG_ZEROCOPY);
-    }
-    if (sent_length < 0) {
-      // If this particular send failed, drop ref taken earlier in this method.
-      tcp->tcp_zerocopy_send_ctx.UndoSend();
-      if (errno == EAGAIN) {
-        record->UnwindIfThrottled(unwind_slice_idx, unwind_byte_idx);
-        return false;
-      } else if (errno == EPIPE) {
-        *error = tcp_annotate_error(GRPC_OS_ERROR(errno, "sendmsg"), tcp);
-        tcp_shutdown_buffer_list(tcp);
-        return true;
-      } else {
-        *error = tcp_annotate_error(GRPC_OS_ERROR(errno, "sendmsg"), tcp);
-        tcp_shutdown_buffer_list(tcp);
-        return true;
-      }
-    }
-    tcp->bytes_counter += sent_length;
-    record->UpdateOffsetForBytesSent(sending_length,
-                                     static_cast<size_t>(sent_length));
-    if (record->AllSlicesSent()) {
-      *error = GRPC_ERROR_NONE;
-      return true;
-    }
-  }
-}
-
-static void UnrefMaybePutZerocopySendRecord(grpc_tcp* tcp,
-                                            TcpZerocopySendRecord* record,
-                                            uint32_t seq,
-                                            const char* /* tag */) {
-  if (record->Unref()) {
-    tcp->tcp_zerocopy_send_ctx.PutSendRecord(record);
-  }
-}
-
-static bool tcp_flush_zerocopy(grpc_tcp* tcp, TcpZerocopySendRecord* record,
-                               grpc_error** error) {
-  bool done = do_tcp_flush_zerocopy(tcp, record, error);
-  if (done) {
-    // Either we encountered an error, or we successfully sent all the bytes.
-    // In either case, we're done with this record.
-    UnrefMaybePutZerocopySendRecord(tcp, record, 0, "flush_done");
-  }
-  return done;
-}
-
+msg_iovlen_type TcpZerocopySendRecord::PopulateIovs(size_t* unwind_slice_idx, 
+                                                    size_t* unwind_byte_idx, 
+                                                    size_t* sending_length, 
+                                                    iovec* iov) { 
+  msg_iovlen_type iov_size; 
+  *unwind_slice_idx = out_offset_.slice_idx; 
+  *unwind_byte_idx = out_offset_.byte_idx; 
+  for (iov_size = 0; 
+       out_offset_.slice_idx != buf_.count && iov_size != MAX_WRITE_IOVEC; 
+       iov_size++) { 
+    iov[iov_size].iov_base = 
+        GRPC_SLICE_START_PTR(buf_.slices[out_offset_.slice_idx]) + 
+        out_offset_.byte_idx; 
+    iov[iov_size].iov_len = 
+        GRPC_SLICE_LENGTH(buf_.slices[out_offset_.slice_idx]) - 
+        out_offset_.byte_idx; 
+    *sending_length += iov[iov_size].iov_len; 
+    ++(out_offset_.slice_idx); 
+    out_offset_.byte_idx = 0; 
+  } 
+  GPR_DEBUG_ASSERT(iov_size > 0); 
+  return iov_size; 
+} 
+ 
+void TcpZerocopySendRecord::UpdateOffsetForBytesSent(size_t sending_length, 
+                                                     size_t actually_sent) { 
+  size_t trailing = sending_length - actually_sent; 
+  while (trailing > 0) { 
+    size_t slice_length; 
+    out_offset_.slice_idx--; 
+    slice_length = GRPC_SLICE_LENGTH(buf_.slices[out_offset_.slice_idx]); 
+    if (slice_length > trailing) { 
+      out_offset_.byte_idx = slice_length - trailing; 
+      break; 
+    } else { 
+      trailing -= slice_length; 
+    } 
+  } 
+} 
+ 
+// returns true if done, false if pending; if returning true, *error is set 
+static bool do_tcp_flush_zerocopy(grpc_tcp* tcp, TcpZerocopySendRecord* record, 
+                                  grpc_error** error) { 
+  struct msghdr msg; 
+  struct iovec iov[MAX_WRITE_IOVEC]; 
+  msg_iovlen_type iov_size; 
+  ssize_t sent_length = 0; 
+  size_t sending_length; 
+  size_t unwind_slice_idx; 
+  size_t unwind_byte_idx; 
+  while (true) { 
+    sending_length = 0; 
+    iov_size = record->PopulateIovs(&unwind_slice_idx, &unwind_byte_idx, 
+                                    &sending_length, iov); 
+    msg.msg_name = nullptr; 
+    msg.msg_namelen = 0; 
+    msg.msg_iov = iov; 
+    msg.msg_iovlen = iov_size; 
+    msg.msg_flags = 0; 
+    bool tried_sending_message = false; 
+    // Before calling sendmsg (with or without timestamps): we 
+    // take a single ref on the zerocopy send record. 
+    tcp->tcp_zerocopy_send_ctx.NoteSend(record); 
+    if (tcp->outgoing_buffer_arg != nullptr) { 
+      if (!tcp->ts_capable || 
+          !tcp_write_with_timestamps(tcp, &msg, sending_length, &sent_length, 
+                                     MSG_ZEROCOPY)) { 
+        /* We could not set socket options to collect Fathom timestamps. 
+         * Fallback on writing without timestamps. */ 
+        tcp->ts_capable = false; 
+        tcp_shutdown_buffer_list(tcp); 
+      } else { 
+        tried_sending_message = true; 
+      } 
+    } 
+    if (!tried_sending_message) { 
+      msg.msg_control = nullptr; 
+      msg.msg_controllen = 0; 
+      GRPC_STATS_INC_TCP_WRITE_SIZE(sending_length); 
+      GRPC_STATS_INC_TCP_WRITE_IOV_SIZE(iov_size); 
+      sent_length = tcp_send(tcp->fd, &msg, MSG_ZEROCOPY); 
+    } 
+    if (sent_length < 0) { 
+      // If this particular send failed, drop ref taken earlier in this method. 
+      tcp->tcp_zerocopy_send_ctx.UndoSend(); 
+      if (errno == EAGAIN) { 
+        record->UnwindIfThrottled(unwind_slice_idx, unwind_byte_idx); 
+        return false; 
+      } else if (errno == EPIPE) { 
+        *error = tcp_annotate_error(GRPC_OS_ERROR(errno, "sendmsg"), tcp); 
+        tcp_shutdown_buffer_list(tcp); 
+        return true; 
+      } else { 
+        *error = tcp_annotate_error(GRPC_OS_ERROR(errno, "sendmsg"), tcp); 
+        tcp_shutdown_buffer_list(tcp); 
+        return true; 
+      } 
+    } 
+    tcp->bytes_counter += sent_length; 
+    record->UpdateOffsetForBytesSent(sending_length, 
+                                     static_cast<size_t>(sent_length)); 
+    if (record->AllSlicesSent()) { 
+      *error = GRPC_ERROR_NONE; 
+      return true; 
+    } 
+  } 
+} 
+ 
+static void UnrefMaybePutZerocopySendRecord(grpc_tcp* tcp, 
+                                            TcpZerocopySendRecord* record, 
+                                            uint32_t seq, 
+                                            const char* /* tag */) { 
+  if (record->Unref()) { 
+    tcp->tcp_zerocopy_send_ctx.PutSendRecord(record); 
+  } 
+} 
+ 
+static bool tcp_flush_zerocopy(grpc_tcp* tcp, TcpZerocopySendRecord* record, 
+                               grpc_error** error) { 
+  bool done = do_tcp_flush_zerocopy(tcp, record, error); 
+  if (done) { 
+    // Either we encountered an error, or we successfully sent all the bytes. 
+    // In either case, we're done with this record. 
+    UnrefMaybePutZerocopySendRecord(tcp, record, 0, "flush_done"); 
+  } 
+  return done; 
+} 
+ 
 static bool tcp_flush(grpc_tcp* tcp, grpc_error** error) {
   struct msghdr msg;
   struct iovec iov[MAX_WRITE_IOVEC];
@@ -1420,7 +1420,7 @@ static bool tcp_flush(grpc_tcp* tcp, grpc_error** error) {
   // buffer as we write
   size_t outgoing_slice_idx = 0;
 
-  while (true) {
+  while (true) { 
     sending_length = 0;
     unwind_slice_idx = outgoing_slice_idx;
     unwind_byte_idx = tcp->outgoing_byte_idx;
@@ -1520,21 +1520,21 @@ static void tcp_handle_write(void* arg /* grpc_tcp */, grpc_error* error) {
   if (error != GRPC_ERROR_NONE) {
     cb = tcp->write_cb;
     tcp->write_cb = nullptr;
-    if (tcp->current_zerocopy_send != nullptr) {
-      UnrefMaybePutZerocopySendRecord(tcp, tcp->current_zerocopy_send, 0,
-                                      "handle_write_err");
-      tcp->current_zerocopy_send = nullptr;
-    }
+    if (tcp->current_zerocopy_send != nullptr) { 
+      UnrefMaybePutZerocopySendRecord(tcp, tcp->current_zerocopy_send, 0, 
+                                      "handle_write_err"); 
+      tcp->current_zerocopy_send = nullptr; 
+    } 
     grpc_core::Closure::Run(DEBUG_LOCATION, cb, GRPC_ERROR_REF(error));
     TCP_UNREF(tcp, "write");
     return;
   }
 
-  bool flush_result =
-      tcp->current_zerocopy_send != nullptr
-          ? tcp_flush_zerocopy(tcp, tcp->current_zerocopy_send, &error)
-          : tcp_flush(tcp, &error);
-  if (!flush_result) {
+  bool flush_result = 
+      tcp->current_zerocopy_send != nullptr 
+          ? tcp_flush_zerocopy(tcp, tcp->current_zerocopy_send, &error) 
+          : tcp_flush(tcp, &error); 
+  if (!flush_result) { 
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
       gpr_log(GPR_INFO, "write: delayed");
     }
@@ -1544,7 +1544,7 @@ static void tcp_handle_write(void* arg /* grpc_tcp */, grpc_error* error) {
   } else {
     cb = tcp->write_cb;
     tcp->write_cb = nullptr;
-    tcp->current_zerocopy_send = nullptr;
+    tcp->current_zerocopy_send = nullptr; 
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
       const char* str = grpc_error_string(error);
       gpr_log(GPR_INFO, "write: %s", str);
@@ -1560,13 +1560,13 @@ static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
   GPR_TIMER_SCOPE("tcp_write", 0);
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
   grpc_error* error = GRPC_ERROR_NONE;
-  TcpZerocopySendRecord* zerocopy_send_record = nullptr;
+  TcpZerocopySendRecord* zerocopy_send_record = nullptr; 
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     size_t i;
 
     for (i = 0; i < buf->count; i++) {
-      gpr_log(GPR_INFO, "WRITE %p (peer=%s)", tcp, tcp->peer_string.c_str());
+      gpr_log(GPR_INFO, "WRITE %p (peer=%s)", tcp, tcp->peer_string.c_str()); 
       if (gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
         char* data =
             grpc_dump_slice(buf->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);
@@ -1577,7 +1577,7 @@ static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
   }
 
   GPR_ASSERT(tcp->write_cb == nullptr);
-  GPR_DEBUG_ASSERT(tcp->current_zerocopy_send == nullptr);
+  GPR_DEBUG_ASSERT(tcp->current_zerocopy_send == nullptr); 
 
   if (buf->length == 0) {
     grpc_core::Closure::Run(
@@ -1589,26 +1589,26 @@ static void tcp_write(grpc_endpoint* ep, grpc_slice_buffer* buf,
     tcp_shutdown_buffer_list(tcp);
     return;
   }
-
-  zerocopy_send_record = tcp_get_send_zerocopy_record(tcp, buf);
-  if (zerocopy_send_record == nullptr) {
-    // Either not enough bytes, or couldn't allocate a zerocopy context.
-    tcp->outgoing_buffer = buf;
-    tcp->outgoing_byte_idx = 0;
-  }
-  tcp->outgoing_buffer_arg = arg;
+ 
+  zerocopy_send_record = tcp_get_send_zerocopy_record(tcp, buf); 
+  if (zerocopy_send_record == nullptr) { 
+    // Either not enough bytes, or couldn't allocate a zerocopy context. 
+    tcp->outgoing_buffer = buf; 
+    tcp->outgoing_byte_idx = 0; 
+  } 
+  tcp->outgoing_buffer_arg = arg; 
   if (arg) {
     GPR_ASSERT(grpc_event_engine_can_track_errors());
   }
 
-  bool flush_result =
-      zerocopy_send_record != nullptr
-          ? tcp_flush_zerocopy(tcp, zerocopy_send_record, &error)
-          : tcp_flush(tcp, &error);
-  if (!flush_result) {
+  bool flush_result = 
+      zerocopy_send_record != nullptr 
+          ? tcp_flush_zerocopy(tcp, zerocopy_send_record, &error) 
+          : tcp_flush(tcp, &error); 
+  if (!flush_result) { 
     TCP_REF(tcp, "write");
     tcp->write_cb = cb;
-    tcp->current_zerocopy_send = zerocopy_send_record;
+    tcp->current_zerocopy_send = zerocopy_send_record; 
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
       gpr_log(GPR_INFO, "write: delayed");
     }
@@ -1636,20 +1636,20 @@ static void tcp_add_to_pollset_set(grpc_endpoint* ep,
 static void tcp_delete_from_pollset_set(grpc_endpoint* ep,
                                         grpc_pollset_set* pollset_set) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
-  ZerocopyDisableAndWaitForRemaining(tcp);
+  ZerocopyDisableAndWaitForRemaining(tcp); 
   grpc_pollset_set_del_fd(pollset_set, tcp->em_fd);
 }
 
-static y_absl::string_view tcp_get_peer(grpc_endpoint* ep) {
+static y_absl::string_view tcp_get_peer(grpc_endpoint* ep) { 
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
-  return tcp->peer_string;
-}
-
-static y_absl::string_view tcp_get_local_address(grpc_endpoint* ep) {
-  grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
-  return tcp->local_address;
+  return tcp->peer_string; 
 }
 
+static y_absl::string_view tcp_get_local_address(grpc_endpoint* ep) { 
+  grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep); 
+  return tcp->local_address; 
+} 
+ 
 static int tcp_get_fd(grpc_endpoint* ep) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
   return tcp->fd;
@@ -1685,7 +1685,7 @@ static const grpc_endpoint_vtable vtable = {tcp_read,
                                             tcp_destroy,
                                             tcp_get_resource_user,
                                             tcp_get_peer,
-                                            tcp_get_local_address,
+                                            tcp_get_local_address, 
                                             tcp_get_fd,
                                             tcp_can_track_err};
 
@@ -1694,15 +1694,15 @@ static const grpc_endpoint_vtable vtable = {tcp_read,
 grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
                                const grpc_channel_args* channel_args,
                                const char* peer_string) {
-  static constexpr bool kZerocpTxEnabledDefault = false;
+  static constexpr bool kZerocpTxEnabledDefault = false; 
   int tcp_read_chunk_size = GRPC_TCP_DEFAULT_READ_SLICE_SIZE;
   int tcp_max_read_chunk_size = 4 * 1024 * 1024;
   int tcp_min_read_chunk_size = 256;
-  bool tcp_tx_zerocopy_enabled = kZerocpTxEnabledDefault;
-  int tcp_tx_zerocopy_send_bytes_thresh =
-      grpc_core::TcpZerocopySendCtx::kDefaultSendBytesThreshold;
-  int tcp_tx_zerocopy_max_simult_sends =
-      grpc_core::TcpZerocopySendCtx::kDefaultMaxSends;
+  bool tcp_tx_zerocopy_enabled = kZerocpTxEnabledDefault; 
+  int tcp_tx_zerocopy_send_bytes_thresh = 
+      grpc_core::TcpZerocopySendCtx::kDefaultSendBytesThreshold; 
+  int tcp_tx_zerocopy_max_simult_sends = 
+      grpc_core::TcpZerocopySendCtx::kDefaultMaxSends; 
   grpc_resource_quota* resource_quota = grpc_resource_quota_create(nullptr);
   if (channel_args != nullptr) {
     for (size_t i = 0; i < channel_args->num_args; i++) {
@@ -1727,23 +1727,23 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
         resource_quota =
             grpc_resource_quota_ref_internal(static_cast<grpc_resource_quota*>(
                 channel_args->args[i].value.pointer.p));
-      } else if (0 == strcmp(channel_args->args[i].key,
-                             GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED)) {
-        tcp_tx_zerocopy_enabled = grpc_channel_arg_get_bool(
-            &channel_args->args[i], kZerocpTxEnabledDefault);
-      } else if (0 == strcmp(channel_args->args[i].key,
-                             GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD)) {
-        grpc_integer_options options = {
-            grpc_core::TcpZerocopySendCtx::kDefaultSendBytesThreshold, 0,
-            INT_MAX};
-        tcp_tx_zerocopy_send_bytes_thresh =
-            grpc_channel_arg_get_integer(&channel_args->args[i], options);
-      } else if (0 == strcmp(channel_args->args[i].key,
-                             GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS)) {
-        grpc_integer_options options = {
-            grpc_core::TcpZerocopySendCtx::kDefaultMaxSends, 0, INT_MAX};
-        tcp_tx_zerocopy_max_simult_sends =
-            grpc_channel_arg_get_integer(&channel_args->args[i], options);
+      } else if (0 == strcmp(channel_args->args[i].key, 
+                             GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED)) { 
+        tcp_tx_zerocopy_enabled = grpc_channel_arg_get_bool( 
+            &channel_args->args[i], kZerocpTxEnabledDefault); 
+      } else if (0 == strcmp(channel_args->args[i].key, 
+                             GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD)) { 
+        grpc_integer_options options = { 
+            grpc_core::TcpZerocopySendCtx::kDefaultSendBytesThreshold, 0, 
+            INT_MAX}; 
+        tcp_tx_zerocopy_send_bytes_thresh = 
+            grpc_channel_arg_get_integer(&channel_args->args[i], options); 
+      } else if (0 == strcmp(channel_args->args[i].key, 
+                             GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS)) { 
+        grpc_integer_options options = { 
+            grpc_core::TcpZerocopySendCtx::kDefaultMaxSends, 0, INT_MAX}; 
+        tcp_tx_zerocopy_max_simult_sends = 
+            grpc_channel_arg_get_integer(&channel_args->args[i], options); 
       }
     }
   }
@@ -1754,24 +1754,24 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
   tcp_read_chunk_size = GPR_CLAMP(tcp_read_chunk_size, tcp_min_read_chunk_size,
                                   tcp_max_read_chunk_size);
 
-  grpc_tcp* tcp = new grpc_tcp(tcp_tx_zerocopy_max_simult_sends,
-                               tcp_tx_zerocopy_send_bytes_thresh);
+  grpc_tcp* tcp = new grpc_tcp(tcp_tx_zerocopy_max_simult_sends, 
+                               tcp_tx_zerocopy_send_bytes_thresh); 
   tcp->base.vtable = &vtable;
-  tcp->peer_string = peer_string;
+  tcp->peer_string = peer_string; 
   tcp->fd = grpc_fd_wrapped_fd(em_fd);
-  grpc_resolved_address resolved_local_addr;
-  memset(&resolved_local_addr, 0, sizeof(resolved_local_addr));
-  resolved_local_addr.len = sizeof(resolved_local_addr.addr);
-  if (getsockname(tcp->fd,
-                  reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-                  &resolved_local_addr.len) < 0) {
-    tcp->local_address = "";
-  } else {
-    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
-  }
+  grpc_resolved_address resolved_local_addr; 
+  memset(&resolved_local_addr, 0, sizeof(resolved_local_addr)); 
+  resolved_local_addr.len = sizeof(resolved_local_addr.addr); 
+  if (getsockname(tcp->fd, 
+                  reinterpret_cast<sockaddr*>(resolved_local_addr.addr), 
+                  &resolved_local_addr.len) < 0) { 
+    tcp->local_address = ""; 
+  } else { 
+    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr); 
+  } 
   tcp->read_cb = nullptr;
   tcp->write_cb = nullptr;
-  tcp->current_zerocopy_send = nullptr;
+  tcp->current_zerocopy_send = nullptr; 
   tcp->release_fd_cb = nullptr;
   tcp->release_fd = nullptr;
   tcp->incoming_buffer = nullptr;
@@ -1785,18 +1785,18 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
   tcp->socket_ts_enabled = false;
   tcp->ts_capable = true;
   tcp->outgoing_buffer_arg = nullptr;
-  if (tcp_tx_zerocopy_enabled && !tcp->tcp_zerocopy_send_ctx.memory_limited()) {
-#ifdef GRPC_LINUX_ERRQUEUE
-    const int enable = 1;
-    auto err =
-        setsockopt(tcp->fd, SOL_SOCKET, SO_ZEROCOPY, &enable, sizeof(enable));
-    if (err == 0) {
-      tcp->tcp_zerocopy_send_ctx.set_enabled(true);
-    } else {
-      gpr_log(GPR_ERROR, "Failed to set zerocopy options on the socket.");
-    }
-#endif
-  }
+  if (tcp_tx_zerocopy_enabled && !tcp->tcp_zerocopy_send_ctx.memory_limited()) { 
+#ifdef GRPC_LINUX_ERRQUEUE 
+    const int enable = 1; 
+    auto err = 
+        setsockopt(tcp->fd, SOL_SOCKET, SO_ZEROCOPY, &enable, sizeof(enable)); 
+    if (err == 0) { 
+      tcp->tcp_zerocopy_send_ctx.set_enabled(true); 
+    } else { 
+      gpr_log(GPR_ERROR, "Failed to set zerocopy options on the socket."); 
+    } 
+#endif 
+  } 
   /* paired with unref in grpc_tcp_destroy */
   new (&tcp->refcount) grpc_core::RefCount(1, &grpc_tcp_trace);
   gpr_atm_no_barrier_store(&tcp->shutdown_count, 0);
@@ -1863,7 +1863,7 @@ void grpc_tcp_destroy_and_release_fd(grpc_endpoint* ep, int* fd,
   grpc_slice_buffer_reset_and_unref_internal(&tcp->last_read_buffer);
   if (grpc_event_engine_can_track_errors()) {
     /* Stop errors notification. */
-    ZerocopyDisableAndWaitForRemaining(tcp);
+    ZerocopyDisableAndWaitForRemaining(tcp); 
     gpr_atm_no_barrier_store(&tcp->stop_error_notification, true);
     grpc_fd_set_error(tcp->em_fd);
   }
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server.cc
index 046fd4979b..c48216e5df 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server.cc
@@ -28,10 +28,10 @@ grpc_error* grpc_tcp_server_create(grpc_closure* shutdown_complete,
   return grpc_tcp_server_impl->create(shutdown_complete, args, server);
 }
 
-void grpc_tcp_server_start(grpc_tcp_server* server,
-                           const std::vector<grpc_pollset*>* pollsets,
+void grpc_tcp_server_start(grpc_tcp_server* server, 
+                           const std::vector<grpc_pollset*>* pollsets, 
                            grpc_tcp_server_cb on_accept_cb, void* cb_arg) {
-  grpc_tcp_server_impl->start(server, pollsets, on_accept_cb, cb_arg);
+  grpc_tcp_server_impl->start(server, pollsets, on_accept_cb, cb_arg); 
 }
 
 grpc_error* grpc_tcp_server_add_port(grpc_tcp_server* s,
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server.h b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server.h
index 6ba3513da5..10de37d999 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server.h
@@ -24,8 +24,8 @@
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/grpc_types.h>
 
-#include <vector>
-
+#include <vector> 
+ 
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -66,9 +66,9 @@ typedef struct grpc_tcp_server_vtable {
   grpc_error* (*create)(grpc_closure* shutdown_complete,
                         const grpc_channel_args* args,
                         grpc_tcp_server** server);
-  void (*start)(grpc_tcp_server* server,
-                const std::vector<grpc_pollset*>* pollsets,
-                grpc_tcp_server_cb on_accept_cb, void* cb_arg);
+  void (*start)(grpc_tcp_server* server, 
+                const std::vector<grpc_pollset*>* pollsets, 
+                grpc_tcp_server_cb on_accept_cb, void* cb_arg); 
   grpc_error* (*add_port)(grpc_tcp_server* s, const grpc_resolved_address* addr,
                           int* out_port);
   grpc_core::TcpServerFdHandler* (*create_fd_handler)(grpc_tcp_server* s);
@@ -89,8 +89,8 @@ grpc_error* grpc_tcp_server_create(grpc_closure* shutdown_complete,
                                    grpc_tcp_server** server);
 
 /* Start listening to bound ports */
-void grpc_tcp_server_start(grpc_tcp_server* server,
-                           const std::vector<grpc_pollset*>* pollsets,
+void grpc_tcp_server_start(grpc_tcp_server* server, 
+                           const std::vector<grpc_pollset*>* pollsets, 
                            grpc_tcp_server_cb on_accept_cb, void* cb_arg);
 
 /* Add a port to the server, returning the newly allocated port on success, or
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_custom.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_custom.cc
index 0cffa1f571..bab706d683 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_custom.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_custom.cc
@@ -23,12 +23,12 @@
 #include <assert.h>
 #include <string.h>
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_args.h" 
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
@@ -75,7 +75,7 @@ struct grpc_tcp_server {
   grpc_closure* shutdown_complete;
 
   bool shutdown;
-  bool so_reuseport;
+  bool so_reuseport; 
 
   grpc_resource_quota* resource_quota;
 };
@@ -84,13 +84,13 @@ static grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
                                      const grpc_channel_args* args,
                                      grpc_tcp_server** server) {
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
-  // Let the implementation decide if so_reuseport can be enabled or not.
-  s->so_reuseport = true;
+  // Let the implementation decide if so_reuseport can be enabled or not. 
+  s->so_reuseport = true; 
   s->resource_quota = grpc_resource_quota_create(nullptr);
   for (size_t i = 0; i < (args == nullptr ? 0 : args->num_args); i++) {
-    if (!grpc_channel_args_find_bool(args, GRPC_ARG_ALLOW_REUSEPORT, true)) {
-      s->so_reuseport = false;
-    }
+    if (!grpc_channel_args_find_bool(args, GRPC_ARG_ALLOW_REUSEPORT, true)) { 
+      s->so_reuseport = false; 
+    } 
     if (0 == strcmp(GRPC_ARG_RESOURCE_QUOTA, args->args[i].key)) {
       if (args->args[i].type == GRPC_ARG_POINTER) {
         grpc_resource_quota_unref_internal(s->resource_quota);
@@ -216,7 +216,7 @@ static void finish_accept(grpc_tcp_listener* sp, grpc_custom_socket* socket) {
       (grpc_tcp_server_acceptor*)gpr_malloc(sizeof(*acceptor));
   grpc_endpoint* ep = nullptr;
   grpc_resolved_address peer_name;
-  TString peer_name_string;
+  TString peer_name_string; 
   grpc_error* err;
 
   memset(&peer_name, 0, sizeof(grpc_resolved_address));
@@ -230,11 +230,11 @@ static void finish_accept(grpc_tcp_listener* sp, grpc_custom_socket* socket) {
     GRPC_ERROR_UNREF(err);
   }
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    gpr_log(GPR_INFO, "SERVER_CONNECT: %p accepted connection: %s", sp->server,
-            peer_name_string.c_str());
+    gpr_log(GPR_INFO, "SERVER_CONNECT: %p accepted connection: %s", sp->server, 
+            peer_name_string.c_str()); 
   }
   ep = custom_tcp_endpoint_create(socket, sp->server->resource_quota,
-                                  peer_name_string.c_str());
+                                  peer_name_string.c_str()); 
   acceptor->from_server = sp->server;
   acceptor->port_index = sp->port_index;
   acceptor->fd_index = 0;
@@ -283,15 +283,15 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s,
   grpc_error* error;
   grpc_resolved_address sockname_temp;
 
-  // NOTE(lidiz) The last argument is "flags" which is unused by other
-  // implementations. Python IO managers uses it to specify SO_REUSEPORT.
-  int flags = 0;
-  if (s->so_reuseport) {
-    flags |= GRPC_CUSTOM_SOCKET_OPT_SO_REUSEPORT;
-  }
-
+  // NOTE(lidiz) The last argument is "flags" which is unused by other 
+  // implementations. Python IO managers uses it to specify SO_REUSEPORT. 
+  int flags = 0; 
+  if (s->so_reuseport) { 
+    flags |= GRPC_CUSTOM_SOCKET_OPT_SO_REUSEPORT; 
+  } 
+ 
   error = grpc_custom_socket_vtable->bind(socket, (grpc_sockaddr*)addr->addr,
-                                          addr->len, flags);
+                                          addr->len, flags); 
   if (error != GRPC_ERROR_NONE) {
     return error;
   }
@@ -385,9 +385,9 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
   }
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    gpr_log(GPR_INFO, "SERVER %p add_port %s error=%s", s,
-            grpc_sockaddr_to_string(addr, false).c_str(),
-            grpc_error_string(error));
+    gpr_log(GPR_INFO, "SERVER %p add_port %s error=%s", s, 
+            grpc_sockaddr_to_string(addr, false).c_str(), 
+            grpc_error_string(error)); 
   }
 
   family = grpc_sockaddr_get_family(addr);
@@ -417,8 +417,8 @@ static grpc_error* tcp_server_add_port(grpc_tcp_server* s,
   return error;
 }
 
-static void tcp_server_start(grpc_tcp_server* server,
-                             const std::vector<grpc_pollset*>* /*pollsets*/,
+static void tcp_server_start(grpc_tcp_server* server, 
+                             const std::vector<grpc_pollset*>* /*pollsets*/, 
                              grpc_tcp_server_cb on_accept_cb, void* cb_arg) {
   grpc_tcp_listener* sp;
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_posix.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_posix.cc
index b3f3febe63..552ce67ab8 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_posix.cc
@@ -37,11 +37,11 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_format.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -238,19 +238,19 @@ static void on_read(void* arg, grpc_error* err) {
 
     grpc_set_socket_no_sigpipe_if_possible(fd);
 
-    TString addr_str = grpc_sockaddr_to_uri(&addr);
+    TString addr_str = grpc_sockaddr_to_uri(&addr); 
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-      gpr_log(GPR_INFO, "SERVER_CONNECT: incoming connection: %s",
-              addr_str.c_str());
+      gpr_log(GPR_INFO, "SERVER_CONNECT: incoming connection: %s", 
+              addr_str.c_str()); 
     }
 
-    TString name = y_absl::StrCat("tcp-server-connection:", addr_str);
-    grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
+    TString name = y_absl::StrCat("tcp-server-connection:", addr_str); 
+    grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true); 
 
-    read_notifier_pollset = (*(sp->server->pollsets))
-        [static_cast<size_t>(gpr_atm_no_barrier_fetch_add(
-             &sp->server->next_pollset_to_assign, 1)) %
-         sp->server->pollsets->size()];
+    read_notifier_pollset = (*(sp->server->pollsets)) 
+        [static_cast<size_t>(gpr_atm_no_barrier_fetch_add( 
+             &sp->server->next_pollset_to_assign, 1)) % 
+         sp->server->pollsets->size()]; 
 
     grpc_pollset_add_fd(read_notifier_pollset, fdobj);
 
@@ -264,7 +264,7 @@ static void on_read(void* arg, grpc_error* err) {
 
     sp->server->on_accept_cb(
         sp->server->on_accept_cb_arg,
-        grpc_tcp_create(fdobj, sp->server->channel_args, addr_str.c_str()),
+        grpc_tcp_create(fdobj, sp->server->channel_args, addr_str.c_str()), 
         read_notifier_pollset, acceptor);
   }
 
@@ -348,7 +348,7 @@ static grpc_error* add_wildcard_addrs_to_server(grpc_tcp_server* s,
 
 static grpc_error* clone_port(grpc_tcp_listener* listener, unsigned count) {
   grpc_tcp_listener* sp = nullptr;
-  TString addr_str;
+  TString addr_str; 
   grpc_error* err;
 
   for (grpc_tcp_listener* l = listener->next; l && l->is_sibling; l = l->next) {
@@ -366,7 +366,7 @@ static grpc_error* clone_port(grpc_tcp_listener* listener, unsigned count) {
                                          true, &port);
     if (err != GRPC_ERROR_NONE) return err;
     listener->server->nports++;
-    addr_str = grpc_sockaddr_to_string(&listener->addr, true);
+    addr_str = grpc_sockaddr_to_string(&listener->addr, true); 
     sp = static_cast<grpc_tcp_listener*>(gpr_malloc(sizeof(grpc_tcp_listener)));
     sp->next = listener->next;
     listener->next = sp;
@@ -377,11 +377,11 @@ static grpc_error* clone_port(grpc_tcp_listener* listener, unsigned count) {
     listener->sibling = sp;
     sp->server = listener->server;
     sp->fd = fd;
-    sp->emfd = grpc_fd_create(
-        fd,
-        y_absl::StrFormat("tcp-server-listener:%s/clone-%d", addr_str.c_str(), i)
-            .c_str(),
-        true);
+    sp->emfd = grpc_fd_create( 
+        fd, 
+        y_absl::StrFormat("tcp-server-listener:%s/clone-%d", addr_str.c_str(), i) 
+            .c_str(), 
+        true); 
     memcpy(&sp->addr, &listener->addr, sizeof(grpc_resolved_address));
     sp->port = port;
     sp->port_index = listener->port_index;
@@ -487,8 +487,8 @@ static int tcp_server_port_fd(grpc_tcp_server* s, unsigned port_index,
   return -1;
 }
 
-static void tcp_server_start(grpc_tcp_server* s,
-                             const std::vector<grpc_pollset*>* pollsets,
+static void tcp_server_start(grpc_tcp_server* s, 
+                             const std::vector<grpc_pollset*>* pollsets, 
                              grpc_tcp_server_cb on_accept_cb,
                              void* on_accept_cb_arg) {
   size_t i;
@@ -503,11 +503,11 @@ static void tcp_server_start(grpc_tcp_server* s,
   sp = s->head;
   while (sp != nullptr) {
     if (s->so_reuseport && !grpc_is_unix_socket(&sp->addr) &&
-        pollsets->size() > 1) {
+        pollsets->size() > 1) { 
       GPR_ASSERT(GRPC_LOG_IF_ERROR(
-          "clone_port", clone_port(sp, (unsigned)(pollsets->size() - 1))));
-      for (i = 0; i < pollsets->size(); i++) {
-        grpc_pollset_add_fd((*pollsets)[i], sp->emfd);
+          "clone_port", clone_port(sp, (unsigned)(pollsets->size() - 1)))); 
+      for (i = 0; i < pollsets->size(); i++) { 
+        grpc_pollset_add_fd((*pollsets)[i], sp->emfd); 
         GRPC_CLOSURE_INIT(&sp->read_closure, on_read, sp,
                           grpc_schedule_on_exec_ctx);
         grpc_fd_notify_on_read(sp->emfd, &sp->read_closure);
@@ -515,8 +515,8 @@ static void tcp_server_start(grpc_tcp_server* s,
         sp = sp->next;
       }
     } else {
-      for (i = 0; i < pollsets->size(); i++) {
-        grpc_pollset_add_fd((*pollsets)[i], sp->emfd);
+      for (i = 0; i < pollsets->size(); i++) { 
+        grpc_pollset_add_fd((*pollsets)[i], sp->emfd); 
       }
       GRPC_CLOSURE_INIT(&sp->read_closure, on_read, sp,
                         grpc_schedule_on_exec_ctx);
@@ -585,17 +585,17 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
       return;
     }
     grpc_set_socket_no_sigpipe_if_possible(fd);
-    TString addr_str = grpc_sockaddr_to_uri(&addr);
+    TString addr_str = grpc_sockaddr_to_uri(&addr); 
     if (grpc_tcp_trace.enabled()) {
       gpr_log(GPR_INFO, "SERVER_CONNECT: incoming external connection: %s",
-              addr_str.c_str());
+              addr_str.c_str()); 
     }
-    TString name = y_absl::StrCat("tcp-server-connection:", addr_str);
-    grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
+    TString name = y_absl::StrCat("tcp-server-connection:", addr_str); 
+    grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true); 
     read_notifier_pollset =
-        (*(s_->pollsets))[static_cast<size_t>(gpr_atm_no_barrier_fetch_add(
-                              &s_->next_pollset_to_assign, 1)) %
-                          s_->pollsets->size()];
+        (*(s_->pollsets))[static_cast<size_t>(gpr_atm_no_barrier_fetch_add( 
+                              &s_->next_pollset_to_assign, 1)) % 
+                          s_->pollsets->size()]; 
     grpc_pollset_add_fd(read_notifier_pollset, fdobj);
     grpc_tcp_server_acceptor* acceptor =
         static_cast<grpc_tcp_server_acceptor*>(gpr_malloc(sizeof(*acceptor)));
@@ -606,7 +606,7 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
     acceptor->listener_fd = listener_fd;
     acceptor->pending_data = buf;
     s_->on_accept_cb(s_->on_accept_cb_arg,
-                     grpc_tcp_create(fdobj, s_->channel_args, addr_str.c_str()),
+                     grpc_tcp_create(fdobj, s_->channel_args, addr_str.c_str()), 
                      read_notifier_pollset, acceptor);
   }
 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix.h b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix.h
index 6b8a5f9f20..46c74c7127 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix.h
@@ -82,9 +82,9 @@ struct grpc_tcp_server {
   /* shutdown callback */
   grpc_closure* shutdown_complete;
 
-  /* all pollsets interested in new connections. The object pointed at is not
-   * owned by this struct */
-  const std::vector<grpc_pollset*>* pollsets;
+  /* all pollsets interested in new connections. The object pointed at is not 
+   * owned by this struct */ 
+  const std::vector<grpc_pollset*>* pollsets; 
 
   /* next pollset to assign a channel to */
   gpr_atm next_pollset_to_assign;
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix_common.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix_common.cc
index 46bc18e5a0..15cb4e5917 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix_common.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix_common.cc
@@ -29,10 +29,10 @@
 #include <stdio.h>
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -91,8 +91,8 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s, int fd,
       grpc_tcp_server_prepare_socket(s, fd, addr, s->so_reuseport, &port);
   if (err == GRPC_ERROR_NONE) {
     GPR_ASSERT(port > 0);
-    TString addr_str = grpc_sockaddr_to_string(addr, true);
-    TString name = y_absl::StrCat("tcp-server-listener:", addr_str);
+    TString addr_str = grpc_sockaddr_to_string(addr, true); 
+    TString name = y_absl::StrCat("tcp-server-listener:", addr_str); 
     gpr_mu_lock(&s->mu);
     s->nports++;
     GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server");
@@ -106,7 +106,7 @@ static grpc_error* add_socket_to_server(grpc_tcp_server* s, int fd,
     s->tail = sp;
     sp->server = s;
     sp->fd = fd;
-    sp->emfd = grpc_fd_create(fd, name.c_str(), true);
+    sp->emfd = grpc_fd_create(fd, name.c_str(), true); 
     memcpy(&sp->addr, addr, sizeof(grpc_resolved_address));
     sp->port = port;
     sp->port_index = port_index;
@@ -156,14 +156,14 @@ grpc_error* grpc_tcp_server_prepare_socket(grpc_tcp_server* s, int fd,
     if (err != GRPC_ERROR_NONE) goto error;
   }
 
-#ifdef GRPC_LINUX_ERRQUEUE
-  err = grpc_set_socket_zerocopy(fd);
-  if (err != GRPC_ERROR_NONE) {
-    /* it's not fatal, so just log it. */
-    gpr_log(GPR_DEBUG, "Node does not support SO_ZEROCOPY, continuing.");
-    GRPC_ERROR_UNREF(err);
-  }
-#endif
+#ifdef GRPC_LINUX_ERRQUEUE 
+  err = grpc_set_socket_zerocopy(fd); 
+  if (err != GRPC_ERROR_NONE) { 
+    /* it's not fatal, so just log it. */ 
+    gpr_log(GPR_DEBUG, "Node does not support SO_ZEROCOPY, continuing."); 
+    GRPC_ERROR_UNREF(err); 
+  } 
+#endif 
   err = grpc_set_socket_nonblocking(fd, 1);
   if (err != GRPC_ERROR_NONE) goto error;
   err = grpc_set_socket_cloexec(fd, 1);
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix_ifaddrs.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix_ifaddrs.cc
index 1c7cd5cc10..6c0fc41e26 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix_ifaddrs.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_utils_posix_ifaddrs.cc
@@ -29,10 +29,10 @@
 #include <stddef.h>
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -133,21 +133,21 @@ grpc_error* grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
       err = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to set port");
       break;
     }
-    TString addr_str = grpc_sockaddr_to_string(&addr, false);
+    TString addr_str = grpc_sockaddr_to_string(&addr, false); 
     gpr_log(GPR_DEBUG,
             "Adding local addr from interface %s flags 0x%x to server: %s",
-            ifa_name, ifa_it->ifa_flags, addr_str.c_str());
+            ifa_name, ifa_it->ifa_flags, addr_str.c_str()); 
     /* We could have multiple interfaces with the same address (e.g., bonding),
        so look for duplicates. */
     if (find_listener_with_addr(s, &addr) != nullptr) {
-      gpr_log(GPR_DEBUG, "Skipping duplicate addr %s on interface %s",
-              addr_str.c_str(), ifa_name);
+      gpr_log(GPR_DEBUG, "Skipping duplicate addr %s on interface %s", 
+              addr_str.c_str(), ifa_name); 
       continue;
     }
     if ((err = grpc_tcp_server_add_addr(s, &addr, port_index, fd_index, &dsmode,
                                         &new_sp)) != GRPC_ERROR_NONE) {
-      grpc_error* root_err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          y_absl::StrCat("Failed to add listener: ", addr_str).c_str());
+      grpc_error* root_err = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+          y_absl::StrCat("Failed to add listener: ", addr_str).c_str()); 
       err = grpc_error_add_child(root_err, err);
       break;
     } else {
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_windows.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_windows.cc
index 13c17260dc..4a3fef4eb1 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_windows.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_server_windows.cc
@@ -27,10 +27,10 @@
 #include <inttypes.h>
 #include <io.h>
 
-#include <vector>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <vector> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
@@ -46,7 +46,7 @@
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_internal.h" 
 
 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
 
@@ -228,11 +228,11 @@ static grpc_error* prepare_socket(SOCKET sock,
 failure:
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   grpc_error_set_int(
-      grpc_error_set_str(
-          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-              "Failed to prepare server socket", &error, 1),
-          GRPC_ERROR_STR_TARGET_ADDRESS,
-          grpc_slice_from_cpp_string(grpc_sockaddr_to_uri(addr))),
+      grpc_error_set_str( 
+          GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( 
+              "Failed to prepare server socket", &error, 1), 
+          GRPC_ERROR_STR_TARGET_ADDRESS, 
+          grpc_slice_from_cpp_string(grpc_sockaddr_to_uri(addr))), 
       GRPC_ERROR_INT_FD, (intptr_t)sock);
   GRPC_ERROR_UNREF(error);
   if (sock != INVALID_SOCKET) closesocket(sock);
@@ -349,7 +349,7 @@ static void on_accept(void* arg, grpc_error* error) {
       int peer_name_len = (int)peer_name.len;
       err = getpeername(sock, (grpc_sockaddr*)peer_name.addr, &peer_name_len);
       peer_name.len = (size_t)peer_name_len;
-      TString peer_name_string;
+      TString peer_name_string; 
       if (!err) {
         peer_name_string = grpc_sockaddr_to_uri(&peer_name);
       } else {
@@ -357,9 +357,9 @@ static void on_accept(void* arg, grpc_error* error) {
         gpr_log(GPR_ERROR, "getpeername error: %s", utf8_message);
         gpr_free(utf8_message);
       }
-      TString fd_name = y_absl::StrCat("tcp_server:", peer_name_string);
-      ep = grpc_tcp_create(grpc_winsocket_create(sock, fd_name.c_str()),
-                           sp->server->channel_args, peer_name_string.c_str());
+      TString fd_name = y_absl::StrCat("tcp_server:", peer_name_string); 
+      ep = grpc_tcp_create(grpc_winsocket_create(sock, fd_name.c_str()), 
+                           sp->server->channel_args, peer_name_string.c_str()); 
     } else {
       closesocket(sock);
     }
@@ -520,8 +520,8 @@ done:
   return error;
 }
 
-static void tcp_server_start(grpc_tcp_server* s,
-                             const std::vector<grpc_pollset*>* /*pollsets*/,
+static void tcp_server_start(grpc_tcp_server* s, 
+                             const std::vector<grpc_pollset*>* /*pollsets*/, 
                              grpc_tcp_server_cb on_accept_cb,
                              void* on_accept_cb_arg) {
   grpc_tcp_listener* sp;
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_uv.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_uv.cc
index 371b38c991..9b484fadb8 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_uv.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_uv.cc
@@ -370,7 +370,7 @@ static void uv_resolve_callback(uv_getaddrinfo_t* req, int status,
                                tcp_error_create("getaddrinfo failed", status));
 }
 
-static grpc_error* uv_resolve(const char* host, const char* port,
+static grpc_error* uv_resolve(const char* host, const char* port, 
                               grpc_resolved_addresses** result) {
   int status;
   uv_getaddrinfo_t req;
@@ -388,8 +388,8 @@ static grpc_error* uv_resolve(const char* host, const char* port,
   return tcp_error_create("getaddrinfo failed", status);
 }
 
-static void uv_resolve_async(grpc_custom_resolver* r, const char* host,
-                             const char* port) {
+static void uv_resolve_async(grpc_custom_resolver* r, const char* host, 
+                             const char* port) { 
   int status;
   uv_getaddrinfo_t* req =
       (uv_getaddrinfo_t*)gpr_malloc(sizeof(uv_getaddrinfo_t));
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/tcp_windows.cc b/contrib/libs/grpc/src/core/lib/iomgr/tcp_windows.cc
index 3d410a2d3f..e219538c36 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/tcp_windows.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/tcp_windows.cc
@@ -125,8 +125,8 @@ typedef struct grpc_tcp {
   int shutting_down;
   grpc_error* shutdown_error;
 
-  TString peer_string;
-  TString local_address;
+  TString peer_string; 
+  TString local_address; 
 } grpc_tcp;
 
 static void tcp_free(grpc_tcp* tcp) {
@@ -135,7 +135,7 @@ static void tcp_free(grpc_tcp* tcp) {
   grpc_slice_buffer_destroy_internal(&tcp->last_read_buffer);
   grpc_resource_user_unref(tcp->resource_user);
   if (tcp->shutting_down) GRPC_ERROR_UNREF(tcp->shutdown_error);
-  delete tcp;
+  delete tcp; 
 }
 
 #ifndef NDEBUG
@@ -213,8 +213,8 @@ static void on_read(void* tcpp, grpc_error* error) {
           for (i = 0; i < tcp->read_slices->count; i++) {
             char* dump = grpc_dump_slice(tcp->read_slices->slices[i],
                                          GPR_DUMP_HEX | GPR_DUMP_ASCII);
-            gpr_log(GPR_INFO, "READ %p (peer=%s): %s", tcp,
-                    tcp->peer_string.c_str(), dump);
+            gpr_log(GPR_INFO, "READ %p (peer=%s): %s", tcp, 
+                    tcp->peer_string.c_str(), dump); 
             gpr_free(dump);
           }
         }
@@ -361,8 +361,8 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
     for (i = 0; i < slices->count; i++) {
       char* data =
           grpc_dump_slice(slices->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_INFO, "WRITE %p (peer=%s): %s", tcp, tcp->peer_string.c_str(),
-              data);
+      gpr_log(GPR_INFO, "WRITE %p (peer=%s): %s", tcp, tcp->peer_string.c_str(), 
+              data); 
       gpr_free(data);
     }
   }
@@ -476,16 +476,16 @@ static void win_destroy(grpc_endpoint* ep) {
   TCP_UNREF(tcp, "destroy");
 }
 
-static y_absl::string_view win_get_peer(grpc_endpoint* ep) {
+static y_absl::string_view win_get_peer(grpc_endpoint* ep) { 
   grpc_tcp* tcp = (grpc_tcp*)ep;
-  return tcp->peer_string;
-}
-
-static y_absl::string_view win_get_local_address(grpc_endpoint* ep) {
-  grpc_tcp* tcp = (grpc_tcp*)ep;
-  return tcp->local_address;
+  return tcp->peer_string; 
 }
 
+static y_absl::string_view win_get_local_address(grpc_endpoint* ep) { 
+  grpc_tcp* tcp = (grpc_tcp*)ep; 
+  return tcp->local_address; 
+} 
+ 
 static grpc_resource_user* win_get_resource_user(grpc_endpoint* ep) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   return tcp->resource_user;
@@ -504,7 +504,7 @@ static grpc_endpoint_vtable vtable = {win_read,
                                       win_destroy,
                                       win_get_resource_user,
                                       win_get_peer,
-                                      win_get_local_address,
+                                      win_get_local_address, 
                                       win_get_fd,
                                       win_can_track_err};
 
@@ -521,7 +521,7 @@ grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
       }
     }
   }
-  grpc_tcp* tcp = new grpc_tcp;
+  grpc_tcp* tcp = new grpc_tcp; 
   memset(tcp, 0, sizeof(grpc_tcp));
   tcp->base.vtable = &vtable;
   tcp->socket = socket;
@@ -529,16 +529,16 @@ grpc_endpoint* grpc_tcp_create(grpc_winsocket* socket,
   gpr_ref_init(&tcp->refcount, 1);
   GRPC_CLOSURE_INIT(&tcp->on_read, on_read, tcp, grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&tcp->on_write, on_write, tcp, grpc_schedule_on_exec_ctx);
-  grpc_resolved_address resolved_local_addr;
-  resolved_local_addr.len = sizeof(resolved_local_addr.addr);
-  if (getsockname(tcp->socket->socket,
-                  reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-                  &resolved_local_addr.len) < 0) {
-    tcp->local_address = "";
-  } else {
-    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
-  }
-  tcp->peer_string = peer_string;
+  grpc_resolved_address resolved_local_addr; 
+  resolved_local_addr.len = sizeof(resolved_local_addr.addr); 
+  if (getsockname(tcp->socket->socket, 
+                  reinterpret_cast<sockaddr*>(resolved_local_addr.addr), 
+                  &resolved_local_addr.len) < 0) { 
+    tcp->local_address = ""; 
+  } else { 
+    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr); 
+  } 
+  tcp->peer_string = peer_string; 
   grpc_slice_buffer_init(&tcp->last_read_buffer);
   tcp->resource_user = grpc_resource_user_create(resource_quota, peer_string);
   grpc_resource_quota_unref_internal(resource_quota);
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/timer_generic.cc b/contrib/libs/grpc/src/core/lib/iomgr/timer_generic.cc
index fb0e50c53c..38ec91f56d 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/timer_generic.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/timer_generic.cc
@@ -22,10 +22,10 @@
 
 #include <inttypes.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include "src/core/lib/iomgr/timer.h"
 
 #include <grpc/support/alloc.h>
@@ -709,22 +709,22 @@ static grpc_timer_check_result timer_check(grpc_millis* next) {
 
   // tracing
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    TString next_str;
+    TString next_str; 
     if (next == nullptr) {
-      next_str = "NULL";
+      next_str = "NULL"; 
     } else {
-      next_str = y_absl::StrCat(*next);
+      next_str = y_absl::StrCat(*next); 
     }
 #if GPR_ARCH_64
     gpr_log(GPR_INFO,
             "TIMER CHECK BEGIN: now=%" PRId64 " next=%s tls_min=%" PRId64
             " glob_min=%" PRId64,
-            now, next_str.c_str(), min_timer,
+            now, next_str.c_str(), min_timer, 
             static_cast<grpc_millis>(gpr_atm_no_barrier_load(
                 (gpr_atm*)(&g_shared_mutables.min_timer))));
 #else
     gpr_log(GPR_INFO, "TIMER CHECK BEGIN: now=%" PRId64 " next=%s min=%" PRId64,
-            now, next_str.c_str(), min_timer);
+            now, next_str.c_str(), min_timer); 
 #endif
   }
   // actual code
@@ -732,13 +732,13 @@ static grpc_timer_check_result timer_check(grpc_millis* next) {
       run_some_expired_timers(now, next, shutdown_error);
   // tracing
   if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    TString next_str;
+    TString next_str; 
     if (next == nullptr) {
-      next_str = "NULL";
+      next_str = "NULL"; 
     } else {
-      next_str = y_absl::StrCat(*next);
+      next_str = y_absl::StrCat(*next); 
     }
-    gpr_log(GPR_INFO, "TIMER CHECK END: r=%d; next=%s", r, next_str.c_str());
+    gpr_log(GPR_INFO, "TIMER CHECK END: r=%d; next=%s", r, next_str.c_str()); 
   }
   return r;
 }
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/udp_server.cc b/contrib/libs/grpc/src/core/lib/iomgr/udp_server.cc
index 1e7734d681..0f32f004cd 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/udp_server.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/udp_server.cc
@@ -44,12 +44,12 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <util/generic/string.h>
-#include <vector>
-
-#include "y_absl/container/inlined_vector.h"
-#include "y_absl/strings/str_cat.h"
-
+#include <util/generic/string.h> 
+#include <vector> 
+ 
+#include "y_absl/container/inlined_vector.h" 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -78,7 +78,7 @@ class GrpcUdpListener {
   ~GrpcUdpListener();
 
   /* Called when grpc server starts to listening on the grpc_fd. */
-  void StartListening(const std::vector<grpc_pollset*>* pollsets,
+  void StartListening(const std::vector<grpc_pollset*>* pollsets, 
                       GrpcUdpHandlerFactory* handler_factory);
 
   /* Called when data is available to read from the socket.
@@ -152,9 +152,9 @@ GrpcUdpListener::GrpcUdpListener(grpc_udp_server* server, int fd,
       server_(server),
       orphan_notified_(false),
       already_shutdown_(false) {
-  TString addr_str = grpc_sockaddr_to_string(addr, true);
-  TString name = y_absl::StrCat("udp-server-listener:", addr_str);
-  emfd_ = grpc_fd_create(fd, name.c_str(), true);
+  TString addr_str = grpc_sockaddr_to_string(addr, true); 
+  TString name = y_absl::StrCat("udp-server-listener:", addr_str); 
+  emfd_ = grpc_fd_create(fd, name.c_str(), true); 
   memcpy(&addr_, addr, sizeof(grpc_resolved_address));
   GPR_ASSERT(emfd_);
   gpr_mu_init(&mutex_);
@@ -178,7 +178,7 @@ struct grpc_udp_server {
   int shutdown;
 
   /* An array of listeners */
-  y_absl::InlinedVector<GrpcUdpListener, 16> listeners;
+  y_absl::InlinedVector<GrpcUdpListener, 16> listeners; 
 
   /* factory for use to create udp listeners */
   GrpcUdpHandlerFactory* handler_factory;
@@ -186,9 +186,9 @@ struct grpc_udp_server {
   /* shutdown callback */
   grpc_closure* shutdown_complete;
 
-  /* all pollsets interested in new connections. The object pointed at is not
-   * owned by this struct. */
-  const std::vector<grpc_pollset*>* pollsets;
+  /* all pollsets interested in new connections. The object pointed at is not 
+   * owned by this struct. */ 
+  const std::vector<grpc_pollset*>* pollsets; 
   /* opaque object to pass to callbacks */
   void* user_data;
 
@@ -282,7 +282,7 @@ static void deactivated_all_ports(grpc_udp_server* s) {
 
   GPR_ASSERT(s->shutdown);
 
-  if (s->listeners.empty()) {
+  if (s->listeners.empty()) { 
     gpr_mu_unlock(&s->mu);
     finish_shutdown(s);
     return;
@@ -412,8 +412,8 @@ static int prepare_socket(grpc_socket_factory* socket_factory, int fd,
   }
 
   if (bind_socket(socket_factory, fd, addr) < 0) {
-    TString addr_str = grpc_sockaddr_to_string(addr, false);
-    gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str.c_str(), strerror(errno));
+    TString addr_str = grpc_sockaddr_to_string(addr, false); 
+    gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str.c_str(), strerror(errno)); 
     goto error;
   }
 
@@ -580,8 +580,8 @@ int grpc_udp_server_add_port(grpc_udp_server* s,
             "Try to have multiple listeners on same port, but SO_REUSEPORT is "
             "not supported. Only create 1 listener.");
   }
-  TString addr_str = grpc_sockaddr_to_string(addr, true);
-  gpr_log(GPR_DEBUG, "add address: %s to server", addr_str.c_str());
+  TString addr_str = grpc_sockaddr_to_string(addr, true); 
+  gpr_log(GPR_DEBUG, "add address: %s to server", addr_str.c_str()); 
 
   int allocated_port1 = -1;
   int allocated_port2 = -1;
@@ -701,29 +701,29 @@ int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index) {
   return s->listeners[port_index].fd();
 }
 
-void grpc_udp_server_start(grpc_udp_server* udp_server,
-                           const std::vector<grpc_pollset*>* pollsets,
-                           void* user_data) {
+void grpc_udp_server_start(grpc_udp_server* udp_server, 
+                           const std::vector<grpc_pollset*>* pollsets, 
+                           void* user_data) { 
   gpr_log(GPR_DEBUG, "grpc_udp_server_start");
-  gpr_mu_lock(&udp_server->mu);
-  GPR_ASSERT(udp_server->active_ports == 0);
-  udp_server->pollsets = pollsets;
-  udp_server->user_data = user_data;
+  gpr_mu_lock(&udp_server->mu); 
+  GPR_ASSERT(udp_server->active_ports == 0); 
+  udp_server->pollsets = pollsets; 
+  udp_server->user_data = user_data; 
 
-  for (auto& listener : udp_server->listeners) {
-    listener.StartListening(pollsets, udp_server->handler_factory);
+  for (auto& listener : udp_server->listeners) { 
+    listener.StartListening(pollsets, udp_server->handler_factory); 
   }
 
-  gpr_mu_unlock(&udp_server->mu);
+  gpr_mu_unlock(&udp_server->mu); 
 }
 
-void GrpcUdpListener::StartListening(const std::vector<grpc_pollset*>* pollsets,
+void GrpcUdpListener::StartListening(const std::vector<grpc_pollset*>* pollsets, 
                                      GrpcUdpHandlerFactory* handler_factory) {
   gpr_mu_lock(&mutex_);
   handler_factory_ = handler_factory;
   udp_handler_ = handler_factory->CreateUdpHandler(emfd_, server_->user_data);
-  for (grpc_pollset* pollset : *pollsets) {
-    grpc_pollset_add_fd(pollset, emfd_);
+  for (grpc_pollset* pollset : *pollsets) { 
+    grpc_pollset_add_fd(pollset, emfd_); 
   }
   GRPC_CLOSURE_INIT(&read_closure_, on_read, this, grpc_schedule_on_exec_ctx);
   grpc_fd_notify_on_read(emfd_, &read_closure_);
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/udp_server.h b/contrib/libs/grpc/src/core/lib/iomgr/udp_server.h
index 6cda332a5b..aaca6c53c8 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/udp_server.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/udp_server.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <vector>
-
+#include <vector> 
+ 
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -74,9 +74,9 @@ class GrpcUdpHandlerFactory {
 grpc_udp_server* grpc_udp_server_create(const grpc_channel_args* args);
 
 /* Start listening to bound ports. user_data is passed to callbacks. */
-void grpc_udp_server_start(grpc_udp_server* udp_server,
-                           const std::vector<grpc_pollset*>* pollsets,
-                           void* user_data);
+void grpc_udp_server_start(grpc_udp_server* udp_server, 
+                           const std::vector<grpc_pollset*>* pollsets, 
+                           void* user_data); 
 
 int grpc_udp_server_get_fd(grpc_udp_server* s, unsigned port_index);
 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix.cc b/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix.cc
index fd26673b38..8f02f7bd25 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix.cc
@@ -28,8 +28,8 @@
 #include <sys/types.h>
 #include <sys/un.h>
 
-#include "y_absl/strings/str_cat.h"
-
+#include "y_absl/strings/str_cat.h" 
+ 
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 
 #include <grpc/support/alloc.h>
@@ -46,10 +46,10 @@ grpc_error* grpc_resolve_unix_domain_address(const char* name,
   struct sockaddr_un* un;
   if (strlen(name) >
       GPR_ARRAY_SIZE(((struct sockaddr_un*)nullptr)->sun_path) - 1) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat("Path name should not have more than ",
-                     GPR_ARRAY_SIZE(un->sun_path) - 1, " characters")
-            .c_str());
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat("Path name should not have more than ", 
+                     GPR_ARRAY_SIZE(un->sun_path) - 1, " characters") 
+            .c_str()); 
   }
   *addrs = static_cast<grpc_resolved_addresses*>(
       gpr_malloc(sizeof(grpc_resolved_addresses)));
@@ -86,14 +86,14 @@ void grpc_unlink_if_unix_domain_socket(
   }
 }
 
-TString grpc_sockaddr_to_uri_unix_if_possible(
+TString grpc_sockaddr_to_uri_unix_if_possible( 
     const grpc_resolved_address* resolved_addr) {
   const grpc_sockaddr* addr =
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
   if (addr->sa_family != AF_UNIX) {
-    return "";
+    return ""; 
   }
-  return y_absl::StrCat("unix:", ((struct sockaddr_un*)addr)->sun_path);
+  return y_absl::StrCat("unix:", ((struct sockaddr_un*)addr)->sun_path); 
 }
 
 #endif
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix.h b/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix.h
index 962adde71c..f5cbae30b6 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 #include "src/core/lib/iomgr/port.h"
 
 #include <grpc/support/string_util.h>
@@ -39,7 +39,7 @@ int grpc_is_unix_socket(const grpc_resolved_address* resolved_addr);
 void grpc_unlink_if_unix_domain_socket(
     const grpc_resolved_address* resolved_addr);
 
-TString grpc_sockaddr_to_uri_unix_if_possible(
+TString grpc_sockaddr_to_uri_unix_if_possible( 
     const grpc_resolved_address* resolved_addr);
 
 #endif /* GRPC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H */
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix_noop.cc b/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix_noop.cc
index e391914ab5..2548c1349b 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix_noop.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/unix_sockets_posix_noop.cc
@@ -22,8 +22,8 @@
 
 #ifndef GRPC_HAVE_UNIX_SOCKET
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 #include <grpc/support/log.h>
 
 void grpc_create_socketpair_if_unix(int sv[2]) {
@@ -44,9 +44,9 @@ int grpc_is_unix_socket(const grpc_resolved_address* addr) { return false; }
 
 void grpc_unlink_if_unix_domain_socket(const grpc_resolved_address* addr) {}
 
-TString grpc_sockaddr_to_uri_unix_if_possible(
-    const grpc_resolved_address* addr) {
-  return "";
+TString grpc_sockaddr_to_uri_unix_if_possible( 
+    const grpc_resolved_address* addr) { 
+  return ""; 
 }
 
 #endif
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/work_serializer.cc b/contrib/libs/grpc/src/core/lib/iomgr/work_serializer.cc
index db573e3b6f..f2d2e64bcf 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/work_serializer.cc
+++ b/contrib/libs/grpc/src/core/lib/iomgr/work_serializer.cc
@@ -1,155 +1,155 @@
-/*
- *
- * 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/work_serializer.h"
-
-namespace grpc_core {
-
-DebugOnlyTraceFlag grpc_work_serializer_trace(false, "work_serializer");
-
-struct CallbackWrapper {
-  CallbackWrapper(std::function<void()> cb, const grpc_core::DebugLocation& loc)
-      : callback(std::move(cb)), location(loc) {}
-
-  MultiProducerSingleConsumerQueue::Node mpscq_node;
-  const std::function<void()> callback;
-  const DebugLocation location;
-};
-
-class WorkSerializer::WorkSerializerImpl : public Orphanable {
- public:
-  void Run(std::function<void()> callback,
-           const grpc_core::DebugLocation& location);
-
-  void Orphan() override;
-
- private:
-  void DrainQueue();
-
-  // An initial size of 1 keeps track of whether the work serializer has been
-  // orphaned.
-  Atomic<size_t> size_{1};
-  MultiProducerSingleConsumerQueue queue_;
-};
-
-void WorkSerializer::WorkSerializerImpl::Run(
-    std::function<void()> callback, const grpc_core::DebugLocation& location) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-    gpr_log(GPR_INFO, "WorkSerializer::Run() %p Scheduling callback [%s:%d]",
-            this, location.file(), location.line());
-  }
-  const size_t prev_size = size_.FetchAdd(1);
-  // The work serializer should not have been orphaned.
-  GPR_DEBUG_ASSERT(prev_size > 0);
-  if (prev_size == 1) {
-    // There is no other closure executing right now on this work serializer.
-    // Execute this closure immediately.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-      gpr_log(GPR_INFO, "  Executing immediately");
-    }
-    callback();
-    // Loan this thread to the work serializer thread and drain the queue.
-    DrainQueue();
-  } else {
-    CallbackWrapper* cb_wrapper =
-        new CallbackWrapper(std::move(callback), location);
-    // There already are closures executing on this work serializer. Simply add
-    // this closure to the queue.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-      gpr_log(GPR_INFO, "  Scheduling on queue : item %p", cb_wrapper);
-    }
-    queue_.Push(&cb_wrapper->mpscq_node);
-  }
-}
-
-void WorkSerializer::WorkSerializerImpl::Orphan() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-    gpr_log(GPR_INFO, "WorkSerializer::Orphan() %p", this);
-  }
-  size_t prev_size = size_.FetchSub(1);
-  if (prev_size == 1) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-      gpr_log(GPR_INFO, "  Destroying");
-    }
-    delete this;
-  }
-}
-
-// The thread that calls this loans itself to the work serializer so as to
-// execute all the scheduled callback. This is called from within
-// WorkSerializer::Run() after executing a callback immediately, and hence size_
-// is at least 1.
-void WorkSerializer::WorkSerializerImpl::DrainQueue() {
-  while (true) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-      gpr_log(GPR_INFO, "WorkSerializer::DrainQueue() %p", this);
-    }
-    size_t prev_size = size_.FetchSub(1);
-    GPR_DEBUG_ASSERT(prev_size >= 1);
-    // It is possible that while draining the queue, one of the callbacks ended
-    // up orphaning the work serializer. In that case, delete the object.
-    if (prev_size == 1) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-        gpr_log(GPR_INFO, "  Queue Drained. Destroying");
-      }
-      delete this;
-      return;
-    }
-    if (prev_size == 2) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-        gpr_log(GPR_INFO, "  Queue Drained");
-      }
-      return;
-    }
-    // There is at least one callback on the queue. Pop the callback from the
-    // queue and execute it.
-    CallbackWrapper* cb_wrapper = nullptr;
-    bool empty_unused;
-    while ((cb_wrapper = reinterpret_cast<CallbackWrapper*>(
-                queue_.PopAndCheckEnd(&empty_unused))) == nullptr) {
-      // This can happen either due to a race condition within the mpscq
-      // implementation or because of a race with Run()
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-        gpr_log(GPR_INFO, "  Queue returned nullptr, trying again");
-      }
-    }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) {
-      gpr_log(GPR_INFO, "  Running item %p : callback scheduled at [%s:%d]",
-              cb_wrapper, cb_wrapper->location.file(),
-              cb_wrapper->location.line());
-    }
-    cb_wrapper->callback();
-    delete cb_wrapper;
-  }
-}
-
-// WorkSerializer
-
-WorkSerializer::WorkSerializer()
-    : impl_(MakeOrphanable<WorkSerializerImpl>()) {}
-
-WorkSerializer::~WorkSerializer() {}
-
-void WorkSerializer::Run(std::function<void()> callback,
-                         const grpc_core::DebugLocation& location) {
-  impl_->Run(std::move(callback), location);
-}
-
-}  // namespace grpc_core
+/* 
+ * 
+ * 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. 
+ * 
+ */ 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/iomgr/work_serializer.h" 
+ 
+namespace grpc_core { 
+ 
+DebugOnlyTraceFlag grpc_work_serializer_trace(false, "work_serializer"); 
+ 
+struct CallbackWrapper { 
+  CallbackWrapper(std::function<void()> cb, const grpc_core::DebugLocation& loc) 
+      : callback(std::move(cb)), location(loc) {} 
+ 
+  MultiProducerSingleConsumerQueue::Node mpscq_node; 
+  const std::function<void()> callback; 
+  const DebugLocation location; 
+}; 
+ 
+class WorkSerializer::WorkSerializerImpl : public Orphanable { 
+ public: 
+  void Run(std::function<void()> callback, 
+           const grpc_core::DebugLocation& location); 
+ 
+  void Orphan() override; 
+ 
+ private: 
+  void DrainQueue(); 
+ 
+  // An initial size of 1 keeps track of whether the work serializer has been 
+  // orphaned. 
+  Atomic<size_t> size_{1}; 
+  MultiProducerSingleConsumerQueue queue_; 
+}; 
+ 
+void WorkSerializer::WorkSerializerImpl::Run( 
+    std::function<void()> callback, const grpc_core::DebugLocation& location) { 
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) { 
+    gpr_log(GPR_INFO, "WorkSerializer::Run() %p Scheduling callback [%s:%d]", 
+            this, location.file(), location.line()); 
+  } 
+  const size_t prev_size = size_.FetchAdd(1); 
+  // The work serializer should not have been orphaned. 
+  GPR_DEBUG_ASSERT(prev_size > 0); 
+  if (prev_size == 1) { 
+    // There is no other closure executing right now on this work serializer. 
+    // Execute this closure immediately. 
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) { 
+      gpr_log(GPR_INFO, "  Executing immediately"); 
+    } 
+    callback(); 
+    // Loan this thread to the work serializer thread and drain the queue. 
+    DrainQueue(); 
+  } else { 
+    CallbackWrapper* cb_wrapper = 
+        new CallbackWrapper(std::move(callback), location); 
+    // There already are closures executing on this work serializer. Simply add 
+    // this closure to the queue. 
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) { 
+      gpr_log(GPR_INFO, "  Scheduling on queue : item %p", cb_wrapper); 
+    } 
+    queue_.Push(&cb_wrapper->mpscq_node); 
+  } 
+} 
+ 
+void WorkSerializer::WorkSerializerImpl::Orphan() { 
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) { 
+    gpr_log(GPR_INFO, "WorkSerializer::Orphan() %p", this); 
+  } 
+  size_t prev_size = size_.FetchSub(1); 
+  if (prev_size == 1) { 
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) { 
+      gpr_log(GPR_INFO, "  Destroying"); 
+    } 
+    delete this; 
+  } 
+} 
+ 
+// The thread that calls this loans itself to the work serializer so as to 
+// execute all the scheduled callback. This is called from within 
+// WorkSerializer::Run() after executing a callback immediately, and hence size_ 
+// is at least 1. 
+void WorkSerializer::WorkSerializerImpl::DrainQueue() { 
+  while (true) { 
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) { 
+      gpr_log(GPR_INFO, "WorkSerializer::DrainQueue() %p", this); 
+    } 
+    size_t prev_size = size_.FetchSub(1); 
+    GPR_DEBUG_ASSERT(prev_size >= 1); 
+    // It is possible that while draining the queue, one of the callbacks ended 
+    // up orphaning the work serializer. In that case, delete the object. 
+    if (prev_size == 1) { 
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) { 
+        gpr_log(GPR_INFO, "  Queue Drained. Destroying"); 
+      } 
+      delete this; 
+      return; 
+    } 
+    if (prev_size == 2) { 
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) { 
+        gpr_log(GPR_INFO, "  Queue Drained"); 
+      } 
+      return; 
+    } 
+    // There is at least one callback on the queue. Pop the callback from the 
+    // queue and execute it. 
+    CallbackWrapper* cb_wrapper = nullptr; 
+    bool empty_unused; 
+    while ((cb_wrapper = reinterpret_cast<CallbackWrapper*>( 
+                queue_.PopAndCheckEnd(&empty_unused))) == nullptr) { 
+      // This can happen either due to a race condition within the mpscq 
+      // implementation or because of a race with Run() 
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) { 
+        gpr_log(GPR_INFO, "  Queue returned nullptr, trying again"); 
+      } 
+    } 
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_work_serializer_trace)) { 
+      gpr_log(GPR_INFO, "  Running item %p : callback scheduled at [%s:%d]", 
+              cb_wrapper, cb_wrapper->location.file(), 
+              cb_wrapper->location.line()); 
+    } 
+    cb_wrapper->callback(); 
+    delete cb_wrapper; 
+  } 
+} 
+ 
+// WorkSerializer 
+ 
+WorkSerializer::WorkSerializer() 
+    : impl_(MakeOrphanable<WorkSerializerImpl>()) {} 
+ 
+WorkSerializer::~WorkSerializer() {} 
+ 
+void WorkSerializer::Run(std::function<void()> callback, 
+                         const grpc_core::DebugLocation& location) { 
+  impl_->Run(std::move(callback), location); 
+} 
+ 
+}  // namespace grpc_core 
diff --git a/contrib/libs/grpc/src/core/lib/iomgr/work_serializer.h b/contrib/libs/grpc/src/core/lib/iomgr/work_serializer.h
index 53c80701a1..77a1a383cc 100644
--- a/contrib/libs/grpc/src/core/lib/iomgr/work_serializer.h
+++ b/contrib/libs/grpc/src/core/lib/iomgr/work_serializer.h
@@ -1,65 +1,65 @@
-/*
- *
- * 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include <functional>
-
-#include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/atomic.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/mpscq.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-
-#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H
-
-namespace grpc_core {
-
-// WorkSerializer is a mechanism to schedule callbacks in a synchronized manner.
-// All callbacks scheduled on a WorkSerializer instance will be executed
-// serially in a borrowed thread. The API provides a FIFO guarantee to the
-// execution of callbacks scheduled on the thread.
-// When a thread calls Run() with a callback, the thread is considered borrowed.
-// The callback might run inline, or it might run asynchronously in a different
-// thread that is already inside of Run(). If the callback runs directly inline,
-// other callbacks from other threads might also be executed before Run()
-// returns. Since an arbitrary set of callbacks might be executed when Run() is
-// called, generally no locks should be held while calling Run().
-class WorkSerializer {
- public:
-  WorkSerializer();
-
-  ~WorkSerializer();
-
-  // TODO(yashkt): Replace grpc_core::DebugLocation with y_absl::SourceLocation
-  // once we can start using it directly.
-  void Run(std::function<void()> callback,
-           const grpc_core::DebugLocation& location);
-
- private:
-  class WorkSerializerImpl;
-
-  OrphanablePtr<WorkSerializerImpl> impl_;
-};
-
-} /* namespace grpc_core */
-
-#endif /* GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H */
+/* 
+ * 
+ * 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. 
+ * 
+ */ 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <functional> 
+ 
+#include "src/core/lib/debug/trace.h" 
+#include "src/core/lib/gprpp/atomic.h" 
+#include "src/core/lib/gprpp/debug_location.h" 
+#include "src/core/lib/gprpp/mpscq.h" 
+#include "src/core/lib/gprpp/orphanable.h" 
+#include "src/core/lib/gprpp/ref_counted.h" 
+#include "src/core/lib/iomgr/exec_ctx.h" 
+ 
+#ifndef GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H 
+#define GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H 
+ 
+namespace grpc_core { 
+ 
+// WorkSerializer is a mechanism to schedule callbacks in a synchronized manner. 
+// All callbacks scheduled on a WorkSerializer instance will be executed 
+// serially in a borrowed thread. The API provides a FIFO guarantee to the 
+// execution of callbacks scheduled on the thread. 
+// When a thread calls Run() with a callback, the thread is considered borrowed. 
+// The callback might run inline, or it might run asynchronously in a different 
+// thread that is already inside of Run(). If the callback runs directly inline, 
+// other callbacks from other threads might also be executed before Run() 
+// returns. Since an arbitrary set of callbacks might be executed when Run() is 
+// called, generally no locks should be held while calling Run(). 
+class WorkSerializer { 
+ public: 
+  WorkSerializer(); 
+ 
+  ~WorkSerializer(); 
+ 
+  // TODO(yashkt): Replace grpc_core::DebugLocation with y_absl::SourceLocation 
+  // once we can start using it directly. 
+  void Run(std::function<void()> callback, 
+           const grpc_core::DebugLocation& location); 
+ 
+ private: 
+  class WorkSerializerImpl; 
+ 
+  OrphanablePtr<WorkSerializerImpl> impl_; 
+}; 
+ 
+} /* namespace grpc_core */ 
+ 
+#endif /* GRPC_CORE_LIB_IOMGR_WORK_SERIALIZER_H */ 
diff --git a/contrib/libs/grpc/src/core/lib/json/json.h b/contrib/libs/grpc/src/core/lib/json/json.h
index f426fbf1dd..82a3b0aa07 100644
--- a/contrib/libs/grpc/src/core/lib/json/json.h
+++ b/contrib/libs/grpc/src/core/lib/json/json.h
@@ -23,219 +23,219 @@
 
 #include <stdlib.h>
 
-#include <map>
-#include <util/generic/string.h>
-#include <util/string/cast.h>
-#include <vector>
-
-#include "y_absl/strings/string_view.h"
-
-#include "src/core/lib/iomgr/error.h"
-
-namespace grpc_core {
-
-// A JSON value, which can be any one of object, array, string,
-// number, true, false, or null.
-class Json {
- public:
-  // TODO(roth): Currently, numbers are stored internally as strings,
-  // which makes the API a bit cumbersome to use. When we have time,
-  // consider whether there's a better alternative (e.g., maybe storing
-  // each numeric type as the native C++ type and automatically converting
-  // to string as needed).
-  enum class Type {
-    JSON_NULL,
-    JSON_TRUE,
-    JSON_FALSE,
-    NUMBER,
-    STRING,
-    OBJECT,
-    ARRAY
-  };
-
-  using Object = std::map<TString, Json>;
-  using Array = std::vector<Json>;
-
-  // Parses JSON string from json_str.  On error, sets *error.
-  static Json Parse(y_absl::string_view json_str, grpc_error** error);
-
-  Json() = default;
-
-  // Copyable.
-  Json(const Json& other) { CopyFrom(other); }
-  Json& operator=(const Json& other) {
-    CopyFrom(other);
-    return *this;
-  }
-
-  // Moveable.
-  Json(Json&& other) { MoveFrom(std::move(other)); }
-  Json& operator=(Json&& other) {
-    MoveFrom(std::move(other));
-    return *this;
-  }
-
-  // Construct from copying a string.
-  // If is_number is true, the type will be NUMBER instead of STRING.
-  Json(const TString& string, bool is_number = false)
-      : type_(is_number ? Type::NUMBER : Type::STRING), string_value_(string) {}
-  Json& operator=(const TString& string) {
-    type_ = Type::STRING;
-    string_value_ = string;
-    return *this;
-  }
-
-  // Same thing for C-style strings, both const and mutable.
-  Json(const char* string, bool is_number = false)
-      : Json(TString(string), is_number) {}
-  Json& operator=(const char* string) {
-    *this = TString(string);
-    return *this;
-  }
-  Json(char* string, bool is_number = false)
-      : Json(TString(string), is_number) {}
-  Json& operator=(char* string) {
-    *this = TString(string);
-    return *this;
-  }
-
-  // Construct by moving a string.
-  Json(TString&& string)
-      : type_(Type::STRING), string_value_(std::move(string)) {}
-  Json& operator=(TString&& string) {
-    type_ = Type::STRING;
-    string_value_ = std::move(string);
-    return *this;
-  }
-
-  // Construct from bool.
-  Json(bool b) : type_(b ? Type::JSON_TRUE : Type::JSON_FALSE) {}
-  Json& operator=(bool b) {
-    type_ = b ? Type::JSON_TRUE : Type::JSON_FALSE;
-    return *this;
-  }
-
-  // Construct from any numeric type.
-  template <typename NumericType>
-  Json(NumericType number)
-      : type_(Type::NUMBER), string_value_(ToString(number)) {}
-  template <typename NumericType>
-  Json& operator=(NumericType number) {
-    type_ = Type::NUMBER;
-    string_value_ = ToString(number);
-    return *this;
-  }
-
-  // Construct by copying object.
-  Json(const Object& object) : type_(Type::OBJECT), object_value_(object) {}
-  Json& operator=(const Object& object) {
-    type_ = Type::OBJECT;
-    object_value_ = object;
-    return *this;
-  }
-
-  // Construct by moving object.
-  Json(Object&& object)
-      : type_(Type::OBJECT), object_value_(std::move(object)) {}
-  Json& operator=(Object&& object) {
-    type_ = Type::OBJECT;
-    object_value_ = std::move(object);
-    return *this;
-  }
-
-  // Construct by copying array.
-  Json(const Array& array) : type_(Type::ARRAY), array_value_(array) {}
-  Json& operator=(const Array& array) {
-    type_ = Type::ARRAY;
-    array_value_ = array;
-    return *this;
-  }
-
-  // Construct by moving array.
-  Json(Array&& array) : type_(Type::ARRAY), array_value_(std::move(array)) {}
-  Json& operator=(Array&& array) {
-    type_ = Type::ARRAY;
-    array_value_ = std::move(array);
-    return *this;
-  }
-
-  // Dumps JSON from value to string form.
-  TString Dump(int indent = 0) const;
-
-  // Accessor methods.
-  Type type() const { return type_; }
-  const TString& string_value() const { return string_value_; }
-  TString* mutable_string_value() { return &string_value_; }
-  const Object& object_value() const { return object_value_; }
-  Object* mutable_object() { return &object_value_; }
-  const Array& array_value() const { return array_value_; }
-  Array* mutable_array() { return &array_value_; }
-
-  bool operator==(const Json& other) const {
-    if (type_ != other.type_) return false;
-    switch (type_) {
-      case Type::NUMBER:
-      case Type::STRING:
-        if (string_value_ != other.string_value_) return false;
-        break;
-      case Type::OBJECT:
-        if (object_value_ != other.object_value_) return false;
-        break;
-      case Type::ARRAY:
-        if (array_value_ != other.array_value_) return false;
-        break;
-      default:
-        break;
-    }
-    return true;
-  }
-
-  bool operator!=(const Json& other) const { return !(*this == other); }
-
- private:
-  void CopyFrom(const Json& other) {
-    type_ = other.type_;
-    switch (type_) {
-      case Type::NUMBER:
-      case Type::STRING:
-        string_value_ = other.string_value_;
-        break;
-      case Type::OBJECT:
-        object_value_ = other.object_value_;
-        break;
-      case Type::ARRAY:
-        array_value_ = other.array_value_;
-        break;
-      default:
-        break;
-    }
-  }
-
-  void MoveFrom(Json&& other) {
-    type_ = other.type_;
-    other.type_ = Type::JSON_NULL;
-    switch (type_) {
-      case Type::NUMBER:
-      case Type::STRING:
-        string_value_ = std::move(other.string_value_);
-        break;
-      case Type::OBJECT:
-        object_value_ = std::move(other.object_value_);
-        break;
-      case Type::ARRAY:
-        array_value_ = std::move(other.array_value_);
-        break;
-      default:
-        break;
-    }
-  }
-
-  Type type_ = Type::JSON_NULL;
-  TString string_value_;
-  Object object_value_;
-  Array array_value_;
-};
-
-}  // namespace grpc_core
-
+#include <map> 
+#include <util/generic/string.h> 
+#include <util/string/cast.h> 
+#include <vector> 
+
+#include "y_absl/strings/string_view.h" 
+ 
+#include "src/core/lib/iomgr/error.h" 
+
+namespace grpc_core { 
+
+// A JSON value, which can be any one of object, array, string, 
+// number, true, false, or null. 
+class Json { 
+ public: 
+  // TODO(roth): Currently, numbers are stored internally as strings, 
+  // which makes the API a bit cumbersome to use. When we have time, 
+  // consider whether there's a better alternative (e.g., maybe storing 
+  // each numeric type as the native C++ type and automatically converting 
+  // to string as needed). 
+  enum class Type { 
+    JSON_NULL, 
+    JSON_TRUE, 
+    JSON_FALSE, 
+    NUMBER, 
+    STRING, 
+    OBJECT, 
+    ARRAY 
+  }; 
+
+  using Object = std::map<TString, Json>; 
+  using Array = std::vector<Json>; 
+
+  // Parses JSON string from json_str.  On error, sets *error. 
+  static Json Parse(y_absl::string_view json_str, grpc_error** error); 
+
+  Json() = default; 
+
+  // Copyable. 
+  Json(const Json& other) { CopyFrom(other); } 
+  Json& operator=(const Json& other) { 
+    CopyFrom(other); 
+    return *this; 
+  } 
+
+  // Moveable. 
+  Json(Json&& other) { MoveFrom(std::move(other)); } 
+  Json& operator=(Json&& other) { 
+    MoveFrom(std::move(other)); 
+    return *this; 
+  } 
+
+  // Construct from copying a string. 
+  // If is_number is true, the type will be NUMBER instead of STRING. 
+  Json(const TString& string, bool is_number = false) 
+      : type_(is_number ? Type::NUMBER : Type::STRING), string_value_(string) {} 
+  Json& operator=(const TString& string) { 
+    type_ = Type::STRING; 
+    string_value_ = string; 
+    return *this; 
+  } 
+
+  // Same thing for C-style strings, both const and mutable. 
+  Json(const char* string, bool is_number = false) 
+      : Json(TString(string), is_number) {} 
+  Json& operator=(const char* string) { 
+    *this = TString(string); 
+    return *this; 
+  } 
+  Json(char* string, bool is_number = false) 
+      : Json(TString(string), is_number) {} 
+  Json& operator=(char* string) { 
+    *this = TString(string); 
+    return *this; 
+  } 
+ 
+  // Construct by moving a string. 
+  Json(TString&& string) 
+      : type_(Type::STRING), string_value_(std::move(string)) {} 
+  Json& operator=(TString&& string) { 
+    type_ = Type::STRING; 
+    string_value_ = std::move(string); 
+    return *this; 
+  } 
+ 
+  // Construct from bool. 
+  Json(bool b) : type_(b ? Type::JSON_TRUE : Type::JSON_FALSE) {} 
+  Json& operator=(bool b) { 
+    type_ = b ? Type::JSON_TRUE : Type::JSON_FALSE; 
+    return *this; 
+  } 
+ 
+  // Construct from any numeric type. 
+  template <typename NumericType> 
+  Json(NumericType number) 
+      : type_(Type::NUMBER), string_value_(ToString(number)) {} 
+  template <typename NumericType> 
+  Json& operator=(NumericType number) { 
+    type_ = Type::NUMBER; 
+    string_value_ = ToString(number); 
+    return *this; 
+  } 
+ 
+  // Construct by copying object. 
+  Json(const Object& object) : type_(Type::OBJECT), object_value_(object) {} 
+  Json& operator=(const Object& object) { 
+    type_ = Type::OBJECT; 
+    object_value_ = object; 
+    return *this; 
+  } 
+ 
+  // Construct by moving object. 
+  Json(Object&& object) 
+      : type_(Type::OBJECT), object_value_(std::move(object)) {} 
+  Json& operator=(Object&& object) { 
+    type_ = Type::OBJECT; 
+    object_value_ = std::move(object); 
+    return *this; 
+  } 
+ 
+  // Construct by copying array. 
+  Json(const Array& array) : type_(Type::ARRAY), array_value_(array) {} 
+  Json& operator=(const Array& array) { 
+    type_ = Type::ARRAY; 
+    array_value_ = array; 
+    return *this; 
+  } 
+ 
+  // Construct by moving array. 
+  Json(Array&& array) : type_(Type::ARRAY), array_value_(std::move(array)) {} 
+  Json& operator=(Array&& array) { 
+    type_ = Type::ARRAY; 
+    array_value_ = std::move(array); 
+    return *this; 
+  } 
+ 
+  // Dumps JSON from value to string form. 
+  TString Dump(int indent = 0) const; 
+ 
+  // Accessor methods. 
+  Type type() const { return type_; } 
+  const TString& string_value() const { return string_value_; } 
+  TString* mutable_string_value() { return &string_value_; } 
+  const Object& object_value() const { return object_value_; } 
+  Object* mutable_object() { return &object_value_; } 
+  const Array& array_value() const { return array_value_; } 
+  Array* mutable_array() { return &array_value_; } 
+ 
+  bool operator==(const Json& other) const { 
+    if (type_ != other.type_) return false; 
+    switch (type_) { 
+      case Type::NUMBER: 
+      case Type::STRING: 
+        if (string_value_ != other.string_value_) return false; 
+        break; 
+      case Type::OBJECT: 
+        if (object_value_ != other.object_value_) return false; 
+        break; 
+      case Type::ARRAY: 
+        if (array_value_ != other.array_value_) return false; 
+        break; 
+      default: 
+        break; 
+    } 
+    return true; 
+  } 
+ 
+  bool operator!=(const Json& other) const { return !(*this == other); } 
+ 
+ private: 
+  void CopyFrom(const Json& other) { 
+    type_ = other.type_; 
+    switch (type_) { 
+      case Type::NUMBER: 
+      case Type::STRING: 
+        string_value_ = other.string_value_; 
+        break; 
+      case Type::OBJECT: 
+        object_value_ = other.object_value_; 
+        break; 
+      case Type::ARRAY: 
+        array_value_ = other.array_value_; 
+        break; 
+      default: 
+        break; 
+    } 
+  } 
+ 
+  void MoveFrom(Json&& other) { 
+    type_ = other.type_; 
+    other.type_ = Type::JSON_NULL; 
+    switch (type_) { 
+      case Type::NUMBER: 
+      case Type::STRING: 
+        string_value_ = std::move(other.string_value_); 
+        break; 
+      case Type::OBJECT: 
+        object_value_ = std::move(other.object_value_); 
+        break; 
+      case Type::ARRAY: 
+        array_value_ = std::move(other.array_value_); 
+        break; 
+      default: 
+        break; 
+    } 
+  } 
+ 
+  Type type_ = Type::JSON_NULL; 
+  TString string_value_; 
+  Object object_value_; 
+  Array array_value_; 
+}; 
+ 
+}  // namespace grpc_core 
+ 
 #endif /* GRPC_CORE_LIB_JSON_JSON_H */
diff --git a/contrib/libs/grpc/src/core/lib/json/json_reader.cc b/contrib/libs/grpc/src/core/lib/json/json_reader.cc
index e251cb7882..f2dbe5844d 100644
--- a/contrib/libs/grpc/src/core/lib/json/json_reader.cc
+++ b/contrib/libs/grpc/src/core/lib/json/json_reader.cc
@@ -20,267 +20,267 @@
 
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_format.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/support/log.h>
 
-#include "src/core/lib/json/json.h"
-
-#define GRPC_JSON_MAX_DEPTH 255
-#define GRPC_JSON_MAX_ERRORS 16
-
-namespace grpc_core {
-
-namespace {
-
-class JsonReader {
- public:
-  static grpc_error* Parse(y_absl::string_view input, Json* output);
-
- private:
-  enum class Status {
-    GRPC_JSON_DONE,          /* The parser finished successfully. */
-    GRPC_JSON_PARSE_ERROR,   /* The parser found an error in the json stream. */
-    GRPC_JSON_INTERNAL_ERROR /* The parser got an internal error. */
-  };
-
-  enum class State {
-    GRPC_JSON_STATE_OBJECT_KEY_BEGIN,
-    GRPC_JSON_STATE_OBJECT_KEY_STRING,
-    GRPC_JSON_STATE_OBJECT_KEY_END,
-    GRPC_JSON_STATE_VALUE_BEGIN,
-    GRPC_JSON_STATE_VALUE_STRING,
-    GRPC_JSON_STATE_STRING_ESCAPE,
-    GRPC_JSON_STATE_STRING_ESCAPE_U1,
-    GRPC_JSON_STATE_STRING_ESCAPE_U2,
-    GRPC_JSON_STATE_STRING_ESCAPE_U3,
-    GRPC_JSON_STATE_STRING_ESCAPE_U4,
-    GRPC_JSON_STATE_VALUE_NUMBER,
-    GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL,
-    GRPC_JSON_STATE_VALUE_NUMBER_ZERO,
-    GRPC_JSON_STATE_VALUE_NUMBER_DOT,
-    GRPC_JSON_STATE_VALUE_NUMBER_E,
-    GRPC_JSON_STATE_VALUE_NUMBER_EPM,
-    GRPC_JSON_STATE_VALUE_TRUE_R,
-    GRPC_JSON_STATE_VALUE_TRUE_U,
-    GRPC_JSON_STATE_VALUE_TRUE_E,
-    GRPC_JSON_STATE_VALUE_FALSE_A,
-    GRPC_JSON_STATE_VALUE_FALSE_L,
-    GRPC_JSON_STATE_VALUE_FALSE_S,
-    GRPC_JSON_STATE_VALUE_FALSE_E,
-    GRPC_JSON_STATE_VALUE_NULL_U,
-    GRPC_JSON_STATE_VALUE_NULL_L1,
-    GRPC_JSON_STATE_VALUE_NULL_L2,
-    GRPC_JSON_STATE_VALUE_END,
-    GRPC_JSON_STATE_END
-  };
-
-  /* The first non-unicode value is 0x110000. But let's pick
-   * a value high enough to start our error codes from. These
-   * values are safe to return from the read_char function.
-   */
-  static constexpr uint32_t GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0;
-
-  explicit JsonReader(y_absl::string_view input)
-      : original_input_(reinterpret_cast<const uint8_t*>(input.data())),
-        input_(original_input_),
-        remaining_input_(input.size()) {}
-
-  Status Run();
-  uint32_t ReadChar();
-  bool IsComplete();
-
-  size_t CurrentIndex() const { return input_ - original_input_ - 1; }
-
-  void StringAddChar(uint32_t c);
-  void StringAddUtf32(uint32_t c);
-
-  Json* CreateAndLinkValue();
-  bool StartContainer(Json::Type type);
-  void EndContainer();
-  void SetKey();
-  void SetString();
-  bool SetNumber();
-  void SetTrue();
-  void SetFalse();
-  void SetNull();
-
-  const uint8_t* original_input_;
-  const uint8_t* input_;
-  size_t remaining_input_;
-
-  State state_ = State::GRPC_JSON_STATE_VALUE_BEGIN;
-  bool escaped_string_was_key_ = false;
-  bool container_just_begun_ = false;
-  uint16_t unicode_char_ = 0;
-  uint16_t unicode_high_surrogate_ = 0;
-  std::vector<grpc_error*> errors_;
-  bool truncated_errors_ = false;
-
-  Json root_value_;
-  std::vector<Json*> stack_;
-
-  TString key_;
-  TString string_;
-};
-
-void JsonReader::StringAddChar(uint32_t c) {
-  string_.push_back(static_cast<uint8_t>(c));
-}
-
-void JsonReader::StringAddUtf32(uint32_t c) {
-  if (c <= 0x7f) {
-    StringAddChar(c);
-  } else if (c <= 0x7ff) {
-    uint32_t b1 = 0xc0 | ((c >> 6) & 0x1f);
-    uint32_t b2 = 0x80 | (c & 0x3f);
-    StringAddChar(b1);
-    StringAddChar(b2);
-  } else if (c <= 0xffff) {
-    uint32_t b1 = 0xe0 | ((c >> 12) & 0x0f);
-    uint32_t b2 = 0x80 | ((c >> 6) & 0x3f);
-    uint32_t b3 = 0x80 | (c & 0x3f);
-    StringAddChar(b1);
-    StringAddChar(b2);
-    StringAddChar(b3);
-  } else if (c <= 0x1fffff) {
-    uint32_t b1 = 0xf0 | ((c >> 18) & 0x07);
-    uint32_t b2 = 0x80 | ((c >> 12) & 0x3f);
-    uint32_t b3 = 0x80 | ((c >> 6) & 0x3f);
-    uint32_t b4 = 0x80 | (c & 0x3f);
-    StringAddChar(b1);
-    StringAddChar(b2);
-    StringAddChar(b3);
-    StringAddChar(b4);
-  }
-}
-
-uint32_t JsonReader::ReadChar() {
-  if (remaining_input_ == 0) return GRPC_JSON_READ_CHAR_EOF;
-  const uint32_t r = *input_++;
-  --remaining_input_;
-  if (r == 0) {
-    remaining_input_ = 0;
-    return GRPC_JSON_READ_CHAR_EOF;
-  }
-  return r;
+#include "src/core/lib/json/json.h" 
+
+#define GRPC_JSON_MAX_DEPTH 255 
+#define GRPC_JSON_MAX_ERRORS 16 
+ 
+namespace grpc_core { 
+ 
+namespace { 
+ 
+class JsonReader { 
+ public: 
+  static grpc_error* Parse(y_absl::string_view input, Json* output); 
+ 
+ private: 
+  enum class Status { 
+    GRPC_JSON_DONE,          /* The parser finished successfully. */ 
+    GRPC_JSON_PARSE_ERROR,   /* The parser found an error in the json stream. */ 
+    GRPC_JSON_INTERNAL_ERROR /* The parser got an internal error. */ 
+  }; 
+ 
+  enum class State { 
+    GRPC_JSON_STATE_OBJECT_KEY_BEGIN, 
+    GRPC_JSON_STATE_OBJECT_KEY_STRING, 
+    GRPC_JSON_STATE_OBJECT_KEY_END, 
+    GRPC_JSON_STATE_VALUE_BEGIN, 
+    GRPC_JSON_STATE_VALUE_STRING, 
+    GRPC_JSON_STATE_STRING_ESCAPE, 
+    GRPC_JSON_STATE_STRING_ESCAPE_U1, 
+    GRPC_JSON_STATE_STRING_ESCAPE_U2, 
+    GRPC_JSON_STATE_STRING_ESCAPE_U3, 
+    GRPC_JSON_STATE_STRING_ESCAPE_U4, 
+    GRPC_JSON_STATE_VALUE_NUMBER, 
+    GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL, 
+    GRPC_JSON_STATE_VALUE_NUMBER_ZERO, 
+    GRPC_JSON_STATE_VALUE_NUMBER_DOT, 
+    GRPC_JSON_STATE_VALUE_NUMBER_E, 
+    GRPC_JSON_STATE_VALUE_NUMBER_EPM, 
+    GRPC_JSON_STATE_VALUE_TRUE_R, 
+    GRPC_JSON_STATE_VALUE_TRUE_U, 
+    GRPC_JSON_STATE_VALUE_TRUE_E, 
+    GRPC_JSON_STATE_VALUE_FALSE_A, 
+    GRPC_JSON_STATE_VALUE_FALSE_L, 
+    GRPC_JSON_STATE_VALUE_FALSE_S, 
+    GRPC_JSON_STATE_VALUE_FALSE_E, 
+    GRPC_JSON_STATE_VALUE_NULL_U, 
+    GRPC_JSON_STATE_VALUE_NULL_L1, 
+    GRPC_JSON_STATE_VALUE_NULL_L2, 
+    GRPC_JSON_STATE_VALUE_END, 
+    GRPC_JSON_STATE_END 
+  }; 
+ 
+  /* The first non-unicode value is 0x110000. But let's pick 
+   * a value high enough to start our error codes from. These 
+   * values are safe to return from the read_char function. 
+   */ 
+  static constexpr uint32_t GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0; 
+ 
+  explicit JsonReader(y_absl::string_view input) 
+      : original_input_(reinterpret_cast<const uint8_t*>(input.data())), 
+        input_(original_input_), 
+        remaining_input_(input.size()) {} 
+ 
+  Status Run(); 
+  uint32_t ReadChar(); 
+  bool IsComplete(); 
+ 
+  size_t CurrentIndex() const { return input_ - original_input_ - 1; } 
+ 
+  void StringAddChar(uint32_t c); 
+  void StringAddUtf32(uint32_t c); 
+ 
+  Json* CreateAndLinkValue(); 
+  bool StartContainer(Json::Type type); 
+  void EndContainer(); 
+  void SetKey(); 
+  void SetString(); 
+  bool SetNumber(); 
+  void SetTrue(); 
+  void SetFalse(); 
+  void SetNull(); 
+
+  const uint8_t* original_input_; 
+  const uint8_t* input_; 
+  size_t remaining_input_; 
+ 
+  State state_ = State::GRPC_JSON_STATE_VALUE_BEGIN; 
+  bool escaped_string_was_key_ = false; 
+  bool container_just_begun_ = false; 
+  uint16_t unicode_char_ = 0; 
+  uint16_t unicode_high_surrogate_ = 0; 
+  std::vector<grpc_error*> errors_; 
+  bool truncated_errors_ = false; 
+ 
+  Json root_value_; 
+  std::vector<Json*> stack_; 
+ 
+  TString key_; 
+  TString string_; 
+}; 
+ 
+void JsonReader::StringAddChar(uint32_t c) { 
+  string_.push_back(static_cast<uint8_t>(c)); 
 }
 
-Json* JsonReader::CreateAndLinkValue() {
-  Json* value;
-  if (stack_.empty()) {
-    value = &root_value_;
-  } else {
-    Json* parent = stack_.back();
-    if (parent->type() == Json::Type::OBJECT) {
-      if (parent->object_value().find(key_) != parent->object_value().end()) {
-        if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
-          truncated_errors_ = true;
-        } else {
-          errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-              y_absl::StrFormat("duplicate key \"%s\" at index %" PRIuPTR, key_,
-                              CurrentIndex())
-                  .c_str()));
-        }
-      }
-      value = &(*parent->mutable_object())[std::move(key_)];
-    } else {
-      GPR_ASSERT(parent->type() == Json::Type::ARRAY);
-      parent->mutable_array()->emplace_back();
-      value = &parent->mutable_array()->back();
-    }
-  }
-  return value;
+void JsonReader::StringAddUtf32(uint32_t c) { 
+  if (c <= 0x7f) { 
+    StringAddChar(c); 
+  } else if (c <= 0x7ff) { 
+    uint32_t b1 = 0xc0 | ((c >> 6) & 0x1f); 
+    uint32_t b2 = 0x80 | (c & 0x3f); 
+    StringAddChar(b1); 
+    StringAddChar(b2); 
+  } else if (c <= 0xffff) { 
+    uint32_t b1 = 0xe0 | ((c >> 12) & 0x0f); 
+    uint32_t b2 = 0x80 | ((c >> 6) & 0x3f); 
+    uint32_t b3 = 0x80 | (c & 0x3f); 
+    StringAddChar(b1); 
+    StringAddChar(b2); 
+    StringAddChar(b3); 
+  } else if (c <= 0x1fffff) { 
+    uint32_t b1 = 0xf0 | ((c >> 18) & 0x07); 
+    uint32_t b2 = 0x80 | ((c >> 12) & 0x3f); 
+    uint32_t b3 = 0x80 | ((c >> 6) & 0x3f); 
+    uint32_t b4 = 0x80 | (c & 0x3f); 
+    StringAddChar(b1); 
+    StringAddChar(b2); 
+    StringAddChar(b3); 
+    StringAddChar(b4); 
+  } 
 }
 
-bool JsonReader::StartContainer(Json::Type type) {
-  if (stack_.size() == GRPC_JSON_MAX_DEPTH) {
-    if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
-      truncated_errors_ = true;
-    } else {
-      errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          y_absl::StrFormat("exceeded max stack depth (%d) at index %" PRIuPTR,
-                          GRPC_JSON_MAX_DEPTH, CurrentIndex())
-              .c_str()));
-    }
-    return false;
-  }
-  Json* value = CreateAndLinkValue();
-  if (type == Json::Type::OBJECT) {
-    *value = Json::Object();
-  } else {
-    GPR_ASSERT(type == Json::Type::ARRAY);
-    *value = Json::Array();
-  }
-  stack_.push_back(value);
-  return true;
+uint32_t JsonReader::ReadChar() { 
+  if (remaining_input_ == 0) return GRPC_JSON_READ_CHAR_EOF; 
+  const uint32_t r = *input_++; 
+  --remaining_input_; 
+  if (r == 0) { 
+    remaining_input_ = 0; 
+    return GRPC_JSON_READ_CHAR_EOF; 
+  } 
+  return r; 
 }
 
-void JsonReader::EndContainer() {
-  GPR_ASSERT(!stack_.empty());
-  stack_.pop_back();
+Json* JsonReader::CreateAndLinkValue() { 
+  Json* value; 
+  if (stack_.empty()) { 
+    value = &root_value_; 
+  } else { 
+    Json* parent = stack_.back(); 
+    if (parent->type() == Json::Type::OBJECT) { 
+      if (parent->object_value().find(key_) != parent->object_value().end()) { 
+        if (errors_.size() == GRPC_JSON_MAX_ERRORS) { 
+          truncated_errors_ = true; 
+        } else { 
+          errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+              y_absl::StrFormat("duplicate key \"%s\" at index %" PRIuPTR, key_, 
+                              CurrentIndex()) 
+                  .c_str())); 
+        } 
+      } 
+      value = &(*parent->mutable_object())[std::move(key_)]; 
+    } else { 
+      GPR_ASSERT(parent->type() == Json::Type::ARRAY); 
+      parent->mutable_array()->emplace_back(); 
+      value = &parent->mutable_array()->back(); 
+    } 
+  } 
+  return value; 
+} 
+ 
+bool JsonReader::StartContainer(Json::Type type) { 
+  if (stack_.size() == GRPC_JSON_MAX_DEPTH) { 
+    if (errors_.size() == GRPC_JSON_MAX_ERRORS) { 
+      truncated_errors_ = true; 
+    } else { 
+      errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+          y_absl::StrFormat("exceeded max stack depth (%d) at index %" PRIuPTR, 
+                          GRPC_JSON_MAX_DEPTH, CurrentIndex()) 
+              .c_str())); 
+    } 
+    return false; 
+  } 
+  Json* value = CreateAndLinkValue(); 
+  if (type == Json::Type::OBJECT) { 
+    *value = Json::Object(); 
+  } else { 
+    GPR_ASSERT(type == Json::Type::ARRAY); 
+    *value = Json::Array(); 
+  } 
+  stack_.push_back(value); 
+  return true; 
+} 
+ 
+void JsonReader::EndContainer() { 
+  GPR_ASSERT(!stack_.empty()); 
+  stack_.pop_back(); 
 }
 
-void JsonReader::SetKey() {
-  key_ = std::move(string_);
-  string_.clear();
+void JsonReader::SetKey() { 
+  key_ = std::move(string_); 
+  string_.clear(); 
 }
 
-void JsonReader::SetString() {
-  Json* value = CreateAndLinkValue();
-  *value = std::move(string_);
-  string_.clear();
+void JsonReader::SetString() { 
+  Json* value = CreateAndLinkValue(); 
+  *value = std::move(string_); 
+  string_.clear(); 
 }
 
-bool JsonReader::SetNumber() {
-  Json* value = CreateAndLinkValue();
-  *value = Json(string_, /*is_number=*/true);
-  string_.clear();
-  return true;
+bool JsonReader::SetNumber() { 
+  Json* value = CreateAndLinkValue(); 
+  *value = Json(string_, /*is_number=*/true); 
+  string_.clear(); 
+  return true; 
 }
 
-void JsonReader::SetTrue() {
-  Json* value = CreateAndLinkValue();
-  *value = true;
-  string_.clear();
+void JsonReader::SetTrue() { 
+  Json* value = CreateAndLinkValue(); 
+  *value = true; 
+  string_.clear(); 
 }
 
-void JsonReader::SetFalse() {
-  Json* value = CreateAndLinkValue();
-  *value = false;
-  string_.clear();
+void JsonReader::SetFalse() { 
+  Json* value = CreateAndLinkValue(); 
+  *value = false; 
+  string_.clear(); 
 }
 
-void JsonReader::SetNull() { CreateAndLinkValue(); }
+void JsonReader::SetNull() { CreateAndLinkValue(); } 
 
-bool JsonReader::IsComplete() {
-  return (stack_.empty() && (state_ == State::GRPC_JSON_STATE_END ||
-                             state_ == State::GRPC_JSON_STATE_VALUE_END));
+bool JsonReader::IsComplete() { 
+  return (stack_.empty() && (state_ == State::GRPC_JSON_STATE_END || 
+                             state_ == State::GRPC_JSON_STATE_VALUE_END)); 
 }
 
-/* Call this function to start parsing the input. It will return the following:
- *    . GRPC_JSON_DONE if the input got eof, and the parsing finished
- *      successfully.
- *    . GRPC_JSON_PARSE_ERROR if the input was somehow invalid.
- *    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid
- *      internal state.
- */
-JsonReader::Status JsonReader::Run() {
-  uint32_t c;
+/* Call this function to start parsing the input. It will return the following: 
+ *    . GRPC_JSON_DONE if the input got eof, and the parsing finished 
+ *      successfully. 
+ *    . GRPC_JSON_PARSE_ERROR if the input was somehow invalid. 
+ *    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid 
+ *      internal state. 
+ */ 
+JsonReader::Status JsonReader::Run() { 
+  uint32_t c; 
 
   /* This state-machine is a strict implementation of ECMA-404 */
-  while (true) {
-    c = ReadChar();
+  while (true) { 
+    c = ReadChar(); 
     switch (c) {
-      /* Let's process the error case first. */
+      /* Let's process the error case first. */ 
       case GRPC_JSON_READ_CHAR_EOF:
-        if (IsComplete()) {
-          return Status::GRPC_JSON_DONE;
+        if (IsComplete()) { 
+          return Status::GRPC_JSON_DONE; 
         } else {
-          return Status::GRPC_JSON_PARSE_ERROR;
+          return Status::GRPC_JSON_PARSE_ERROR; 
         }
         break;
 
@@ -289,33 +289,33 @@ JsonReader::Status JsonReader::Run() {
       case '\t':
       case '\n':
       case '\r':
-        switch (state_) {
-          case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN:
-          case State::GRPC_JSON_STATE_OBJECT_KEY_END:
-          case State::GRPC_JSON_STATE_VALUE_BEGIN:
-          case State::GRPC_JSON_STATE_VALUE_END:
-          case State::GRPC_JSON_STATE_END:
-            break;
-
-          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING:
-          case State::GRPC_JSON_STATE_VALUE_STRING:
-            if (c != ' ') return Status::GRPC_JSON_PARSE_ERROR;
-            if (unicode_high_surrogate_ != 0) {
-              return Status::GRPC_JSON_PARSE_ERROR;
-            }
-            StringAddChar(c);
+        switch (state_) { 
+          case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN: 
+          case State::GRPC_JSON_STATE_OBJECT_KEY_END: 
+          case State::GRPC_JSON_STATE_VALUE_BEGIN: 
+          case State::GRPC_JSON_STATE_VALUE_END: 
+          case State::GRPC_JSON_STATE_END: 
+            break;
+
+          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING: 
+          case State::GRPC_JSON_STATE_VALUE_STRING: 
+            if (c != ' ') return Status::GRPC_JSON_PARSE_ERROR; 
+            if (unicode_high_surrogate_ != 0) { 
+              return Status::GRPC_JSON_PARSE_ERROR; 
+            } 
+            StringAddChar(c); 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_NUMBER:
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM:
-            if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_VALUE_END;
+          case State::GRPC_JSON_STATE_VALUE_NUMBER: 
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL: 
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO: 
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM: 
+            if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_VALUE_END; 
             break;
 
           default:
-            return Status::GRPC_JSON_PARSE_ERROR;
+            return Status::GRPC_JSON_PARSE_ERROR; 
         }
         break;
 
@@ -323,171 +323,171 @@ JsonReader::Status JsonReader::Run() {
       case ',':
       case '}':
       case ']':
-        switch (state_) {
-          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING:
-          case State::GRPC_JSON_STATE_VALUE_STRING:
-            if (unicode_high_surrogate_ != 0) {
-              return Status::GRPC_JSON_PARSE_ERROR;
+        switch (state_) { 
+          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING: 
+          case State::GRPC_JSON_STATE_VALUE_STRING: 
+            if (unicode_high_surrogate_ != 0) { 
+              return Status::GRPC_JSON_PARSE_ERROR; 
             }
-            StringAddChar(c);
-            break;
-
-          case State::GRPC_JSON_STATE_VALUE_NUMBER:
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM:
-            if (stack_.empty()) {
-              return Status::GRPC_JSON_PARSE_ERROR;
-            } else if (c == '}' &&
-                       stack_.back()->type() != Json::Type::OBJECT) {
-              return Status::GRPC_JSON_PARSE_ERROR;
-              return Status::GRPC_JSON_PARSE_ERROR;
-            } else if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) {
-              return Status::GRPC_JSON_PARSE_ERROR;
+            StringAddChar(c); 
+            break;
+
+          case State::GRPC_JSON_STATE_VALUE_NUMBER: 
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL: 
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO: 
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM: 
+            if (stack_.empty()) { 
+              return Status::GRPC_JSON_PARSE_ERROR; 
+            } else if (c == '}' && 
+                       stack_.back()->type() != Json::Type::OBJECT) { 
+              return Status::GRPC_JSON_PARSE_ERROR; 
+              return Status::GRPC_JSON_PARSE_ERROR; 
+            } else if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) { 
+              return Status::GRPC_JSON_PARSE_ERROR; 
             }
-            if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_VALUE_END;
+            if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_VALUE_END; 
             /* The missing break here is intentional. */
             /* fallthrough */
 
-          case State::GRPC_JSON_STATE_VALUE_END:
-          case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN:
-          case State::GRPC_JSON_STATE_VALUE_BEGIN:
+          case State::GRPC_JSON_STATE_VALUE_END: 
+          case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN: 
+          case State::GRPC_JSON_STATE_VALUE_BEGIN: 
             if (c == ',') {
-              if (state_ != State::GRPC_JSON_STATE_VALUE_END) {
-                return Status::GRPC_JSON_PARSE_ERROR;
+              if (state_ != State::GRPC_JSON_STATE_VALUE_END) { 
+                return Status::GRPC_JSON_PARSE_ERROR; 
               }
-              if (!stack_.empty() &&
-                  stack_.back()->type() == Json::Type::OBJECT) {
-                state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN;
-              } else if (!stack_.empty() &&
-                         stack_.back()->type() == Json::Type::ARRAY) {
-                state_ = State::GRPC_JSON_STATE_VALUE_BEGIN;
+              if (!stack_.empty() && 
+                  stack_.back()->type() == Json::Type::OBJECT) { 
+                state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN; 
+              } else if (!stack_.empty() && 
+                         stack_.back()->type() == Json::Type::ARRAY) { 
+                state_ = State::GRPC_JSON_STATE_VALUE_BEGIN; 
               } else {
-                return Status::GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR; 
               }
             } else {
-              if (stack_.empty()) {
-                return Status::GRPC_JSON_PARSE_ERROR;
-              }
-              if (c == '}' && stack_.back()->type() != Json::Type::OBJECT) {
-                return Status::GRPC_JSON_PARSE_ERROR;
+              if (stack_.empty()) { 
+                return Status::GRPC_JSON_PARSE_ERROR; 
               }
-              if (c == '}' &&
-                  state_ == State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN &&
-                  !container_just_begun_) {
-                return Status::GRPC_JSON_PARSE_ERROR;
+              if (c == '}' && stack_.back()->type() != Json::Type::OBJECT) { 
+                return Status::GRPC_JSON_PARSE_ERROR; 
               }
-              if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) {
-                return Status::GRPC_JSON_PARSE_ERROR;
+              if (c == '}' && 
+                  state_ == State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN && 
+                  !container_just_begun_) { 
+                return Status::GRPC_JSON_PARSE_ERROR; 
               }
-              if (c == ']' && state_ == State::GRPC_JSON_STATE_VALUE_BEGIN &&
-                  !container_just_begun_) {
-                return Status::GRPC_JSON_PARSE_ERROR;
-              }
-              state_ = State::GRPC_JSON_STATE_VALUE_END;
-              EndContainer();
-              if (stack_.empty()) {
-                state_ = State::GRPC_JSON_STATE_END;
+              if (c == ']' && stack_.back()->type() != Json::Type::ARRAY) { 
+                return Status::GRPC_JSON_PARSE_ERROR; 
               }
+              if (c == ']' && state_ == State::GRPC_JSON_STATE_VALUE_BEGIN && 
+                  !container_just_begun_) { 
+                return Status::GRPC_JSON_PARSE_ERROR; 
+              } 
+              state_ = State::GRPC_JSON_STATE_VALUE_END; 
+              EndContainer(); 
+              if (stack_.empty()) { 
+                state_ = State::GRPC_JSON_STATE_END; 
+              } 
             }
             break;
 
           default:
-            return Status::GRPC_JSON_PARSE_ERROR;
+            return Status::GRPC_JSON_PARSE_ERROR; 
         }
         break;
 
       /* In-string escaping. */
       case '\\':
-        switch (state_) {
-          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING:
-            escaped_string_was_key_ = true;
-            state_ = State::GRPC_JSON_STATE_STRING_ESCAPE;
+        switch (state_) { 
+          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING: 
+            escaped_string_was_key_ = true; 
+            state_ = State::GRPC_JSON_STATE_STRING_ESCAPE; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_STRING:
-            escaped_string_was_key_ = false;
-            state_ = State::GRPC_JSON_STATE_STRING_ESCAPE;
+          case State::GRPC_JSON_STATE_VALUE_STRING: 
+            escaped_string_was_key_ = false; 
+            state_ = State::GRPC_JSON_STATE_STRING_ESCAPE; 
             break;
 
           /* This is the \\ case. */
-          case State::GRPC_JSON_STATE_STRING_ESCAPE:
-            if (unicode_high_surrogate_ != 0)
-              return Status::GRPC_JSON_PARSE_ERROR;
-            StringAddChar('\\');
-            if (escaped_string_was_key_) {
-              state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
+          case State::GRPC_JSON_STATE_STRING_ESCAPE: 
+            if (unicode_high_surrogate_ != 0) 
+              return Status::GRPC_JSON_PARSE_ERROR; 
+            StringAddChar('\\'); 
+            if (escaped_string_was_key_) { 
+              state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING; 
             } else {
-              state_ = State::GRPC_JSON_STATE_VALUE_STRING;
+              state_ = State::GRPC_JSON_STATE_VALUE_STRING; 
             }
             break;
 
           default:
-            return Status::GRPC_JSON_PARSE_ERROR;
+            return Status::GRPC_JSON_PARSE_ERROR; 
         }
         break;
 
       default:
-        container_just_begun_ = false;
-        switch (state_) {
-          case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN:
-            if (c != '"') return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
+        container_just_begun_ = false; 
+        switch (state_) { 
+          case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN: 
+            if (c != '"') return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING; 
             break;
 
-          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING:
-            if (unicode_high_surrogate_ != 0) {
-              return Status::GRPC_JSON_PARSE_ERROR;
+          case State::GRPC_JSON_STATE_OBJECT_KEY_STRING: 
+            if (unicode_high_surrogate_ != 0) { 
+              return Status::GRPC_JSON_PARSE_ERROR; 
             }
             if (c == '"') {
-              state_ = State::GRPC_JSON_STATE_OBJECT_KEY_END;
-              SetKey();
+              state_ = State::GRPC_JSON_STATE_OBJECT_KEY_END; 
+              SetKey(); 
             } else {
-              if (c < 32) return Status::GRPC_JSON_PARSE_ERROR;
-              StringAddChar(c);
+              if (c < 32) return Status::GRPC_JSON_PARSE_ERROR; 
+              StringAddChar(c); 
             }
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_STRING:
-            if (unicode_high_surrogate_ != 0) {
-              return Status::GRPC_JSON_PARSE_ERROR;
+          case State::GRPC_JSON_STATE_VALUE_STRING: 
+            if (unicode_high_surrogate_ != 0) { 
+              return Status::GRPC_JSON_PARSE_ERROR; 
             }
             if (c == '"') {
-              state_ = State::GRPC_JSON_STATE_VALUE_END;
-              SetString();
+              state_ = State::GRPC_JSON_STATE_VALUE_END; 
+              SetString(); 
             } else {
-              if (c < 32) return Status::GRPC_JSON_PARSE_ERROR;
-              StringAddChar(c);
+              if (c < 32) return Status::GRPC_JSON_PARSE_ERROR; 
+              StringAddChar(c); 
             }
             break;
 
-          case State::GRPC_JSON_STATE_OBJECT_KEY_END:
-            if (c != ':') return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_VALUE_BEGIN;
+          case State::GRPC_JSON_STATE_OBJECT_KEY_END: 
+            if (c != ':') return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_VALUE_BEGIN; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_BEGIN:
+          case State::GRPC_JSON_STATE_VALUE_BEGIN: 
             switch (c) {
               case 't':
-                state_ = State::GRPC_JSON_STATE_VALUE_TRUE_R;
+                state_ = State::GRPC_JSON_STATE_VALUE_TRUE_R; 
                 break;
 
               case 'f':
-                state_ = State::GRPC_JSON_STATE_VALUE_FALSE_A;
+                state_ = State::GRPC_JSON_STATE_VALUE_FALSE_A; 
                 break;
 
               case 'n':
-                state_ = State::GRPC_JSON_STATE_VALUE_NULL_U;
+                state_ = State::GRPC_JSON_STATE_VALUE_NULL_U; 
                 break;
 
               case '"':
-                state_ = State::GRPC_JSON_STATE_VALUE_STRING;
+                state_ = State::GRPC_JSON_STATE_VALUE_STRING; 
                 break;
 
               case '0':
-                StringAddChar(c);
-                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO;
+                StringAddChar(c); 
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO; 
                 break;
 
               case '1':
@@ -500,71 +500,71 @@ JsonReader::Status JsonReader::Run() {
               case '8':
               case '9':
               case '-':
-                StringAddChar(c);
-                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER;
+                StringAddChar(c); 
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER; 
                 break;
 
               case '{':
-                container_just_begun_ = true;
-                if (!StartContainer(Json::Type::OBJECT)) {
-                  return Status::GRPC_JSON_PARSE_ERROR;
-                }
-                state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN;
+                container_just_begun_ = true; 
+                if (!StartContainer(Json::Type::OBJECT)) { 
+                  return Status::GRPC_JSON_PARSE_ERROR; 
+                } 
+                state_ = State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN; 
                 break;
 
               case '[':
-                container_just_begun_ = true;
-                if (!StartContainer(Json::Type::ARRAY)) {
-                  return Status::GRPC_JSON_PARSE_ERROR;
-                }
+                container_just_begun_ = true; 
+                if (!StartContainer(Json::Type::ARRAY)) { 
+                  return Status::GRPC_JSON_PARSE_ERROR; 
+                } 
                 break;
               default:
-                return Status::GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR; 
             }
             break;
 
-          case State::GRPC_JSON_STATE_STRING_ESCAPE:
-            if (escaped_string_was_key_) {
-              state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
+          case State::GRPC_JSON_STATE_STRING_ESCAPE: 
+            if (escaped_string_was_key_) { 
+              state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING; 
             } else {
-              state_ = State::GRPC_JSON_STATE_VALUE_STRING;
+              state_ = State::GRPC_JSON_STATE_VALUE_STRING; 
             }
-            if (unicode_high_surrogate_ && c != 'u') {
-              return Status::GRPC_JSON_PARSE_ERROR;
+            if (unicode_high_surrogate_ && c != 'u') { 
+              return Status::GRPC_JSON_PARSE_ERROR; 
             }
             switch (c) {
               case '"':
               case '/':
-                StringAddChar(c);
+                StringAddChar(c); 
                 break;
               case 'b':
-                StringAddChar('\b');
+                StringAddChar('\b'); 
                 break;
               case 'f':
-                StringAddChar('\f');
+                StringAddChar('\f'); 
                 break;
               case 'n':
-                StringAddChar('\n');
+                StringAddChar('\n'); 
                 break;
               case 'r':
-                StringAddChar('\r');
+                StringAddChar('\r'); 
                 break;
               case 't':
-                StringAddChar('\t');
+                StringAddChar('\t'); 
                 break;
               case 'u':
-                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U1;
-                unicode_char_ = 0;
+                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U1; 
+                unicode_char_ = 0; 
                 break;
               default:
-                return Status::GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR; 
             }
             break;
 
-          case State::GRPC_JSON_STATE_STRING_ESCAPE_U1:
-          case State::GRPC_JSON_STATE_STRING_ESCAPE_U2:
-          case State::GRPC_JSON_STATE_STRING_ESCAPE_U3:
-          case State::GRPC_JSON_STATE_STRING_ESCAPE_U4:
+          case State::GRPC_JSON_STATE_STRING_ESCAPE_U1: 
+          case State::GRPC_JSON_STATE_STRING_ESCAPE_U2: 
+          case State::GRPC_JSON_STATE_STRING_ESCAPE_U3: 
+          case State::GRPC_JSON_STATE_STRING_ESCAPE_U4: 
             if ((c >= '0') && (c <= '9')) {
               c -= '0';
             } else if ((c >= 'A') && (c <= 'F')) {
@@ -572,60 +572,60 @@ JsonReader::Status JsonReader::Run() {
             } else if ((c >= 'a') && (c <= 'f')) {
               c -= 'a' - 10;
             } else {
-              return Status::GRPC_JSON_PARSE_ERROR;
+              return Status::GRPC_JSON_PARSE_ERROR; 
             }
-            unicode_char_ = static_cast<uint16_t>(unicode_char_ << 4);
-            unicode_char_ = static_cast<uint16_t>(unicode_char_ | c);
+            unicode_char_ = static_cast<uint16_t>(unicode_char_ << 4); 
+            unicode_char_ = static_cast<uint16_t>(unicode_char_ | c); 
 
-            switch (state_) {
-              case State::GRPC_JSON_STATE_STRING_ESCAPE_U1:
-                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U2;
+            switch (state_) { 
+              case State::GRPC_JSON_STATE_STRING_ESCAPE_U1: 
+                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U2; 
                 break;
-              case State::GRPC_JSON_STATE_STRING_ESCAPE_U2:
-                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U3;
+              case State::GRPC_JSON_STATE_STRING_ESCAPE_U2: 
+                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U3; 
                 break;
-              case State::GRPC_JSON_STATE_STRING_ESCAPE_U3:
-                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U4;
+              case State::GRPC_JSON_STATE_STRING_ESCAPE_U3: 
+                state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U4; 
                 break;
-              case State::GRPC_JSON_STATE_STRING_ESCAPE_U4:
+              case State::GRPC_JSON_STATE_STRING_ESCAPE_U4: 
                 /* See grpc_json_writer_escape_string to have a description
                  * of what's going on here.
                  */
-                if ((unicode_char_ & 0xfc00) == 0xd800) {
+                if ((unicode_char_ & 0xfc00) == 0xd800) { 
                   /* high surrogate utf-16 */
-                  if (unicode_high_surrogate_ != 0)
-                    return Status::GRPC_JSON_PARSE_ERROR;
-                  unicode_high_surrogate_ = unicode_char_;
-                } else if ((unicode_char_ & 0xfc00) == 0xdc00) {
+                  if (unicode_high_surrogate_ != 0) 
+                    return Status::GRPC_JSON_PARSE_ERROR; 
+                  unicode_high_surrogate_ = unicode_char_; 
+                } else if ((unicode_char_ & 0xfc00) == 0xdc00) { 
                   /* low surrogate utf-16 */
                   uint32_t utf32;
-                  if (unicode_high_surrogate_ == 0)
-                    return Status::GRPC_JSON_PARSE_ERROR;
+                  if (unicode_high_surrogate_ == 0) 
+                    return Status::GRPC_JSON_PARSE_ERROR; 
                   utf32 = 0x10000;
                   utf32 += static_cast<uint32_t>(
-                      (unicode_high_surrogate_ - 0xd800) * 0x400);
-                  utf32 += static_cast<uint32_t>(unicode_char_ - 0xdc00);
-                  StringAddUtf32(utf32);
-                  unicode_high_surrogate_ = 0;
+                      (unicode_high_surrogate_ - 0xd800) * 0x400); 
+                  utf32 += static_cast<uint32_t>(unicode_char_ - 0xdc00); 
+                  StringAddUtf32(utf32); 
+                  unicode_high_surrogate_ = 0; 
                 } else {
                   /* anything else */
-                  if (unicode_high_surrogate_ != 0)
-                    return Status::GRPC_JSON_PARSE_ERROR;
-                  StringAddUtf32(unicode_char_);
+                  if (unicode_high_surrogate_ != 0) 
+                    return Status::GRPC_JSON_PARSE_ERROR; 
+                  StringAddUtf32(unicode_char_); 
                 }
-                if (escaped_string_was_key_) {
-                  state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
+                if (escaped_string_was_key_) { 
+                  state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING; 
                 } else {
-                  state_ = State::GRPC_JSON_STATE_VALUE_STRING;
+                  state_ = State::GRPC_JSON_STATE_VALUE_STRING; 
                 }
                 break;
               default:
-                GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR);
+                GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR); 
             }
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_NUMBER:
-            StringAddChar(c);
+          case State::GRPC_JSON_STATE_VALUE_NUMBER: 
+            StringAddChar(c); 
             switch (c) {
               case '0':
               case '1':
@@ -640,18 +640,18 @@ JsonReader::Status JsonReader::Run() {
                 break;
               case 'e':
               case 'E':
-                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_E;
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_E; 
                 break;
               case '.':
-                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_DOT;
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_DOT; 
                 break;
               default:
-                return Status::GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR; 
             }
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
-            StringAddChar(c);
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL: 
+            StringAddChar(c); 
             switch (c) {
               case '0':
               case '1':
@@ -666,21 +666,21 @@ JsonReader::Status JsonReader::Run() {
                 break;
               case 'e':
               case 'E':
-                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_E;
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_E; 
                 break;
               default:
-                return Status::GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR; 
             }
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
-            if (c != '.') return Status::GRPC_JSON_PARSE_ERROR;
-            StringAddChar(c);
-            state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_DOT;
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO: 
+            if (c != '.') return Status::GRPC_JSON_PARSE_ERROR; 
+            StringAddChar(c); 
+            state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_DOT; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_DOT:
-            StringAddChar(c);
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_DOT: 
+            StringAddChar(c); 
             switch (c) {
               case '0':
               case '1':
@@ -692,15 +692,15 @@ JsonReader::Status JsonReader::Run() {
               case '7':
               case '8':
               case '9':
-                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL;
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL; 
                 break;
               default:
-                return Status::GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR; 
             }
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_E:
-            StringAddChar(c);
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_E: 
+            StringAddChar(c); 
             switch (c) {
               case '0':
               case '1':
@@ -714,15 +714,15 @@ JsonReader::Status JsonReader::Run() {
               case '9':
               case '+':
               case '-':
-                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_EPM;
+                state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_EPM; 
                 break;
               default:
-                return Status::GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR; 
             }
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM:
-            StringAddChar(c);
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM: 
+            StringAddChar(c); 
             switch (c) {
               case '0':
               case '1':
@@ -736,119 +736,119 @@ JsonReader::Status JsonReader::Run() {
               case '9':
                 break;
               default:
-                return Status::GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR; 
             }
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_TRUE_R:
-            if (c != 'r') return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_VALUE_TRUE_U;
+          case State::GRPC_JSON_STATE_VALUE_TRUE_R: 
+            if (c != 'r') return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_VALUE_TRUE_U; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_TRUE_U:
-            if (c != 'u') return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_VALUE_TRUE_E;
+          case State::GRPC_JSON_STATE_VALUE_TRUE_U: 
+            if (c != 'u') return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_VALUE_TRUE_E; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_TRUE_E:
-            if (c != 'e') return Status::GRPC_JSON_PARSE_ERROR;
-            SetTrue();
-            state_ = State::GRPC_JSON_STATE_VALUE_END;
+          case State::GRPC_JSON_STATE_VALUE_TRUE_E: 
+            if (c != 'e') return Status::GRPC_JSON_PARSE_ERROR; 
+            SetTrue(); 
+            state_ = State::GRPC_JSON_STATE_VALUE_END; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_FALSE_A:
-            if (c != 'a') return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_VALUE_FALSE_L;
+          case State::GRPC_JSON_STATE_VALUE_FALSE_A: 
+            if (c != 'a') return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_VALUE_FALSE_L; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_FALSE_L:
-            if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_VALUE_FALSE_S;
+          case State::GRPC_JSON_STATE_VALUE_FALSE_L: 
+            if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_VALUE_FALSE_S; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_FALSE_S:
-            if (c != 's') return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_VALUE_FALSE_E;
+          case State::GRPC_JSON_STATE_VALUE_FALSE_S: 
+            if (c != 's') return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_VALUE_FALSE_E; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_FALSE_E:
-            if (c != 'e') return Status::GRPC_JSON_PARSE_ERROR;
-            SetFalse();
-            state_ = State::GRPC_JSON_STATE_VALUE_END;
+          case State::GRPC_JSON_STATE_VALUE_FALSE_E: 
+            if (c != 'e') return Status::GRPC_JSON_PARSE_ERROR; 
+            SetFalse(); 
+            state_ = State::GRPC_JSON_STATE_VALUE_END; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_NULL_U:
-            if (c != 'u') return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_VALUE_NULL_L1;
+          case State::GRPC_JSON_STATE_VALUE_NULL_U: 
+            if (c != 'u') return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_VALUE_NULL_L1; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_NULL_L1:
-            if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR;
-            state_ = State::GRPC_JSON_STATE_VALUE_NULL_L2;
+          case State::GRPC_JSON_STATE_VALUE_NULL_L1: 
+            if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR; 
+            state_ = State::GRPC_JSON_STATE_VALUE_NULL_L2; 
             break;
 
-          case State::GRPC_JSON_STATE_VALUE_NULL_L2:
-            if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR;
-            SetNull();
-            state_ = State::GRPC_JSON_STATE_VALUE_END;
+          case State::GRPC_JSON_STATE_VALUE_NULL_L2: 
+            if (c != 'l') return Status::GRPC_JSON_PARSE_ERROR; 
+            SetNull(); 
+            state_ = State::GRPC_JSON_STATE_VALUE_END; 
             break;
 
           /* All of the VALUE_END cases are handled in the specialized case
            * above. */
-          case State::GRPC_JSON_STATE_VALUE_END:
+          case State::GRPC_JSON_STATE_VALUE_END: 
             switch (c) {
               case ',':
               case '}':
               case ']':
-                GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR);
+                GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR); 
                 break;
 
               default:
-                return Status::GRPC_JSON_PARSE_ERROR;
+                return Status::GRPC_JSON_PARSE_ERROR; 
             }
             break;
 
-          case State::GRPC_JSON_STATE_END:
-            return Status::GRPC_JSON_PARSE_ERROR;
+          case State::GRPC_JSON_STATE_END: 
+            return Status::GRPC_JSON_PARSE_ERROR; 
         }
     }
   }
 
-  GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR);
-}
-
-grpc_error* JsonReader::Parse(y_absl::string_view input, Json* output) {
-  JsonReader reader(input);
-  Status status = reader.Run();
-  if (reader.truncated_errors_) {
-    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "too many errors encountered during JSON parsing -- fix reported "
-        "errors and try again to see additional errors"));
-  }
-  if (status == Status::GRPC_JSON_INTERNAL_ERROR) {
-    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat("internal error in JSON parser at index ",
-                     reader.CurrentIndex())
-            .c_str()));
-  } else if (status == Status::GRPC_JSON_PARSE_ERROR) {
-    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat("JSON parse error at index ", reader.CurrentIndex())
-            .c_str()));
-  }
-  if (!reader.errors_.empty()) {
-    return GRPC_ERROR_CREATE_FROM_VECTOR("JSON parsing failed",
-                                         &reader.errors_);
-  }
-  *output = std::move(reader.root_value_);
-  return GRPC_ERROR_NONE;
-}
-
-}  // namespace
-
-Json Json::Parse(y_absl::string_view json_str, grpc_error** error) {
-  Json value;
-  *error = JsonReader::Parse(json_str, &value);
-  return value;
+  GPR_UNREACHABLE_CODE(return Status::GRPC_JSON_INTERNAL_ERROR); 
 }
-
-}  // namespace grpc_core
+ 
+grpc_error* JsonReader::Parse(y_absl::string_view input, Json* output) { 
+  JsonReader reader(input); 
+  Status status = reader.Run(); 
+  if (reader.truncated_errors_) { 
+    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING( 
+        "too many errors encountered during JSON parsing -- fix reported " 
+        "errors and try again to see additional errors")); 
+  } 
+  if (status == Status::GRPC_JSON_INTERNAL_ERROR) { 
+    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat("internal error in JSON parser at index ", 
+                     reader.CurrentIndex()) 
+            .c_str())); 
+  } else if (status == Status::GRPC_JSON_PARSE_ERROR) { 
+    reader.errors_.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat("JSON parse error at index ", reader.CurrentIndex()) 
+            .c_str())); 
+  } 
+  if (!reader.errors_.empty()) { 
+    return GRPC_ERROR_CREATE_FROM_VECTOR("JSON parsing failed", 
+                                         &reader.errors_); 
+  } 
+  *output = std::move(reader.root_value_); 
+  return GRPC_ERROR_NONE; 
+} 
+ 
+}  // namespace 
+ 
+Json Json::Parse(y_absl::string_view json_str, grpc_error** error) { 
+  Json value; 
+  *error = JsonReader::Parse(json_str, &value); 
+  return value; 
+} 
+ 
+}  // namespace grpc_core 
diff --git a/contrib/libs/grpc/src/core/lib/json/json_util.cc b/contrib/libs/grpc/src/core/lib/json/json_util.cc
index 1c90aeb5b4..44e0f4bd4e 100644
--- a/contrib/libs/grpc/src/core/lib/json/json_util.cc
+++ b/contrib/libs/grpc/src/core/lib/json/json_util.cc
@@ -1,58 +1,58 @@
-//
-//
-// 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.
-//
-//
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/json/json_util.h"
-
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/string.h"
-
-namespace grpc_core {
-
-bool ParseDurationFromJson(const Json& field, grpc_millis* duration) {
-  if (field.type() != Json::Type::STRING) return false;
-  size_t len = field.string_value().size();
-  if (field.string_value()[len - 1] != 's') return false;
-  grpc_core::UniquePtr<char> buf(gpr_strdup(field.string_value().c_str()));
-  *(buf.get() + len - 1) = '\0';  // Remove trailing 's'.
-  char* decimal_point = strchr(buf.get(), '.');
-  int nanos = 0;
-  if (decimal_point != nullptr) {
-    *decimal_point = '\0';
-    nanos = gpr_parse_nonnegative_int(decimal_point + 1);
-    if (nanos == -1) {
-      return false;
-    }
-    int num_digits = static_cast<int>(strlen(decimal_point + 1));
-    if (num_digits > 9) {  // We don't accept greater precision than nanos.
-      return false;
-    }
-    for (int i = 0; i < (9 - num_digits); ++i) {
-      nanos *= 10;
-    }
-  }
-  int seconds =
-      decimal_point == buf.get() ? 0 : gpr_parse_nonnegative_int(buf.get());
-  if (seconds == -1) return false;
-  *duration = seconds * GPR_MS_PER_SEC + nanos / GPR_NS_PER_MS;
-  return true;
-}
-
-}  // namespace grpc_core
+// 
+// 
+// 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. 
+// 
+// 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/json/json_util.h" 
+ 
+#include <grpc/support/string_util.h> 
+ 
+#include "src/core/lib/gpr/string.h" 
+ 
+namespace grpc_core { 
+ 
+bool ParseDurationFromJson(const Json& field, grpc_millis* duration) { 
+  if (field.type() != Json::Type::STRING) return false; 
+  size_t len = field.string_value().size(); 
+  if (field.string_value()[len - 1] != 's') return false; 
+  grpc_core::UniquePtr<char> buf(gpr_strdup(field.string_value().c_str())); 
+  *(buf.get() + len - 1) = '\0';  // Remove trailing 's'. 
+  char* decimal_point = strchr(buf.get(), '.'); 
+  int nanos = 0; 
+  if (decimal_point != nullptr) { 
+    *decimal_point = '\0'; 
+    nanos = gpr_parse_nonnegative_int(decimal_point + 1); 
+    if (nanos == -1) { 
+      return false; 
+    } 
+    int num_digits = static_cast<int>(strlen(decimal_point + 1)); 
+    if (num_digits > 9) {  // We don't accept greater precision than nanos. 
+      return false; 
+    } 
+    for (int i = 0; i < (9 - num_digits); ++i) { 
+      nanos *= 10; 
+    } 
+  } 
+  int seconds = 
+      decimal_point == buf.get() ? 0 : gpr_parse_nonnegative_int(buf.get()); 
+  if (seconds == -1) return false; 
+  *duration = seconds * GPR_MS_PER_SEC + nanos / GPR_NS_PER_MS; 
+  return true; 
+} 
+ 
+}  // namespace grpc_core 
diff --git a/contrib/libs/grpc/src/core/lib/json/json_util.h b/contrib/libs/grpc/src/core/lib/json/json_util.h
index 071087f765..cec3eb8ff5 100644
--- a/contrib/libs/grpc/src/core/lib/json/json_util.h
+++ b/contrib/libs/grpc/src/core/lib/json/json_util.h
@@ -1,37 +1,37 @@
-//
-//
-// 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_CORE_LIB_JSON_JSON_UTIL_H
-#define GRPC_CORE_LIB_JSON_JSON_UTIL_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/json/json.h"
-
-namespace grpc_core {
-
-// Parses a JSON field of the form generated for a google.proto.Duration
-// proto message, as per:
-//   https://developers.google.com/protocol-buffers/docs/proto3#json
-// Returns true on success, false otherwise.
-bool ParseDurationFromJson(const Json& field, grpc_millis* duration);
-
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_JSON_JSON_UTIL_H
+// 
+// 
+// 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_CORE_LIB_JSON_JSON_UTIL_H 
+#define GRPC_CORE_LIB_JSON_JSON_UTIL_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/iomgr/exec_ctx.h" 
+#include "src/core/lib/json/json.h" 
+ 
+namespace grpc_core { 
+ 
+// Parses a JSON field of the form generated for a google.proto.Duration 
+// proto message, as per: 
+//   https://developers.google.com/protocol-buffers/docs/proto3#json 
+// Returns true on success, false otherwise. 
+bool ParseDurationFromJson(const Json& field, grpc_millis* duration); 
+ 
+}  // namespace grpc_core 
+ 
+#endif  // GRPC_CORE_LIB_JSON_JSON_UTIL_H 
diff --git a/contrib/libs/grpc/src/core/lib/json/json_writer.cc b/contrib/libs/grpc/src/core/lib/json/json_writer.cc
index f2043d55a0..a6e02a5f94 100644
--- a/contrib/libs/grpc/src/core/lib/json/json_writer.cc
+++ b/contrib/libs/grpc/src/core/lib/json/json_writer.cc
@@ -18,155 +18,155 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdlib.h>
+#include <stdlib.h> 
 #include <string.h>
 
-#include "y_absl/strings/string_view.h"
+#include "y_absl/strings/string_view.h" 
+ 
+#include <grpc/support/alloc.h> 
+#include <grpc/support/log.h> 
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/json/json.h"
-
-namespace grpc_core {
-
-namespace {
-
-/* The idea of the writer is basically symmetrical of the reader. While the
- * reader emits various calls to your code, the writer takes basically the
- * same calls and emit json out of it. It doesn't try to make any check on
- * the order of the calls you do on it. Meaning you can theorically force
- * it to generate invalid json.
- *
- * Also, unlike the reader, the writer expects UTF-8 encoded input strings.
- * These strings will be UTF-8 validated, and any invalid character will
- * cut the conversion short, before any invalid UTF-8 sequence, thus forming
- * a valid UTF-8 string overall.
- */
-class JsonWriter {
- public:
-  static TString Dump(const Json& value, int indent);
-
- private:
-  explicit JsonWriter(int indent) : indent_(indent) {}
-
-  void OutputCheck(size_t needed);
-  void OutputChar(char c);
-  void OutputString(const y_absl::string_view str);
-  void OutputIndent();
-  void ValueEnd();
-  void EscapeUtf16(uint16_t utf16);
-  void EscapeString(const TString& string);
-  void ContainerBegins(Json::Type type);
-  void ContainerEnds(Json::Type type);
-  void ObjectKey(const TString& string);
-  void ValueRaw(const TString& string);
-  void ValueString(const TString& string);
-
-  void DumpObject(const Json::Object& object);
-  void DumpArray(const Json::Array& array);
-  void DumpValue(const Json& value);
-
-  int indent_;
-  int depth_ = 0;
-  bool container_empty_ = true;
-  bool got_key_ = false;
-  TString output_;
-};
-
-/* This function checks if there's enough space left in the output buffer,
- * and will enlarge it if necessary. We're only allocating chunks of 256
- * bytes at a time (or multiples thereof).
- */
-void JsonWriter::OutputCheck(size_t needed) {
-  size_t free_space = output_.capacity() - output_.size();
-  if (free_space >= needed) return;
-  needed -= free_space;
-  /* Round up by 256 bytes. */
-  needed = (needed + 0xff) & ~0xffU;
-  output_.reserve(output_.capacity() + needed);
+#include "src/core/lib/json/json.h" 
+ 
+namespace grpc_core { 
+ 
+namespace { 
+ 
+/* The idea of the writer is basically symmetrical of the reader. While the 
+ * reader emits various calls to your code, the writer takes basically the 
+ * same calls and emit json out of it. It doesn't try to make any check on 
+ * the order of the calls you do on it. Meaning you can theorically force 
+ * it to generate invalid json. 
+ * 
+ * Also, unlike the reader, the writer expects UTF-8 encoded input strings. 
+ * These strings will be UTF-8 validated, and any invalid character will 
+ * cut the conversion short, before any invalid UTF-8 sequence, thus forming 
+ * a valid UTF-8 string overall. 
+ */ 
+class JsonWriter { 
+ public: 
+  static TString Dump(const Json& value, int indent); 
+ 
+ private: 
+  explicit JsonWriter(int indent) : indent_(indent) {} 
+ 
+  void OutputCheck(size_t needed); 
+  void OutputChar(char c); 
+  void OutputString(const y_absl::string_view str); 
+  void OutputIndent(); 
+  void ValueEnd(); 
+  void EscapeUtf16(uint16_t utf16); 
+  void EscapeString(const TString& string); 
+  void ContainerBegins(Json::Type type); 
+  void ContainerEnds(Json::Type type); 
+  void ObjectKey(const TString& string); 
+  void ValueRaw(const TString& string); 
+  void ValueString(const TString& string); 
+ 
+  void DumpObject(const Json::Object& object); 
+  void DumpArray(const Json::Array& array); 
+  void DumpValue(const Json& value); 
+ 
+  int indent_; 
+  int depth_ = 0; 
+  bool container_empty_ = true; 
+  bool got_key_ = false; 
+  TString output_; 
+}; 
+ 
+/* This function checks if there's enough space left in the output buffer, 
+ * and will enlarge it if necessary. We're only allocating chunks of 256 
+ * bytes at a time (or multiples thereof). 
+ */ 
+void JsonWriter::OutputCheck(size_t needed) { 
+  size_t free_space = output_.capacity() - output_.size(); 
+  if (free_space >= needed) return; 
+  needed -= free_space; 
+  /* Round up by 256 bytes. */ 
+  needed = (needed + 0xff) & ~0xffU; 
+  output_.reserve(output_.capacity() + needed); 
 }
 
-void JsonWriter::OutputChar(char c) {
-  OutputCheck(1);
-  output_.push_back(c);
+void JsonWriter::OutputChar(char c) { 
+  OutputCheck(1); 
+  output_.push_back(c); 
 }
 
-void JsonWriter::OutputString(const y_absl::string_view str) {
-  OutputCheck(str.size());
-  output_.append(str.data(), str.size());
+void JsonWriter::OutputString(const y_absl::string_view str) { 
+  OutputCheck(str.size()); 
+  output_.append(str.data(), str.size()); 
 }
 
-void JsonWriter::OutputIndent() {
+void JsonWriter::OutputIndent() { 
   static const char spacesstr[] =
       "                "
       "                "
       "                "
       "                ";
-  unsigned spaces = static_cast<unsigned>(depth_ * indent_);
-  if (indent_ == 0) return;
-  if (got_key_) {
-    OutputChar(' ');
+  unsigned spaces = static_cast<unsigned>(depth_ * indent_); 
+  if (indent_ == 0) return; 
+  if (got_key_) { 
+    OutputChar(' '); 
     return;
   }
   while (spaces >= (sizeof(spacesstr) - 1)) {
-    OutputString(y_absl::string_view(spacesstr, sizeof(spacesstr) - 1));
+    OutputString(y_absl::string_view(spacesstr, sizeof(spacesstr) - 1)); 
     spaces -= static_cast<unsigned>(sizeof(spacesstr) - 1);
   }
   if (spaces == 0) return;
-  OutputString(
-      y_absl::string_view(spacesstr + sizeof(spacesstr) - 1 - spaces, spaces));
+  OutputString( 
+      y_absl::string_view(spacesstr + sizeof(spacesstr) - 1 - spaces, spaces)); 
 }
 
-void JsonWriter::ValueEnd() {
-  if (container_empty_) {
-    container_empty_ = false;
-    if (indent_ == 0 || depth_ == 0) return;
-    OutputChar('\n');
+void JsonWriter::ValueEnd() { 
+  if (container_empty_) { 
+    container_empty_ = false; 
+    if (indent_ == 0 || depth_ == 0) return; 
+    OutputChar('\n'); 
   } else {
-    OutputChar(',');
-    if (indent_ == 0) return;
-    OutputChar('\n');
+    OutputChar(','); 
+    if (indent_ == 0) return; 
+    OutputChar('\n'); 
   }
 }
 
-void JsonWriter::EscapeUtf16(uint16_t utf16) {
+void JsonWriter::EscapeUtf16(uint16_t utf16) { 
   static const char hex[] = "0123456789abcdef";
-  OutputString(y_absl::string_view("\\u", 2));
-  OutputChar(hex[(utf16 >> 12) & 0x0f]);
-  OutputChar(hex[(utf16 >> 8) & 0x0f]);
-  OutputChar(hex[(utf16 >> 4) & 0x0f]);
-  OutputChar(hex[(utf16)&0x0f]);
+  OutputString(y_absl::string_view("\\u", 2)); 
+  OutputChar(hex[(utf16 >> 12) & 0x0f]); 
+  OutputChar(hex[(utf16 >> 8) & 0x0f]); 
+  OutputChar(hex[(utf16 >> 4) & 0x0f]); 
+  OutputChar(hex[(utf16)&0x0f]); 
 }
 
-void JsonWriter::EscapeString(const TString& string) {
-  OutputChar('"');
-  for (size_t idx = 0; idx < string.size(); ++idx) {
-    uint8_t c = static_cast<uint8_t>(string[idx]);
+void JsonWriter::EscapeString(const TString& string) { 
+  OutputChar('"'); 
+  for (size_t idx = 0; idx < string.size(); ++idx) { 
+    uint8_t c = static_cast<uint8_t>(string[idx]); 
     if (c == 0) {
       break;
-    } else if (c >= 32 && c <= 126) {
-      if (c == '\\' || c == '"') OutputChar('\\');
-      OutputChar(static_cast<char>(c));
-    } else if (c < 32 || c == 127) {
+    } else if (c >= 32 && c <= 126) { 
+      if (c == '\\' || c == '"') OutputChar('\\'); 
+      OutputChar(static_cast<char>(c)); 
+    } else if (c < 32 || c == 127) { 
       switch (c) {
         case '\b':
-          OutputString(y_absl::string_view("\\b", 2));
+          OutputString(y_absl::string_view("\\b", 2)); 
           break;
         case '\f':
-          OutputString(y_absl::string_view("\\f", 2));
+          OutputString(y_absl::string_view("\\f", 2)); 
           break;
         case '\n':
-          OutputString(y_absl::string_view("\\n", 2));
+          OutputString(y_absl::string_view("\\n", 2)); 
           break;
         case '\r':
-          OutputString(y_absl::string_view("\\r", 2));
+          OutputString(y_absl::string_view("\\r", 2)); 
           break;
         case '\t':
-          OutputString(y_absl::string_view("\\t", 2));
+          OutputString(y_absl::string_view("\\t", 2)); 
           break;
         default:
-          EscapeUtf16(c);
+          EscapeUtf16(c); 
           break;
       }
     } else {
@@ -188,13 +188,13 @@ void JsonWriter::EscapeString(const TString& string) {
       }
       for (i = 0; i < extra; i++) {
         utf32 <<= 6;
-        ++idx;
-        /* Breaks out and bail if we hit the end of the string. */
-        if (idx == string.size()) {
-          valid = 0;
-          break;
-        }
-        c = static_cast<uint8_t>(string[idx]);
+        ++idx; 
+        /* Breaks out and bail if we hit the end of the string. */ 
+        if (idx == string.size()) { 
+          valid = 0; 
+          break; 
+        } 
+        c = static_cast<uint8_t>(string[idx]); 
         /* Breaks out and bail on any invalid UTF-8 sequence, including \0. */
         if ((c & 0xc0) != 0x80) {
           valid = 0;
@@ -227,111 +227,111 @@ void JsonWriter::EscapeString(const TString& string) {
          * That range is exactly 20 bits.
          */
         utf32 -= 0x10000;
-        EscapeUtf16(static_cast<uint16_t>(0xd800 | (utf32 >> 10)));
-        EscapeUtf16(static_cast<uint16_t>(0xdc00 | (utf32 & 0x3ff)));
+        EscapeUtf16(static_cast<uint16_t>(0xd800 | (utf32 >> 10))); 
+        EscapeUtf16(static_cast<uint16_t>(0xdc00 | (utf32 & 0x3ff))); 
       } else {
-        EscapeUtf16(static_cast<uint16_t>(utf32));
+        EscapeUtf16(static_cast<uint16_t>(utf32)); 
       }
     }
   }
-  OutputChar('"');
-}
-
-void JsonWriter::ContainerBegins(Json::Type type) {
-  if (!got_key_) ValueEnd();
-  OutputIndent();
-  OutputChar(type == Json::Type::OBJECT ? '{' : '[');
-  container_empty_ = true;
-  got_key_ = false;
-  depth_++;
-}
+  OutputChar('"'); 
+} 
 
-void JsonWriter::ContainerEnds(Json::Type type) {
-  if (indent_ && !container_empty_) OutputChar('\n');
-  depth_--;
-  if (!container_empty_) OutputIndent();
-  OutputChar(type == Json::Type::OBJECT ? '}' : ']');
-  container_empty_ = false;
-  got_key_ = false;
+void JsonWriter::ContainerBegins(Json::Type type) { 
+  if (!got_key_) ValueEnd(); 
+  OutputIndent(); 
+  OutputChar(type == Json::Type::OBJECT ? '{' : '['); 
+  container_empty_ = true; 
+  got_key_ = false; 
+  depth_++; 
 }
 
-void JsonWriter::ObjectKey(const TString& string) {
-  ValueEnd();
-  OutputIndent();
-  EscapeString(string);
-  OutputChar(':');
-  got_key_ = true;
+void JsonWriter::ContainerEnds(Json::Type type) { 
+  if (indent_ && !container_empty_) OutputChar('\n'); 
+  depth_--; 
+  if (!container_empty_) OutputIndent(); 
+  OutputChar(type == Json::Type::OBJECT ? '}' : ']'); 
+  container_empty_ = false; 
+  got_key_ = false; 
 }
 
-void JsonWriter::ValueRaw(const TString& string) {
-  if (!got_key_) ValueEnd();
-  OutputIndent();
-  OutputString(string);
-  got_key_ = false;
+void JsonWriter::ObjectKey(const TString& string) { 
+  ValueEnd(); 
+  OutputIndent(); 
+  EscapeString(string); 
+  OutputChar(':'); 
+  got_key_ = true; 
 }
 
-void JsonWriter::ValueString(const TString& string) {
-  if (!got_key_) ValueEnd();
-  OutputIndent();
-  EscapeString(string);
-  got_key_ = false;
+void JsonWriter::ValueRaw(const TString& string) { 
+  if (!got_key_) ValueEnd(); 
+  OutputIndent(); 
+  OutputString(string); 
+  got_key_ = false; 
 }
 
-void JsonWriter::DumpObject(const Json::Object& object) {
-  ContainerBegins(Json::Type::OBJECT);
-  for (const auto& p : object) {
-    ObjectKey(p.first.data());
-    DumpValue(p.second);
-  }
-  ContainerEnds(Json::Type::OBJECT);
+void JsonWriter::ValueString(const TString& string) { 
+  if (!got_key_) ValueEnd(); 
+  OutputIndent(); 
+  EscapeString(string); 
+  got_key_ = false; 
 }
 
-void JsonWriter::DumpArray(const Json::Array& array) {
-  ContainerBegins(Json::Type::ARRAY);
-  for (const auto& v : array) {
-    DumpValue(v);
-  }
-  ContainerEnds(Json::Type::ARRAY);
+void JsonWriter::DumpObject(const Json::Object& object) { 
+  ContainerBegins(Json::Type::OBJECT); 
+  for (const auto& p : object) { 
+    ObjectKey(p.first.data()); 
+    DumpValue(p.second); 
+  } 
+  ContainerEnds(Json::Type::OBJECT); 
 }
 
-void JsonWriter::DumpValue(const Json& value) {
-  switch (value.type()) {
-    case Json::Type::OBJECT:
-      DumpObject(value.object_value());
-      break;
-    case Json::Type::ARRAY:
-      DumpArray(value.array_value());
-      break;
-    case Json::Type::STRING:
-      ValueString(value.string_value());
-      break;
-    case Json::Type::NUMBER:
-      ValueRaw(value.string_value());
-      break;
-    case Json::Type::JSON_TRUE:
-      ValueRaw(TString("true", 4));
-      break;
-    case Json::Type::JSON_FALSE:
-      ValueRaw(TString("false", 5));
-      break;
-    case Json::Type::JSON_NULL:
-      ValueRaw(TString("null", 4));
-      break;
-    default:
-      GPR_UNREACHABLE_CODE(abort());
-  }
-}
-
-TString JsonWriter::Dump(const Json& value, int indent) {
-  JsonWriter writer(indent);
-  writer.DumpValue(value);
-  return std::move(writer.output_);
+void JsonWriter::DumpArray(const Json::Array& array) { 
+  ContainerBegins(Json::Type::ARRAY); 
+  for (const auto& v : array) { 
+    DumpValue(v); 
+  } 
+  ContainerEnds(Json::Type::ARRAY); 
 }
-
-}  // namespace
-
-TString Json::Dump(int indent) const {
-  return JsonWriter::Dump(*this, indent);
-}
-
-}  // namespace grpc_core
+ 
+void JsonWriter::DumpValue(const Json& value) { 
+  switch (value.type()) { 
+    case Json::Type::OBJECT: 
+      DumpObject(value.object_value()); 
+      break; 
+    case Json::Type::ARRAY: 
+      DumpArray(value.array_value()); 
+      break; 
+    case Json::Type::STRING: 
+      ValueString(value.string_value()); 
+      break; 
+    case Json::Type::NUMBER: 
+      ValueRaw(value.string_value()); 
+      break; 
+    case Json::Type::JSON_TRUE: 
+      ValueRaw(TString("true", 4)); 
+      break; 
+    case Json::Type::JSON_FALSE: 
+      ValueRaw(TString("false", 5)); 
+      break; 
+    case Json::Type::JSON_NULL: 
+      ValueRaw(TString("null", 4)); 
+      break; 
+    default: 
+      GPR_UNREACHABLE_CODE(abort()); 
+  } 
+} 
+ 
+TString JsonWriter::Dump(const Json& value, int indent) { 
+  JsonWriter writer(indent); 
+  writer.DumpValue(value); 
+  return std::move(writer.output_); 
+} 
+ 
+}  // namespace 
+ 
+TString Json::Dump(int indent) const { 
+  return JsonWriter::Dump(*this, indent); 
+} 
+ 
+}  // namespace grpc_core 
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/authorization_engine.cc b/contrib/libs/grpc/src/core/lib/security/authorization/authorization_engine.cc
index 4a9386633b..776f0c8912 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/authorization_engine.cc
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/authorization_engine.cc
@@ -1,177 +1,177 @@
-// 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.
-
-#include <grpc/support/port_platform.h>
-
-#include "y_absl/memory/memory.h"
-
-#include "src/core/lib/security/authorization/authorization_engine.h"
-
-namespace grpc_core {
-
-namespace {
-
-// Symbols for traversing Envoy Attributes
-constexpr char kUrlPath[] = "url_path";
-constexpr char kHost[] = "host";
-constexpr char kMethod[] = "method";
-constexpr char kHeaders[] = "headers";
-constexpr char kSourceAddress[] = "source_address";
-constexpr char kSourcePort[] = "source_port";
-constexpr char kDestinationAddress[] = "destination_address";
-constexpr char kDestinationPort[] = "destination_port";
-constexpr char kSpiffeId[] = "spiffe_id";
-constexpr char kCertServerName[] = "cert_server_name";
-
-}  // namespace
-
-std::unique_ptr<AuthorizationEngine>
-AuthorizationEngine::CreateAuthorizationEngine(
-    const std::vector<envoy_config_rbac_v3_RBAC*>& rbac_policies) {
-  if (rbac_policies.empty() || rbac_policies.size() > 2) {
-    gpr_log(GPR_ERROR,
-            "Invalid rbac policies vector. Must contain either one or two rbac "
-            "policies.");
-    return nullptr;
-  } else if (rbac_policies.size() == 2 &&
-             (envoy_config_rbac_v3_RBAC_action(rbac_policies[0]) != kDeny ||
-              envoy_config_rbac_v3_RBAC_action(rbac_policies[1]) != kAllow)) {
-    gpr_log(GPR_ERROR,
-            "Invalid rbac policies vector. Must contain one deny \
-                         policy and one allow policy, in that order.");
-    return nullptr;
-  } else {
-    return y_absl::make_unique<AuthorizationEngine>(rbac_policies);
-  }
-}
-
-AuthorizationEngine::AuthorizationEngine(
-    const std::vector<envoy_config_rbac_v3_RBAC*>& rbac_policies) {
-  for (const auto& rbac_policy : rbac_policies) {
-    // Extract array of policies and store their condition fields in either
-    // allow_if_matched_ or deny_if_matched_, depending on the policy action.
-    upb::Arena temp_arena;
-    size_t policy_num = UPB_MAP_BEGIN;
-    const envoy_config_rbac_v3_RBAC_PoliciesEntry* policy_entry;
-    while ((policy_entry = envoy_config_rbac_v3_RBAC_policies_next(
-                rbac_policy, &policy_num)) != nullptr) {
-      const upb_strview policy_name_strview =
-          envoy_config_rbac_v3_RBAC_PoliciesEntry_key(policy_entry);
-      const TString policy_name(policy_name_strview.data,
-                                    policy_name_strview.size);
-      const envoy_config_rbac_v3_Policy* policy =
-          envoy_config_rbac_v3_RBAC_PoliciesEntry_value(policy_entry);
-      const google_api_expr_v1alpha1_Expr* condition =
-          envoy_config_rbac_v3_Policy_condition(policy);
-      // Parse condition to make a pointer tied to the lifetime of arena_.
-      size_t serial_len;
-      const char* serialized = google_api_expr_v1alpha1_Expr_serialize(
-          condition, temp_arena.ptr(), &serial_len);
-      const google_api_expr_v1alpha1_Expr* parsed_condition =
-          google_api_expr_v1alpha1_Expr_parse(serialized, serial_len,
-                                              arena_.ptr());
-      if (envoy_config_rbac_v3_RBAC_action(rbac_policy) == kAllow) {
-        allow_if_matched_.insert(std::make_pair(policy_name, parsed_condition));
-      } else {
-        deny_if_matched_.insert(std::make_pair(policy_name, parsed_condition));
-      }
-    }
-  }
-}
-
-std::unique_ptr<mock_cel::Activation> AuthorizationEngine::CreateActivation(
-    const EvaluateArgs& args) {
-  std::unique_ptr<mock_cel::Activation> activation;
-  for (const auto& elem : envoy_attributes_) {
-    if (elem == kUrlPath) {
-      y_absl::string_view url_path(args.GetPath());
-      if (!url_path.empty()) {
-        activation->InsertValue(kUrlPath,
-                                mock_cel::CelValue::CreateStringView(url_path));
-      }
-    } else if (elem == kHost) {
-      y_absl::string_view host(args.GetHost());
-      if (!host.empty()) {
-        activation->InsertValue(kHost,
-                                mock_cel::CelValue::CreateStringView(host));
-      }
-    } else if (elem == kMethod) {
-      y_absl::string_view method(args.GetMethod());
-      if (!method.empty()) {
-        activation->InsertValue(kMethod,
-                                mock_cel::CelValue::CreateStringView(method));
-      }
-    } else if (elem == kHeaders) {
-      std::multimap<y_absl::string_view, y_absl::string_view> headers =
-          args.GetHeaders();
-      std::vector<std::pair<mock_cel::CelValue, mock_cel::CelValue>>
-          header_items;
-      for (const auto& header_key : header_keys_) {
-        auto header_item = headers.find(header_key);
-        if (header_item != headers.end()) {
-          header_items.push_back(
-              std::pair<mock_cel::CelValue, mock_cel::CelValue>(
-                  mock_cel::CelValue::CreateStringView(header_key),
-                  mock_cel::CelValue::CreateStringView(header_item->second)));
-        }
-      }
-      headers_ = mock_cel::ContainerBackedMapImpl::Create(
-          y_absl::Span<std::pair<mock_cel::CelValue, mock_cel::CelValue>>(
-              header_items));
-      activation->InsertValue(kHeaders,
-                              mock_cel::CelValue::CreateMap(headers_.get()));
-    } else if (elem == kSourceAddress) {
-      y_absl::string_view source_address(args.GetPeerAddress());
-      if (!source_address.empty()) {
-        activation->InsertValue(
-            kSourceAddress,
-            mock_cel::CelValue::CreateStringView(source_address));
-      }
-    } else if (elem == kSourcePort) {
-      activation->InsertValue(
-          kSourcePort, mock_cel::CelValue::CreateInt64(args.GetPeerPort()));
-    } else if (elem == kDestinationAddress) {
-      y_absl::string_view destination_address(args.GetLocalAddress());
-      if (!destination_address.empty()) {
-        activation->InsertValue(
-            kDestinationAddress,
-            mock_cel::CelValue::CreateStringView(destination_address));
-      }
-    } else if (elem == kDestinationPort) {
-      activation->InsertValue(kDestinationPort, mock_cel::CelValue::CreateInt64(
-                                                    args.GetLocalPort()));
-    } else if (elem == kSpiffeId) {
-      y_absl::string_view spiffe_id(args.GetSpiffeId());
-      if (!spiffe_id.empty()) {
-        activation->InsertValue(
-            kSpiffeId, mock_cel::CelValue::CreateStringView(spiffe_id));
-      }
-    } else if (elem == kCertServerName) {
-      y_absl::string_view cert_server_name(args.GetCertServerName());
-      if (!cert_server_name.empty()) {
-        activation->InsertValue(
-            kCertServerName,
-            mock_cel::CelValue::CreateStringView(cert_server_name));
-      }
-    } else {
-      gpr_log(GPR_ERROR,
-              "Error: Authorization engine does not support evaluating "
-              "attribute %s.",
-              elem.c_str());
-    }
-  }
-  return activation;
-}
-
-}  // namespace grpc_core
+// 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. 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "y_absl/memory/memory.h" 
+ 
+#include "src/core/lib/security/authorization/authorization_engine.h" 
+ 
+namespace grpc_core { 
+ 
+namespace { 
+ 
+// Symbols for traversing Envoy Attributes 
+constexpr char kUrlPath[] = "url_path"; 
+constexpr char kHost[] = "host"; 
+constexpr char kMethod[] = "method"; 
+constexpr char kHeaders[] = "headers"; 
+constexpr char kSourceAddress[] = "source_address"; 
+constexpr char kSourcePort[] = "source_port"; 
+constexpr char kDestinationAddress[] = "destination_address"; 
+constexpr char kDestinationPort[] = "destination_port"; 
+constexpr char kSpiffeId[] = "spiffe_id"; 
+constexpr char kCertServerName[] = "cert_server_name"; 
+ 
+}  // namespace 
+ 
+std::unique_ptr<AuthorizationEngine> 
+AuthorizationEngine::CreateAuthorizationEngine( 
+    const std::vector<envoy_config_rbac_v3_RBAC*>& rbac_policies) { 
+  if (rbac_policies.empty() || rbac_policies.size() > 2) { 
+    gpr_log(GPR_ERROR, 
+            "Invalid rbac policies vector. Must contain either one or two rbac " 
+            "policies."); 
+    return nullptr; 
+  } else if (rbac_policies.size() == 2 && 
+             (envoy_config_rbac_v3_RBAC_action(rbac_policies[0]) != kDeny || 
+              envoy_config_rbac_v3_RBAC_action(rbac_policies[1]) != kAllow)) { 
+    gpr_log(GPR_ERROR, 
+            "Invalid rbac policies vector. Must contain one deny \ 
+                         policy and one allow policy, in that order."); 
+    return nullptr; 
+  } else { 
+    return y_absl::make_unique<AuthorizationEngine>(rbac_policies); 
+  } 
+} 
+ 
+AuthorizationEngine::AuthorizationEngine( 
+    const std::vector<envoy_config_rbac_v3_RBAC*>& rbac_policies) { 
+  for (const auto& rbac_policy : rbac_policies) { 
+    // Extract array of policies and store their condition fields in either 
+    // allow_if_matched_ or deny_if_matched_, depending on the policy action. 
+    upb::Arena temp_arena; 
+    size_t policy_num = UPB_MAP_BEGIN; 
+    const envoy_config_rbac_v3_RBAC_PoliciesEntry* policy_entry; 
+    while ((policy_entry = envoy_config_rbac_v3_RBAC_policies_next( 
+                rbac_policy, &policy_num)) != nullptr) { 
+      const upb_strview policy_name_strview = 
+          envoy_config_rbac_v3_RBAC_PoliciesEntry_key(policy_entry); 
+      const TString policy_name(policy_name_strview.data, 
+                                    policy_name_strview.size); 
+      const envoy_config_rbac_v3_Policy* policy = 
+          envoy_config_rbac_v3_RBAC_PoliciesEntry_value(policy_entry); 
+      const google_api_expr_v1alpha1_Expr* condition = 
+          envoy_config_rbac_v3_Policy_condition(policy); 
+      // Parse condition to make a pointer tied to the lifetime of arena_. 
+      size_t serial_len; 
+      const char* serialized = google_api_expr_v1alpha1_Expr_serialize( 
+          condition, temp_arena.ptr(), &serial_len); 
+      const google_api_expr_v1alpha1_Expr* parsed_condition = 
+          google_api_expr_v1alpha1_Expr_parse(serialized, serial_len, 
+                                              arena_.ptr()); 
+      if (envoy_config_rbac_v3_RBAC_action(rbac_policy) == kAllow) { 
+        allow_if_matched_.insert(std::make_pair(policy_name, parsed_condition)); 
+      } else { 
+        deny_if_matched_.insert(std::make_pair(policy_name, parsed_condition)); 
+      } 
+    } 
+  } 
+} 
+ 
+std::unique_ptr<mock_cel::Activation> AuthorizationEngine::CreateActivation( 
+    const EvaluateArgs& args) { 
+  std::unique_ptr<mock_cel::Activation> activation; 
+  for (const auto& elem : envoy_attributes_) { 
+    if (elem == kUrlPath) { 
+      y_absl::string_view url_path(args.GetPath()); 
+      if (!url_path.empty()) { 
+        activation->InsertValue(kUrlPath, 
+                                mock_cel::CelValue::CreateStringView(url_path)); 
+      } 
+    } else if (elem == kHost) { 
+      y_absl::string_view host(args.GetHost()); 
+      if (!host.empty()) { 
+        activation->InsertValue(kHost, 
+                                mock_cel::CelValue::CreateStringView(host)); 
+      } 
+    } else if (elem == kMethod) { 
+      y_absl::string_view method(args.GetMethod()); 
+      if (!method.empty()) { 
+        activation->InsertValue(kMethod, 
+                                mock_cel::CelValue::CreateStringView(method)); 
+      } 
+    } else if (elem == kHeaders) { 
+      std::multimap<y_absl::string_view, y_absl::string_view> headers = 
+          args.GetHeaders(); 
+      std::vector<std::pair<mock_cel::CelValue, mock_cel::CelValue>> 
+          header_items; 
+      for (const auto& header_key : header_keys_) { 
+        auto header_item = headers.find(header_key); 
+        if (header_item != headers.end()) { 
+          header_items.push_back( 
+              std::pair<mock_cel::CelValue, mock_cel::CelValue>( 
+                  mock_cel::CelValue::CreateStringView(header_key), 
+                  mock_cel::CelValue::CreateStringView(header_item->second))); 
+        } 
+      } 
+      headers_ = mock_cel::ContainerBackedMapImpl::Create( 
+          y_absl::Span<std::pair<mock_cel::CelValue, mock_cel::CelValue>>( 
+              header_items)); 
+      activation->InsertValue(kHeaders, 
+                              mock_cel::CelValue::CreateMap(headers_.get())); 
+    } else if (elem == kSourceAddress) { 
+      y_absl::string_view source_address(args.GetPeerAddress()); 
+      if (!source_address.empty()) { 
+        activation->InsertValue( 
+            kSourceAddress, 
+            mock_cel::CelValue::CreateStringView(source_address)); 
+      } 
+    } else if (elem == kSourcePort) { 
+      activation->InsertValue( 
+          kSourcePort, mock_cel::CelValue::CreateInt64(args.GetPeerPort())); 
+    } else if (elem == kDestinationAddress) { 
+      y_absl::string_view destination_address(args.GetLocalAddress()); 
+      if (!destination_address.empty()) { 
+        activation->InsertValue( 
+            kDestinationAddress, 
+            mock_cel::CelValue::CreateStringView(destination_address)); 
+      } 
+    } else if (elem == kDestinationPort) { 
+      activation->InsertValue(kDestinationPort, mock_cel::CelValue::CreateInt64( 
+                                                    args.GetLocalPort())); 
+    } else if (elem == kSpiffeId) { 
+      y_absl::string_view spiffe_id(args.GetSpiffeId()); 
+      if (!spiffe_id.empty()) { 
+        activation->InsertValue( 
+            kSpiffeId, mock_cel::CelValue::CreateStringView(spiffe_id)); 
+      } 
+    } else if (elem == kCertServerName) { 
+      y_absl::string_view cert_server_name(args.GetCertServerName()); 
+      if (!cert_server_name.empty()) { 
+        activation->InsertValue( 
+            kCertServerName, 
+            mock_cel::CelValue::CreateStringView(cert_server_name)); 
+      } 
+    } else { 
+      gpr_log(GPR_ERROR, 
+              "Error: Authorization engine does not support evaluating " 
+              "attribute %s.", 
+              elem.c_str()); 
+    } 
+  } 
+  return activation; 
+} 
+ 
+}  // namespace grpc_core 
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/authorization_engine.h b/contrib/libs/grpc/src/core/lib/security/authorization/authorization_engine.h
index 24cded28a3..38e3fb42e2 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/authorization_engine.h
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/authorization_engine.h
@@ -1,84 +1,84 @@
-
-// 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_CORE_LIB_SECURITY_AUTHORIZATION_AUTHORIZATION_ENGINE_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_AUTHORIZATION_ENGINE_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/support/log.h>
-#include <map>
-#include <memory>
-#include <util/generic/string.h>
-#include <vector>
-
-#include "y_absl/container/flat_hash_set.h"
-#include "envoy/config/rbac/v3/rbac.upb.h"
-#include "google/api/expr/v1alpha1/syntax.upb.h"
-#include "upb/upb.hpp"
-
-#include "src/core/lib/security/authorization/evaluate_args.h"
-#include "src/core/lib/security/authorization/mock_cel/activation.h"
-
-namespace grpc_core {
-
-// AuthorizationEngine makes an AuthorizationDecision to ALLOW or DENY the
-// current action based on the condition fields in provided RBAC policies.
-// The engine may be constructed with one or two policies. If two polcies,
-// the first policy is deny-if-matched and the second is allow-if-matched.
-// The engine returns UNDECIDED decision if it fails to find a match in any
-// policy. This engine ignores the principal and permission fields in RBAC
-// policies. It is the caller's responsibility to provide RBAC policies that
-// are compatible with this engine.
-//
-// Example:
-// AuthorizationEngine*
-// auth_engine = AuthorizationEngine::CreateAuthorizationEngine(rbac_policies);
-// auth_engine->Evaluate(evaluate_args); // returns authorization decision.
-class AuthorizationEngine {
- public:
-  // rbac_policies must be a vector containing either a single policy of any
-  // kind, or one deny policy and one allow policy, in that order.
-  static std::unique_ptr<AuthorizationEngine> CreateAuthorizationEngine(
-      const std::vector<envoy_config_rbac_v3_RBAC*>& rbac_policies);
-
-  // Users should use the CreateAuthorizationEngine factory function
-  // instead of calling the AuthorizationEngine constructor directly.
-  explicit AuthorizationEngine(
-      const std::vector<envoy_config_rbac_v3_RBAC*>& rbac_policies);
-  // TODO(mywang@google.com): add an Evaluate member function.
-
- private:
-  enum Action {
-    kAllow,
-    kDeny,
-  };
-
-  std::unique_ptr<mock_cel::Activation> CreateActivation(
-      const EvaluateArgs& args);
-
-  std::map<const TString, const google_api_expr_v1alpha1_Expr*>
-      deny_if_matched_;
-  std::map<const TString, const google_api_expr_v1alpha1_Expr*>
-      allow_if_matched_;
-  upb::Arena arena_;
-  y_absl::flat_hash_set<TString> envoy_attributes_;
-  y_absl::flat_hash_set<TString> header_keys_;
-  std::unique_ptr<mock_cel::CelMap> headers_;
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_SECURITY_AUTHORIZATION_AUTHORIZATION_ENGINE_H */
+ 
+// 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_CORE_LIB_SECURITY_AUTHORIZATION_AUTHORIZATION_ENGINE_H 
+#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_AUTHORIZATION_ENGINE_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <grpc/support/log.h> 
+#include <map> 
+#include <memory> 
+#include <util/generic/string.h> 
+#include <vector> 
+ 
+#include "y_absl/container/flat_hash_set.h" 
+#include "envoy/config/rbac/v3/rbac.upb.h" 
+#include "google/api/expr/v1alpha1/syntax.upb.h" 
+#include "upb/upb.hpp" 
+ 
+#include "src/core/lib/security/authorization/evaluate_args.h" 
+#include "src/core/lib/security/authorization/mock_cel/activation.h" 
+ 
+namespace grpc_core { 
+ 
+// AuthorizationEngine makes an AuthorizationDecision to ALLOW or DENY the 
+// current action based on the condition fields in provided RBAC policies. 
+// The engine may be constructed with one or two policies. If two polcies, 
+// the first policy is deny-if-matched and the second is allow-if-matched. 
+// The engine returns UNDECIDED decision if it fails to find a match in any 
+// policy. This engine ignores the principal and permission fields in RBAC 
+// policies. It is the caller's responsibility to provide RBAC policies that 
+// are compatible with this engine. 
+// 
+// Example: 
+// AuthorizationEngine* 
+// auth_engine = AuthorizationEngine::CreateAuthorizationEngine(rbac_policies); 
+// auth_engine->Evaluate(evaluate_args); // returns authorization decision. 
+class AuthorizationEngine { 
+ public: 
+  // rbac_policies must be a vector containing either a single policy of any 
+  // kind, or one deny policy and one allow policy, in that order. 
+  static std::unique_ptr<AuthorizationEngine> CreateAuthorizationEngine( 
+      const std::vector<envoy_config_rbac_v3_RBAC*>& rbac_policies); 
+ 
+  // Users should use the CreateAuthorizationEngine factory function 
+  // instead of calling the AuthorizationEngine constructor directly. 
+  explicit AuthorizationEngine( 
+      const std::vector<envoy_config_rbac_v3_RBAC*>& rbac_policies); 
+  // TODO(mywang@google.com): add an Evaluate member function. 
+ 
+ private: 
+  enum Action { 
+    kAllow, 
+    kDeny, 
+  }; 
+ 
+  std::unique_ptr<mock_cel::Activation> CreateActivation( 
+      const EvaluateArgs& args); 
+ 
+  std::map<const TString, const google_api_expr_v1alpha1_Expr*> 
+      deny_if_matched_; 
+  std::map<const TString, const google_api_expr_v1alpha1_Expr*> 
+      allow_if_matched_; 
+  upb::Arena arena_; 
+  y_absl::flat_hash_set<TString> envoy_attributes_; 
+  y_absl::flat_hash_set<TString> header_keys_; 
+  std::unique_ptr<mock_cel::CelMap> headers_; 
+}; 
+ 
+}  // namespace grpc_core 
+ 
+#endif /* GRPC_CORE_LIB_SECURITY_AUTHORIZATION_AUTHORIZATION_ENGINE_H */ 
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/evaluate_args.cc b/contrib/libs/grpc/src/core/lib/security/authorization/evaluate_args.cc
index 48af382f12..8f3e1ea6b3 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/evaluate_args.cc
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/evaluate_args.cc
@@ -1,153 +1,153 @@
-//
-//
-// 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.
-//
-//
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/security/authorization/evaluate_args.h"
-
-#include "src/core/lib/iomgr/parse_address.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
-#include "src/core/lib/slice/slice_utils.h"
-
-namespace grpc_core {
-
-y_absl::string_view EvaluateArgs::GetPath() const {
-  y_absl::string_view path;
-  if (metadata_ != nullptr && metadata_->idx.named.path != nullptr) {
-    grpc_linked_mdelem* elem = metadata_->idx.named.path;
-    const grpc_slice& val = GRPC_MDVALUE(elem->md);
-    path = StringViewFromSlice(val);
-  }
-  return path;
-}
-
-y_absl::string_view EvaluateArgs::GetHost() const {
-  y_absl::string_view host;
-  if (metadata_ != nullptr && metadata_->idx.named.host != nullptr) {
-    grpc_linked_mdelem* elem = metadata_->idx.named.host;
-    const grpc_slice& val = GRPC_MDVALUE(elem->md);
-    host = StringViewFromSlice(val);
-  }
-  return host;
-}
-
-y_absl::string_view EvaluateArgs::GetMethod() const {
-  y_absl::string_view method;
-  if (metadata_ != nullptr && metadata_->idx.named.method != nullptr) {
-    grpc_linked_mdelem* elem = metadata_->idx.named.method;
-    const grpc_slice& val = GRPC_MDVALUE(elem->md);
-    method = StringViewFromSlice(val);
-  }
-  return method;
-}
-
-std::multimap<y_absl::string_view, y_absl::string_view> EvaluateArgs::GetHeaders()
-    const {
-  std::multimap<y_absl::string_view, y_absl::string_view> headers;
-  if (metadata_ == nullptr) {
-    return headers;
-  }
-  for (grpc_linked_mdelem* elem = metadata_->list.head; elem != nullptr;
-       elem = elem->next) {
-    const grpc_slice& key = GRPC_MDKEY(elem->md);
-    const grpc_slice& val = GRPC_MDVALUE(elem->md);
-    headers.emplace(StringViewFromSlice(key), StringViewFromSlice(val));
-  }
-  return headers;
-}
-
-y_absl::string_view EvaluateArgs::GetLocalAddress() const {
-  y_absl::string_view addr = grpc_endpoint_get_local_address(endpoint_);
-  size_t first_colon = addr.find(":");
-  size_t last_colon = addr.rfind(":");
-  if (first_colon == TString::npos || last_colon == TString::npos) {
-    return "";
-  } else {
-    return addr.substr(first_colon + 1, last_colon - first_colon - 1);
-  }
-}
-
-int EvaluateArgs::GetLocalPort() const {
-  if (endpoint_ == nullptr) {
-    return 0;
-  }
-  grpc_uri* uri = grpc_uri_parse(
-      TString(grpc_endpoint_get_local_address(endpoint_)).c_str(), true);
-  grpc_resolved_address resolved_addr;
-  if (uri == nullptr || !grpc_parse_uri(uri, &resolved_addr)) {
-    grpc_uri_destroy(uri);
-    return 0;
-  }
-  grpc_uri_destroy(uri);
-  return grpc_sockaddr_get_port(&resolved_addr);
-}
-
-y_absl::string_view EvaluateArgs::GetPeerAddress() const {
-  y_absl::string_view addr = grpc_endpoint_get_peer(endpoint_);
-  size_t first_colon = addr.find(":");
-  size_t last_colon = addr.rfind(":");
-  if (first_colon == TString::npos || last_colon == TString::npos) {
-    return "";
-  } else {
-    return addr.substr(first_colon + 1, last_colon - first_colon - 1);
-  }
-}
-
-int EvaluateArgs::GetPeerPort() const {
-  if (endpoint_ == nullptr) {
-    return 0;
-  }
-  grpc_uri* uri = grpc_uri_parse(
-      TString(grpc_endpoint_get_peer(endpoint_)).c_str(), true);
-  grpc_resolved_address resolved_addr;
-  if (uri == nullptr || !grpc_parse_uri(uri, &resolved_addr)) {
-    grpc_uri_destroy(uri);
-    return 0;
-  }
-  grpc_uri_destroy(uri);
-  return grpc_sockaddr_get_port(&resolved_addr);
-}
-
-y_absl::string_view EvaluateArgs::GetSpiffeId() const {
-  if (auth_context_ == nullptr) {
-    return "";
-  }
-  grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
-      auth_context_, GRPC_PEER_SPIFFE_ID_PROPERTY_NAME);
-  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
-  if (prop == nullptr || grpc_auth_property_iterator_next(&it) != nullptr) {
-    return "";
-  }
-  return y_absl::string_view(prop->value, prop->value_length);
-}
-
-y_absl::string_view EvaluateArgs::GetCertServerName() const {
-  if (auth_context_ == nullptr) {
-    return "";
-  }
-  grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
-      auth_context_, GRPC_X509_CN_PROPERTY_NAME);
-  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
-  if (prop == nullptr || grpc_auth_property_iterator_next(&it) != nullptr) {
-    return "";
-  }
-  return y_absl::string_view(prop->value, prop->value_length);
-}
-
-}  // namespace grpc_core
+// 
+// 
+// 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. 
+// 
+// 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/security/authorization/evaluate_args.h" 
+ 
+#include "src/core/lib/iomgr/parse_address.h" 
+#include "src/core/lib/iomgr/resolve_address.h" 
+#include "src/core/lib/iomgr/sockaddr_utils.h" 
+#include "src/core/lib/slice/slice_utils.h" 
+ 
+namespace grpc_core { 
+ 
+y_absl::string_view EvaluateArgs::GetPath() const { 
+  y_absl::string_view path; 
+  if (metadata_ != nullptr && metadata_->idx.named.path != nullptr) { 
+    grpc_linked_mdelem* elem = metadata_->idx.named.path; 
+    const grpc_slice& val = GRPC_MDVALUE(elem->md); 
+    path = StringViewFromSlice(val); 
+  } 
+  return path; 
+} 
+ 
+y_absl::string_view EvaluateArgs::GetHost() const { 
+  y_absl::string_view host; 
+  if (metadata_ != nullptr && metadata_->idx.named.host != nullptr) { 
+    grpc_linked_mdelem* elem = metadata_->idx.named.host; 
+    const grpc_slice& val = GRPC_MDVALUE(elem->md); 
+    host = StringViewFromSlice(val); 
+  } 
+  return host; 
+} 
+ 
+y_absl::string_view EvaluateArgs::GetMethod() const { 
+  y_absl::string_view method; 
+  if (metadata_ != nullptr && metadata_->idx.named.method != nullptr) { 
+    grpc_linked_mdelem* elem = metadata_->idx.named.method; 
+    const grpc_slice& val = GRPC_MDVALUE(elem->md); 
+    method = StringViewFromSlice(val); 
+  } 
+  return method; 
+} 
+ 
+std::multimap<y_absl::string_view, y_absl::string_view> EvaluateArgs::GetHeaders() 
+    const { 
+  std::multimap<y_absl::string_view, y_absl::string_view> headers; 
+  if (metadata_ == nullptr) { 
+    return headers; 
+  } 
+  for (grpc_linked_mdelem* elem = metadata_->list.head; elem != nullptr; 
+       elem = elem->next) { 
+    const grpc_slice& key = GRPC_MDKEY(elem->md); 
+    const grpc_slice& val = GRPC_MDVALUE(elem->md); 
+    headers.emplace(StringViewFromSlice(key), StringViewFromSlice(val)); 
+  } 
+  return headers; 
+} 
+ 
+y_absl::string_view EvaluateArgs::GetLocalAddress() const { 
+  y_absl::string_view addr = grpc_endpoint_get_local_address(endpoint_); 
+  size_t first_colon = addr.find(":"); 
+  size_t last_colon = addr.rfind(":"); 
+  if (first_colon == TString::npos || last_colon == TString::npos) { 
+    return ""; 
+  } else { 
+    return addr.substr(first_colon + 1, last_colon - first_colon - 1); 
+  } 
+} 
+ 
+int EvaluateArgs::GetLocalPort() const { 
+  if (endpoint_ == nullptr) { 
+    return 0; 
+  } 
+  grpc_uri* uri = grpc_uri_parse( 
+      TString(grpc_endpoint_get_local_address(endpoint_)).c_str(), true); 
+  grpc_resolved_address resolved_addr; 
+  if (uri == nullptr || !grpc_parse_uri(uri, &resolved_addr)) { 
+    grpc_uri_destroy(uri); 
+    return 0; 
+  } 
+  grpc_uri_destroy(uri); 
+  return grpc_sockaddr_get_port(&resolved_addr); 
+} 
+ 
+y_absl::string_view EvaluateArgs::GetPeerAddress() const { 
+  y_absl::string_view addr = grpc_endpoint_get_peer(endpoint_); 
+  size_t first_colon = addr.find(":"); 
+  size_t last_colon = addr.rfind(":"); 
+  if (first_colon == TString::npos || last_colon == TString::npos) { 
+    return ""; 
+  } else { 
+    return addr.substr(first_colon + 1, last_colon - first_colon - 1); 
+  } 
+} 
+ 
+int EvaluateArgs::GetPeerPort() const { 
+  if (endpoint_ == nullptr) { 
+    return 0; 
+  } 
+  grpc_uri* uri = grpc_uri_parse( 
+      TString(grpc_endpoint_get_peer(endpoint_)).c_str(), true); 
+  grpc_resolved_address resolved_addr; 
+  if (uri == nullptr || !grpc_parse_uri(uri, &resolved_addr)) { 
+    grpc_uri_destroy(uri); 
+    return 0; 
+  } 
+  grpc_uri_destroy(uri); 
+  return grpc_sockaddr_get_port(&resolved_addr); 
+} 
+ 
+y_absl::string_view EvaluateArgs::GetSpiffeId() const { 
+  if (auth_context_ == nullptr) { 
+    return ""; 
+  } 
+  grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name( 
+      auth_context_, GRPC_PEER_SPIFFE_ID_PROPERTY_NAME); 
+  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it); 
+  if (prop == nullptr || grpc_auth_property_iterator_next(&it) != nullptr) { 
+    return ""; 
+  } 
+  return y_absl::string_view(prop->value, prop->value_length); 
+} 
+ 
+y_absl::string_view EvaluateArgs::GetCertServerName() const { 
+  if (auth_context_ == nullptr) { 
+    return ""; 
+  } 
+  grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name( 
+      auth_context_, GRPC_X509_CN_PROPERTY_NAME); 
+  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it); 
+  if (prop == nullptr || grpc_auth_property_iterator_next(&it) != nullptr) { 
+    return ""; 
+  } 
+  return y_absl::string_view(prop->value, prop->value_length); 
+} 
+ 
+}  // namespace grpc_core 
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/evaluate_args.h b/contrib/libs/grpc/src/core/lib/security/authorization/evaluate_args.h
index 1409cdc6c3..9f72af4862 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/evaluate_args.h
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/evaluate_args.h
@@ -1,59 +1,59 @@
-//
-//
-// 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_CORE_LIB_SECURITY_AUTHORIZATION_EVALUATE_ARGS_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_EVALUATE_ARGS_H
-
-#include <grpc/support/port_platform.h>
-
-#include <map>
-
-#include "src/core/lib/iomgr/endpoint.h"
-#include "src/core/lib/security/context/security_context.h"
-#include "src/core/lib/transport/metadata_batch.h"
-
-namespace grpc_core {
-
-class EvaluateArgs {
- public:
-  EvaluateArgs(grpc_metadata_batch* metadata, grpc_auth_context* auth_context,
-               grpc_endpoint* endpoint)
-      : metadata_(metadata), auth_context_(auth_context), endpoint_(endpoint) {}
-
-  y_absl::string_view GetPath() const;
-  y_absl::string_view GetHost() const;
-  y_absl::string_view GetMethod() const;
-  std::multimap<y_absl::string_view, y_absl::string_view> GetHeaders() const;
-  y_absl::string_view GetLocalAddress() const;
-  int GetLocalPort() const;
-  y_absl::string_view GetPeerAddress() const;
-  int GetPeerPort() const;
-  y_absl::string_view GetSpiffeId() const;
-  y_absl::string_view GetCertServerName() const;
-
-  // TODO: Add a getter function for source.principal
-
- private:
-  grpc_metadata_batch* metadata_;
-  grpc_auth_context* auth_context_;
-  grpc_endpoint* endpoint_;
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_EVALUATE_ARGS_H
+// 
+// 
+// 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_CORE_LIB_SECURITY_AUTHORIZATION_EVALUATE_ARGS_H 
+#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_EVALUATE_ARGS_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <map> 
+ 
+#include "src/core/lib/iomgr/endpoint.h" 
+#include "src/core/lib/security/context/security_context.h" 
+#include "src/core/lib/transport/metadata_batch.h" 
+ 
+namespace grpc_core { 
+ 
+class EvaluateArgs { 
+ public: 
+  EvaluateArgs(grpc_metadata_batch* metadata, grpc_auth_context* auth_context, 
+               grpc_endpoint* endpoint) 
+      : metadata_(metadata), auth_context_(auth_context), endpoint_(endpoint) {} 
+ 
+  y_absl::string_view GetPath() const; 
+  y_absl::string_view GetHost() const; 
+  y_absl::string_view GetMethod() const; 
+  std::multimap<y_absl::string_view, y_absl::string_view> GetHeaders() const; 
+  y_absl::string_view GetLocalAddress() const; 
+  int GetLocalPort() const; 
+  y_absl::string_view GetPeerAddress() const; 
+  int GetPeerPort() const; 
+  y_absl::string_view GetSpiffeId() const; 
+  y_absl::string_view GetCertServerName() const; 
+ 
+  // TODO: Add a getter function for source.principal 
+ 
+ private: 
+  grpc_metadata_batch* metadata_; 
+  grpc_auth_context* auth_context_; 
+  grpc_endpoint* endpoint_; 
+}; 
+ 
+}  // namespace grpc_core 
+ 
+#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_EVALUATE_ARGS_H 
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/activation.h b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/activation.h
index 34520c761d..8beccfd014 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/activation.h
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/activation.h
@@ -1,57 +1,57 @@
-// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_ACTIVATION_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_ACTIVATION_H
-
-#include <grpc/support/port_platform.h>
-
-#include "y_absl/strings/string_view.h"
-
-#include "src/core/lib/security/authorization/mock_cel/cel_value.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// Base class for an activation. This is a temporary stub implementation of CEL
-// APIs. Once gRPC imports the CEL library, this class will be removed.
-class BaseActivation {
- public:
-  BaseActivation() = default;
-
-  // Non-copyable/non-assignable
-  BaseActivation(const BaseActivation&) = delete;
-  BaseActivation& operator=(const BaseActivation&) = delete;
-};
-
-// Instance of Activation class is used by evaluator.
-// It provides binding between references used in expressions
-// and actual values. This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this class will be removed.
-class Activation : public BaseActivation {
- public:
-  Activation() = default;
-
-  // Non-copyable/non-assignable
-  Activation(const Activation&) = delete;
-  Activation& operator=(const Activation&) = delete;
-
-  // Insert value into Activation.
-  void InsertValue(y_absl::string_view name, const CelValue& value) {}
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_ACTIVATION_H
+// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_ACTIVATION_H 
+#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_ACTIVATION_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "y_absl/strings/string_view.h" 
+ 
+#include "src/core/lib/security/authorization/mock_cel/cel_value.h" 
+ 
+namespace grpc_core { 
+namespace mock_cel { 
+ 
+// Base class for an activation. This is a temporary stub implementation of CEL 
+// APIs. Once gRPC imports the CEL library, this class will be removed. 
+class BaseActivation { 
+ public: 
+  BaseActivation() = default; 
+ 
+  // Non-copyable/non-assignable 
+  BaseActivation(const BaseActivation&) = delete; 
+  BaseActivation& operator=(const BaseActivation&) = delete; 
+}; 
+ 
+// Instance of Activation class is used by evaluator. 
+// It provides binding between references used in expressions 
+// and actual values. This is a temporary stub implementation of CEL APIs. 
+// Once gRPC imports the CEL library, this class will be removed. 
+class Activation : public BaseActivation { 
+ public: 
+  Activation() = default; 
+ 
+  // Non-copyable/non-assignable 
+  Activation(const Activation&) = delete; 
+  Activation& operator=(const Activation&) = delete; 
+ 
+  // Insert value into Activation. 
+  void InsertValue(y_absl::string_view name, const CelValue& value) {} 
+}; 
+ 
+}  // namespace mock_cel 
+}  // namespace grpc_core 
+ 
+#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_ACTIVATION_H 
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_expr_builder_factory.h b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_expr_builder_factory.h
index 9bacaeede7..d97e2aaca7 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_expr_builder_factory.h
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_expr_builder_factory.h
@@ -1,42 +1,42 @@
-// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPR_BUILDER_FACTORY_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPR_BUILDER_FACTORY_H
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-
-#include "src/core/lib/security/authorization/mock_cel/flat_expr_builder.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this file will be removed.
-
-struct InterpreterOptions {
-  bool short_circuiting = true;
-};
-
-std::unique_ptr<CelExpressionBuilder> CreateCelExpressionBuilder(
-    const InterpreterOptions& options) {
-  return y_absl::make_unique<FlatExprBuilder>();
-}
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPR_BUILDER_FACTORY_H
\ No newline at end of file
+// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPR_BUILDER_FACTORY_H 
+#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPR_BUILDER_FACTORY_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <memory> 
+ 
+#include "src/core/lib/security/authorization/mock_cel/flat_expr_builder.h" 
+ 
+namespace grpc_core { 
+namespace mock_cel { 
+ 
+// This is a temporary stub implementation of CEL APIs. 
+// Once gRPC imports the CEL library, this file will be removed. 
+ 
+struct InterpreterOptions { 
+  bool short_circuiting = true; 
+}; 
+ 
+std::unique_ptr<CelExpressionBuilder> CreateCelExpressionBuilder( 
+    const InterpreterOptions& options) { 
+  return y_absl::make_unique<FlatExprBuilder>(); 
+} 
+ 
+}  // namespace mock_cel 
+}  // namespace grpc_core 
+ 
+#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPR_BUILDER_FACTORY_H 
\ No newline at end of file
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_expression.h b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_expression.h
index 4ee422e942..7ed9d9e38b 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_expression.h
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_expression.h
@@ -1,68 +1,68 @@
-// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPRESSION_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPRESSION_H
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-#include <vector>
-
-#include "google/api/expr/v1alpha1/syntax.upb.h"
-#include "src/core/lib/security/authorization/mock_cel/activation.h"
-#include "src/core/lib/security/authorization/mock_cel/cel_value.h"
-#include "src/core/lib/security/authorization/mock_cel/statusor.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this file will be removed.
-
-// Base interface for expression evaluating objects.
-class CelExpression {
- public:
-  virtual ~CelExpression() = default;
-
-  // Evaluates expression and returns value.
-  // activation contains bindings from parameter names to values
-  virtual StatusOr<CelValue> Evaluate(
-      const BaseActivation& activation) const = 0;
-};
-
-// Base class for Expression Builder implementations
-// Provides user with factory to register extension functions.
-// ExpressionBuilder MUST NOT be destroyed before CelExpression objects
-// it built.
-class CelExpressionBuilder {
- public:
-  virtual ~CelExpressionBuilder() = default;
-
-  // Creates CelExpression object from AST tree.
-  // expr specifies root of AST tree
-  virtual StatusOr<std::unique_ptr<CelExpression>> CreateExpression(
-      const google_api_expr_v1alpha1_Expr* expr,
-      const google_api_expr_v1alpha1_SourceInfo* source_info) const = 0;
-
-  virtual StatusOr<std::unique_ptr<CelExpression>> CreateExpression(
-      const google_api_expr_v1alpha1_Expr* expr,
-      const google_api_expr_v1alpha1_SourceInfo* source_info,
-      std::vector<y_absl::Status>* warnings) const = 0;
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPRESSION_H
\ No newline at end of file
+// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPRESSION_H 
+#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPRESSION_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <memory> 
+#include <vector> 
+ 
+#include "google/api/expr/v1alpha1/syntax.upb.h" 
+#include "src/core/lib/security/authorization/mock_cel/activation.h" 
+#include "src/core/lib/security/authorization/mock_cel/cel_value.h" 
+#include "src/core/lib/security/authorization/mock_cel/statusor.h" 
+ 
+namespace grpc_core { 
+namespace mock_cel { 
+ 
+// This is a temporary stub implementation of CEL APIs. 
+// Once gRPC imports the CEL library, this file will be removed. 
+ 
+// Base interface for expression evaluating objects. 
+class CelExpression { 
+ public: 
+  virtual ~CelExpression() = default; 
+ 
+  // Evaluates expression and returns value. 
+  // activation contains bindings from parameter names to values 
+  virtual StatusOr<CelValue> Evaluate( 
+      const BaseActivation& activation) const = 0; 
+}; 
+ 
+// Base class for Expression Builder implementations 
+// Provides user with factory to register extension functions. 
+// ExpressionBuilder MUST NOT be destroyed before CelExpression objects 
+// it built. 
+class CelExpressionBuilder { 
+ public: 
+  virtual ~CelExpressionBuilder() = default; 
+ 
+  // Creates CelExpression object from AST tree. 
+  // expr specifies root of AST tree 
+  virtual StatusOr<std::unique_ptr<CelExpression>> CreateExpression( 
+      const google_api_expr_v1alpha1_Expr* expr, 
+      const google_api_expr_v1alpha1_SourceInfo* source_info) const = 0; 
+ 
+  virtual StatusOr<std::unique_ptr<CelExpression>> CreateExpression( 
+      const google_api_expr_v1alpha1_Expr* expr, 
+      const google_api_expr_v1alpha1_SourceInfo* source_info, 
+      std::vector<y_absl::Status>* warnings) const = 0; 
+}; 
+ 
+}  // namespace mock_cel 
+}  // namespace grpc_core 
+ 
+#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_EXPRESSION_H 
\ No newline at end of file
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_value.h b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_value.h
index d06b1fcec4..6aad178ade 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_value.h
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/cel_value.h
@@ -1,93 +1,93 @@
-// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H
-
-// CelValue is a holder, capable of storing all kinds of data
-// supported by CEL.
-// CelValue defines explicitly typed/named getters/setters.
-// When storing pointers to objects, CelValue does not accept ownership
-// to them and does not control their lifecycle. Instead objects are expected
-// to be either external to expression evaluation, and controlled beyond the
-// scope or to be allocated and associated with some allocation/ownership
-// controller (Arena).
-// Usage examples:
-// (a) For primitive types:
-//    CelValue value = CelValue::CreateInt64(1);
-// (b) For string:
-//    TString* msg("test");
-//    CelValue value = CelValue::CreateString(msg);
-
-#include <grpc/support/port_platform.h>
-
-#include "y_absl/strings/string_view.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// Break cyclic depdendencies for container types.
-class CelMap {
- public:
-  CelMap() = default;
-};
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this class will be removed.
-class CelValue {
- public:
-  // Default constructor.
-  // Creates CelValue with null data type.
-  CelValue() : CelValue(nullptr) {}
-
-  // We will use factory methods instead of public constructors
-  // The reason for this is the high risk of implicit type conversions
-  // between bool/int/pointer types.
-  // We rely on copy elision to avoid extra copying.
-  static CelValue CreateNull() { return CelValue(nullptr); }
-
-  static CelValue CreateInt64(int64_t value) { return CreateNull(); }
-
-  static CelValue CreateUint64(uint64_t value) { return CreateNull(); }
-
-  static CelValue CreateStringView(y_absl::string_view value) {
-    return CreateNull();
-  }
-
-  static CelValue CreateString(const TString* str) { return CreateNull(); }
-
-  static CelValue CreateMap(const CelMap* value) { return CreateNull(); }
-
- private:
-  // Constructs CelValue wrapping value supplied as argument.
-  // Value type T should be supported by specification of ValueHolder.
-  template <class T>
-  explicit CelValue(T value) {}
-};
-
-// CelMap implementation that uses STL map container as backing storage.
-class ContainerBackedMapImpl : public CelMap {
- public:
-  ContainerBackedMapImpl() = default;
-
-  static std::unique_ptr<CelMap> Create(
-      y_absl::Span<std::pair<CelValue, CelValue>> key_values) {
-    return y_absl::make_unique<ContainerBackedMapImpl>();
-  }
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H
+// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H 
+#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H 
+ 
+// CelValue is a holder, capable of storing all kinds of data 
+// supported by CEL. 
+// CelValue defines explicitly typed/named getters/setters. 
+// When storing pointers to objects, CelValue does not accept ownership 
+// to them and does not control their lifecycle. Instead objects are expected 
+// to be either external to expression evaluation, and controlled beyond the 
+// scope or to be allocated and associated with some allocation/ownership 
+// controller (Arena). 
+// Usage examples: 
+// (a) For primitive types: 
+//    CelValue value = CelValue::CreateInt64(1); 
+// (b) For string: 
+//    TString* msg("test"); 
+//    CelValue value = CelValue::CreateString(msg); 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "y_absl/strings/string_view.h" 
+ 
+namespace grpc_core { 
+namespace mock_cel { 
+ 
+// Break cyclic depdendencies for container types. 
+class CelMap { 
+ public: 
+  CelMap() = default; 
+}; 
+ 
+// This is a temporary stub implementation of CEL APIs. 
+// Once gRPC imports the CEL library, this class will be removed. 
+class CelValue { 
+ public: 
+  // Default constructor. 
+  // Creates CelValue with null data type. 
+  CelValue() : CelValue(nullptr) {} 
+ 
+  // We will use factory methods instead of public constructors 
+  // The reason for this is the high risk of implicit type conversions 
+  // between bool/int/pointer types. 
+  // We rely on copy elision to avoid extra copying. 
+  static CelValue CreateNull() { return CelValue(nullptr); } 
+ 
+  static CelValue CreateInt64(int64_t value) { return CreateNull(); } 
+ 
+  static CelValue CreateUint64(uint64_t value) { return CreateNull(); } 
+ 
+  static CelValue CreateStringView(y_absl::string_view value) { 
+    return CreateNull(); 
+  } 
+ 
+  static CelValue CreateString(const TString* str) { return CreateNull(); } 
+ 
+  static CelValue CreateMap(const CelMap* value) { return CreateNull(); } 
+ 
+ private: 
+  // Constructs CelValue wrapping value supplied as argument. 
+  // Value type T should be supported by specification of ValueHolder. 
+  template <class T> 
+  explicit CelValue(T value) {} 
+}; 
+ 
+// CelMap implementation that uses STL map container as backing storage. 
+class ContainerBackedMapImpl : public CelMap { 
+ public: 
+  ContainerBackedMapImpl() = default; 
+ 
+  static std::unique_ptr<CelMap> Create( 
+      y_absl::Span<std::pair<CelValue, CelValue>> key_values) { 
+    return y_absl::make_unique<ContainerBackedMapImpl>(); 
+  } 
+}; 
+ 
+}  // namespace mock_cel 
+}  // namespace grpc_core 
+ 
+#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_CEL_VALUE_H 
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/evaluator_core.h b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/evaluator_core.h
index 8362e10175..d254747a6c 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/evaluator_core.h
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/evaluator_core.h
@@ -1,67 +1,67 @@
-// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_EVALUATOR_CORE_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_EVALUATOR_CORE_H
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-#include <set>
-#include <vector>
-
-#include "google/api/expr/v1alpha1/syntax.upb.h"
-#include "src/core/lib/security/authorization/mock_cel/activation.h"
-#include "src/core/lib/security/authorization/mock_cel/cel_expression.h"
-#include "src/core/lib/security/authorization/mock_cel/cel_value.h"
-#include "src/core/lib/security/authorization/mock_cel/statusor.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this file will be removed.
-
-class ExpressionStep {
- public:
-  virtual ~ExpressionStep() = default;
-};
-
-using ExecutionPath = std::vector<std::unique_ptr<const ExpressionStep>>;
-
-// Implementation of the CelExpression that utilizes flattening
-// of the expression tree.
-class CelExpressionFlatImpl : public CelExpression {
-  // Constructs CelExpressionFlatImpl instance.
-  // path is flat execution path that is based upon
-  // flattened AST tree. Max iterations dictates the maximum number of
-  // iterations in the comprehension expressions (use 0 to disable the upper
-  // bound).
- public:
-  CelExpressionFlatImpl(const google_api_expr_v1alpha1_Expr* root_expr,
-                        ExecutionPath path, int max_iterations,
-                        std::set<TString> iter_variable_names,
-                        bool enable_unknowns = false,
-                        bool enable_unknown_function_results = false) {}
-
-  // Implementation of CelExpression evaluate method.
-  StatusOr<CelValue> Evaluate(const BaseActivation& activation) const override {
-    return CelValue::CreateNull();
-  }
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_EVALUATOR_CORE_H
\ No newline at end of file
+// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_EVALUATOR_CORE_H 
+#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_EVALUATOR_CORE_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <memory> 
+#include <set> 
+#include <vector> 
+ 
+#include "google/api/expr/v1alpha1/syntax.upb.h" 
+#include "src/core/lib/security/authorization/mock_cel/activation.h" 
+#include "src/core/lib/security/authorization/mock_cel/cel_expression.h" 
+#include "src/core/lib/security/authorization/mock_cel/cel_value.h" 
+#include "src/core/lib/security/authorization/mock_cel/statusor.h" 
+ 
+namespace grpc_core { 
+namespace mock_cel { 
+ 
+// This is a temporary stub implementation of CEL APIs. 
+// Once gRPC imports the CEL library, this file will be removed. 
+ 
+class ExpressionStep { 
+ public: 
+  virtual ~ExpressionStep() = default; 
+}; 
+ 
+using ExecutionPath = std::vector<std::unique_ptr<const ExpressionStep>>; 
+ 
+// Implementation of the CelExpression that utilizes flattening 
+// of the expression tree. 
+class CelExpressionFlatImpl : public CelExpression { 
+  // Constructs CelExpressionFlatImpl instance. 
+  // path is flat execution path that is based upon 
+  // flattened AST tree. Max iterations dictates the maximum number of 
+  // iterations in the comprehension expressions (use 0 to disable the upper 
+  // bound). 
+ public: 
+  CelExpressionFlatImpl(const google_api_expr_v1alpha1_Expr* root_expr, 
+                        ExecutionPath path, int max_iterations, 
+                        std::set<TString> iter_variable_names, 
+                        bool enable_unknowns = false, 
+                        bool enable_unknown_function_results = false) {} 
+ 
+  // Implementation of CelExpression evaluate method. 
+  StatusOr<CelValue> Evaluate(const BaseActivation& activation) const override { 
+    return CelValue::CreateNull(); 
+  } 
+}; 
+ 
+}  // namespace mock_cel 
+}  // namespace grpc_core 
+ 
+#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_EVALUATOR_CORE_H 
\ No newline at end of file
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/flat_expr_builder.h b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/flat_expr_builder.h
index c734704186..682ee7a07d 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/flat_expr_builder.h
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/flat_expr_builder.h
@@ -1,56 +1,56 @@
-// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_FLAT_EXPR_BUILDER_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_FLAT_EXPR_BUILDER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-
-#include "src/core/lib/security/authorization/mock_cel/evaluator_core.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this file will be removed.
-
-// CelExpressionBuilder implementation.
-// Builds instances of CelExpressionFlatImpl.
-class FlatExprBuilder : public CelExpressionBuilder {
- public:
-  FlatExprBuilder() = default;
-
-  cel_base::StatusOr<std::unique_ptr<CelExpression>> CreateExpression(
-      const google::api::expr::v1alpha1::Expr* expr,
-      const google::api::expr::v1alpha1::SourceInfo* source_info)
-      const override {
-    ExecutionPath path;
-    return y_absl::make_unique<CelExpressionFlatImpl>(nullptr, path, 0);
-  }
-
-  cel_base::StatusOr<std::unique_ptr<CelExpression>> CreateExpression(
-      const google::api::expr::v1alpha1::Expr* expr,
-      const google::api::expr::v1alpha1::SourceInfo* source_info,
-      std::vector<y_absl::Status>* warnings) const override {
-    ExecutionPath path;
-    return y_absl::make_unique<CelExpressionFlatImpl>(nullptr, path, 0);
-  }
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_FLAT_EXPR_BUILDER_H
+// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_FLAT_EXPR_BUILDER_H 
+#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_FLAT_EXPR_BUILDER_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <memory> 
+ 
+#include "src/core/lib/security/authorization/mock_cel/evaluator_core.h" 
+ 
+namespace grpc_core { 
+namespace mock_cel { 
+ 
+// This is a temporary stub implementation of CEL APIs. 
+// Once gRPC imports the CEL library, this file will be removed. 
+ 
+// CelExpressionBuilder implementation. 
+// Builds instances of CelExpressionFlatImpl. 
+class FlatExprBuilder : public CelExpressionBuilder { 
+ public: 
+  FlatExprBuilder() = default; 
+ 
+  cel_base::StatusOr<std::unique_ptr<CelExpression>> CreateExpression( 
+      const google::api::expr::v1alpha1::Expr* expr, 
+      const google::api::expr::v1alpha1::SourceInfo* source_info) 
+      const override { 
+    ExecutionPath path; 
+    return y_absl::make_unique<CelExpressionFlatImpl>(nullptr, path, 0); 
+  } 
+ 
+  cel_base::StatusOr<std::unique_ptr<CelExpression>> CreateExpression( 
+      const google::api::expr::v1alpha1::Expr* expr, 
+      const google::api::expr::v1alpha1::SourceInfo* source_info, 
+      std::vector<y_absl::Status>* warnings) const override { 
+    ExecutionPath path; 
+    return y_absl::make_unique<CelExpressionFlatImpl>(nullptr, path, 0); 
+  } 
+}; 
+ 
+}  // namespace mock_cel 
+}  // namespace grpc_core 
+ 
+#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_FLAT_EXPR_BUILDER_H 
diff --git a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/statusor.h b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/statusor.h
index 2002d814c9..37931d0893 100644
--- a/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/statusor.h
+++ b/contrib/libs/grpc/src/core/lib/security/authorization/mock_cel/statusor.h
@@ -1,50 +1,50 @@
-// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_STATUSOR_H
-#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_STATUSOR_H
-
-#include <grpc/support/port_platform.h>
-
-#include <memory>
-
-#include "y_absl/status/status.h"
-
-namespace grpc_core {
-namespace mock_cel {
-
-// This is a temporary stub implementation of CEL APIs.
-// Once gRPC imports the CEL library, this file will be removed.
-
-template <typename T>
-class ABSL_MUST_USE_RESULT StatusOr;
-
-template <typename T>
-class StatusOr {
- public:
-  StatusOr() = default;
-
-  StatusOr(const T& value) {}
-
-  StatusOr(const y_absl::Status& status) {}
-
-  StatusOr(y_absl::Status&& status) {}
-
-  bool ok() const { return true; }
-};
-
-}  // namespace mock_cel
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_STATUSOR_H
\ No newline at end of file
+// 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_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_STATUSOR_H 
+#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_STATUSOR_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <memory> 
+ 
+#include "y_absl/status/status.h" 
+ 
+namespace grpc_core { 
+namespace mock_cel { 
+ 
+// This is a temporary stub implementation of CEL APIs. 
+// Once gRPC imports the CEL library, this file will be removed. 
+ 
+template <typename T> 
+class ABSL_MUST_USE_RESULT StatusOr; 
+ 
+template <typename T> 
+class StatusOr { 
+ public: 
+  StatusOr() = default; 
+ 
+  StatusOr(const T& value) {} 
+ 
+  StatusOr(const y_absl::Status& status) {} 
+ 
+  StatusOr(y_absl::Status&& status) {} 
+ 
+  bool ok() const { return true; } 
+}; 
+ 
+}  // namespace mock_cel 
+}  // namespace grpc_core 
+ 
+#endif  // GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MOCK_CEL_STATUSOR_H 
\ No newline at end of file
diff --git a/contrib/libs/grpc/src/core/lib/security/certificate_provider.h b/contrib/libs/grpc/src/core/lib/security/certificate_provider.h
index 5a9cfee0b9..edf50e023b 100644
--- a/contrib/libs/grpc/src/core/lib/security/certificate_provider.h
+++ b/contrib/libs/grpc/src/core/lib/security/certificate_provider.h
@@ -1,60 +1,60 @@
-//
-//
-// 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_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_H
-#define GRPC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/pollset_set.h"
-
-// TODO(yashkt): After https://github.com/grpc/grpc/pull/23572, remove this
-// forward declaration and include the header for the distributor instead.
-struct grpc_tls_certificate_distributor;
-
-// Interface for a grpc_tls_certificate_provider that handles the process to
-// fetch credentials and validation contexts. Implementations are free to rely
-// on local or remote sources to fetch the latest secrets, and free to share any
-// state among different instances as they deem fit.
-//
-// On creation, grpc_tls_certificate_provider creates a
-// grpc_tls_certificate_distributor object. When the credentials and validation
-// contexts become valid or changed, a grpc_tls_certificate_provider should
-// notify its distributor so as to propagate the update to the watchers.
-struct grpc_tls_certificate_provider
-    : public grpc_core::RefCounted<grpc_tls_certificate_provider> {
- public:
-  grpc_tls_certificate_provider()
-      : interested_parties_(grpc_pollset_set_create()) {}
-
-  virtual ~grpc_tls_certificate_provider() {
-    grpc_pollset_set_destroy(interested_parties_);
-  }
-
-  grpc_pollset_set* interested_parties() const { return interested_parties_; }
-
-  virtual grpc_core::RefCountedPtr<grpc_tls_certificate_distributor>
-  distributor() const = 0;
-
- private:
-  grpc_pollset_set* interested_parties_;
-};
-
-#endif  // GRPC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_H
+// 
+// 
+// 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_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_H 
+#define GRPC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/gprpp/ref_counted.h" 
+#include "src/core/lib/gprpp/ref_counted_ptr.h" 
+#include "src/core/lib/iomgr/pollset_set.h" 
+ 
+// TODO(yashkt): After https://github.com/grpc/grpc/pull/23572, remove this 
+// forward declaration and include the header for the distributor instead. 
+struct grpc_tls_certificate_distributor; 
+ 
+// Interface for a grpc_tls_certificate_provider that handles the process to 
+// fetch credentials and validation contexts. Implementations are free to rely 
+// on local or remote sources to fetch the latest secrets, and free to share any 
+// state among different instances as they deem fit. 
+// 
+// On creation, grpc_tls_certificate_provider creates a 
+// grpc_tls_certificate_distributor object. When the credentials and validation 
+// contexts become valid or changed, a grpc_tls_certificate_provider should 
+// notify its distributor so as to propagate the update to the watchers. 
+struct grpc_tls_certificate_provider 
+    : public grpc_core::RefCounted<grpc_tls_certificate_provider> { 
+ public: 
+  grpc_tls_certificate_provider() 
+      : interested_parties_(grpc_pollset_set_create()) {} 
+ 
+  virtual ~grpc_tls_certificate_provider() { 
+    grpc_pollset_set_destroy(interested_parties_); 
+  } 
+ 
+  grpc_pollset_set* interested_parties() const { return interested_parties_; } 
+ 
+  virtual grpc_core::RefCountedPtr<grpc_tls_certificate_distributor> 
+  distributor() const = 0; 
+ 
+ private: 
+  grpc_pollset_set* interested_parties_; 
+}; 
+ 
+#endif  // GRPC_CORE_LIB_SECURITY_CERTIFICATE_PROVIDER_H 
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/alts/check_gcp_environment.cc b/contrib/libs/grpc/src/core/lib/security/credentials/alts/check_gcp_environment.cc
index 9c98d7a5f4..9962bf4469 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/alts/check_gcp_environment.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/alts/check_gcp_environment.cc
@@ -30,7 +30,7 @@
 const size_t kBiosDataBufferSize = 256;
 
 static char* trim(const char* src) {
-  if (src == nullptr || *src == '\0') {
+  if (src == nullptr || *src == '\0') { 
     return nullptr;
   }
   char* des = nullptr;
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/composite/composite_credentials.cc b/contrib/libs/grpc/src/core/lib/security/credentials/composite/composite_credentials.cc
index a6c82d4774..a39a910e95 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/composite/composite_credentials.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/composite/composite_credentials.cc
@@ -22,10 +22,10 @@
 
 #include <cstring>
 #include <new>
-#include <vector>
+#include <vector> 
 
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_join.h"
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/str_join.h" 
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/surface/api_trace.h"
@@ -119,15 +119,15 @@ void grpc_composite_call_credentials::cancel_get_request_metadata(
   GRPC_ERROR_UNREF(error);
 }
 
-TString grpc_composite_call_credentials::debug_string() {
-  std::vector<TString> outputs;
-  for (auto& inner_cred : inner_) {
-    outputs.emplace_back(inner_cred->debug_string());
-  }
-  return y_absl::StrCat("CompositeCallCredentials{", y_absl::StrJoin(outputs, ","),
-                      "}");
-}
-
+TString grpc_composite_call_credentials::debug_string() { 
+  std::vector<TString> outputs; 
+  for (auto& inner_cred : inner_) { 
+    outputs.emplace_back(inner_cred->debug_string()); 
+  } 
+  return y_absl::StrCat("CompositeCallCredentials{", y_absl::StrJoin(outputs, ","), 
+                      "}"); 
+} 
+ 
 static size_t get_creds_array_size(const grpc_call_credentials* creds,
                                    bool is_composite) {
   return is_composite
@@ -163,13 +163,13 @@ grpc_composite_call_credentials::grpc_composite_call_credentials(
   inner_.reserve(size);
   push_to_inner(std::move(creds1), creds1_is_composite);
   push_to_inner(std::move(creds2), creds2_is_composite);
-  min_security_level_ = GRPC_SECURITY_NONE;
-  for (size_t i = 0; i < inner_.size(); ++i) {
-    if (static_cast<int>(min_security_level_) <
-        static_cast<int>(inner_[i]->min_security_level())) {
-      min_security_level_ = inner_[i]->min_security_level();
-    }
-  }
+  min_security_level_ = GRPC_SECURITY_NONE; 
+  for (size_t i = 0; i < inner_.size(); ++i) { 
+    if (static_cast<int>(min_security_level_) < 
+        static_cast<int>(inner_[i]->min_security_level())) { 
+      min_security_level_ = inner_[i]->min_security_level(); 
+    } 
+  } 
 }
 
 static grpc_core::RefCountedPtr<grpc_call_credentials>
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/composite/composite_credentials.h b/contrib/libs/grpc/src/core/lib/security/credentials/composite/composite_credentials.h
index 5bebb9bd5a..7e7a99bd7c 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/composite/composite_credentials.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/composite/composite_credentials.h
@@ -21,10 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/container/inlined_vector.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/container/inlined_vector.h" 
+ 
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/security/credentials/credentials.h"
 
@@ -72,7 +72,7 @@ class grpc_composite_channel_credentials : public grpc_channel_credentials {
 class grpc_composite_call_credentials : public grpc_call_credentials {
  public:
   using CallCredentialsList =
-      y_absl::InlinedVector<grpc_core::RefCountedPtr<grpc_call_credentials>, 2>;
+      y_absl::InlinedVector<grpc_core::RefCountedPtr<grpc_call_credentials>, 2>; 
 
   grpc_composite_call_credentials(
       grpc_core::RefCountedPtr<grpc_call_credentials> creds1,
@@ -88,17 +88,17 @@ class grpc_composite_call_credentials : public grpc_call_credentials {
   void cancel_get_request_metadata(grpc_credentials_mdelem_array* md_array,
                                    grpc_error* error) override;
 
-  grpc_security_level min_security_level() const override {
-    return min_security_level_;
-  }
-
+  grpc_security_level min_security_level() const override { 
+    return min_security_level_; 
+  } 
+ 
   const CallCredentialsList& inner() const { return inner_; }
-  TString debug_string() override;
+  TString debug_string() override; 
 
  private:
   void push_to_inner(grpc_core::RefCountedPtr<grpc_call_credentials> creds,
                      bool is_composite);
-  grpc_security_level min_security_level_;
+  grpc_security_level min_security_level_; 
   CallCredentialsList inner_;
 };
 
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/credentials.h b/contrib/libs/grpc/src/core/lib/security/credentials/credentials.h
index 15a85cbd0b..d22d435add 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/credentials.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/credentials.h
@@ -21,10 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <string.h>
-
-#include <util/generic/string.h>
-
+#include <string.h> 
+ 
+#include <util/generic/string.h> 
+ 
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/sync.h>
@@ -81,13 +81,13 @@ typedef enum {
 /* --- Google utils --- */
 
 /* It is the caller's responsibility to gpr_free the result if not NULL. */
-TString grpc_get_well_known_google_credentials_file_path(void);
+TString grpc_get_well_known_google_credentials_file_path(void); 
 
 /* Implementation function for the different platforms. */
-TString grpc_get_well_known_google_credentials_file_path_impl(void);
+TString grpc_get_well_known_google_credentials_file_path_impl(void); 
 
 /* Override for testing only. Not thread-safe */
-typedef TString (*grpc_well_known_credentials_path_getter)(void);
+typedef TString (*grpc_well_known_credentials_path_getter)(void); 
 void grpc_override_well_known_credentials_path_getter(
     grpc_well_known_credentials_path_getter getter);
 
@@ -172,11 +172,11 @@ void grpc_credentials_mdelem_array_destroy(grpc_credentials_mdelem_array* list);
 struct grpc_call_credentials
     : public grpc_core::RefCounted<grpc_call_credentials> {
  public:
-  explicit grpc_call_credentials(
-      const char* type,
-      grpc_security_level min_security_level = GRPC_PRIVACY_AND_INTEGRITY)
-      : type_(type), min_security_level_(min_security_level) {}
-
+  explicit grpc_call_credentials( 
+      const char* type, 
+      grpc_security_level min_security_level = GRPC_PRIVACY_AND_INTEGRITY) 
+      : type_(type), min_security_level_(min_security_level) {} 
+ 
   virtual ~grpc_call_credentials() = default;
 
   // Returns true if completed synchronously, in which case \a error will
@@ -195,19 +195,19 @@ struct grpc_call_credentials
   virtual void cancel_get_request_metadata(
       grpc_credentials_mdelem_array* md_array, grpc_error* error) = 0;
 
-  virtual grpc_security_level min_security_level() const {
-    return min_security_level_;
-  }
-
-  virtual TString debug_string() {
-    return "grpc_call_credentials did not provide debug string";
-  }
-
+  virtual grpc_security_level min_security_level() const { 
+    return min_security_level_; 
+  } 
+ 
+  virtual TString debug_string() { 
+    return "grpc_call_credentials did not provide debug string"; 
+  } 
+ 
   const char* type() const { return type_; }
 
  private:
   const char* type_;
-  const grpc_security_level min_security_level_;
+  const grpc_security_level min_security_level_; 
 };
 
 /* Metadata-only credentials with the specified key and value where
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/fake/fake_credentials.h b/contrib/libs/grpc/src/core/lib/security/credentials/fake/fake_credentials.h
index 27f3a28451..f3331121b0 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/fake/fake_credentials.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/fake/fake_credentials.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <string.h>
-
+#include <string.h> 
+ 
 #include "src/core/lib/security/credentials/credentials.h"
 
 #define GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS \
@@ -61,8 +61,8 @@ class grpc_md_only_test_credentials : public grpc_call_credentials {
  public:
   grpc_md_only_test_credentials(const char* md_key, const char* md_value,
                                 bool is_async)
-      : grpc_call_credentials(GRPC_CALL_CREDENTIALS_TYPE_OAUTH2,
-                              GRPC_SECURITY_NONE),
+      : grpc_call_credentials(GRPC_CALL_CREDENTIALS_TYPE_OAUTH2, 
+                              GRPC_SECURITY_NONE), 
         md_(grpc_mdelem_from_slices(grpc_slice_from_copied_string(md_key),
                                     grpc_slice_from_copied_string(md_value))),
         is_async_(is_async) {}
@@ -77,8 +77,8 @@ class grpc_md_only_test_credentials : public grpc_call_credentials {
   void cancel_get_request_metadata(grpc_credentials_mdelem_array* md_array,
                                    grpc_error* error) override;
 
-  TString debug_string() override { return "MD only Test Credentials"; };
-
+  TString debug_string() override { return "MD only Test Credentials"; }; 
+ 
  private:
   grpc_mdelem md_;
   bool is_async_;
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/google_default/credentials_generic.cc b/contrib/libs/grpc/src/core/lib/security/credentials/google_default/credentials_generic.cc
index e8b9bbdadc..7dd1a93541 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/google_default/credentials_generic.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/google_default/credentials_generic.cc
@@ -20,24 +20,24 @@
 
 #include "src/core/lib/security/credentials/google_default/google_default_credentials.h"
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/env.h"
 
-TString grpc_get_well_known_google_credentials_file_path_impl(void) {
+TString grpc_get_well_known_google_credentials_file_path_impl(void) { 
   char* base = gpr_getenv(GRPC_GOOGLE_CREDENTIALS_PATH_ENV_VAR);
   if (base == nullptr) {
     gpr_log(GPR_ERROR, "Could not get " GRPC_GOOGLE_CREDENTIALS_PATH_ENV_VAR
                        " environment variable.");
-    return "";
+    return ""; 
   }
-  TString result =
-      y_absl::StrCat(base, "/", GRPC_GOOGLE_CREDENTIALS_PATH_SUFFIX);
+  TString result = 
+      y_absl::StrCat(base, "/", GRPC_GOOGLE_CREDENTIALS_PATH_SUFFIX); 
   gpr_free(base);
   return result;
 }
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/google_default/google_default_credentials.cc b/contrib/libs/grpc/src/core/lib/security/credentials/google_default/google_default_credentials.cc
index 8f3ca009a5..11949d1cde 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/google_default/google_default_credentials.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/google_default/google_default_credentials.cc
@@ -44,13 +44,13 @@
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/surface/api_trace.h"
 
-using grpc_core::Json;
-
+using grpc_core::Json; 
+ 
 /* -- Constants. -- */
 
 #define GRPC_COMPUTE_ENGINE_DETECTION_HOST "metadata.google.internal."
-#define GRPC_GOOGLE_CREDENTIAL_CREATION_ERROR \
-  "Failed to create Google credentials"
+#define GRPC_GOOGLE_CREDENTIAL_CREATION_ERROR \ 
+  "Failed to create Google credentials" 
 
 /* -- Default credentials. -- */
 
@@ -90,7 +90,7 @@ grpc_google_default_channel_credentials::create_security_connector(
   bool use_alts =
       is_grpclb_load_balancer || is_backend_from_grpclb_load_balancer;
   /* Return failure if ALTS is selected but not running on GCE. */
-  if (use_alts && alts_creds_ == nullptr) {
+  if (use_alts && alts_creds_ == nullptr) { 
     gpr_log(GPR_ERROR, "ALTS is selected, but not running on GCE.");
     return nullptr;
   }
@@ -217,23 +217,23 @@ static int is_metadata_server_reachable() {
 
 /* Takes ownership of creds_path if not NULL. */
 static grpc_error* create_default_creds_from_path(
-    const TString& creds_path,
-    grpc_core::RefCountedPtr<grpc_call_credentials>* creds) {
+    const TString& creds_path, 
+    grpc_core::RefCountedPtr<grpc_call_credentials>* creds) { 
   grpc_auth_json_key key;
   grpc_auth_refresh_token token;
   grpc_core::RefCountedPtr<grpc_call_credentials> result;
   grpc_slice creds_data = grpc_empty_slice();
   grpc_error* error = GRPC_ERROR_NONE;
-  Json json;
-  if (creds_path.empty()) {
+  Json json; 
+  if (creds_path.empty()) { 
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("creds_path unset");
     goto end;
   }
-  error = grpc_load_file(creds_path.c_str(), 0, &creds_data);
-  if (error != GRPC_ERROR_NONE) goto end;
-  json = Json::Parse(grpc_core::StringViewFromSlice(creds_data), &error);
-  if (error != GRPC_ERROR_NONE) goto end;
-  if (json.type() != Json::Type::OBJECT) {
+  error = grpc_load_file(creds_path.c_str(), 0, &creds_data); 
+  if (error != GRPC_ERROR_NONE) goto end; 
+  json = Json::Parse(grpc_core::StringViewFromSlice(creds_data), &error); 
+  if (error != GRPC_ERROR_NONE) goto end; 
+  if (json.type() != Json::Type::OBJECT) { 
     error = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to parse JSON"),
         GRPC_ERROR_STR_RAW_BYTES, grpc_slice_ref_internal(creds_data));
@@ -274,13 +274,13 @@ end:
   return error;
 }
 
-static void update_tenancy() {
+static void update_tenancy() { 
   gpr_once_init(&g_once, init_default_credentials);
-  grpc_core::MutexLock lock(&g_state_mu);
+  grpc_core::MutexLock lock(&g_state_mu); 
 
   /* Try a platform-provided hint for GCE. */
   if (!g_metadata_server_available) {
-    g_metadata_server_available = g_gce_tenancy_checker();
+    g_metadata_server_available = g_gce_tenancy_checker(); 
   }
   /* TODO: Add a platform-provided hint for GAE. */
 
@@ -288,64 +288,64 @@ static void update_tenancy() {
   if (!g_metadata_server_available) {
     g_metadata_server_available = is_metadata_server_reachable();
   }
-}
-
-static bool metadata_server_available() {
-  grpc_core::MutexLock lock(&g_state_mu);
-  return static_cast<bool>(g_metadata_server_available);
-}
-
-static grpc_core::RefCountedPtr<grpc_call_credentials> make_default_call_creds(
-    grpc_error** error) {
-  grpc_core::RefCountedPtr<grpc_call_credentials> call_creds;
-  grpc_error* err;
-
-  /* First, try the environment variable. */
-  char* path_from_env = gpr_getenv(GRPC_GOOGLE_CREDENTIALS_ENV_VAR);
-  if (path_from_env != nullptr) {
-    err = create_default_creds_from_path(path_from_env, &call_creds);
-    gpr_free(path_from_env);
-    if (err == GRPC_ERROR_NONE) return call_creds;
-    *error = grpc_error_add_child(*error, err);
-  }
-
-  /* Then the well-known file. */
-  err = create_default_creds_from_path(
-      grpc_get_well_known_google_credentials_file_path(), &call_creds);
-  if (err == GRPC_ERROR_NONE) return call_creds;
-  *error = grpc_error_add_child(*error, err);
-
-  update_tenancy();
-
-  if (metadata_server_available()) {
+} 
+
+static bool metadata_server_available() { 
+  grpc_core::MutexLock lock(&g_state_mu); 
+  return static_cast<bool>(g_metadata_server_available); 
+} 
+ 
+static grpc_core::RefCountedPtr<grpc_call_credentials> make_default_call_creds( 
+    grpc_error** error) { 
+  grpc_core::RefCountedPtr<grpc_call_credentials> call_creds; 
+  grpc_error* err; 
+ 
+  /* First, try the environment variable. */ 
+  char* path_from_env = gpr_getenv(GRPC_GOOGLE_CREDENTIALS_ENV_VAR); 
+  if (path_from_env != nullptr) { 
+    err = create_default_creds_from_path(path_from_env, &call_creds); 
+    gpr_free(path_from_env); 
+    if (err == GRPC_ERROR_NONE) return call_creds; 
+    *error = grpc_error_add_child(*error, err); 
+  } 
+ 
+  /* Then the well-known file. */ 
+  err = create_default_creds_from_path( 
+      grpc_get_well_known_google_credentials_file_path(), &call_creds); 
+  if (err == GRPC_ERROR_NONE) return call_creds; 
+  *error = grpc_error_add_child(*error, err); 
+ 
+  update_tenancy(); 
+ 
+  if (metadata_server_available()) { 
     call_creds = grpc_core::RefCountedPtr<grpc_call_credentials>(
         grpc_google_compute_engine_credentials_create(nullptr));
     if (call_creds == nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          GRPC_GOOGLE_CREDENTIAL_CREATION_ERROR);
-      *error = grpc_error_add_child(
-          *error, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                      "Failed to get credentials from network"));
+      *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING( 
+          GRPC_GOOGLE_CREDENTIAL_CREATION_ERROR); 
+      *error = grpc_error_add_child( 
+          *error, GRPC_ERROR_CREATE_FROM_STATIC_STRING( 
+                      "Failed to get credentials from network")); 
     }
   }
 
-  return call_creds;
-}
-
-grpc_channel_credentials* grpc_google_default_credentials_create(
-    grpc_call_credentials* call_credentials) {
-  grpc_channel_credentials* result = nullptr;
-  grpc_core::RefCountedPtr<grpc_call_credentials> call_creds(call_credentials);
-  grpc_error* error = nullptr;
-  grpc_core::ExecCtx exec_ctx;
-
-  GRPC_API_TRACE("grpc_google_default_credentials_create(%p)", 1,
-                 (call_credentials));
-
-  if (call_creds == nullptr) {
-    call_creds = make_default_call_creds(&error);
-  }
-
+  return call_creds; 
+} 
+ 
+grpc_channel_credentials* grpc_google_default_credentials_create( 
+    grpc_call_credentials* call_credentials) { 
+  grpc_channel_credentials* result = nullptr; 
+  grpc_core::RefCountedPtr<grpc_call_credentials> call_creds(call_credentials); 
+  grpc_error* error = nullptr; 
+  grpc_core::ExecCtx exec_ctx; 
+ 
+  GRPC_API_TRACE("grpc_google_default_credentials_create(%p)", 1, 
+                 (call_credentials)); 
+ 
+  if (call_creds == nullptr) { 
+    call_creds = make_default_call_creds(&error); 
+  } 
+ 
   if (call_creds != nullptr) {
     /* Create google default credentials. */
     grpc_channel_credentials* ssl_creds =
@@ -358,8 +358,8 @@ grpc_channel_credentials* grpc_google_default_credentials_create(
     grpc_alts_credentials_options_destroy(options);
     auto creds =
         grpc_core::MakeRefCounted<grpc_google_default_channel_credentials>(
-            grpc_core::RefCountedPtr<grpc_channel_credentials>(alts_creds),
-            grpc_core::RefCountedPtr<grpc_channel_credentials>(ssl_creds));
+            grpc_core::RefCountedPtr<grpc_channel_credentials>(alts_creds), 
+            grpc_core::RefCountedPtr<grpc_channel_credentials>(ssl_creds)); 
     result = grpc_composite_channel_credentials_create(
         creds.get(), call_creds.get(), nullptr);
     GPR_ASSERT(result != nullptr);
@@ -393,7 +393,7 @@ void grpc_flush_cached_google_default_credentials(void) {
 
 static grpc_well_known_credentials_path_getter creds_path_getter = nullptr;
 
-TString grpc_get_well_known_google_credentials_file_path(void) {
+TString grpc_get_well_known_google_credentials_file_path(void) { 
   if (creds_path_getter != nullptr) return creds_path_getter();
   return grpc_get_well_known_google_credentials_file_path_impl();
 }
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/iam/iam_credentials.cc b/contrib/libs/grpc/src/core/lib/security/credentials/iam/iam_credentials.cc
index a03e4970b8..086409028c 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/iam/iam_credentials.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/iam/iam_credentials.cc
@@ -25,10 +25,10 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
-#include "y_absl/strings/str_format.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/surface/api_trace.h"
-
+#include "y_absl/strings/str_format.h" 
+#include "src/core/lib/gprpp/ref_counted_ptr.h" 
+#include "src/core/lib/surface/api_trace.h" 
+ 
 grpc_google_iam_credentials::~grpc_google_iam_credentials() {
   grpc_credentials_mdelem_array_destroy(&md_array_);
 }
@@ -48,10 +48,10 @@ void grpc_google_iam_credentials::cancel_get_request_metadata(
 
 grpc_google_iam_credentials::grpc_google_iam_credentials(
     const char* token, const char* authority_selector)
-    : grpc_call_credentials(GRPC_CALL_CREDENTIALS_TYPE_IAM),
-      debug_string_(y_absl::StrFormat(
-          "GoogleIAMCredentials{Token:%s,AuthoritySelector:%s}",
-          token != nullptr ? "present" : "absent", authority_selector)) {
+    : grpc_call_credentials(GRPC_CALL_CREDENTIALS_TYPE_IAM), 
+      debug_string_(y_absl::StrFormat( 
+          "GoogleIAMCredentials{Token:%s,AuthoritySelector:%s}", 
+          token != nullptr ? "present" : "absent", authority_selector)) { 
   grpc_mdelem md = grpc_mdelem_from_slices(
       grpc_slice_from_static_string(GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY),
       grpc_slice_from_copied_string(token));
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/iam/iam_credentials.h b/contrib/libs/grpc/src/core/lib/security/credentials/iam/iam_credentials.h
index 76b6acfa28..d0d0ee8a55 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/iam/iam_credentials.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/iam/iam_credentials.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 #include "src/core/lib/security/credentials/credentials.h"
 
 class grpc_google_iam_credentials : public grpc_call_credentials {
@@ -39,11 +39,11 @@ class grpc_google_iam_credentials : public grpc_call_credentials {
 
   void cancel_get_request_metadata(grpc_credentials_mdelem_array* md_array,
                                    grpc_error* error) override;
-  TString debug_string() override { return debug_string_; }
+  TString debug_string() override { return debug_string_; } 
 
  private:
   grpc_credentials_mdelem_array md_array_;
-  const TString debug_string_;
+  const TString debug_string_; 
 };
 
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_IAM_IAM_CREDENTIALS_H */
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/json_token.cc b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/json_token.cc
index c0c5b52782..e09338c4b6 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/json_token.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/json_token.cc
@@ -39,8 +39,8 @@ extern "C" {
 #include <openssl/pem.h>
 }
 
-using grpc_core::Json;
-
+using grpc_core::Json; 
+ 
 /* --- Constants. --- */
 
 /* 1 hour max. */
@@ -67,7 +67,7 @@ int grpc_auth_json_key_is_valid(const grpc_auth_json_key* json_key) {
          strcmp(json_key->type, GRPC_AUTH_JSON_TYPE_INVALID);
 }
 
-grpc_auth_json_key grpc_auth_json_key_create_from_json(const Json& json) {
+grpc_auth_json_key grpc_auth_json_key_create_from_json(const Json& json) { 
   grpc_auth_json_key result;
   BIO* bio = nullptr;
   const char* prop_value;
@@ -76,7 +76,7 @@ grpc_auth_json_key grpc_auth_json_key_create_from_json(const Json& json) {
 
   memset(&result, 0, sizeof(grpc_auth_json_key));
   result.type = GRPC_AUTH_JSON_TYPE_INVALID;
-  if (json.type() == Json::Type::JSON_NULL) {
+  if (json.type() == Json::Type::JSON_NULL) { 
     gpr_log(GPR_ERROR, "Invalid json.");
     goto end;
   }
@@ -124,10 +124,10 @@ end:
 
 grpc_auth_json_key grpc_auth_json_key_create_from_string(
     const char* json_string) {
-  grpc_error* error = GRPC_ERROR_NONE;
-  Json json = Json::Parse(json_string, &error);
-  GRPC_LOG_IF_ERROR("JSON key parsing", error);
-  return grpc_auth_json_key_create_from_json(json);
+  grpc_error* error = GRPC_ERROR_NONE; 
+  Json json = Json::Parse(json_string, &error); 
+  GRPC_LOG_IF_ERROR("JSON key parsing", error); 
+  return grpc_auth_json_key_create_from_json(json); 
 }
 
 void grpc_auth_json_key_destruct(grpc_auth_json_key* json_key) {
@@ -154,13 +154,13 @@ void grpc_auth_json_key_destruct(grpc_auth_json_key* json_key) {
 /* --- jwt encoding and signature. --- */
 
 static char* encoded_jwt_header(const char* key_id, const char* algorithm) {
-  Json json = Json::Object{
-      {"alg", algorithm},
-      {"typ", GRPC_JWT_TYPE},
-      {"kid", key_id},
-  };
-  TString json_str = json.Dump();
-  return grpc_base64_encode(json_str.c_str(), json_str.size(), 1, 0);
+  Json json = Json::Object{ 
+      {"alg", algorithm}, 
+      {"typ", GRPC_JWT_TYPE}, 
+      {"kid", key_id}, 
+  }; 
+  TString json_str = json.Dump(); 
+  return grpc_base64_encode(json_str.c_str(), json_str.size(), 1, 0); 
 }
 
 static char* encoded_jwt_claim(const grpc_auth_json_key* json_key,
@@ -173,22 +173,22 @@ static char* encoded_jwt_claim(const grpc_auth_json_key* json_key,
     expiration = gpr_time_add(now, grpc_max_auth_token_lifetime());
   }
 
-  Json::Object object = {
-      {"iss", json_key->client_email},
-      {"aud", audience},
-      {"iat", now.tv_sec},
-      {"exp", expiration.tv_sec},
-  };
+  Json::Object object = { 
+      {"iss", json_key->client_email}, 
+      {"aud", audience}, 
+      {"iat", now.tv_sec}, 
+      {"exp", expiration.tv_sec}, 
+  }; 
   if (scope != nullptr) {
-    object["scope"] = scope;
+    object["scope"] = scope; 
   } else {
     /* Unscoped JWTs need a sub field. */
-    object["sub"] = json_key->client_email;
+    object["sub"] = json_key->client_email; 
   }
 
-  Json json(object);
-  TString json_str = json.Dump();
-  return grpc_base64_encode(json_str.c_str(), json_str.size(), 1, 0);
+  Json json(object); 
+  TString json_str = json.Dump(); 
+  return grpc_base64_encode(json_str.c_str(), json_str.size(), 1, 0); 
 }
 
 static char* dot_concat_and_free_strings(char* str1, char* str2) {
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/json_token.h b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/json_token.h
index b9a41c6b2b..ac393473a7 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/json_token.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/json_token.h
@@ -49,8 +49,8 @@ grpc_auth_json_key grpc_auth_json_key_create_from_string(
 
 /* Creates a json_key object from parsed json. Returns an invalid object if a
    parsing error has been encountered. */
-grpc_auth_json_key grpc_auth_json_key_create_from_json(
-    const grpc_core::Json& json);
+grpc_auth_json_key grpc_auth_json_key_create_from_json( 
+    const grpc_core::Json& json); 
 
 /* Destructs the object. */
 void grpc_auth_json_key_destruct(grpc_auth_json_key* json_key);
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_credentials.cc b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_credentials.cc
index d5555c3aa1..aec34cf109 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_credentials.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_credentials.cc
@@ -23,13 +23,13 @@
 #include <inttypes.h>
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_internal.h" 
 #include "src/core/lib/surface/api_trace.h"
 
 #include <grpc/support/alloc.h>
@@ -37,8 +37,8 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
-using grpc_core::Json;
-
+using grpc_core::Json; 
+ 
 void grpc_service_account_jwt_access_credentials::reset_cache() {
   GRPC_MDELEM_UNREF(cached_.jwt_md);
   cached_.jwt_md = GRPC_MDNULL;
@@ -86,14 +86,14 @@ bool grpc_service_account_jwt_access_credentials::get_request_metadata(
     jwt = grpc_jwt_encode_and_sign(&key_, context.service_url, jwt_lifetime_,
                                    nullptr);
     if (jwt != nullptr) {
-      TString md_value = y_absl::StrCat("Bearer ", jwt);
+      TString md_value = y_absl::StrCat("Bearer ", jwt); 
       gpr_free(jwt);
       cached_.jwt_expiration =
           gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), jwt_lifetime_);
       cached_.service_url = gpr_strdup(context.service_url);
       cached_.jwt_md = grpc_mdelem_from_slices(
           grpc_slice_from_static_string(GRPC_AUTHORIZATION_METADATA_KEY),
-          grpc_slice_from_cpp_string(std::move(md_value)));
+          grpc_slice_from_cpp_string(std::move(md_value))); 
       jwt_md = GRPC_MDELEM_REF(cached_.jwt_md);
     }
     gpr_mu_unlock(&cache_mu_);
@@ -141,14 +141,14 @@ grpc_service_account_jwt_access_credentials_create_from_auth_json_key(
 }
 
 static char* redact_private_key(const char* json_key) {
-  grpc_error* error = GRPC_ERROR_NONE;
-  Json json = Json::Parse(json_key, &error);
-  if (error != GRPC_ERROR_NONE || json.type() != Json::Type::OBJECT) {
-    GRPC_ERROR_UNREF(error);
+  grpc_error* error = GRPC_ERROR_NONE; 
+  Json json = Json::Parse(json_key, &error); 
+  if (error != GRPC_ERROR_NONE || json.type() != Json::Type::OBJECT) { 
+    GRPC_ERROR_UNREF(error); 
     return gpr_strdup("<Json failed to parse.>");
   }
-  (*json.mutable_object())["private_key"] = "<redacted>";
-  return gpr_strdup(json.Dump(/*indent=*/2).c_str());
+  (*json.mutable_object())["private_key"] = "<redacted>"; 
+  return gpr_strdup(json.Dump(/*indent=*/2).c_str()); 
 }
 
 grpc_call_credentials* grpc_service_account_jwt_access_credentials_create(
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_credentials.h b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_credentials.h
index 9b60deacb5..949b1905c0 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_credentials.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_credentials.h
@@ -21,12 +21,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <util/generic/string.h>
-
-#include <grpc/support/time.h>
-
-#include "y_absl/strings/str_format.h"
-#include "y_absl/time/time.h"
+#include <util/generic/string.h> 
+ 
+#include <grpc/support/time.h> 
+ 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/time/time.h" 
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/jwt/json_token.h"
 
@@ -49,12 +49,12 @@ class grpc_service_account_jwt_access_credentials
   const gpr_timespec& jwt_lifetime() const { return jwt_lifetime_; }
   const grpc_auth_json_key& key() const { return key_; }
 
-  TString debug_string() override {
-    return y_absl::StrFormat("JWTAccessCredentials{ExpirationTime:%s}",
-                           y_absl::FormatTime(y_absl::FromUnixMicros(
-                               gpr_timespec_to_micros(jwt_lifetime_))));
-  };
-
+  TString debug_string() override { 
+    return y_absl::StrFormat("JWTAccessCredentials{ExpirationTime:%s}", 
+                           y_absl::FormatTime(y_absl::FromUnixMicros( 
+                               gpr_timespec_to_micros(jwt_lifetime_)))); 
+  }; 
+ 
  private:
   void reset_cache();
 
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_verifier.cc b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_verifier.cc
index 0c9e118826..32573ab98d 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_verifier.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_verifier.cc
@@ -35,15 +35,15 @@ extern "C" {
 }
 
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
+#include "src/core/lib/gprpp/manual_constructor.h" 
 #include "src/core/lib/http/httpcli.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/slice/b64.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/ssl_types.h"
 
-using grpc_core::Json;
-
+using grpc_core::Json; 
+ 
 /* --- Utils. --- */
 
 const char* grpc_jwt_verifier_status_to_string(
@@ -80,39 +80,39 @@ static const EVP_MD* evp_md_from_alg(const char* alg) {
   }
 }
 
-static Json parse_json_part_from_jwt(const char* str, size_t len) {
-  grpc_slice slice = grpc_base64_decode_with_len(str, len, 1);
-  if (GRPC_SLICE_IS_EMPTY(slice)) {
+static Json parse_json_part_from_jwt(const char* str, size_t len) { 
+  grpc_slice slice = grpc_base64_decode_with_len(str, len, 1); 
+  if (GRPC_SLICE_IS_EMPTY(slice)) { 
     gpr_log(GPR_ERROR, "Invalid base64.");
-    return Json();  // JSON null
+    return Json();  // JSON null 
   }
-  y_absl::string_view string = grpc_core::StringViewFromSlice(slice);
-  grpc_error* error = GRPC_ERROR_NONE;
-  Json json = Json::Parse(string, &error);
-  if (error != GRPC_ERROR_NONE) {
-    gpr_log(GPR_ERROR, "JSON parse error: %s", grpc_error_string(error));
-    GRPC_ERROR_UNREF(error);
-    json = Json();  // JSON null
+  y_absl::string_view string = grpc_core::StringViewFromSlice(slice); 
+  grpc_error* error = GRPC_ERROR_NONE; 
+  Json json = Json::Parse(string, &error); 
+  if (error != GRPC_ERROR_NONE) { 
+    gpr_log(GPR_ERROR, "JSON parse error: %s", grpc_error_string(error)); 
+    GRPC_ERROR_UNREF(error); 
+    json = Json();  // JSON null 
   }
-  grpc_slice_unref_internal(slice);
+  grpc_slice_unref_internal(slice); 
   return json;
 }
 
-static const char* validate_string_field(const Json& json, const char* key) {
-  if (json.type() != Json::Type::STRING) {
-    gpr_log(GPR_ERROR, "Invalid %s field", key);
+static const char* validate_string_field(const Json& json, const char* key) { 
+  if (json.type() != Json::Type::STRING) { 
+    gpr_log(GPR_ERROR, "Invalid %s field", key); 
     return nullptr;
   }
-  return json.string_value().c_str();
+  return json.string_value().c_str(); 
 }
 
-static gpr_timespec validate_time_field(const Json& json, const char* key) {
+static gpr_timespec validate_time_field(const Json& json, const char* key) { 
   gpr_timespec result = gpr_time_0(GPR_CLOCK_REALTIME);
-  if (json.type() != Json::Type::NUMBER) {
-    gpr_log(GPR_ERROR, "Invalid %s field", key);
+  if (json.type() != Json::Type::NUMBER) { 
+    gpr_log(GPR_ERROR, "Invalid %s field", key); 
     return result;
   }
-  result.tv_sec = strtol(json.string_value().c_str(), nullptr, 10);
+  result.tv_sec = strtol(json.string_value().c_str(), nullptr, 10); 
   return result;
 }
 
@@ -123,51 +123,51 @@ struct jose_header {
   const char* kid;
   const char* typ;
   /* TODO(jboeuf): Add others as needed (jku, jwk, x5u, x5c and so on...). */
-  grpc_core::ManualConstructor<Json> json;
+  grpc_core::ManualConstructor<Json> json; 
 };
 static void jose_header_destroy(jose_header* h) {
-  h->json.Destroy();
+  h->json.Destroy(); 
   gpr_free(h);
 }
 
-static jose_header* jose_header_from_json(Json json) {
-  const char* alg_value;
-  Json::Object::const_iterator it;
+static jose_header* jose_header_from_json(Json json) { 
+  const char* alg_value; 
+  Json::Object::const_iterator it; 
   jose_header* h = static_cast<jose_header*>(gpr_zalloc(sizeof(jose_header)));
-  if (json.type() != Json::Type::OBJECT) {
-    gpr_log(GPR_ERROR, "JSON value is not an object");
-    goto error;
+  if (json.type() != Json::Type::OBJECT) { 
+    gpr_log(GPR_ERROR, "JSON value is not an object"); 
+    goto error; 
   }
-  // Check alg field.
-  it = json.object_value().find("alg");
-  if (it == json.object_value().end()) {
+  // Check alg field. 
+  it = json.object_value().find("alg"); 
+  if (it == json.object_value().end()) { 
     gpr_log(GPR_ERROR, "Missing alg field.");
     goto error;
   }
-  /* We only support RSA-1.5 signatures for now.
-     Beware of this if we add HMAC support:
-     https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/
-   */
-  alg_value = it->second.string_value().c_str();
-  if (it->second.type() != Json::Type::STRING || strncmp(alg_value, "RS", 2) ||
-      evp_md_from_alg(alg_value) == nullptr) {
-    gpr_log(GPR_ERROR, "Invalid alg field");
-    goto error;
-  }
-  h->alg = alg_value;
-  // Check typ field.
-  it = json.object_value().find("typ");
-  if (it != json.object_value().end()) {
-    h->typ = validate_string_field(it->second, "typ");
-    if (h->typ == nullptr) goto error;
-  }
-  // Check kid field.
-  it = json.object_value().find("kid");
-  if (it != json.object_value().end()) {
-    h->kid = validate_string_field(it->second, "kid");
-    if (h->kid == nullptr) goto error;
-  }
-  h->json.Init(std::move(json));
+  /* We only support RSA-1.5 signatures for now. 
+     Beware of this if we add HMAC support: 
+     https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/ 
+   */ 
+  alg_value = it->second.string_value().c_str(); 
+  if (it->second.type() != Json::Type::STRING || strncmp(alg_value, "RS", 2) || 
+      evp_md_from_alg(alg_value) == nullptr) { 
+    gpr_log(GPR_ERROR, "Invalid alg field"); 
+    goto error; 
+  } 
+  h->alg = alg_value; 
+  // Check typ field. 
+  it = json.object_value().find("typ"); 
+  if (it != json.object_value().end()) { 
+    h->typ = validate_string_field(it->second, "typ"); 
+    if (h->typ == nullptr) goto error; 
+  } 
+  // Check kid field. 
+  it = json.object_value().find("kid"); 
+  if (it != json.object_value().end()) { 
+    h->kid = validate_string_field(it->second, "kid"); 
+    if (h->kid == nullptr) goto error; 
+  } 
+  h->json.Init(std::move(json)); 
   return h;
 
 error:
@@ -187,17 +187,17 @@ struct grpc_jwt_claims {
   gpr_timespec exp;
   gpr_timespec nbf;
 
-  grpc_core::ManualConstructor<Json> json;
+  grpc_core::ManualConstructor<Json> json; 
 };
 
 void grpc_jwt_claims_destroy(grpc_jwt_claims* claims) {
-  claims->json.Destroy();
+  claims->json.Destroy(); 
   gpr_free(claims);
 }
 
-const Json* grpc_jwt_claims_json(const grpc_jwt_claims* claims) {
+const Json* grpc_jwt_claims_json(const grpc_jwt_claims* claims) { 
   if (claims == nullptr) return nullptr;
-  return claims->json.get();
+  return claims->json.get(); 
 }
 
 const char* grpc_jwt_claims_subject(const grpc_jwt_claims* claims) {
@@ -235,43 +235,43 @@ gpr_timespec grpc_jwt_claims_not_before(const grpc_jwt_claims* claims) {
   return claims->nbf;
 }
 
-grpc_jwt_claims* grpc_jwt_claims_from_json(Json json) {
+grpc_jwt_claims* grpc_jwt_claims_from_json(Json json) { 
   grpc_jwt_claims* claims =
-      static_cast<grpc_jwt_claims*>(gpr_zalloc(sizeof(grpc_jwt_claims)));
-  claims->json.Init(std::move(json));
+      static_cast<grpc_jwt_claims*>(gpr_zalloc(sizeof(grpc_jwt_claims))); 
+  claims->json.Init(std::move(json)); 
   claims->iat = gpr_inf_past(GPR_CLOCK_REALTIME);
   claims->nbf = gpr_inf_past(GPR_CLOCK_REALTIME);
   claims->exp = gpr_inf_future(GPR_CLOCK_REALTIME);
 
   /* Per the spec, all fields are optional. */
-  for (const auto& p : claims->json->object_value()) {
-    if (p.first == "sub") {
-      claims->sub = validate_string_field(p.second, "sub");
+  for (const auto& p : claims->json->object_value()) { 
+    if (p.first == "sub") { 
+      claims->sub = validate_string_field(p.second, "sub"); 
       if (claims->sub == nullptr) goto error;
-    } else if (p.first == "iss") {
-      claims->iss = validate_string_field(p.second, "iss");
+    } else if (p.first == "iss") { 
+      claims->iss = validate_string_field(p.second, "iss"); 
       if (claims->iss == nullptr) goto error;
-    } else if (p.first == "aud") {
-      claims->aud = validate_string_field(p.second, "aud");
+    } else if (p.first == "aud") { 
+      claims->aud = validate_string_field(p.second, "aud"); 
       if (claims->aud == nullptr) goto error;
-    } else if (p.first == "jti") {
-      claims->jti = validate_string_field(p.second, "jti");
+    } else if (p.first == "jti") { 
+      claims->jti = validate_string_field(p.second, "jti"); 
       if (claims->jti == nullptr) goto error;
-    } else if (p.first == "iat") {
-      claims->iat = validate_time_field(p.second, "iat");
-      if (gpr_time_cmp(claims->iat, gpr_time_0(GPR_CLOCK_REALTIME)) == 0) {
+    } else if (p.first == "iat") { 
+      claims->iat = validate_time_field(p.second, "iat"); 
+      if (gpr_time_cmp(claims->iat, gpr_time_0(GPR_CLOCK_REALTIME)) == 0) { 
         goto error;
-      }
-    } else if (p.first == "exp") {
-      claims->exp = validate_time_field(p.second, "exp");
-      if (gpr_time_cmp(claims->exp, gpr_time_0(GPR_CLOCK_REALTIME)) == 0) {
+      } 
+    } else if (p.first == "exp") { 
+      claims->exp = validate_time_field(p.second, "exp"); 
+      if (gpr_time_cmp(claims->exp, gpr_time_0(GPR_CLOCK_REALTIME)) == 0) { 
         goto error;
-      }
-    } else if (p.first == "nbf") {
-      claims->nbf = validate_time_field(p.second, "nbf");
-      if (gpr_time_cmp(claims->nbf, gpr_time_0(GPR_CLOCK_REALTIME)) == 0) {
+      } 
+    } else if (p.first == "nbf") { 
+      claims->nbf = validate_time_field(p.second, "nbf"); 
+      if (gpr_time_cmp(claims->nbf, gpr_time_0(GPR_CLOCK_REALTIME)) == 0) { 
         goto error;
-      }
+      } 
     }
   }
   return claims;
@@ -334,7 +334,7 @@ typedef enum {
   HTTP_RESPONSE_COUNT /* must be last */
 } http_response_index;
 
-struct verifier_cb_ctx {
+struct verifier_cb_ctx { 
   grpc_jwt_verifier* verifier;
   grpc_polling_entity pollent;
   jose_header* header;
@@ -345,7 +345,7 @@ struct verifier_cb_ctx {
   void* user_data;
   grpc_jwt_verification_done_cb user_cb;
   grpc_http_response responses[HTTP_RESPONSE_COUNT];
-};
+}; 
 /* Takes ownership of the header, claims and signature. */
 static verifier_cb_ctx* verifier_cb_ctx_create(
     grpc_jwt_verifier* verifier, grpc_pollset* pollset, jose_header* header,
@@ -390,10 +390,10 @@ gpr_timespec grpc_jwt_verifier_clock_skew = {60, 0, GPR_TIMESPAN};
 /* Max delay defaults to one minute. */
 grpc_millis grpc_jwt_verifier_max_delay = 60 * GPR_MS_PER_SEC;
 
-struct email_key_mapping {
+struct email_key_mapping { 
   char* email_domain;
   char* key_url_prefix;
-};
+}; 
 struct grpc_jwt_verifier {
   email_key_mapping* mappings;
   size_t num_mappings; /* Should be very few, linear search ok. */
@@ -401,32 +401,32 @@ struct grpc_jwt_verifier {
   grpc_httpcli_context http_ctx;
 };
 
-static Json json_from_http(const grpc_httpcli_response* response) {
+static Json json_from_http(const grpc_httpcli_response* response) { 
   if (response == nullptr) {
     gpr_log(GPR_ERROR, "HTTP response is NULL.");
-    return Json();  // JSON null
+    return Json();  // JSON null 
   }
   if (response->status != 200) {
     gpr_log(GPR_ERROR, "Call to http server failed with error %d.",
             response->status);
-    return Json();  // JSON null
+    return Json();  // JSON null 
   }
-  grpc_error* error = GRPC_ERROR_NONE;
-  Json json = Json::Parse(
-      y_absl::string_view(response->body, response->body_length), &error);
-  if (error != GRPC_ERROR_NONE) {
+  grpc_error* error = GRPC_ERROR_NONE; 
+  Json json = Json::Parse( 
+      y_absl::string_view(response->body, response->body_length), &error); 
+  if (error != GRPC_ERROR_NONE) { 
     gpr_log(GPR_ERROR, "Invalid JSON found in response.");
-    return Json();  // JSON null
+    return Json();  // JSON null 
   }
   return json;
 }
 
-static const Json* find_property_by_name(const Json& json, const char* name) {
-  auto it = json.object_value().find(name);
-  if (it == json.object_value().end()) {
-    return nullptr;
+static const Json* find_property_by_name(const Json& json, const char* name) { 
+  auto it = json.object_value().find(name); 
+  if (it == json.object_value().end()) { 
+    return nullptr; 
   }
-  return &it->second;
+  return &it->second; 
 }
 
 static EVP_PKEY* extract_pkey_from_x509(const char* x509_str) {
@@ -497,15 +497,15 @@ static int RSA_set0_key(RSA* r, BIGNUM* n, BIGNUM* e, BIGNUM* d) {
 }
 #endif  // OPENSSL_VERSION_NUMBER < 0x10100000L
 
-static EVP_PKEY* pkey_from_jwk(const Json& json, const char* kty) {
+static EVP_PKEY* pkey_from_jwk(const Json& json, const char* kty) { 
   RSA* rsa = nullptr;
   EVP_PKEY* result = nullptr;
   BIGNUM* tmp_n = nullptr;
   BIGNUM* tmp_e = nullptr;
-  Json::Object::const_iterator it;
+  Json::Object::const_iterator it; 
 
-  GPR_ASSERT(json.type() == Json::Type::OBJECT);
-  GPR_ASSERT(kty != nullptr);
+  GPR_ASSERT(json.type() == Json::Type::OBJECT); 
+  GPR_ASSERT(kty != nullptr); 
   if (strcmp(kty, "RSA") != 0) {
     gpr_log(GPR_ERROR, "Unsupported key type %s.", kty);
     goto end;
@@ -515,20 +515,20 @@ static EVP_PKEY* pkey_from_jwk(const Json& json, const char* kty) {
     gpr_log(GPR_ERROR, "Could not create rsa key.");
     goto end;
   }
-  it = json.object_value().find("n");
-  if (it == json.object_value().end()) {
-    gpr_log(GPR_ERROR, "Missing RSA public key field.");
-    goto end;
+  it = json.object_value().find("n"); 
+  if (it == json.object_value().end()) { 
+    gpr_log(GPR_ERROR, "Missing RSA public key field."); 
+    goto end; 
   }
-  tmp_n = bignum_from_base64(validate_string_field(it->second, "n"));
-  if (tmp_n == nullptr) goto end;
-  it = json.object_value().find("e");
-  if (it == json.object_value().end()) {
+  tmp_n = bignum_from_base64(validate_string_field(it->second, "n")); 
+  if (tmp_n == nullptr) goto end; 
+  it = json.object_value().find("e"); 
+  if (it == json.object_value().end()) { 
     gpr_log(GPR_ERROR, "Missing RSA public key field.");
     goto end;
   }
-  tmp_e = bignum_from_base64(validate_string_field(it->second, "e"));
-  if (tmp_e == nullptr) goto end;
+  tmp_e = bignum_from_base64(validate_string_field(it->second, "e")); 
+  if (tmp_e == nullptr) goto end; 
   if (!RSA_set0_key(rsa, tmp_n, tmp_e, nullptr)) {
     gpr_log(GPR_ERROR, "Cannot set RSA key from inputs.");
     goto end;
@@ -546,41 +546,41 @@ end:
   return result;
 }
 
-static EVP_PKEY* find_verification_key(const Json& json, const char* header_alg,
+static EVP_PKEY* find_verification_key(const Json& json, const char* header_alg, 
                                        const char* header_kid) {
   /* Try to parse the json as a JWK set:
      https://tools.ietf.org/html/rfc7517#section-5. */
-  const Json* jwt_keys = find_property_by_name(json, "keys");
-  if (jwt_keys == nullptr) {
+  const Json* jwt_keys = find_property_by_name(json, "keys"); 
+  if (jwt_keys == nullptr) { 
     /* Use the google proprietary format which is:
        { <kid1>: <x5091>, <kid2>: <x5092>, ... } */
-    const Json* cur = find_property_by_name(json, header_kid);
+    const Json* cur = find_property_by_name(json, header_kid); 
     if (cur == nullptr) return nullptr;
-    return extract_pkey_from_x509(cur->string_value().c_str());
+    return extract_pkey_from_x509(cur->string_value().c_str()); 
   }
-  if (jwt_keys->type() != Json::Type::ARRAY) {
+  if (jwt_keys->type() != Json::Type::ARRAY) { 
     gpr_log(GPR_ERROR,
             "Unexpected value type of keys property in jwks key set.");
     return nullptr;
   }
   /* Key format is specified in:
      https://tools.ietf.org/html/rfc7518#section-6. */
-  for (const Json& jkey : jwt_keys->array_value()) {
-    if (jkey.type() != Json::Type::OBJECT) continue;
+  for (const Json& jkey : jwt_keys->array_value()) { 
+    if (jkey.type() != Json::Type::OBJECT) continue; 
     const char* alg = nullptr;
-    auto it = jkey.object_value().find("alg");
-    if (it != jkey.object_value().end()) {
-      alg = validate_string_field(it->second, "alg");
-    }
+    auto it = jkey.object_value().find("alg"); 
+    if (it != jkey.object_value().end()) { 
+      alg = validate_string_field(it->second, "alg"); 
+    } 
     const char* kid = nullptr;
-    it = jkey.object_value().find("kid");
-    if (it != jkey.object_value().end()) {
-      kid = validate_string_field(it->second, "kid");
-    }
+    it = jkey.object_value().find("kid"); 
+    if (it != jkey.object_value().end()) { 
+      kid = validate_string_field(it->second, "kid"); 
+    } 
     const char* kty = nullptr;
-    it = jkey.object_value().find("kty");
-    if (it != jkey.object_value().end()) {
-      kty = validate_string_field(it->second, "kty");
+    it = jkey.object_value().find("kty"); 
+    if (it != jkey.object_value().end()) { 
+      kty = validate_string_field(it->second, "kty"); 
     }
     if (alg != nullptr && kid != nullptr && kty != nullptr &&
         strcmp(kid, header_kid) == 0 && strcmp(alg, header_alg) == 0) {
@@ -628,12 +628,12 @@ end:
 
 static void on_keys_retrieved(void* user_data, grpc_error* /*error*/) {
   verifier_cb_ctx* ctx = static_cast<verifier_cb_ctx*>(user_data);
-  Json json = json_from_http(&ctx->responses[HTTP_RESPONSE_KEYS]);
+  Json json = json_from_http(&ctx->responses[HTTP_RESPONSE_KEYS]); 
   EVP_PKEY* verification_key = nullptr;
   grpc_jwt_verifier_status status = GRPC_JWT_VERIFIER_GENERIC_ERROR;
   grpc_jwt_claims* claims = nullptr;
 
-  if (json.type() == Json::Type::JSON_NULL) {
+  if (json.type() == Json::Type::JSON_NULL) { 
     status = GRPC_JWT_VERIFIER_KEY_RETRIEVAL_ERROR;
     goto end;
   }
@@ -668,20 +668,20 @@ end:
 static void on_openid_config_retrieved(void* user_data, grpc_error* /*error*/) {
   verifier_cb_ctx* ctx = static_cast<verifier_cb_ctx*>(user_data);
   const grpc_http_response* response = &ctx->responses[HTTP_RESPONSE_OPENID];
-  Json json = json_from_http(response);
+  Json json = json_from_http(response); 
   grpc_httpcli_request req;
   const char* jwks_uri;
   grpc_resource_quota* resource_quota = nullptr;
-  const Json* cur;
+  const Json* cur; 
 
   /* TODO(jboeuf): Cache the jwks_uri in order to avoid this hop next time. */
-  if (json.type() == Json::Type::JSON_NULL) goto error;
+  if (json.type() == Json::Type::JSON_NULL) goto error; 
   cur = find_property_by_name(json, "jwks_uri");
   if (cur == nullptr) {
     gpr_log(GPR_ERROR, "Could not find jwks_uri in openid config.");
     goto error;
   }
-  jwks_uri = validate_string_field(*cur, "jwks_uri");
+  jwks_uri = validate_string_field(*cur, "jwks_uri"); 
   if (jwks_uri == nullptr) goto error;
   if (strstr(jwks_uri, "https://") != jwks_uri) {
     gpr_log(GPR_ERROR, "Invalid non https jwks_uri: %s.", jwks_uri);
@@ -852,23 +852,23 @@ void grpc_jwt_verifier_verify(grpc_jwt_verifier* verifier,
   grpc_slice signature;
   size_t signed_jwt_len;
   const char* cur = jwt;
-  Json json;
+  Json json; 
 
   GPR_ASSERT(verifier != nullptr && jwt != nullptr && audience != nullptr &&
              cb != nullptr);
   dot = strchr(cur, '.');
   if (dot == nullptr) goto error;
-  json = parse_json_part_from_jwt(cur, static_cast<size_t>(dot - cur));
-  if (json.type() == Json::Type::JSON_NULL) goto error;
-  header = jose_header_from_json(std::move(json));
+  json = parse_json_part_from_jwt(cur, static_cast<size_t>(dot - cur)); 
+  if (json.type() == Json::Type::JSON_NULL) goto error; 
+  header = jose_header_from_json(std::move(json)); 
   if (header == nullptr) goto error;
 
   cur = dot + 1;
   dot = strchr(cur, '.');
   if (dot == nullptr) goto error;
-  json = parse_json_part_from_jwt(cur, static_cast<size_t>(dot - cur));
-  if (json.type() == Json::Type::JSON_NULL) goto error;
-  claims = grpc_jwt_claims_from_json(std::move(json));
+  json = parse_json_part_from_jwt(cur, static_cast<size_t>(dot - cur)); 
+  if (json.type() == Json::Type::JSON_NULL) goto error; 
+  claims = grpc_jwt_claims_from_json(std::move(json)); 
   if (claims == nullptr) goto error;
 
   signed_jwt_len = static_cast<size_t>(dot - jwt);
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_verifier.h b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_verifier.h
index 66ddbf2206..4a799b1601 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_verifier.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/jwt/jwt_verifier.h
@@ -56,7 +56,7 @@ typedef struct grpc_jwt_claims grpc_jwt_claims;
 void grpc_jwt_claims_destroy(grpc_jwt_claims* claims);
 
 /* Returns the whole JSON tree of the claims. */
-const grpc_core::Json* grpc_jwt_claims_json(const grpc_jwt_claims* claims);
+const grpc_core::Json* grpc_jwt_claims_json(const grpc_jwt_claims* claims); 
 
 /* Access to registered claims in https://tools.ietf.org/html/rfc7519#page-9 */
 const char* grpc_jwt_claims_subject(const grpc_jwt_claims* claims);
@@ -114,7 +114,7 @@ void grpc_jwt_verifier_verify(grpc_jwt_verifier* verifier,
 
 /* --- TESTING ONLY exposed functions. --- */
 
-grpc_jwt_claims* grpc_jwt_claims_from_json(grpc_core::Json json);
+grpc_jwt_claims* grpc_jwt_claims_from_json(grpc_core::Json json); 
 grpc_jwt_verifier_status grpc_jwt_claims_check(const grpc_jwt_claims* claims,
                                                const char* audience);
 const char* grpc_jwt_issuer_email_domain(const char* issuer);
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc b/contrib/libs/grpc/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc
index 552ee37cfc..bd1204e5c6 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/oauth2/oauth2_credentials.cc
@@ -23,11 +23,11 @@
 
 #include <string.h>
 
-#include "y_absl/container/inlined_vector.h"
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/str_join.h"
-
+#include "y_absl/container/inlined_vector.h" 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/str_join.h" 
+ 
 #include <grpc/grpc_security.h>
 #include <grpc/impl/codegen/slice.h>
 #include <grpc/slice.h>
@@ -44,8 +44,8 @@
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/uri/uri_parser.h"
 
-using grpc_core::Json;
-
+using grpc_core::Json; 
+ 
 //
 // Auth Refresh Token.
 //
@@ -57,7 +57,7 @@ int grpc_auth_refresh_token_is_valid(
 }
 
 grpc_auth_refresh_token grpc_auth_refresh_token_create_from_json(
-    const Json& json) {
+    const Json& json) { 
   grpc_auth_refresh_token result;
   const char* prop_value;
   int success = 0;
@@ -65,7 +65,7 @@ grpc_auth_refresh_token grpc_auth_refresh_token_create_from_json(
 
   memset(&result, 0, sizeof(grpc_auth_refresh_token));
   result.type = GRPC_AUTH_JSON_TYPE_INVALID;
-  if (json.type() != Json::Type::OBJECT) {
+  if (json.type() != Json::Type::OBJECT) { 
     gpr_log(GPR_ERROR, "Invalid json.");
     goto end;
   }
@@ -94,13 +94,13 @@ end:
 
 grpc_auth_refresh_token grpc_auth_refresh_token_create_from_string(
     const char* json_string) {
-  grpc_error* error = GRPC_ERROR_NONE;
-  Json json = Json::Parse(json_string, &error);
-  if (error != GRPC_ERROR_NONE) {
-    gpr_log(GPR_ERROR, "JSON parsing failed: %s", grpc_error_string(error));
-    GRPC_ERROR_UNREF(error);
-  }
-  return grpc_auth_refresh_token_create_from_json(json);
+  grpc_error* error = GRPC_ERROR_NONE; 
+  Json json = Json::Parse(json_string, &error); 
+  if (error != GRPC_ERROR_NONE) { 
+    gpr_log(GPR_ERROR, "JSON parsing failed: %s", grpc_error_string(error)); 
+    GRPC_ERROR_UNREF(error); 
+  } 
+  return grpc_auth_refresh_token_create_from_json(json); 
 }
 
 void grpc_auth_refresh_token_destruct(grpc_auth_refresh_token* refresh_token) {
@@ -138,7 +138,7 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response(
     grpc_millis* token_lifetime) {
   char* null_terminated_body = nullptr;
   grpc_credentials_status status = GRPC_CREDENTIALS_OK;
-  Json json;
+  Json json; 
 
   if (response == nullptr) {
     gpr_log(GPR_ERROR, "Received NULL response.");
@@ -160,54 +160,54 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response(
     status = GRPC_CREDENTIALS_ERROR;
     goto end;
   } else {
-    const char* access_token = nullptr;
-    const char* token_type = nullptr;
-    const char* expires_in = nullptr;
-    Json::Object::const_iterator it;
-    grpc_error* error = GRPC_ERROR_NONE;
-    json = Json::Parse(null_terminated_body, &error);
-    if (error != GRPC_ERROR_NONE) {
-      gpr_log(GPR_ERROR, "Could not parse JSON from %s: %s",
-              null_terminated_body, grpc_error_string(error));
-      GRPC_ERROR_UNREF(error);
+    const char* access_token = nullptr; 
+    const char* token_type = nullptr; 
+    const char* expires_in = nullptr; 
+    Json::Object::const_iterator it; 
+    grpc_error* error = GRPC_ERROR_NONE; 
+    json = Json::Parse(null_terminated_body, &error); 
+    if (error != GRPC_ERROR_NONE) { 
+      gpr_log(GPR_ERROR, "Could not parse JSON from %s: %s", 
+              null_terminated_body, grpc_error_string(error)); 
+      GRPC_ERROR_UNREF(error); 
       status = GRPC_CREDENTIALS_ERROR;
       goto end;
     }
-    if (json.type() != Json::Type::OBJECT) {
+    if (json.type() != Json::Type::OBJECT) { 
       gpr_log(GPR_ERROR, "Response should be a JSON object");
       status = GRPC_CREDENTIALS_ERROR;
       goto end;
     }
-    it = json.object_value().find("access_token");
-    if (it == json.object_value().end() ||
-        it->second.type() != Json::Type::STRING) {
+    it = json.object_value().find("access_token"); 
+    if (it == json.object_value().end() || 
+        it->second.type() != Json::Type::STRING) { 
       gpr_log(GPR_ERROR, "Missing or invalid access_token in JSON.");
       status = GRPC_CREDENTIALS_ERROR;
       goto end;
     }
-    access_token = it->second.string_value().c_str();
-    it = json.object_value().find("token_type");
-    if (it == json.object_value().end() ||
-        it->second.type() != Json::Type::STRING) {
+    access_token = it->second.string_value().c_str(); 
+    it = json.object_value().find("token_type"); 
+    if (it == json.object_value().end() || 
+        it->second.type() != Json::Type::STRING) { 
       gpr_log(GPR_ERROR, "Missing or invalid token_type in JSON.");
       status = GRPC_CREDENTIALS_ERROR;
       goto end;
     }
-    token_type = it->second.string_value().c_str();
-    it = json.object_value().find("expires_in");
-    if (it == json.object_value().end() ||
-        it->second.type() != Json::Type::NUMBER) {
+    token_type = it->second.string_value().c_str(); 
+    it = json.object_value().find("expires_in"); 
+    if (it == json.object_value().end() || 
+        it->second.type() != Json::Type::NUMBER) { 
       gpr_log(GPR_ERROR, "Missing or invalid expires_in in JSON.");
       status = GRPC_CREDENTIALS_ERROR;
       goto end;
     }
-    expires_in = it->second.string_value().c_str();
-    *token_lifetime = strtol(expires_in, nullptr, 10) * GPR_MS_PER_SEC;
+    expires_in = it->second.string_value().c_str(); 
+    *token_lifetime = strtol(expires_in, nullptr, 10) * GPR_MS_PER_SEC; 
     if (!GRPC_MDISNULL(*token_md)) GRPC_MDELEM_UNREF(*token_md);
     *token_md = grpc_mdelem_from_slices(
         grpc_core::ExternallyManagedSlice(GRPC_AUTHORIZATION_METADATA_KEY),
-        grpc_slice_from_cpp_string(
-            y_absl::StrCat(token_type, " ", access_token)));
+        grpc_slice_from_cpp_string( 
+            y_absl::StrCat(token_type, " ", access_token))); 
     status = GRPC_CREDENTIALS_OK;
   }
 
@@ -216,7 +216,7 @@ end:
     GRPC_MDELEM_UNREF(*token_md);
     *token_md = GRPC_MDNULL;
   }
-  gpr_free(null_terminated_body);
+  gpr_free(null_terminated_body); 
   return status;
 }
 
@@ -360,10 +360,10 @@ grpc_oauth2_token_fetcher_credentials::grpc_oauth2_token_fetcher_credentials()
   grpc_httpcli_context_init(&httpcli_context_);
 }
 
-TString grpc_oauth2_token_fetcher_credentials::debug_string() {
-  return "OAuth2TokenFetcherCredentials";
-}
-
+TString grpc_oauth2_token_fetcher_credentials::debug_string() { 
+  return "OAuth2TokenFetcherCredentials"; 
+} 
+ 
 //
 //  Google Compute Engine credentials.
 //
@@ -402,12 +402,12 @@ class grpc_compute_engine_token_fetcher_credentials
     grpc_resource_quota_unref_internal(resource_quota);
   }
 
-  TString debug_string() override {
-    return y_absl::StrFormat(
-        "GoogleComputeEngineTokenFetcherCredentials{%s}",
-        grpc_oauth2_token_fetcher_credentials::debug_string());
-  }
-
+  TString debug_string() override { 
+    return y_absl::StrFormat( 
+        "GoogleComputeEngineTokenFetcherCredentials{%s}", 
+        grpc_oauth2_token_fetcher_credentials::debug_string()); 
+  } 
+ 
  private:
   grpc_closure http_get_cb_closure_;
 };
@@ -441,9 +441,9 @@ void grpc_google_refresh_token_credentials::fetch_oauth2(
       const_cast<char*>("Content-Type"),
       const_cast<char*>("application/x-www-form-urlencoded")};
   grpc_httpcli_request request;
-  TString body = y_absl::StrFormat(
-      GRPC_REFRESH_TOKEN_POST_BODY_FORMAT_STRING, refresh_token_.client_id,
-      refresh_token_.client_secret, refresh_token_.refresh_token);
+  TString body = y_absl::StrFormat( 
+      GRPC_REFRESH_TOKEN_POST_BODY_FORMAT_STRING, refresh_token_.client_id, 
+      refresh_token_.client_secret, refresh_token_.refresh_token); 
   memset(&request, 0, sizeof(grpc_httpcli_request));
   request.host = (char*)GRPC_GOOGLE_OAUTH2_SERVICE_HOST;
   request.http.path = (char*)GRPC_GOOGLE_OAUTH2_SERVICE_TOKEN_PATH;
@@ -455,8 +455,8 @@ void grpc_google_refresh_token_credentials::fetch_oauth2(
      extreme memory pressure. */
   grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("oauth2_credentials_refresh");
-  grpc_httpcli_post(httpcli_context, pollent, resource_quota, &request,
-                    body.c_str(), body.size(), deadline,
+  grpc_httpcli_post(httpcli_context, pollent, resource_quota, &request, 
+                    body.c_str(), body.size(), deadline, 
                     GRPC_CLOSURE_INIT(&http_post_cb_closure_, response_cb,
                                       metadata_req, grpc_schedule_on_exec_ctx),
                     &metadata_req->response);
@@ -478,21 +478,21 @@ grpc_refresh_token_credentials_create_from_auth_refresh_token(
       refresh_token);
 }
 
-TString grpc_google_refresh_token_credentials::debug_string() {
-  return y_absl::StrFormat("GoogleRefreshToken{ClientID:%s,%s}",
-                         refresh_token_.client_id,
-                         grpc_oauth2_token_fetcher_credentials::debug_string());
-}
-
-static TString create_loggable_refresh_token(
-    grpc_auth_refresh_token* token) {
+TString grpc_google_refresh_token_credentials::debug_string() { 
+  return y_absl::StrFormat("GoogleRefreshToken{ClientID:%s,%s}", 
+                         refresh_token_.client_id, 
+                         grpc_oauth2_token_fetcher_credentials::debug_string()); 
+} 
+ 
+static TString create_loggable_refresh_token( 
+    grpc_auth_refresh_token* token) { 
   if (strcmp(token->type, GRPC_AUTH_JSON_TYPE_INVALID) == 0) {
-    return "<Invalid json token>";
+    return "<Invalid json token>"; 
   }
-  return y_absl::StrFormat(
-      "{\n type: %s\n client_id: %s\n client_secret: "
-      "<redacted>\n refresh_token: <redacted>\n}",
-      token->type, token->client_id);
+  return y_absl::StrFormat( 
+      "{\n type: %s\n client_id: %s\n client_secret: " 
+      "<redacted>\n refresh_token: <redacted>\n}", 
+      token->type, token->client_id); 
 }
 
 grpc_call_credentials* grpc_google_refresh_token_credentials_create(
@@ -503,7 +503,7 @@ grpc_call_credentials* grpc_google_refresh_token_credentials_create(
     gpr_log(GPR_INFO,
             "grpc_refresh_token_credentials_create(json_refresh_token=%s, "
             "reserved=%p)",
-            create_loggable_refresh_token(&token).c_str(), reserved);
+            create_loggable_refresh_token(&token).c_str(), reserved); 
   }
   GPR_ASSERT(reserved == nullptr);
   return grpc_refresh_token_credentials_create_from_auth_refresh_token(token)
@@ -518,10 +518,10 @@ namespace grpc_core {
 
 namespace {
 
-void MaybeAddToBody(const char* field_name, const char* field,
-                    std::vector<TString>* body) {
+void MaybeAddToBody(const char* field_name, const char* field, 
+                    std::vector<TString>* body) { 
   if (field == nullptr || strlen(field) == 0) return;
-  body->push_back(y_absl::StrFormat("&%s=%s", field_name, field));
+  body->push_back(y_absl::StrFormat("&%s=%s", field_name, field)); 
 }
 
 grpc_error* LoadTokenFile(const char* path, gpr_slice* token) {
@@ -551,13 +551,13 @@ class StsTokenFetcherCredentials
 
   ~StsTokenFetcherCredentials() override { grpc_uri_destroy(sts_url_); }
 
-  TString debug_string() override {
-    return y_absl::StrFormat(
-        "StsTokenFetcherCredentials{Path:%s,Authority:%s,%s}", sts_url_->path,
-        sts_url_->authority,
-        grpc_oauth2_token_fetcher_credentials::debug_string());
-  }
-
+  TString debug_string() override { 
+    return y_absl::StrFormat( 
+        "StsTokenFetcherCredentials{Path:%s,Authority:%s,%s}", sts_url_->path, 
+        sts_url_->authority, 
+        grpc_oauth2_token_fetcher_credentials::debug_string()); 
+  } 
+ 
  private:
   void fetch_oauth2(grpc_credentials_metadata_request* metadata_req,
                     grpc_httpcli_context* http_context,
@@ -601,17 +601,17 @@ class StsTokenFetcherCredentials
 
   grpc_error* FillBody(char** body, size_t* body_length) {
     *body = nullptr;
-    std::vector<TString> body_parts;
+    std::vector<TString> body_parts; 
     grpc_slice subject_token = grpc_empty_slice();
     grpc_slice actor_token = grpc_empty_slice();
     grpc_error* err = GRPC_ERROR_NONE;
 
-    auto cleanup = [&body, &body_length, &body_parts, &subject_token,
+    auto cleanup = [&body, &body_length, &body_parts, &subject_token, 
                     &actor_token, &err]() {
       if (err == GRPC_ERROR_NONE) {
-        TString body_str = y_absl::StrJoin(body_parts, "");
-        *body = gpr_strdup(body_str.c_str());
-        *body_length = body_str.size();
+        TString body_str = y_absl::StrJoin(body_parts, ""); 
+        *body = gpr_strdup(body_str.c_str()); 
+        *body_length = body_str.size(); 
       }
       grpc_slice_unref_internal(subject_token);
       grpc_slice_unref_internal(actor_token);
@@ -620,23 +620,23 @@ class StsTokenFetcherCredentials
 
     err = LoadTokenFile(subject_token_path_.get(), &subject_token);
     if (err != GRPC_ERROR_NONE) return cleanup();
-    body_parts.push_back(y_absl::StrFormat(
-        GRPC_STS_POST_MINIMAL_BODY_FORMAT_STRING,
+    body_parts.push_back(y_absl::StrFormat( 
+        GRPC_STS_POST_MINIMAL_BODY_FORMAT_STRING, 
         reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(subject_token)),
-        subject_token_type_.get()));
-    MaybeAddToBody("resource", resource_.get(), &body_parts);
-    MaybeAddToBody("audience", audience_.get(), &body_parts);
-    MaybeAddToBody("scope", scope_.get(), &body_parts);
-    MaybeAddToBody("requested_token_type", requested_token_type_.get(),
-                   &body_parts);
-    if ((actor_token_path_ != nullptr) && *actor_token_path_ != '\0') {
+        subject_token_type_.get())); 
+    MaybeAddToBody("resource", resource_.get(), &body_parts); 
+    MaybeAddToBody("audience", audience_.get(), &body_parts); 
+    MaybeAddToBody("scope", scope_.get(), &body_parts); 
+    MaybeAddToBody("requested_token_type", requested_token_type_.get(), 
+                   &body_parts); 
+    if ((actor_token_path_ != nullptr) && *actor_token_path_ != '\0') { 
       err = LoadTokenFile(actor_token_path_.get(), &actor_token);
       if (err != GRPC_ERROR_NONE) return cleanup();
       MaybeAddToBody(
-          "actor_token",
-          reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(actor_token)),
-          &body_parts);
-      MaybeAddToBody("actor_token_type", actor_token_type_.get(), &body_parts);
+          "actor_token", 
+          reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(actor_token)), 
+          &body_parts); 
+      MaybeAddToBody("actor_token_type", actor_token_type_.get(), &body_parts); 
     }
     return cleanup();
   }
@@ -661,7 +661,7 @@ grpc_error* ValidateStsCredentialsOptions(
     void operator()(grpc_uri* uri) { grpc_uri_destroy(uri); }
   };
   *sts_url_out = nullptr;
-  y_absl::InlinedVector<grpc_error*, 3> error_list;
+  y_absl::InlinedVector<grpc_error*, 3> error_list; 
   std::unique_ptr<grpc_uri, GrpcUriDeleter> sts_url(
       options->token_exchange_service_uri != nullptr
           ? grpc_uri_parse(options->token_exchange_service_uri, false)
@@ -741,15 +741,15 @@ grpc_access_token_credentials::grpc_access_token_credentials(
   grpc_core::ExecCtx exec_ctx;
   access_token_md_ = grpc_mdelem_from_slices(
       grpc_core::ExternallyManagedSlice(GRPC_AUTHORIZATION_METADATA_KEY),
-      grpc_slice_from_cpp_string(y_absl::StrCat("Bearer ", access_token)));
-}
-
-TString grpc_access_token_credentials::debug_string() {
-  bool access_token_present = !GRPC_MDISNULL(access_token_md_);
-  return y_absl::StrFormat("AccessTokenCredentials{Token:%s}",
-                         access_token_present ? "present" : "absent");
+      grpc_slice_from_cpp_string(y_absl::StrCat("Bearer ", access_token))); 
 }
 
+TString grpc_access_token_credentials::debug_string() { 
+  bool access_token_present = !GRPC_MDISNULL(access_token_md_); 
+  return y_absl::StrFormat("AccessTokenCredentials{Token:%s}", 
+                         access_token_present ? "present" : "absent"); 
+} 
+ 
 grpc_call_credentials* grpc_access_token_credentials_create(
     const char* access_token, void* reserved) {
   GRPC_API_TRACE(
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/oauth2/oauth2_credentials.h b/contrib/libs/grpc/src/core/lib/security/credentials/oauth2/oauth2_credentials.h
index fd886405cf..96f7479c5e 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/oauth2/oauth2_credentials.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/oauth2/oauth2_credentials.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 #include <grpc/grpc_security.h>
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/security/credentials/credentials.h"
@@ -52,7 +52,7 @@ grpc_auth_refresh_token grpc_auth_refresh_token_create_from_string(
 /// Creates a refresh token object from parsed json. Returns an invalid object
 /// if a parsing error has been encountered.
 grpc_auth_refresh_token grpc_auth_refresh_token_create_from_json(
-    const grpc_core::Json& json);
+    const grpc_core::Json& json); 
 
 /// Destructs the object.
 void grpc_auth_refresh_token_destruct(grpc_auth_refresh_token* refresh_token);
@@ -85,7 +85,7 @@ class grpc_oauth2_token_fetcher_credentials : public grpc_call_credentials {
 
   void on_http_response(grpc_credentials_metadata_request* r,
                         grpc_error* error);
-  TString debug_string() override;
+  TString debug_string() override; 
 
  protected:
   virtual void fetch_oauth2(grpc_credentials_metadata_request* req,
@@ -114,8 +114,8 @@ class grpc_google_refresh_token_credentials final
     return refresh_token_;
   }
 
-  TString debug_string() override;
-
+  TString debug_string() override; 
+ 
  protected:
   void fetch_oauth2(grpc_credentials_metadata_request* req,
                     grpc_httpcli_context* httpcli_context,
@@ -142,8 +142,8 @@ class grpc_access_token_credentials final : public grpc_call_credentials {
   void cancel_get_request_metadata(grpc_credentials_mdelem_array* md_array,
                                    grpc_error* error) override;
 
-  TString debug_string() override;
-
+  TString debug_string() override; 
+ 
  private:
   grpc_mdelem access_token_md_;
 };
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/plugin/plugin_credentials.cc b/contrib/libs/grpc/src/core/lib/security/credentials/plugin/plugin_credentials.cc
index 40d8fec6e4..3c172053a2 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/plugin/plugin_credentials.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/plugin/plugin_credentials.cc
@@ -22,8 +22,8 @@
 
 #include <string.h>
 
-#include "y_absl/strings/str_cat.h"
-
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -43,19 +43,19 @@ grpc_plugin_credentials::~grpc_plugin_credentials() {
   }
 }
 
-TString grpc_plugin_credentials::debug_string() {
-  char* debug_c_str = nullptr;
-  if (plugin_.debug_string != nullptr) {
-    debug_c_str = plugin_.debug_string(plugin_.state);
-  }
-  TString debug_str(
-      debug_c_str != nullptr
-          ? debug_c_str
-          : "grpc_plugin_credentials did not provide a debug string");
-  gpr_free(debug_c_str);
-  return debug_str;
-}
-
+TString grpc_plugin_credentials::debug_string() { 
+  char* debug_c_str = nullptr; 
+  if (plugin_.debug_string != nullptr) { 
+    debug_c_str = plugin_.debug_string(plugin_.state); 
+  } 
+  TString debug_str( 
+      debug_c_str != nullptr 
+          ? debug_c_str 
+          : "grpc_plugin_credentials did not provide a debug string"); 
+  gpr_free(debug_c_str); 
+  return debug_str; 
+} 
+ 
 void grpc_plugin_credentials::pending_request_remove_locked(
     pending_request* pending_request) {
   if (pending_request->prev == nullptr) {
@@ -87,10 +87,10 @@ static grpc_error* process_plugin_result(
     size_t num_md, grpc_status_code status, const char* error_details) {
   grpc_error* error = GRPC_ERROR_NONE;
   if (status != GRPC_STATUS_OK) {
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat("Getting metadata from plugin failed with error: ",
-                     error_details)
-            .c_str());
+    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat("Getting metadata from plugin failed with error: ", 
+                     error_details) 
+            .c_str()); 
   } else {
     bool seen_illegal_header = false;
     for (size_t i = 0; i < num_md; ++i) {
@@ -253,17 +253,17 @@ void grpc_plugin_credentials::cancel_get_request_metadata(
 }
 
 grpc_plugin_credentials::grpc_plugin_credentials(
-    grpc_metadata_credentials_plugin plugin,
-    grpc_security_level min_security_level)
-    : grpc_call_credentials(plugin.type, min_security_level), plugin_(plugin) {
+    grpc_metadata_credentials_plugin plugin, 
+    grpc_security_level min_security_level) 
+    : grpc_call_credentials(plugin.type, min_security_level), plugin_(plugin) { 
   gpr_mu_init(&mu_);
 }
 
 grpc_call_credentials* grpc_metadata_credentials_create_from_plugin(
-    grpc_metadata_credentials_plugin plugin,
-    grpc_security_level min_security_level, void* reserved) {
+    grpc_metadata_credentials_plugin plugin, 
+    grpc_security_level min_security_level, void* reserved) { 
   GRPC_API_TRACE("grpc_metadata_credentials_create_from_plugin(reserved=%p)", 1,
                  (reserved));
   GPR_ASSERT(reserved == nullptr);
-  return new grpc_plugin_credentials(plugin, min_security_level);
+  return new grpc_plugin_credentials(plugin, min_security_level); 
 }
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/plugin/plugin_credentials.h b/contrib/libs/grpc/src/core/lib/security/credentials/plugin/plugin_credentials.h
index 78bca05fb9..aaac8165f3 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/plugin/plugin_credentials.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/plugin/plugin_credentials.h
@@ -39,8 +39,8 @@ struct grpc_plugin_credentials final : public grpc_call_credentials {
     struct pending_request* next;
   };
 
-  explicit grpc_plugin_credentials(grpc_metadata_credentials_plugin plugin,
-                                   grpc_security_level min_security_level);
+  explicit grpc_plugin_credentials(grpc_metadata_credentials_plugin plugin, 
+                                   grpc_security_level min_security_level); 
   ~grpc_plugin_credentials() override;
 
   bool get_request_metadata(grpc_polling_entity* pollent,
@@ -59,8 +59,8 @@ struct grpc_plugin_credentials final : public grpc_call_credentials {
   // cancelled before completion.
   void pending_request_complete(pending_request* r);
 
-  TString debug_string() override;
-
+  TString debug_string() override; 
+ 
  private:
   void pending_request_remove_locked(pending_request* pending_request);
 
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/ssl/ssl_credentials.cc b/contrib/libs/grpc/src/core/lib/security/credentials/ssl/ssl_credentials.cc
index 3bb7790f5c..76edf780f4 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/ssl/ssl_credentials.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/ssl/ssl_credentials.cc
@@ -117,16 +117,16 @@ void grpc_ssl_credentials::build_config(
   }
 }
 
-void grpc_ssl_credentials::set_min_tls_version(
-    grpc_tls_version min_tls_version) {
-  config_.min_tls_version = min_tls_version;
-}
-
-void grpc_ssl_credentials::set_max_tls_version(
-    grpc_tls_version max_tls_version) {
-  config_.max_tls_version = max_tls_version;
-}
-
+void grpc_ssl_credentials::set_min_tls_version( 
+    grpc_tls_version min_tls_version) { 
+  config_.min_tls_version = min_tls_version; 
+} 
+ 
+void grpc_ssl_credentials::set_max_tls_version( 
+    grpc_tls_version max_tls_version) { 
+  config_.max_tls_version = max_tls_version; 
+} 
+ 
 /* Deprecated in favor of grpc_ssl_credentials_create_ex. Will be removed
  * once all of its call sites are migrated to grpc_ssl_credentials_create_ex. */
 grpc_channel_credentials* grpc_ssl_credentials_create(
@@ -223,16 +223,16 @@ void grpc_ssl_server_credentials::build_config(
   config_.num_key_cert_pairs = num_key_cert_pairs;
 }
 
-void grpc_ssl_server_credentials::set_min_tls_version(
-    grpc_tls_version min_tls_version) {
-  config_.min_tls_version = min_tls_version;
-}
-
-void grpc_ssl_server_credentials::set_max_tls_version(
-    grpc_tls_version max_tls_version) {
-  config_.max_tls_version = max_tls_version;
-}
-
+void grpc_ssl_server_credentials::set_min_tls_version( 
+    grpc_tls_version min_tls_version) { 
+  config_.min_tls_version = min_tls_version; 
+} 
+ 
+void grpc_ssl_server_credentials::set_max_tls_version( 
+    grpc_tls_version max_tls_version) { 
+  config_.max_tls_version = max_tls_version; 
+} 
+ 
 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,
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/ssl/ssl_credentials.h b/contrib/libs/grpc/src/core/lib/security/credentials/ssl/ssl_credentials.h
index 4c90813f8d..f06aa0c575 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/ssl/ssl_credentials.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/ssl/ssl_credentials.h
@@ -38,11 +38,11 @@ class grpc_ssl_credentials : public grpc_channel_credentials {
       const char* target, const grpc_channel_args* args,
       grpc_channel_args** new_args) override;
 
-  // TODO(mattstev): Plumb to wrapped languages. Until then, setting the TLS
-  // version should be done for testing purposes only.
-  void set_min_tls_version(grpc_tls_version min_tls_version);
-  void set_max_tls_version(grpc_tls_version max_tls_version);
-
+  // TODO(mattstev): Plumb to wrapped languages. Until then, setting the TLS 
+  // version should be done for testing purposes only. 
+  void set_min_tls_version(grpc_tls_version min_tls_version); 
+  void set_max_tls_version(grpc_tls_version max_tls_version); 
+ 
  private:
   void build_config(const char* pem_root_certs,
                     grpc_ssl_pem_key_cert_pair* pem_key_cert_pair,
@@ -82,11 +82,11 @@ class grpc_ssl_server_credentials final : public grpc_server_credentials {
                                           config);
   }
 
-  // TODO(mattstev): Plumb to wrapped languages. Until then, setting the TLS
-  // version should be done for testing purposes only.
-  void set_min_tls_version(grpc_tls_version min_tls_version);
-  void set_max_tls_version(grpc_tls_version max_tls_version);
-
+  // TODO(mattstev): Plumb to wrapped languages. Until then, setting the TLS 
+  // version should be done for testing purposes only. 
+  void set_min_tls_version(grpc_tls_version min_tls_version); 
+  void set_max_tls_version(grpc_tls_version max_tls_version); 
+ 
   const grpc_ssl_server_config& config() const { return config_; }
 
  private:
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.cc b/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.cc
index a925cf613e..a03d040ebb 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.cc
@@ -1,321 +1,321 @@
-//
-// 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.
-//
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-#include <stdlib.h>
-#include <string.h>
-
-void grpc_tls_certificate_distributor::SetKeyMaterials(
-    const TString& cert_name, y_absl::optional<TString> pem_root_certs,
-    y_absl::optional<PemKeyCertPairList> pem_key_cert_pairs) {
-  GPR_ASSERT(pem_root_certs.has_value() || pem_key_cert_pairs.has_value());
-  grpc_core::MutexLock lock(&mu_);
-  auto& cert_info = certificate_info_map_[cert_name];
-  if (pem_root_certs.has_value()) {
-    // Successful credential updates will clear any pre-existing error.
-    cert_info.SetRootError(GRPC_ERROR_NONE);
-    for (auto* watcher_ptr : cert_info.root_cert_watchers) {
-      GPR_ASSERT(watcher_ptr != nullptr);
-      const auto watcher_it = watchers_.find(watcher_ptr);
-      GPR_ASSERT(watcher_it != watchers_.end());
-      GPR_ASSERT(watcher_it->second.root_cert_name.has_value());
-      y_absl::optional<PemKeyCertPairList> pem_key_cert_pairs_to_report;
-      if (pem_key_cert_pairs.has_value() &&
-          watcher_it->second.identity_cert_name == cert_name) {
-        pem_key_cert_pairs_to_report = pem_key_cert_pairs;
-      } else if (watcher_it->second.identity_cert_name.has_value()) {
-        auto& identity_cert_info =
-            certificate_info_map_[*watcher_it->second.identity_cert_name];
-        pem_key_cert_pairs_to_report = identity_cert_info.pem_key_cert_pairs;
-      }
-      watcher_ptr->OnCertificatesChanged(
-          pem_root_certs, std::move(pem_key_cert_pairs_to_report));
-    }
-    cert_info.pem_root_certs = std::move(*pem_root_certs);
-  }
-  if (pem_key_cert_pairs.has_value()) {
-    // Successful credential updates will clear any pre-existing error.
-    cert_info.SetIdentityError(GRPC_ERROR_NONE);
-    for (const auto watcher_ptr : cert_info.identity_cert_watchers) {
-      GPR_ASSERT(watcher_ptr != nullptr);
-      const auto watcher_it = watchers_.find(watcher_ptr);
-      GPR_ASSERT(watcher_it != watchers_.end());
-      GPR_ASSERT(watcher_it->second.identity_cert_name.has_value());
-      y_absl::optional<y_absl::string_view> pem_root_certs_to_report;
-      if (pem_root_certs.has_value() &&
-          watcher_it->second.root_cert_name == cert_name) {
-        // In this case, We've already sent the credential updates at the time
-        // when checking pem_root_certs, so we will skip here.
-        continue;
-      } else if (watcher_it->second.root_cert_name.has_value()) {
-        auto& root_cert_info =
-            certificate_info_map_[*watcher_it->second.root_cert_name];
-        pem_root_certs_to_report = root_cert_info.pem_root_certs;
-      }
-      watcher_ptr->OnCertificatesChanged(pem_root_certs_to_report,
-                                         pem_key_cert_pairs);
-    }
-    cert_info.pem_key_cert_pairs = std::move(*pem_key_cert_pairs);
-  }
-}
-
-bool grpc_tls_certificate_distributor::HasRootCerts(
-    const TString& root_cert_name) {
-  grpc_core::MutexLock lock(&mu_);
-  const auto it = certificate_info_map_.find(root_cert_name);
-  return it != certificate_info_map_.end() &&
-         !it->second.pem_root_certs.empty();
-};
-
-bool grpc_tls_certificate_distributor::HasKeyCertPairs(
-    const TString& identity_cert_name) {
-  grpc_core::MutexLock lock(&mu_);
-  const auto it = certificate_info_map_.find(identity_cert_name);
-  return it != certificate_info_map_.end() &&
-         !it->second.pem_key_cert_pairs.empty();
-};
-
-void grpc_tls_certificate_distributor::SetErrorForCert(
-    const TString& cert_name, y_absl::optional<grpc_error*> root_cert_error,
-    y_absl::optional<grpc_error*> identity_cert_error) {
-  GPR_ASSERT(root_cert_error.has_value() || identity_cert_error.has_value());
-  grpc_core::MutexLock lock(&mu_);
-  CertificateInfo& cert_info = certificate_info_map_[cert_name];
-  if (root_cert_error.has_value()) {
-    for (auto* watcher_ptr : cert_info.root_cert_watchers) {
-      GPR_ASSERT(watcher_ptr != nullptr);
-      const auto watcher_it = watchers_.find(watcher_ptr);
-      GPR_ASSERT(watcher_it != watchers_.end());
-      // identity_cert_error_to_report is the error of the identity cert this
-      // watcher is watching, if there is any.
-      grpc_error* identity_cert_error_to_report = GRPC_ERROR_NONE;
-      if (identity_cert_error.has_value() &&
-          watcher_it->second.identity_cert_name == cert_name) {
-        identity_cert_error_to_report = *identity_cert_error;
-      } else if (watcher_it->second.identity_cert_name.has_value()) {
-        auto& identity_cert_info =
-            certificate_info_map_[*watcher_it->second.identity_cert_name];
-        identity_cert_error_to_report = identity_cert_info.identity_cert_error;
-      }
-      watcher_ptr->OnError(GRPC_ERROR_REF(*root_cert_error),
-                           GRPC_ERROR_REF(identity_cert_error_to_report));
-    }
-    cert_info.SetRootError(*root_cert_error);
-  }
-  if (identity_cert_error.has_value()) {
-    for (auto* watcher_ptr : cert_info.identity_cert_watchers) {
-      GPR_ASSERT(watcher_ptr != nullptr);
-      const auto watcher_it = watchers_.find(watcher_ptr);
-      GPR_ASSERT(watcher_it != watchers_.end());
-      // root_cert_error_to_report is the error of the root cert this watcher is
-      // watching, if there is any.
-      grpc_error* root_cert_error_to_report = GRPC_ERROR_NONE;
-      if (root_cert_error.has_value() &&
-          watcher_it->second.root_cert_name == cert_name) {
-        // In this case, We've already sent the error updates at the time when
-        // checking root_cert_error, so we will skip here.
-        continue;
-      } else if (watcher_it->second.root_cert_name.has_value()) {
-        auto& root_cert_info =
-            certificate_info_map_[*watcher_it->second.root_cert_name];
-        root_cert_error_to_report = root_cert_info.root_cert_error;
-      }
-      watcher_ptr->OnError(GRPC_ERROR_REF(root_cert_error_to_report),
-                           GRPC_ERROR_REF(*identity_cert_error));
-    }
-    cert_info.SetIdentityError(*identity_cert_error);
-  }
-};
-
-void grpc_tls_certificate_distributor::SetError(grpc_error* error) {
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
-  grpc_core::MutexLock lock(&mu_);
-  for (const auto& watcher : watchers_) {
-    const auto watcher_ptr = watcher.first;
-    GPR_ASSERT(watcher_ptr != nullptr);
-    const auto& watcher_info = watcher.second;
-    watcher_ptr->OnError(
-        watcher_info.root_cert_name.has_value() ? GRPC_ERROR_REF(error)
-                                                : GRPC_ERROR_NONE,
-        watcher_info.identity_cert_name.has_value() ? GRPC_ERROR_REF(error)
-                                                    : GRPC_ERROR_NONE);
-  }
-  for (auto& cert_info_entry : certificate_info_map_) {
-    auto& cert_info = cert_info_entry.second;
-    cert_info.SetRootError(GRPC_ERROR_REF(error));
-    cert_info.SetIdentityError(GRPC_ERROR_REF(error));
-  }
-  GRPC_ERROR_UNREF(error);
-};
-
-void grpc_tls_certificate_distributor::WatchTlsCertificates(
-    std::unique_ptr<TlsCertificatesWatcherInterface> watcher,
-    y_absl::optional<TString> root_cert_name,
-    y_absl::optional<TString> identity_cert_name) {
-  bool start_watching_root_cert = false;
-  bool already_watching_identity_for_root_cert = false;
-  bool start_watching_identity_cert = false;
-  bool already_watching_root_for_identity_cert = false;
-  GPR_ASSERT(root_cert_name.has_value() || identity_cert_name.has_value());
-  TlsCertificatesWatcherInterface* watcher_ptr = watcher.get();
-  GPR_ASSERT(watcher_ptr != nullptr);
-  // Update watchers_ and certificate_info_map_.
-  {
-    grpc_core::MutexLock lock(&mu_);
-    const auto watcher_it = watchers_.find(watcher_ptr);
-    // The caller needs to cancel the watcher first if it wants to re-register
-    // the watcher.
-    GPR_ASSERT(watcher_it == watchers_.end());
-    watchers_[watcher_ptr] = {std::move(watcher), root_cert_name,
-                              identity_cert_name};
-    y_absl::optional<y_absl::string_view> updated_root_certs;
-    y_absl::optional<PemKeyCertPairList> updated_identity_pairs;
-    grpc_error* root_error = GRPC_ERROR_NONE;
-    grpc_error* identity_error = GRPC_ERROR_NONE;
-    if (root_cert_name.has_value()) {
-      CertificateInfo& cert_info = certificate_info_map_[*root_cert_name];
-      start_watching_root_cert = cert_info.root_cert_watchers.empty();
-      already_watching_identity_for_root_cert =
-          !cert_info.identity_cert_watchers.empty();
-      cert_info.root_cert_watchers.insert(watcher_ptr);
-      root_error = GRPC_ERROR_REF(cert_info.root_cert_error);
-      // Empty credentials will be treated as no updates.
-      if (!cert_info.pem_root_certs.empty()) {
-        updated_root_certs = cert_info.pem_root_certs;
-      }
-    }
-    if (identity_cert_name.has_value()) {
-      CertificateInfo& cert_info = certificate_info_map_[*identity_cert_name];
-      start_watching_identity_cert = cert_info.identity_cert_watchers.empty();
-      already_watching_root_for_identity_cert =
-          !cert_info.root_cert_watchers.empty();
-      cert_info.identity_cert_watchers.insert(watcher_ptr);
-      identity_error = GRPC_ERROR_REF(cert_info.identity_cert_error);
-      // Empty credentials will be treated as no updates.
-      if (!cert_info.pem_key_cert_pairs.empty()) {
-        updated_identity_pairs = cert_info.pem_key_cert_pairs;
-      }
-    }
-    // Notify this watcher if the certs it is watching already had some
-    // contents. Note that an *_cert_error in cert_info only indicates error
-    // occurred while trying to fetch the latest cert, but the updated_*_certs
-    // should always be valid. So we will send the updates regardless of
-    // *_cert_error.
-    if (updated_root_certs.has_value() || updated_identity_pairs.has_value()) {
-      watcher_ptr->OnCertificatesChanged(updated_root_certs,
-                                         std::move(updated_identity_pairs));
-    }
-    // Notify this watcher if the certs it is watching already had some errors.
-    if (root_error != GRPC_ERROR_NONE || identity_error != GRPC_ERROR_NONE) {
-      watcher_ptr->OnError(GRPC_ERROR_REF(root_error),
-                           GRPC_ERROR_REF(identity_error));
-    }
-    GRPC_ERROR_UNREF(root_error);
-    GRPC_ERROR_UNREF(identity_error);
-  }
-  // Invoke watch status callback if needed.
-  {
-    grpc_core::MutexLock lock(&callback_mu_);
-    if (watch_status_callback_ != nullptr) {
-      if (root_cert_name == identity_cert_name &&
-          (start_watching_root_cert || start_watching_identity_cert)) {
-        watch_status_callback_(*root_cert_name, start_watching_root_cert,
-                               start_watching_identity_cert);
-      } else {
-        if (start_watching_root_cert) {
-          watch_status_callback_(*root_cert_name, true,
-                                 already_watching_identity_for_root_cert);
-        }
-        if (start_watching_identity_cert) {
-          watch_status_callback_(*identity_cert_name,
-                                 already_watching_root_for_identity_cert, true);
-        }
-      }
-    }
-  }
-};
-
-void grpc_tls_certificate_distributor::CancelTlsCertificatesWatch(
-    TlsCertificatesWatcherInterface* watcher) {
-  y_absl::optional<TString> root_cert_name;
-  y_absl::optional<TString> identity_cert_name;
-  bool stop_watching_root_cert = false;
-  bool already_watching_identity_for_root_cert = false;
-  bool stop_watching_identity_cert = false;
-  bool already_watching_root_for_identity_cert = false;
-  // Update watchers_ and certificate_info_map_.
-  {
-    grpc_core::MutexLock lock(&mu_);
-    auto it = watchers_.find(watcher);
-    if (it == watchers_.end()) return;
-    WatcherInfo& watcher_info = it->second;
-    root_cert_name = std::move(watcher_info.root_cert_name);
-    identity_cert_name = std::move(watcher_info.identity_cert_name);
-    watchers_.erase(it);
-    if (root_cert_name.has_value()) {
-      auto it = certificate_info_map_.find(*root_cert_name);
-      GPR_ASSERT(it != certificate_info_map_.end());
-      CertificateInfo& cert_info = it->second;
-      cert_info.root_cert_watchers.erase(watcher);
-      stop_watching_root_cert = cert_info.root_cert_watchers.empty();
-      already_watching_identity_for_root_cert =
-          !cert_info.identity_cert_watchers.empty();
-      if (stop_watching_root_cert && !already_watching_identity_for_root_cert) {
-        certificate_info_map_.erase(it);
-      }
-    }
-    if (identity_cert_name.has_value()) {
-      auto it = certificate_info_map_.find(*identity_cert_name);
-      GPR_ASSERT(it != certificate_info_map_.end());
-      CertificateInfo& cert_info = it->second;
-      cert_info.identity_cert_watchers.erase(watcher);
-      stop_watching_identity_cert = cert_info.identity_cert_watchers.empty();
-      already_watching_root_for_identity_cert =
-          !cert_info.root_cert_watchers.empty();
-      if (stop_watching_identity_cert &&
-          !already_watching_root_for_identity_cert) {
-        certificate_info_map_.erase(it);
-      }
-    }
-  }
-  // Invoke watch status callback if needed.
-  {
-    grpc_core::MutexLock lock(&callback_mu_);
-    if (watch_status_callback_ != nullptr) {
-      if (root_cert_name == identity_cert_name &&
-          (stop_watching_root_cert || stop_watching_identity_cert)) {
-        watch_status_callback_(*root_cert_name, !stop_watching_root_cert,
-                               !stop_watching_identity_cert);
-      } else {
-        if (stop_watching_root_cert) {
-          watch_status_callback_(*root_cert_name, false,
-                                 already_watching_identity_for_root_cert);
-        }
-        if (stop_watching_identity_cert) {
-          watch_status_callback_(*identity_cert_name,
-                                 already_watching_root_for_identity_cert,
-                                 false);
-        }
-      }
-    }
-  }
-};
+// 
+// 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. 
+// 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h" 
+ 
+#include <grpc/support/alloc.h> 
+#include <grpc/support/log.h> 
+#include <grpc/support/string_util.h> 
+#include <stdlib.h> 
+#include <string.h> 
+ 
+void grpc_tls_certificate_distributor::SetKeyMaterials( 
+    const TString& cert_name, y_absl::optional<TString> pem_root_certs, 
+    y_absl::optional<PemKeyCertPairList> pem_key_cert_pairs) { 
+  GPR_ASSERT(pem_root_certs.has_value() || pem_key_cert_pairs.has_value()); 
+  grpc_core::MutexLock lock(&mu_); 
+  auto& cert_info = certificate_info_map_[cert_name]; 
+  if (pem_root_certs.has_value()) { 
+    // Successful credential updates will clear any pre-existing error. 
+    cert_info.SetRootError(GRPC_ERROR_NONE); 
+    for (auto* watcher_ptr : cert_info.root_cert_watchers) { 
+      GPR_ASSERT(watcher_ptr != nullptr); 
+      const auto watcher_it = watchers_.find(watcher_ptr); 
+      GPR_ASSERT(watcher_it != watchers_.end()); 
+      GPR_ASSERT(watcher_it->second.root_cert_name.has_value()); 
+      y_absl::optional<PemKeyCertPairList> pem_key_cert_pairs_to_report; 
+      if (pem_key_cert_pairs.has_value() && 
+          watcher_it->second.identity_cert_name == cert_name) { 
+        pem_key_cert_pairs_to_report = pem_key_cert_pairs; 
+      } else if (watcher_it->second.identity_cert_name.has_value()) { 
+        auto& identity_cert_info = 
+            certificate_info_map_[*watcher_it->second.identity_cert_name]; 
+        pem_key_cert_pairs_to_report = identity_cert_info.pem_key_cert_pairs; 
+      } 
+      watcher_ptr->OnCertificatesChanged( 
+          pem_root_certs, std::move(pem_key_cert_pairs_to_report)); 
+    } 
+    cert_info.pem_root_certs = std::move(*pem_root_certs); 
+  } 
+  if (pem_key_cert_pairs.has_value()) { 
+    // Successful credential updates will clear any pre-existing error. 
+    cert_info.SetIdentityError(GRPC_ERROR_NONE); 
+    for (const auto watcher_ptr : cert_info.identity_cert_watchers) { 
+      GPR_ASSERT(watcher_ptr != nullptr); 
+      const auto watcher_it = watchers_.find(watcher_ptr); 
+      GPR_ASSERT(watcher_it != watchers_.end()); 
+      GPR_ASSERT(watcher_it->second.identity_cert_name.has_value()); 
+      y_absl::optional<y_absl::string_view> pem_root_certs_to_report; 
+      if (pem_root_certs.has_value() && 
+          watcher_it->second.root_cert_name == cert_name) { 
+        // In this case, We've already sent the credential updates at the time 
+        // when checking pem_root_certs, so we will skip here. 
+        continue; 
+      } else if (watcher_it->second.root_cert_name.has_value()) { 
+        auto& root_cert_info = 
+            certificate_info_map_[*watcher_it->second.root_cert_name]; 
+        pem_root_certs_to_report = root_cert_info.pem_root_certs; 
+      } 
+      watcher_ptr->OnCertificatesChanged(pem_root_certs_to_report, 
+                                         pem_key_cert_pairs); 
+    } 
+    cert_info.pem_key_cert_pairs = std::move(*pem_key_cert_pairs); 
+  } 
+} 
+ 
+bool grpc_tls_certificate_distributor::HasRootCerts( 
+    const TString& root_cert_name) { 
+  grpc_core::MutexLock lock(&mu_); 
+  const auto it = certificate_info_map_.find(root_cert_name); 
+  return it != certificate_info_map_.end() && 
+         !it->second.pem_root_certs.empty(); 
+}; 
+ 
+bool grpc_tls_certificate_distributor::HasKeyCertPairs( 
+    const TString& identity_cert_name) { 
+  grpc_core::MutexLock lock(&mu_); 
+  const auto it = certificate_info_map_.find(identity_cert_name); 
+  return it != certificate_info_map_.end() && 
+         !it->second.pem_key_cert_pairs.empty(); 
+}; 
+ 
+void grpc_tls_certificate_distributor::SetErrorForCert( 
+    const TString& cert_name, y_absl::optional<grpc_error*> root_cert_error, 
+    y_absl::optional<grpc_error*> identity_cert_error) { 
+  GPR_ASSERT(root_cert_error.has_value() || identity_cert_error.has_value()); 
+  grpc_core::MutexLock lock(&mu_); 
+  CertificateInfo& cert_info = certificate_info_map_[cert_name]; 
+  if (root_cert_error.has_value()) { 
+    for (auto* watcher_ptr : cert_info.root_cert_watchers) { 
+      GPR_ASSERT(watcher_ptr != nullptr); 
+      const auto watcher_it = watchers_.find(watcher_ptr); 
+      GPR_ASSERT(watcher_it != watchers_.end()); 
+      // identity_cert_error_to_report is the error of the identity cert this 
+      // watcher is watching, if there is any. 
+      grpc_error* identity_cert_error_to_report = GRPC_ERROR_NONE; 
+      if (identity_cert_error.has_value() && 
+          watcher_it->second.identity_cert_name == cert_name) { 
+        identity_cert_error_to_report = *identity_cert_error; 
+      } else if (watcher_it->second.identity_cert_name.has_value()) { 
+        auto& identity_cert_info = 
+            certificate_info_map_[*watcher_it->second.identity_cert_name]; 
+        identity_cert_error_to_report = identity_cert_info.identity_cert_error; 
+      } 
+      watcher_ptr->OnError(GRPC_ERROR_REF(*root_cert_error), 
+                           GRPC_ERROR_REF(identity_cert_error_to_report)); 
+    } 
+    cert_info.SetRootError(*root_cert_error); 
+  } 
+  if (identity_cert_error.has_value()) { 
+    for (auto* watcher_ptr : cert_info.identity_cert_watchers) { 
+      GPR_ASSERT(watcher_ptr != nullptr); 
+      const auto watcher_it = watchers_.find(watcher_ptr); 
+      GPR_ASSERT(watcher_it != watchers_.end()); 
+      // root_cert_error_to_report is the error of the root cert this watcher is 
+      // watching, if there is any. 
+      grpc_error* root_cert_error_to_report = GRPC_ERROR_NONE; 
+      if (root_cert_error.has_value() && 
+          watcher_it->second.root_cert_name == cert_name) { 
+        // In this case, We've already sent the error updates at the time when 
+        // checking root_cert_error, so we will skip here. 
+        continue; 
+      } else if (watcher_it->second.root_cert_name.has_value()) { 
+        auto& root_cert_info = 
+            certificate_info_map_[*watcher_it->second.root_cert_name]; 
+        root_cert_error_to_report = root_cert_info.root_cert_error; 
+      } 
+      watcher_ptr->OnError(GRPC_ERROR_REF(root_cert_error_to_report), 
+                           GRPC_ERROR_REF(*identity_cert_error)); 
+    } 
+    cert_info.SetIdentityError(*identity_cert_error); 
+  } 
+}; 
+ 
+void grpc_tls_certificate_distributor::SetError(grpc_error* error) { 
+  GPR_ASSERT(error != GRPC_ERROR_NONE); 
+  grpc_core::MutexLock lock(&mu_); 
+  for (const auto& watcher : watchers_) { 
+    const auto watcher_ptr = watcher.first; 
+    GPR_ASSERT(watcher_ptr != nullptr); 
+    const auto& watcher_info = watcher.second; 
+    watcher_ptr->OnError( 
+        watcher_info.root_cert_name.has_value() ? GRPC_ERROR_REF(error) 
+                                                : GRPC_ERROR_NONE, 
+        watcher_info.identity_cert_name.has_value() ? GRPC_ERROR_REF(error) 
+                                                    : GRPC_ERROR_NONE); 
+  } 
+  for (auto& cert_info_entry : certificate_info_map_) { 
+    auto& cert_info = cert_info_entry.second; 
+    cert_info.SetRootError(GRPC_ERROR_REF(error)); 
+    cert_info.SetIdentityError(GRPC_ERROR_REF(error)); 
+  } 
+  GRPC_ERROR_UNREF(error); 
+}; 
+ 
+void grpc_tls_certificate_distributor::WatchTlsCertificates( 
+    std::unique_ptr<TlsCertificatesWatcherInterface> watcher, 
+    y_absl::optional<TString> root_cert_name, 
+    y_absl::optional<TString> identity_cert_name) { 
+  bool start_watching_root_cert = false; 
+  bool already_watching_identity_for_root_cert = false; 
+  bool start_watching_identity_cert = false; 
+  bool already_watching_root_for_identity_cert = false; 
+  GPR_ASSERT(root_cert_name.has_value() || identity_cert_name.has_value()); 
+  TlsCertificatesWatcherInterface* watcher_ptr = watcher.get(); 
+  GPR_ASSERT(watcher_ptr != nullptr); 
+  // Update watchers_ and certificate_info_map_. 
+  { 
+    grpc_core::MutexLock lock(&mu_); 
+    const auto watcher_it = watchers_.find(watcher_ptr); 
+    // The caller needs to cancel the watcher first if it wants to re-register 
+    // the watcher. 
+    GPR_ASSERT(watcher_it == watchers_.end()); 
+    watchers_[watcher_ptr] = {std::move(watcher), root_cert_name, 
+                              identity_cert_name}; 
+    y_absl::optional<y_absl::string_view> updated_root_certs; 
+    y_absl::optional<PemKeyCertPairList> updated_identity_pairs; 
+    grpc_error* root_error = GRPC_ERROR_NONE; 
+    grpc_error* identity_error = GRPC_ERROR_NONE; 
+    if (root_cert_name.has_value()) { 
+      CertificateInfo& cert_info = certificate_info_map_[*root_cert_name]; 
+      start_watching_root_cert = cert_info.root_cert_watchers.empty(); 
+      already_watching_identity_for_root_cert = 
+          !cert_info.identity_cert_watchers.empty(); 
+      cert_info.root_cert_watchers.insert(watcher_ptr); 
+      root_error = GRPC_ERROR_REF(cert_info.root_cert_error); 
+      // Empty credentials will be treated as no updates. 
+      if (!cert_info.pem_root_certs.empty()) { 
+        updated_root_certs = cert_info.pem_root_certs; 
+      } 
+    } 
+    if (identity_cert_name.has_value()) { 
+      CertificateInfo& cert_info = certificate_info_map_[*identity_cert_name]; 
+      start_watching_identity_cert = cert_info.identity_cert_watchers.empty(); 
+      already_watching_root_for_identity_cert = 
+          !cert_info.root_cert_watchers.empty(); 
+      cert_info.identity_cert_watchers.insert(watcher_ptr); 
+      identity_error = GRPC_ERROR_REF(cert_info.identity_cert_error); 
+      // Empty credentials will be treated as no updates. 
+      if (!cert_info.pem_key_cert_pairs.empty()) { 
+        updated_identity_pairs = cert_info.pem_key_cert_pairs; 
+      } 
+    } 
+    // Notify this watcher if the certs it is watching already had some 
+    // contents. Note that an *_cert_error in cert_info only indicates error 
+    // occurred while trying to fetch the latest cert, but the updated_*_certs 
+    // should always be valid. So we will send the updates regardless of 
+    // *_cert_error. 
+    if (updated_root_certs.has_value() || updated_identity_pairs.has_value()) { 
+      watcher_ptr->OnCertificatesChanged(updated_root_certs, 
+                                         std::move(updated_identity_pairs)); 
+    } 
+    // Notify this watcher if the certs it is watching already had some errors. 
+    if (root_error != GRPC_ERROR_NONE || identity_error != GRPC_ERROR_NONE) { 
+      watcher_ptr->OnError(GRPC_ERROR_REF(root_error), 
+                           GRPC_ERROR_REF(identity_error)); 
+    } 
+    GRPC_ERROR_UNREF(root_error); 
+    GRPC_ERROR_UNREF(identity_error); 
+  } 
+  // Invoke watch status callback if needed. 
+  { 
+    grpc_core::MutexLock lock(&callback_mu_); 
+    if (watch_status_callback_ != nullptr) { 
+      if (root_cert_name == identity_cert_name && 
+          (start_watching_root_cert || start_watching_identity_cert)) { 
+        watch_status_callback_(*root_cert_name, start_watching_root_cert, 
+                               start_watching_identity_cert); 
+      } else { 
+        if (start_watching_root_cert) { 
+          watch_status_callback_(*root_cert_name, true, 
+                                 already_watching_identity_for_root_cert); 
+        } 
+        if (start_watching_identity_cert) { 
+          watch_status_callback_(*identity_cert_name, 
+                                 already_watching_root_for_identity_cert, true); 
+        } 
+      } 
+    } 
+  } 
+}; 
+ 
+void grpc_tls_certificate_distributor::CancelTlsCertificatesWatch( 
+    TlsCertificatesWatcherInterface* watcher) { 
+  y_absl::optional<TString> root_cert_name; 
+  y_absl::optional<TString> identity_cert_name; 
+  bool stop_watching_root_cert = false; 
+  bool already_watching_identity_for_root_cert = false; 
+  bool stop_watching_identity_cert = false; 
+  bool already_watching_root_for_identity_cert = false; 
+  // Update watchers_ and certificate_info_map_. 
+  { 
+    grpc_core::MutexLock lock(&mu_); 
+    auto it = watchers_.find(watcher); 
+    if (it == watchers_.end()) return; 
+    WatcherInfo& watcher_info = it->second; 
+    root_cert_name = std::move(watcher_info.root_cert_name); 
+    identity_cert_name = std::move(watcher_info.identity_cert_name); 
+    watchers_.erase(it); 
+    if (root_cert_name.has_value()) { 
+      auto it = certificate_info_map_.find(*root_cert_name); 
+      GPR_ASSERT(it != certificate_info_map_.end()); 
+      CertificateInfo& cert_info = it->second; 
+      cert_info.root_cert_watchers.erase(watcher); 
+      stop_watching_root_cert = cert_info.root_cert_watchers.empty(); 
+      already_watching_identity_for_root_cert = 
+          !cert_info.identity_cert_watchers.empty(); 
+      if (stop_watching_root_cert && !already_watching_identity_for_root_cert) { 
+        certificate_info_map_.erase(it); 
+      } 
+    } 
+    if (identity_cert_name.has_value()) { 
+      auto it = certificate_info_map_.find(*identity_cert_name); 
+      GPR_ASSERT(it != certificate_info_map_.end()); 
+      CertificateInfo& cert_info = it->second; 
+      cert_info.identity_cert_watchers.erase(watcher); 
+      stop_watching_identity_cert = cert_info.identity_cert_watchers.empty(); 
+      already_watching_root_for_identity_cert = 
+          !cert_info.root_cert_watchers.empty(); 
+      if (stop_watching_identity_cert && 
+          !already_watching_root_for_identity_cert) { 
+        certificate_info_map_.erase(it); 
+      } 
+    } 
+  } 
+  // Invoke watch status callback if needed. 
+  { 
+    grpc_core::MutexLock lock(&callback_mu_); 
+    if (watch_status_callback_ != nullptr) { 
+      if (root_cert_name == identity_cert_name && 
+          (stop_watching_root_cert || stop_watching_identity_cert)) { 
+        watch_status_callback_(*root_cert_name, !stop_watching_root_cert, 
+                               !stop_watching_identity_cert); 
+      } else { 
+        if (stop_watching_root_cert) { 
+          watch_status_callback_(*root_cert_name, false, 
+                                 already_watching_identity_for_root_cert); 
+        } 
+        if (stop_watching_identity_cert) { 
+          watch_status_callback_(*identity_cert_name, 
+                                 already_watching_root_for_identity_cert, 
+                                 false); 
+        } 
+      } 
+    } 
+  } 
+}; 
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h b/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h
index 15d76da420..628db70815 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.h
@@ -1,214 +1,214 @@
-//
-// 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_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_DISTRIBUTOR_H
-#define GRPC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_DISTRIBUTOR_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/grpc_security.h>
-
-#include "y_absl/container/inlined_vector.h"
-#include "y_absl/types/optional.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/security/security_connector/ssl_utils.h"
-
-// TLS certificate distributor.
-struct grpc_tls_certificate_distributor
-    : public grpc_core::RefCounted<grpc_tls_certificate_distributor> {
- public:
-  typedef y_absl::InlinedVector<grpc_core::PemKeyCertPair, 1> PemKeyCertPairList;
-
-  // Interface for watching TLS certificates update.
-  class TlsCertificatesWatcherInterface {
-   public:
-    virtual ~TlsCertificatesWatcherInterface() = default;
-
-    // Handles the delivery of the updated root and identity certificates.
-    // An y_absl::nullopt value indicates no corresponding contents for
-    // root_certs or key_cert_pairs. Note that we will send updates of the
-    // latest contents for both root and identity certificates, even when only
-    // one side of it got updated.
-    //
-    // @param root_certs the contents of the reloaded root certs.
-    // @param key_cert_pairs the contents of the reloaded identity key-cert
-    // pairs.
-    virtual void OnCertificatesChanged(
-        y_absl::optional<y_absl::string_view> root_certs,
-        y_absl::optional<PemKeyCertPairList> key_cert_pairs) = 0;
-
-    // Handles an error that occurs while attempting to fetch certificate data.
-    // Note that if a watcher sees an error, it simply means the Provider is
-    // having problems renewing new data. If the watcher has previously received
-    // several OnCertificatesChanged, all the data received from that function
-    // is valid.
-    // In that case, watcher might simply log the error. If the watcher hasn't
-    // received any OnCertificatesChanged before the error occurs, no valid
-    // data is available yet, and the watcher should either fail or "waiting"
-    // for the valid data in a non-blocking way.
-    //
-    // @param root_cert_error the error occurred while reloading root
-    // certificates.
-    // @param identity_cert_error the error occurred while reloading identity
-    // certificates.
-    virtual void OnError(grpc_error* root_cert_error,
-                         grpc_error* identity_cert_error) = 0;
-  };
-
-  // Sets the key materials based on their certificate name. Note that we are
-  // not doing any copies for pem_root_certs and pem_key_cert_pairs. For
-  // pem_root_certs, the original string contents need to outlive the
-  // distributor; for pem_key_cert_pairs, internally it is taking two
-  // unique_ptr(s) to the credential string, so the ownership is actually
-  // transferred.
-  //
-  // @param cert_name The name of the certificates being updated.
-  // @param pem_root_certs The content of root certificates.
-  // @param pem_key_cert_pairs The content of identity key-cert pairs.
-  void SetKeyMaterials(const TString& cert_name,
-                       y_absl::optional<TString> pem_root_certs,
-                       y_absl::optional<PemKeyCertPairList> pem_key_cert_pairs);
-
-  bool HasRootCerts(const TString& root_cert_name);
-
-  bool HasKeyCertPairs(const TString& identity_cert_name);
-
-  // Propagates the error that the caller (e.g. Producer) encounters to all the
-  // watchers watching a particular certificate name.
-  //
-  // @param cert_name The watching cert name of the watchers that the caller
-  // wants to notify when encountering error.
-  // @param root_cert_error The error that the caller encounters when reloading
-  // root certs.
-  // @param identity_cert_error The error that the caller encounters when
-  // reloading identity certs.
-  void SetErrorForCert(const TString& cert_name,
-                       y_absl::optional<grpc_error*> root_cert_error,
-                       y_absl::optional<grpc_error*> identity_cert_error);
-
-  // Propagates the error that the caller (e.g. Producer) encounters to all
-  // watchers.
-  //
-  // @param error The error that the caller encounters.
-  void SetError(grpc_error* error);
-
-  // Sets the TLS certificate watch status callback function. The
-  // grpc_tls_certificate_distributor will invoke this callback when a new
-  // certificate name is watched by a newly registered watcher, or when a
-  // certificate name is no longer watched by any watchers.
-  // Note that when the callback shows a cert is no longer being watched, the
-  // distributor will delete the corresponding certificate data from its cache,
-  // and clear the corresponding error, if there is any. This means that if the
-  // callback subsequently says the same cert is now being watched again, the
-  // provider must re-provide the credentials or re-invoke the errors to the
-  // distributor, to indicate a successful or failed reloading.
-  // @param callback The callback function being set by the caller, e.g the
-  // Producer. Note that this callback will be invoked for each certificate
-  // name.
-  //
-  // For the parameters in the callback function:
-  // string_value The name of the certificates being watched.
-  // bool_value_1 If the root certificates with the specific name are being
-  // watched. bool_value_2 If the identity certificates with the specific name
-  // are being watched.
-  void SetWatchStatusCallback(
-      std::function<void(TString, bool, bool)> callback) {
-    grpc_core::MutexLock lock(&mu_);
-    watch_status_callback_ = callback;
-  };
-
-  // Registers a watcher. The caller may keep a raw pointer to the watcher,
-  // which may be used only for cancellation. (Because the caller does not own
-  // the watcher, the pointer must not be used for any other purpose.) At least
-  // one of root_cert_name and identity_cert_name must be specified.
-  //
-  // @param watcher The watcher being registered.
-  // @param root_cert_name The name of the root certificates that will be
-  // watched. If set to y_absl::nullopt, the root certificates won't be watched.
-  // @param identity_cert_name The name of the identity certificates that will
-  // be watched. If set to y_absl::nullopt, the identity certificates won't be
-  // watched.
-  void WatchTlsCertificates(
-      std::unique_ptr<TlsCertificatesWatcherInterface> watcher,
-      y_absl::optional<TString> root_cert_name,
-      y_absl::optional<TString> identity_cert_name);
-
-  // Cancels a watcher.
-  //
-  // @param watcher The watcher being cancelled.
-  void CancelTlsCertificatesWatch(TlsCertificatesWatcherInterface* watcher);
-
- private:
-  // Contains the information about each watcher.
-  struct WatcherInfo {
-    std::unique_ptr<TlsCertificatesWatcherInterface> watcher;
-    y_absl::optional<TString> root_cert_name;
-    y_absl::optional<TString> identity_cert_name;
-  };
-  // CertificateInfo contains the credential contents and some additional
-  // watcher information.
-  // Note that having errors doesn't indicate the corresponding credentials are
-  // invalid. For example, if root_cert_error != nullptr but pem_root_certs has
-  // value, it simply means an error occurs while trying to fetch the latest
-  // root certs, while pem_root_certs still contains the valid old data.
-  struct CertificateInfo {
-    // The contents of the root certificates.
-    TString pem_root_certs;
-    // The contents of the identity key-certificate pairs.
-    PemKeyCertPairList pem_key_cert_pairs;
-    // The root cert reloading error propagated by the caller.
-    grpc_error* root_cert_error = GRPC_ERROR_NONE;
-    // The identity cert reloading error propagated by the caller.
-    grpc_error* identity_cert_error = GRPC_ERROR_NONE;
-    // The set of watchers watching root certificates.
-    // This is mainly used for quickly looking up the affected watchers while
-    // performing a credential reloading.
-    std::set<TlsCertificatesWatcherInterface*> root_cert_watchers;
-    // The set of watchers watching identity certificates. This is mainly used
-    // for quickly looking up the affected watchers while performing a
-    // credential reloading.
-    std::set<TlsCertificatesWatcherInterface*> identity_cert_watchers;
-
-    ~CertificateInfo() {
-      GRPC_ERROR_UNREF(root_cert_error);
-      GRPC_ERROR_UNREF(identity_cert_error);
-    }
-    void SetRootError(grpc_error* error) {
-      GRPC_ERROR_UNREF(root_cert_error);
-      root_cert_error = error;
-    }
-    void SetIdentityError(grpc_error* error) {
-      GRPC_ERROR_UNREF(identity_cert_error);
-      identity_cert_error = error;
-    }
-  };
-
-  grpc_core::Mutex mu_;
-  // We need a dedicated mutex for watch_status_callback_ for allowing
-  // callers(e.g. Producer) to directly set key materials in the callback
-  // functions.
-  grpc_core::Mutex callback_mu_;
-  // Stores information about each watcher.
-  std::map<TlsCertificatesWatcherInterface*, WatcherInfo> watchers_;
-  // The callback to notify the caller, e.g. the Producer, that the watch status
-  // is changed.
-  std::function<void(TString, bool, bool)> watch_status_callback_;
-  // Stores the names of each certificate, and their corresponding credential
-  // contents as well as some additional watcher information.
-  std::map<TString, CertificateInfo> certificate_info_map_;
-};
-
-#endif  // GRPC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_DISTRIBUTOR_H
+// 
+// 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_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_DISTRIBUTOR_H 
+#define GRPC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_DISTRIBUTOR_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <grpc/grpc_security.h> 
+ 
+#include "y_absl/container/inlined_vector.h" 
+#include "y_absl/types/optional.h" 
+#include "src/core/lib/gprpp/ref_counted.h" 
+#include "src/core/lib/security/security_connector/ssl_utils.h" 
+ 
+// TLS certificate distributor. 
+struct grpc_tls_certificate_distributor 
+    : public grpc_core::RefCounted<grpc_tls_certificate_distributor> { 
+ public: 
+  typedef y_absl::InlinedVector<grpc_core::PemKeyCertPair, 1> PemKeyCertPairList; 
+ 
+  // Interface for watching TLS certificates update. 
+  class TlsCertificatesWatcherInterface { 
+   public: 
+    virtual ~TlsCertificatesWatcherInterface() = default; 
+ 
+    // Handles the delivery of the updated root and identity certificates. 
+    // An y_absl::nullopt value indicates no corresponding contents for 
+    // root_certs or key_cert_pairs. Note that we will send updates of the 
+    // latest contents for both root and identity certificates, even when only 
+    // one side of it got updated. 
+    // 
+    // @param root_certs the contents of the reloaded root certs. 
+    // @param key_cert_pairs the contents of the reloaded identity key-cert 
+    // pairs. 
+    virtual void OnCertificatesChanged( 
+        y_absl::optional<y_absl::string_view> root_certs, 
+        y_absl::optional<PemKeyCertPairList> key_cert_pairs) = 0; 
+ 
+    // Handles an error that occurs while attempting to fetch certificate data. 
+    // Note that if a watcher sees an error, it simply means the Provider is 
+    // having problems renewing new data. If the watcher has previously received 
+    // several OnCertificatesChanged, all the data received from that function 
+    // is valid. 
+    // In that case, watcher might simply log the error. If the watcher hasn't 
+    // received any OnCertificatesChanged before the error occurs, no valid 
+    // data is available yet, and the watcher should either fail or "waiting" 
+    // for the valid data in a non-blocking way. 
+    // 
+    // @param root_cert_error the error occurred while reloading root 
+    // certificates. 
+    // @param identity_cert_error the error occurred while reloading identity 
+    // certificates. 
+    virtual void OnError(grpc_error* root_cert_error, 
+                         grpc_error* identity_cert_error) = 0; 
+  }; 
+ 
+  // Sets the key materials based on their certificate name. Note that we are 
+  // not doing any copies for pem_root_certs and pem_key_cert_pairs. For 
+  // pem_root_certs, the original string contents need to outlive the 
+  // distributor; for pem_key_cert_pairs, internally it is taking two 
+  // unique_ptr(s) to the credential string, so the ownership is actually 
+  // transferred. 
+  // 
+  // @param cert_name The name of the certificates being updated. 
+  // @param pem_root_certs The content of root certificates. 
+  // @param pem_key_cert_pairs The content of identity key-cert pairs. 
+  void SetKeyMaterials(const TString& cert_name, 
+                       y_absl::optional<TString> pem_root_certs, 
+                       y_absl::optional<PemKeyCertPairList> pem_key_cert_pairs); 
+ 
+  bool HasRootCerts(const TString& root_cert_name); 
+ 
+  bool HasKeyCertPairs(const TString& identity_cert_name); 
+ 
+  // Propagates the error that the caller (e.g. Producer) encounters to all the 
+  // watchers watching a particular certificate name. 
+  // 
+  // @param cert_name The watching cert name of the watchers that the caller 
+  // wants to notify when encountering error. 
+  // @param root_cert_error The error that the caller encounters when reloading 
+  // root certs. 
+  // @param identity_cert_error The error that the caller encounters when 
+  // reloading identity certs. 
+  void SetErrorForCert(const TString& cert_name, 
+                       y_absl::optional<grpc_error*> root_cert_error, 
+                       y_absl::optional<grpc_error*> identity_cert_error); 
+ 
+  // Propagates the error that the caller (e.g. Producer) encounters to all 
+  // watchers. 
+  // 
+  // @param error The error that the caller encounters. 
+  void SetError(grpc_error* error); 
+ 
+  // Sets the TLS certificate watch status callback function. The 
+  // grpc_tls_certificate_distributor will invoke this callback when a new 
+  // certificate name is watched by a newly registered watcher, or when a 
+  // certificate name is no longer watched by any watchers. 
+  // Note that when the callback shows a cert is no longer being watched, the 
+  // distributor will delete the corresponding certificate data from its cache, 
+  // and clear the corresponding error, if there is any. This means that if the 
+  // callback subsequently says the same cert is now being watched again, the 
+  // provider must re-provide the credentials or re-invoke the errors to the 
+  // distributor, to indicate a successful or failed reloading. 
+  // @param callback The callback function being set by the caller, e.g the 
+  // Producer. Note that this callback will be invoked for each certificate 
+  // name. 
+  // 
+  // For the parameters in the callback function: 
+  // string_value The name of the certificates being watched. 
+  // bool_value_1 If the root certificates with the specific name are being 
+  // watched. bool_value_2 If the identity certificates with the specific name 
+  // are being watched. 
+  void SetWatchStatusCallback( 
+      std::function<void(TString, bool, bool)> callback) { 
+    grpc_core::MutexLock lock(&mu_); 
+    watch_status_callback_ = callback; 
+  }; 
+ 
+  // Registers a watcher. The caller may keep a raw pointer to the watcher, 
+  // which may be used only for cancellation. (Because the caller does not own 
+  // the watcher, the pointer must not be used for any other purpose.) At least 
+  // one of root_cert_name and identity_cert_name must be specified. 
+  // 
+  // @param watcher The watcher being registered. 
+  // @param root_cert_name The name of the root certificates that will be 
+  // watched. If set to y_absl::nullopt, the root certificates won't be watched. 
+  // @param identity_cert_name The name of the identity certificates that will 
+  // be watched. If set to y_absl::nullopt, the identity certificates won't be 
+  // watched. 
+  void WatchTlsCertificates( 
+      std::unique_ptr<TlsCertificatesWatcherInterface> watcher, 
+      y_absl::optional<TString> root_cert_name, 
+      y_absl::optional<TString> identity_cert_name); 
+ 
+  // Cancels a watcher. 
+  // 
+  // @param watcher The watcher being cancelled. 
+  void CancelTlsCertificatesWatch(TlsCertificatesWatcherInterface* watcher); 
+ 
+ private: 
+  // Contains the information about each watcher. 
+  struct WatcherInfo { 
+    std::unique_ptr<TlsCertificatesWatcherInterface> watcher; 
+    y_absl::optional<TString> root_cert_name; 
+    y_absl::optional<TString> identity_cert_name; 
+  }; 
+  // CertificateInfo contains the credential contents and some additional 
+  // watcher information. 
+  // Note that having errors doesn't indicate the corresponding credentials are 
+  // invalid. For example, if root_cert_error != nullptr but pem_root_certs has 
+  // value, it simply means an error occurs while trying to fetch the latest 
+  // root certs, while pem_root_certs still contains the valid old data. 
+  struct CertificateInfo { 
+    // The contents of the root certificates. 
+    TString pem_root_certs; 
+    // The contents of the identity key-certificate pairs. 
+    PemKeyCertPairList pem_key_cert_pairs; 
+    // The root cert reloading error propagated by the caller. 
+    grpc_error* root_cert_error = GRPC_ERROR_NONE; 
+    // The identity cert reloading error propagated by the caller. 
+    grpc_error* identity_cert_error = GRPC_ERROR_NONE; 
+    // The set of watchers watching root certificates. 
+    // This is mainly used for quickly looking up the affected watchers while 
+    // performing a credential reloading. 
+    std::set<TlsCertificatesWatcherInterface*> root_cert_watchers; 
+    // The set of watchers watching identity certificates. This is mainly used 
+    // for quickly looking up the affected watchers while performing a 
+    // credential reloading. 
+    std::set<TlsCertificatesWatcherInterface*> identity_cert_watchers; 
+ 
+    ~CertificateInfo() { 
+      GRPC_ERROR_UNREF(root_cert_error); 
+      GRPC_ERROR_UNREF(identity_cert_error); 
+    } 
+    void SetRootError(grpc_error* error) { 
+      GRPC_ERROR_UNREF(root_cert_error); 
+      root_cert_error = error; 
+    } 
+    void SetIdentityError(grpc_error* error) { 
+      GRPC_ERROR_UNREF(identity_cert_error); 
+      identity_cert_error = error; 
+    } 
+  }; 
+ 
+  grpc_core::Mutex mu_; 
+  // We need a dedicated mutex for watch_status_callback_ for allowing 
+  // callers(e.g. Producer) to directly set key materials in the callback 
+  // functions. 
+  grpc_core::Mutex callback_mu_; 
+  // Stores information about each watcher. 
+  std::map<TlsCertificatesWatcherInterface*, WatcherInfo> watchers_; 
+  // The callback to notify the caller, e.g. the Producer, that the watch status 
+  // is changed. 
+  std::function<void(TString, bool, bool)> watch_status_callback_; 
+  // Stores the names of each certificate, and their corresponding credential 
+  // contents as well as some additional watcher information. 
+  std::map<TString, CertificateInfo> certificate_info_map_; 
+}; 
+ 
+#endif  // GRPC_CORE_LIB_SECURITY_CREDENTIALS_TLS_GRPC_TLS_CERTIFICATE_DISTRIBUTOR_H 
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_credentials_options.cc b/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_credentials_options.cc
index 906a2f0209..48581cf967 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_credentials_options.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_credentials_options.cc
@@ -29,30 +29,30 @@
 
 /** -- gRPC TLS key materials config API implementation. -- **/
 void grpc_tls_key_materials_config::set_key_materials(
-    const char* pem_root_certs,
-    const grpc_ssl_pem_key_cert_pair** pem_key_cert_pairs,
-    size_t num_key_cert_pairs) {
-  this->set_pem_root_certs(pem_root_certs);
-  grpc_tls_key_materials_config::PemKeyCertPairList cert_pair_list;
-  for (size_t i = 0; i < num_key_cert_pairs; i++) {
-    auto current_pair = static_cast<grpc_ssl_pem_key_cert_pair*>(
-        gpr_zalloc(sizeof(grpc_ssl_pem_key_cert_pair)));
-    current_pair->cert_chain = gpr_strdup(pem_key_cert_pairs[i]->cert_chain);
-    current_pair->private_key = gpr_strdup(pem_key_cert_pairs[i]->private_key);
-    cert_pair_list.emplace_back(grpc_core::PemKeyCertPair(current_pair));
-  }
-  pem_key_cert_pair_list_ = std::move(cert_pair_list);
-}
-
-void grpc_tls_key_materials_config::set_key_materials(
-    const char* pem_root_certs,
-    const PemKeyCertPairList& pem_key_cert_pair_list) {
-  this->set_pem_root_certs(pem_root_certs);
-  grpc_tls_key_materials_config::PemKeyCertPairList dup_list(
-      pem_key_cert_pair_list);
-  pem_key_cert_pair_list_ = std::move(dup_list);
-}
-
+    const char* pem_root_certs, 
+    const grpc_ssl_pem_key_cert_pair** pem_key_cert_pairs, 
+    size_t num_key_cert_pairs) { 
+  this->set_pem_root_certs(pem_root_certs); 
+  grpc_tls_key_materials_config::PemKeyCertPairList cert_pair_list; 
+  for (size_t i = 0; i < num_key_cert_pairs; i++) { 
+    auto current_pair = static_cast<grpc_ssl_pem_key_cert_pair*>( 
+        gpr_zalloc(sizeof(grpc_ssl_pem_key_cert_pair))); 
+    current_pair->cert_chain = gpr_strdup(pem_key_cert_pairs[i]->cert_chain); 
+    current_pair->private_key = gpr_strdup(pem_key_cert_pairs[i]->private_key); 
+    cert_pair_list.emplace_back(grpc_core::PemKeyCertPair(current_pair)); 
+  } 
+  pem_key_cert_pair_list_ = std::move(cert_pair_list); 
+}
+
+void grpc_tls_key_materials_config::set_key_materials( 
+    const char* pem_root_certs, 
+    const PemKeyCertPairList& pem_key_cert_pair_list) { 
+  this->set_pem_root_certs(pem_root_certs); 
+  grpc_tls_key_materials_config::PemKeyCertPairList dup_list( 
+      pem_key_cert_pair_list); 
+  pem_key_cert_pair_list_ = std::move(dup_list); 
+} 
+ 
 /** -- gRPC TLS credential reload config API implementation. -- **/
 grpc_tls_credential_reload_config::grpc_tls_credential_reload_config(
     const void* config_user_data,
@@ -110,26 +110,26 @@ int grpc_tls_credentials_options_set_cert_request_type(
   return 1;
 }
 
-int grpc_tls_credentials_options_set_server_verification_option(
-    grpc_tls_credentials_options* options,
-    grpc_tls_server_verification_option server_verification_option) {
-  if (options == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Invalid nullptr arguments to "
-            "grpc_tls_credentials_options_set_server_verification_option()");
-    return 0;
-  }
-  if (server_verification_option != GRPC_TLS_SERVER_VERIFICATION &&
-      options->server_authorization_check_config() == nullptr) {
-    gpr_log(GPR_ERROR,
-            "server_authorization_check_config needs to be specified when"
-            "server_verification_option is not GRPC_TLS_SERVER_VERIFICATION");
-    return 0;
-  }
-  options->set_server_verification_option(server_verification_option);
-  return 1;
-}
-
+int grpc_tls_credentials_options_set_server_verification_option( 
+    grpc_tls_credentials_options* options, 
+    grpc_tls_server_verification_option server_verification_option) { 
+  if (options == nullptr) { 
+    gpr_log(GPR_ERROR, 
+            "Invalid nullptr arguments to " 
+            "grpc_tls_credentials_options_set_server_verification_option()"); 
+    return 0; 
+  } 
+  if (server_verification_option != GRPC_TLS_SERVER_VERIFICATION && 
+      options->server_authorization_check_config() == nullptr) { 
+    gpr_log(GPR_ERROR, 
+            "server_authorization_check_config needs to be specified when" 
+            "server_verification_option is not GRPC_TLS_SERVER_VERIFICATION"); 
+    return 0; 
+  } 
+  options->set_server_verification_option(server_verification_option); 
+  return 1; 
+} 
+ 
 int grpc_tls_credentials_options_set_key_materials_config(
     grpc_tls_credentials_options* options,
     grpc_tls_key_materials_config* config) {
@@ -183,7 +183,7 @@ int grpc_tls_key_materials_config_set_key_materials(
             "grpc_tls_key_materials_config_set_key_materials()");
     return 0;
   }
-  config->set_key_materials(root_certs, key_cert_pairs, num);
+  config->set_key_materials(root_certs, key_cert_pairs, num); 
   return 1;
 }
 
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h b/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h
index 59411d4169..864f659e61 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h
@@ -23,29 +23,29 @@
 
 #include <grpc/grpc_security.h>
 
-#include "y_absl/container/inlined_vector.h"
-
+#include "y_absl/container/inlined_vector.h" 
+ 
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
 
-struct grpc_tls_error_details
-    : public grpc_core::RefCounted<grpc_tls_error_details> {
- public:
-  grpc_tls_error_details() : error_details_("") {}
-  void set_error_details(const char* err_details) {
-    error_details_ = err_details;
-  }
-  const TString& error_details() { return error_details_; }
-
- private:
-  TString error_details_;
-};
-
+struct grpc_tls_error_details 
+    : public grpc_core::RefCounted<grpc_tls_error_details> { 
+ public: 
+  grpc_tls_error_details() : error_details_("") {} 
+  void set_error_details(const char* err_details) { 
+    error_details_ = err_details; 
+  } 
+  const TString& error_details() { return error_details_; } 
+ 
+ private: 
+  TString error_details_; 
+}; 
+ 
 /** TLS key materials config. **/
 struct grpc_tls_key_materials_config
     : public grpc_core::RefCounted<grpc_tls_key_materials_config> {
  public:
-  typedef y_absl::InlinedVector<grpc_core::PemKeyCertPair, 1> PemKeyCertPairList;
+  typedef y_absl::InlinedVector<grpc_core::PemKeyCertPair, 1> PemKeyCertPairList; 
 
   /** Getters for member fields. **/
   const char* pem_root_certs() const { return pem_root_certs_.get(); }
@@ -55,28 +55,28 @@ struct grpc_tls_key_materials_config
   int version() const { return version_; }
 
   /** Setters for member fields. **/
-  // TODO(ZhenLian): Remove this function
+  // TODO(ZhenLian): Remove this function 
   void set_pem_root_certs(grpc_core::UniquePtr<char> pem_root_certs) {
     pem_root_certs_ = std::move(pem_root_certs);
   }
-  // The ownerships of |pem_root_certs| remain with the caller.
-  void set_pem_root_certs(const char* pem_root_certs) {
-    // make a copy of pem_root_certs.
-    grpc_core::UniquePtr<char> pem_root_ptr(gpr_strdup(pem_root_certs));
-    pem_root_certs_ = std::move(pem_root_ptr);
-  }
+  // The ownerships of |pem_root_certs| remain with the caller. 
+  void set_pem_root_certs(const char* pem_root_certs) { 
+    // make a copy of pem_root_certs. 
+    grpc_core::UniquePtr<char> pem_root_ptr(gpr_strdup(pem_root_certs)); 
+    pem_root_certs_ = std::move(pem_root_ptr); 
+  } 
   void add_pem_key_cert_pair(grpc_core::PemKeyCertPair pem_key_cert_pair) {
     pem_key_cert_pair_list_.push_back(pem_key_cert_pair);
   }
-  // The ownerships of |pem_root_certs| and |pem_key_cert_pairs| remain with the
-  // caller.
-  void set_key_materials(const char* pem_root_certs,
-                         const grpc_ssl_pem_key_cert_pair** pem_key_cert_pairs,
-                         size_t num_key_cert_pairs);
-  // The ownerships of |pem_root_certs| and |pem_key_cert_pair_list| remain with
-  // the caller.
-  void set_key_materials(const char* pem_root_certs,
-                         const PemKeyCertPairList& pem_key_cert_pair_list);
+  // The ownerships of |pem_root_certs| and |pem_key_cert_pairs| remain with the 
+  // caller. 
+  void set_key_materials(const char* pem_root_certs, 
+                         const grpc_ssl_pem_key_cert_pair** pem_key_cert_pairs, 
+                         size_t num_key_cert_pairs); 
+  // The ownerships of |pem_root_certs| and |pem_key_cert_pair_list| remain with 
+  // the caller. 
+  void set_key_materials(const char* pem_root_certs, 
+                         const PemKeyCertPairList& pem_key_cert_pair_list); 
   void set_version(int version) { version_ = version; }
 
  private:
@@ -106,8 +106,8 @@ struct grpc_tls_credential_reload_config
       gpr_log(GPR_ERROR, "schedule API is nullptr");
       if (arg != nullptr) {
         arg->status = GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL;
-        arg->error_details->set_error_details(
-            "schedule API in credential reload config is nullptr");
+        arg->error_details->set_error_details( 
+            "schedule API in credential reload config is nullptr"); 
       }
       return 1;
     }
@@ -121,8 +121,8 @@ struct grpc_tls_credential_reload_config
       gpr_log(GPR_ERROR, "cancel API is nullptr.");
       if (arg != nullptr) {
         arg->status = GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL;
-        arg->error_details->set_error_details(
-            "cancel API in credential reload config is nullptr");
+        arg->error_details->set_error_details( 
+            "cancel API in credential reload config is nullptr"); 
       }
       return;
     }
@@ -182,7 +182,7 @@ struct grpc_tls_server_authorization_check_config
       gpr_log(GPR_ERROR, "schedule API is nullptr");
       if (arg != nullptr) {
         arg->status = GRPC_STATUS_NOT_FOUND;
-        arg->error_details->set_error_details(
+        arg->error_details->set_error_details( 
             "schedule API in server authorization check config is nullptr");
       }
       return 1;
@@ -198,7 +198,7 @@ struct grpc_tls_server_authorization_check_config
       gpr_log(GPR_ERROR, "cancel API is nullptr.");
       if (arg != nullptr) {
         arg->status = GRPC_STATUS_NOT_FOUND;
-        arg->error_details->set_error_details(
+        arg->error_details->set_error_details( 
             "schedule API in server authorization check config is nullptr");
       }
       return;
@@ -261,11 +261,11 @@ struct grpc_tls_credentials_options
   grpc_ssl_client_certificate_request_type cert_request_type() const {
     return cert_request_type_;
   }
-  grpc_tls_server_verification_option server_verification_option() const {
-    return server_verification_option_;
-  }
-  grpc_tls_version min_tls_version() const { return min_tls_version_; }
-  grpc_tls_version max_tls_version() const { return max_tls_version_; }
+  grpc_tls_server_verification_option server_verification_option() const { 
+    return server_verification_option_; 
+  } 
+  grpc_tls_version min_tls_version() const { return min_tls_version_; } 
+  grpc_tls_version max_tls_version() const { return max_tls_version_; } 
   grpc_tls_key_materials_config* key_materials_config() const {
     return key_materials_config_.get();
   }
@@ -282,16 +282,16 @@ struct grpc_tls_credentials_options
       const grpc_ssl_client_certificate_request_type type) {
     cert_request_type_ = type;
   }
-  void set_server_verification_option(
-      const grpc_tls_server_verification_option server_verification_option) {
-    server_verification_option_ = server_verification_option;
-  }
-  void set_min_tls_version(grpc_tls_version min_tls_version) {
-    min_tls_version_ = min_tls_version;
-  }
-  void set_max_tls_version(grpc_tls_version max_tls_version) {
-    max_tls_version_ = max_tls_version;
-  }
+  void set_server_verification_option( 
+      const grpc_tls_server_verification_option server_verification_option) { 
+    server_verification_option_ = server_verification_option; 
+  } 
+  void set_min_tls_version(grpc_tls_version min_tls_version) { 
+    min_tls_version_ = min_tls_version; 
+  } 
+  void set_max_tls_version(grpc_tls_version max_tls_version) { 
+    max_tls_version_ = max_tls_version; 
+  } 
   void set_key_materials_config(
       grpc_core::RefCountedPtr<grpc_tls_key_materials_config> config) {
     key_materials_config_ = std::move(config);
@@ -308,10 +308,10 @@ struct grpc_tls_credentials_options
 
  private:
   grpc_ssl_client_certificate_request_type cert_request_type_;
-  grpc_tls_server_verification_option server_verification_option_ =
-      GRPC_TLS_SERVER_VERIFICATION;
-  grpc_tls_version min_tls_version_ = grpc_tls_version::TLS1_2;
-  grpc_tls_version max_tls_version_ = grpc_tls_version::TLS1_3;
+  grpc_tls_server_verification_option server_verification_option_ = 
+      GRPC_TLS_SERVER_VERIFICATION; 
+  grpc_tls_version min_tls_version_ = grpc_tls_version::TLS1_2; 
+  grpc_tls_version max_tls_version_ = grpc_tls_version::TLS1_3; 
   grpc_core::RefCountedPtr<grpc_tls_key_materials_config> key_materials_config_;
   grpc_core::RefCountedPtr<grpc_tls_credential_reload_config>
       credential_reload_config_;
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/tls/tls_credentials.cc b/contrib/libs/grpc/src/core/lib/security/credentials/tls/tls_credentials.cc
index 701fd3b150..830c9b2985 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/tls/tls_credentials.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/tls/tls_credentials.cc
@@ -1,128 +1,128 @@
-/*
- *
- * 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/security/credentials/tls/tls_credentials.h"
-
-#include <cstring>
-
-#include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/security/security_connector/tls/tls_security_connector.h"
-
-#define GRPC_CREDENTIALS_TYPE_TLS "Tls"
-
-namespace {
-
-bool CredentialOptionSanityCheck(const grpc_tls_credentials_options* options,
-                                 bool is_client) {
-  if (options == nullptr) {
-    gpr_log(GPR_ERROR, "TLS credentials options is nullptr.");
-    return false;
-  }
-  if (options->key_materials_config() == nullptr &&
-      options->credential_reload_config() == nullptr) {
-    gpr_log(GPR_ERROR,
-            "TLS credentials options must specify either key materials or "
-            "credential reload config.");
-    return false;
-  }
-  if (!is_client && options->server_authorization_check_config() != nullptr) {
-    gpr_log(GPR_INFO,
-            "Server's credentials options should not contain server "
-            "authorization check config.");
-  }
-  return true;
-}
-
-}  // namespace
-
-TlsCredentials::TlsCredentials(
-    grpc_core::RefCountedPtr<grpc_tls_credentials_options> options)
-    : grpc_channel_credentials(GRPC_CREDENTIALS_TYPE_TLS),
-      options_(std::move(options)) {}
-
-TlsCredentials::~TlsCredentials() {}
-
-grpc_core::RefCountedPtr<grpc_channel_security_connector>
-TlsCredentials::create_security_connector(
-    grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
-    const char* target_name, const grpc_channel_args* args,
-    grpc_channel_args** new_args) {
-  const char* overridden_target_name = nullptr;
-  tsi_ssl_session_cache* ssl_session_cache = nullptr;
-  for (size_t i = 0; args != nullptr && i < args->num_args; i++) {
-    grpc_arg* arg = &args->args[i];
-    if (strcmp(arg->key, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG) == 0 &&
-        arg->type == GRPC_ARG_STRING) {
-      overridden_target_name = arg->value.string;
-    }
-    if (strcmp(arg->key, GRPC_SSL_SESSION_CACHE_ARG) == 0 &&
-        arg->type == GRPC_ARG_POINTER) {
-      ssl_session_cache =
-          static_cast<tsi_ssl_session_cache*>(arg->value.pointer.p);
-    }
-  }
-  grpc_core::RefCountedPtr<grpc_channel_security_connector> sc =
-      grpc_core::TlsChannelSecurityConnector::CreateTlsChannelSecurityConnector(
-          this->Ref(), std::move(call_creds), target_name,
-          overridden_target_name, ssl_session_cache);
-  if (sc == nullptr) {
-    return nullptr;
-  }
-  grpc_arg new_arg = grpc_channel_arg_string_create(
-      (char*)GRPC_ARG_HTTP2_SCHEME, (char*)"https");
-  *new_args = grpc_channel_args_copy_and_add(args, &new_arg, 1);
-  return sc;
-}
-
-TlsServerCredentials::TlsServerCredentials(
-    grpc_core::RefCountedPtr<grpc_tls_credentials_options> options)
-    : grpc_server_credentials(GRPC_CREDENTIALS_TYPE_TLS),
-      options_(std::move(options)) {}
-
-TlsServerCredentials::~TlsServerCredentials() {}
-
-grpc_core::RefCountedPtr<grpc_server_security_connector>
-TlsServerCredentials::create_security_connector() {
-  return grpc_core::TlsServerSecurityConnector::
-      CreateTlsServerSecurityConnector(this->Ref());
-}
-
-grpc_channel_credentials* grpc_tls_credentials_create(
-    grpc_tls_credentials_options* options) {
-  if (!CredentialOptionSanityCheck(options, true /* is_client */)) {
-    return nullptr;
-  }
-  return new TlsCredentials(
-      grpc_core::RefCountedPtr<grpc_tls_credentials_options>(options));
-}
-
-grpc_server_credentials* grpc_tls_server_credentials_create(
-    grpc_tls_credentials_options* options) {
-  if (!CredentialOptionSanityCheck(options, false /* is_client */)) {
-    return nullptr;
-  }
-  return new TlsServerCredentials(
-      grpc_core::RefCountedPtr<grpc_tls_credentials_options>(options));
-}
+/* 
+ * 
+ * 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. 
+ * 
+ */ 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/security/credentials/tls/tls_credentials.h" 
+ 
+#include <cstring> 
+ 
+#include <grpc/grpc.h> 
+#include <grpc/support/alloc.h> 
+#include <grpc/support/log.h> 
+#include <grpc/support/string_util.h> 
+ 
+#include "src/core/lib/channel/channel_args.h" 
+#include "src/core/lib/security/security_connector/tls/tls_security_connector.h" 
+ 
+#define GRPC_CREDENTIALS_TYPE_TLS "Tls" 
+ 
+namespace { 
+ 
+bool CredentialOptionSanityCheck(const grpc_tls_credentials_options* options, 
+                                 bool is_client) { 
+  if (options == nullptr) { 
+    gpr_log(GPR_ERROR, "TLS credentials options is nullptr."); 
+    return false; 
+  } 
+  if (options->key_materials_config() == nullptr && 
+      options->credential_reload_config() == nullptr) { 
+    gpr_log(GPR_ERROR, 
+            "TLS credentials options must specify either key materials or " 
+            "credential reload config."); 
+    return false; 
+  } 
+  if (!is_client && options->server_authorization_check_config() != nullptr) { 
+    gpr_log(GPR_INFO, 
+            "Server's credentials options should not contain server " 
+            "authorization check config."); 
+  } 
+  return true; 
+} 
+ 
+}  // namespace 
+ 
+TlsCredentials::TlsCredentials( 
+    grpc_core::RefCountedPtr<grpc_tls_credentials_options> options) 
+    : grpc_channel_credentials(GRPC_CREDENTIALS_TYPE_TLS), 
+      options_(std::move(options)) {} 
+ 
+TlsCredentials::~TlsCredentials() {} 
+ 
+grpc_core::RefCountedPtr<grpc_channel_security_connector> 
+TlsCredentials::create_security_connector( 
+    grpc_core::RefCountedPtr<grpc_call_credentials> call_creds, 
+    const char* target_name, const grpc_channel_args* args, 
+    grpc_channel_args** new_args) { 
+  const char* overridden_target_name = nullptr; 
+  tsi_ssl_session_cache* ssl_session_cache = nullptr; 
+  for (size_t i = 0; args != nullptr && i < args->num_args; i++) { 
+    grpc_arg* arg = &args->args[i]; 
+    if (strcmp(arg->key, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG) == 0 && 
+        arg->type == GRPC_ARG_STRING) { 
+      overridden_target_name = arg->value.string; 
+    } 
+    if (strcmp(arg->key, GRPC_SSL_SESSION_CACHE_ARG) == 0 && 
+        arg->type == GRPC_ARG_POINTER) { 
+      ssl_session_cache = 
+          static_cast<tsi_ssl_session_cache*>(arg->value.pointer.p); 
+    } 
+  } 
+  grpc_core::RefCountedPtr<grpc_channel_security_connector> sc = 
+      grpc_core::TlsChannelSecurityConnector::CreateTlsChannelSecurityConnector( 
+          this->Ref(), std::move(call_creds), target_name, 
+          overridden_target_name, ssl_session_cache); 
+  if (sc == nullptr) { 
+    return nullptr; 
+  } 
+  grpc_arg new_arg = grpc_channel_arg_string_create( 
+      (char*)GRPC_ARG_HTTP2_SCHEME, (char*)"https"); 
+  *new_args = grpc_channel_args_copy_and_add(args, &new_arg, 1); 
+  return sc; 
+} 
+ 
+TlsServerCredentials::TlsServerCredentials( 
+    grpc_core::RefCountedPtr<grpc_tls_credentials_options> options) 
+    : grpc_server_credentials(GRPC_CREDENTIALS_TYPE_TLS), 
+      options_(std::move(options)) {} 
+ 
+TlsServerCredentials::~TlsServerCredentials() {} 
+ 
+grpc_core::RefCountedPtr<grpc_server_security_connector> 
+TlsServerCredentials::create_security_connector() { 
+  return grpc_core::TlsServerSecurityConnector:: 
+      CreateTlsServerSecurityConnector(this->Ref()); 
+} 
+ 
+grpc_channel_credentials* grpc_tls_credentials_create( 
+    grpc_tls_credentials_options* options) { 
+  if (!CredentialOptionSanityCheck(options, true /* is_client */)) { 
+    return nullptr; 
+  } 
+  return new TlsCredentials( 
+      grpc_core::RefCountedPtr<grpc_tls_credentials_options>(options)); 
+} 
+ 
+grpc_server_credentials* grpc_tls_server_credentials_create( 
+    grpc_tls_credentials_options* options) { 
+  if (!CredentialOptionSanityCheck(options, false /* is_client */)) { 
+    return nullptr; 
+  } 
+  return new TlsServerCredentials( 
+      grpc_core::RefCountedPtr<grpc_tls_credentials_options>(options)); 
+} 
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/tls/tls_credentials.h b/contrib/libs/grpc/src/core/lib/security/credentials/tls/tls_credentials.h
index 388c71f6b7..27608a054b 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/tls/tls_credentials.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/tls/tls_credentials.h
@@ -1,62 +1,62 @@
-/*
- *
- * 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_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_CREDENTIALS_H
-#define GRPC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_CREDENTIALS_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/grpc_security.h>
-
-#include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"
-
-class TlsCredentials final : public grpc_channel_credentials {
- public:
-  explicit TlsCredentials(
-      grpc_core::RefCountedPtr<grpc_tls_credentials_options> options);
-  ~TlsCredentials() override;
-
-  grpc_core::RefCountedPtr<grpc_channel_security_connector>
-  create_security_connector(
-      grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
-      const char* target_name, const grpc_channel_args* args,
-      grpc_channel_args** new_args) override;
-
-  const grpc_tls_credentials_options& options() const { return *options_; }
-
- private:
-  grpc_core::RefCountedPtr<grpc_tls_credentials_options> options_;
-};
-
-class TlsServerCredentials final : public grpc_server_credentials {
- public:
-  explicit TlsServerCredentials(
-      grpc_core::RefCountedPtr<grpc_tls_credentials_options> options);
-  ~TlsServerCredentials() override;
-
-  grpc_core::RefCountedPtr<grpc_server_security_connector>
-  create_security_connector() override;
-
-  const grpc_tls_credentials_options& options() const { return *options_; }
-
- private:
-  grpc_core::RefCountedPtr<grpc_tls_credentials_options> options_;
-};
-
-#endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_CREDENTIALS_H */
+/* 
+ * 
+ * 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_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_CREDENTIALS_H 
+#define GRPC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_CREDENTIALS_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <grpc/grpc_security.h> 
+ 
+#include "src/core/lib/security/credentials/credentials.h" 
+#include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h" 
+ 
+class TlsCredentials final : public grpc_channel_credentials { 
+ public: 
+  explicit TlsCredentials( 
+      grpc_core::RefCountedPtr<grpc_tls_credentials_options> options); 
+  ~TlsCredentials() override; 
+ 
+  grpc_core::RefCountedPtr<grpc_channel_security_connector> 
+  create_security_connector( 
+      grpc_core::RefCountedPtr<grpc_call_credentials> call_creds, 
+      const char* target_name, const grpc_channel_args* args, 
+      grpc_channel_args** new_args) override; 
+ 
+  const grpc_tls_credentials_options& options() const { return *options_; } 
+ 
+ private: 
+  grpc_core::RefCountedPtr<grpc_tls_credentials_options> options_; 
+}; 
+ 
+class TlsServerCredentials final : public grpc_server_credentials { 
+ public: 
+  explicit TlsServerCredentials( 
+      grpc_core::RefCountedPtr<grpc_tls_credentials_options> options); 
+  ~TlsServerCredentials() override; 
+ 
+  grpc_core::RefCountedPtr<grpc_server_security_connector> 
+  create_security_connector() override; 
+ 
+  const grpc_tls_credentials_options& options() const { return *options_; } 
+ 
+ private: 
+  grpc_core::RefCountedPtr<grpc_tls_credentials_options> options_; 
+}; 
+ 
+#endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_TLS_TLS_CREDENTIALS_H */ 
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/xds/xds_credentials.cc b/contrib/libs/grpc/src/core/lib/security/credentials/xds/xds_credentials.cc
index 682d49badb..a34a584f4c 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/xds/xds_credentials.cc
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/xds/xds_credentials.cc
@@ -1,45 +1,45 @@
-//
-//
-// 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.
-//
-//
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/security/credentials/xds/xds_credentials.h"
-
-namespace grpc_core {
-
-constexpr const char XdsCredentials::kCredentialsTypeXds[];
-
-grpc_core::RefCountedPtr<grpc_channel_security_connector>
-XdsCredentials::create_security_connector(
-    grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
-    const char* target_name, const grpc_channel_args* args,
-    grpc_channel_args** new_args) {
-  /* TODO(yashkt) : To be filled */
-  if (fallback_credentials_ != nullptr) {
-    return fallback_credentials_->create_security_connector(
-        std::move(call_creds), target_name, args, new_args);
-  }
-  return nullptr;
-}
-
-}  // namespace grpc_core
-
-grpc_channel_credentials* grpc_xds_credentials_create(
-    grpc_channel_credentials* fallback_credentials) {
-  return new grpc_core::XdsCredentials(fallback_credentials->Ref());
-}
+// 
+// 
+// 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. 
+// 
+// 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/security/credentials/xds/xds_credentials.h" 
+ 
+namespace grpc_core { 
+ 
+constexpr const char XdsCredentials::kCredentialsTypeXds[]; 
+ 
+grpc_core::RefCountedPtr<grpc_channel_security_connector> 
+XdsCredentials::create_security_connector( 
+    grpc_core::RefCountedPtr<grpc_call_credentials> call_creds, 
+    const char* target_name, const grpc_channel_args* args, 
+    grpc_channel_args** new_args) { 
+  /* TODO(yashkt) : To be filled */ 
+  if (fallback_credentials_ != nullptr) { 
+    return fallback_credentials_->create_security_connector( 
+        std::move(call_creds), target_name, args, new_args); 
+  } 
+  return nullptr; 
+} 
+ 
+}  // namespace grpc_core 
+ 
+grpc_channel_credentials* grpc_xds_credentials_create( 
+    grpc_channel_credentials* fallback_credentials) { 
+  return new grpc_core::XdsCredentials(fallback_credentials->Ref()); 
+} 
diff --git a/contrib/libs/grpc/src/core/lib/security/credentials/xds/xds_credentials.h b/contrib/libs/grpc/src/core/lib/security/credentials/xds/xds_credentials.h
index 51576deebd..fc84d48afa 100644
--- a/contrib/libs/grpc/src/core/lib/security/credentials/xds/xds_credentials.h
+++ b/contrib/libs/grpc/src/core/lib/security/credentials/xds/xds_credentials.h
@@ -1,51 +1,51 @@
-//
-//
-// 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_CORE_LIB_SECURITY_CREDENTIALS_XDS_XDS_CREDENTIALS_H
-#define GRPC_CORE_LIB_SECURITY_CREDENTIALS_XDS_XDS_CREDENTIALS_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/grpc_security.h>
-
-#include "src/core/lib/security/credentials/credentials.h"
-
-namespace grpc_core {
-
-class XdsCredentials final : public grpc_channel_credentials {
- public:
-  static constexpr const char kCredentialsTypeXds[] = "Xds";
-
-  explicit XdsCredentials(
-      grpc_core::RefCountedPtr<grpc_channel_credentials> fallback_credentials)
-      : grpc_channel_credentials(kCredentialsTypeXds),
-        fallback_credentials_(std::move(fallback_credentials)) {}
-
-  grpc_core::RefCountedPtr<grpc_channel_security_connector>
-  create_security_connector(
-      grpc_core::RefCountedPtr<grpc_call_credentials> call_creds,
-      const char* target_name, const grpc_channel_args* args,
-      grpc_channel_args** new_args) override;
-
- private:
-  grpc_core::RefCountedPtr<grpc_channel_credentials> fallback_credentials_;
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_XDS_XDS_CREDENTIALS_H */
+// 
+// 
+// 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_CORE_LIB_SECURITY_CREDENTIALS_XDS_XDS_CREDENTIALS_H 
+#define GRPC_CORE_LIB_SECURITY_CREDENTIALS_XDS_XDS_CREDENTIALS_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include <grpc/grpc_security.h> 
+ 
+#include "src/core/lib/security/credentials/credentials.h" 
+ 
+namespace grpc_core { 
+ 
+class XdsCredentials final : public grpc_channel_credentials { 
+ public: 
+  static constexpr const char kCredentialsTypeXds[] = "Xds"; 
+ 
+  explicit XdsCredentials( 
+      grpc_core::RefCountedPtr<grpc_channel_credentials> fallback_credentials) 
+      : grpc_channel_credentials(kCredentialsTypeXds), 
+        fallback_credentials_(std::move(fallback_credentials)) {} 
+ 
+  grpc_core::RefCountedPtr<grpc_channel_security_connector> 
+  create_security_connector( 
+      grpc_core::RefCountedPtr<grpc_call_credentials> call_creds, 
+      const char* target_name, const grpc_channel_args* args, 
+      grpc_channel_args** new_args) override; 
+ 
+ private: 
+  grpc_core::RefCountedPtr<grpc_channel_credentials> fallback_credentials_; 
+}; 
+ 
+}  // namespace grpc_core 
+ 
+#endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_XDS_XDS_CREDENTIALS_H */ 
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/alts/alts_security_connector.cc b/contrib/libs/grpc/src/core/lib/security/security_connector/alts/alts_security_connector.cc
index d0b532ae18..1902528bc6 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/alts/alts_security_connector.cc
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/alts/alts_security_connector.cc
@@ -82,17 +82,17 @@ class grpc_alts_channel_security_connector final
     tsi_handshaker* handshaker = nullptr;
     const grpc_alts_credentials* creds =
         static_cast<const grpc_alts_credentials*>(channel_creds());
-    size_t user_specified_max_frame_size = 0;
-    const grpc_arg* arg =
-        grpc_channel_args_find(args, GRPC_ARG_TSI_MAX_FRAME_SIZE);
-    if (arg != nullptr && arg->type == GRPC_ARG_INTEGER) {
-      user_specified_max_frame_size = grpc_channel_arg_get_integer(
-          arg, {0, 0, std::numeric_limits<int>::max()});
-    }
-    GPR_ASSERT(alts_tsi_handshaker_create(
-                   creds->options(), target_name_,
-                   creds->handshaker_service_url(), true, interested_parties,
-                   &handshaker, user_specified_max_frame_size) == TSI_OK);
+    size_t user_specified_max_frame_size = 0; 
+    const grpc_arg* arg = 
+        grpc_channel_args_find(args, GRPC_ARG_TSI_MAX_FRAME_SIZE); 
+    if (arg != nullptr && arg->type == GRPC_ARG_INTEGER) { 
+      user_specified_max_frame_size = grpc_channel_arg_get_integer( 
+          arg, {0, 0, std::numeric_limits<int>::max()}); 
+    } 
+    GPR_ASSERT(alts_tsi_handshaker_create( 
+                   creds->options(), target_name_, 
+                   creds->handshaker_service_url(), true, interested_parties, 
+                   &handshaker, user_specified_max_frame_size) == TSI_OK); 
     handshake_manager->Add(
         grpc_core::SecurityHandshakerCreate(handshaker, this, args));
   }
@@ -111,7 +111,7 @@ class grpc_alts_channel_security_connector final
     return strcmp(target_name_, other->target_name_);
   }
 
-  bool check_call_host(y_absl::string_view host,
+  bool check_call_host(y_absl::string_view host, 
                        grpc_auth_context* /*auth_context*/,
                        grpc_closure* /*on_call_host_checked*/,
                        grpc_error** error) override {
@@ -147,17 +147,17 @@ class grpc_alts_server_security_connector final
     tsi_handshaker* handshaker = nullptr;
     const grpc_alts_server_credentials* creds =
         static_cast<const grpc_alts_server_credentials*>(server_creds());
-    size_t user_specified_max_frame_size = 0;
-    const grpc_arg* arg =
-        grpc_channel_args_find(args, GRPC_ARG_TSI_MAX_FRAME_SIZE);
-    if (arg != nullptr && arg->type == GRPC_ARG_INTEGER) {
-      user_specified_max_frame_size = grpc_channel_arg_get_integer(
-          arg, {0, 0, std::numeric_limits<int>::max()});
-    }
+    size_t user_specified_max_frame_size = 0; 
+    const grpc_arg* arg = 
+        grpc_channel_args_find(args, GRPC_ARG_TSI_MAX_FRAME_SIZE); 
+    if (arg != nullptr && arg->type == GRPC_ARG_INTEGER) { 
+      user_specified_max_frame_size = grpc_channel_arg_get_integer( 
+          arg, {0, 0, std::numeric_limits<int>::max()}); 
+    } 
     GPR_ASSERT(alts_tsi_handshaker_create(
                    creds->options(), nullptr, creds->handshaker_service_url(),
-                   false, interested_parties, &handshaker,
-                   user_specified_max_frame_size) == TSI_OK);
+                   false, interested_parties, &handshaker, 
+                   user_specified_max_frame_size) == TSI_OK); 
     handshake_manager->Add(
         grpc_core::SecurityHandshakerCreate(handshaker, this, args));
   }
@@ -193,13 +193,13 @@ grpc_alts_auth_context_from_tsi_peer(const tsi_peer* peer) {
     gpr_log(GPR_ERROR, "Invalid or missing certificate type property.");
     return nullptr;
   }
-  /* Check if security level exists. */
-  const tsi_peer_property* security_level_prop =
-      tsi_peer_get_property_by_name(peer, TSI_SECURITY_LEVEL_PEER_PROPERTY);
-  if (security_level_prop == nullptr) {
-    gpr_log(GPR_ERROR, "Missing security level property.");
-    return nullptr;
-  }
+  /* Check if security level exists. */ 
+  const tsi_peer_property* security_level_prop = 
+      tsi_peer_get_property_by_name(peer, TSI_SECURITY_LEVEL_PEER_PROPERTY); 
+  if (security_level_prop == nullptr) { 
+    gpr_log(GPR_ERROR, "Missing security level property."); 
+    return nullptr; 
+  } 
   /* Validate RPC protocol versions. */
   const tsi_peer_property* rpc_versions_prop =
       tsi_peer_get_property_by_name(peer, TSI_ALTS_RPC_VERSIONS);
@@ -254,12 +254,12 @@ grpc_alts_auth_context_from_tsi_peer(const tsi_peer* peer) {
                                      tsi_prop->value.data,
                                      tsi_prop->value.length);
     }
-    /* Add security level to auth context. */
-    if (strcmp(tsi_prop->name, TSI_SECURITY_LEVEL_PEER_PROPERTY) == 0) {
-      grpc_auth_context_add_property(
-          ctx.get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME,
-          tsi_prop->value.data, tsi_prop->value.length);
-    }
+    /* Add security level to auth context. */ 
+    if (strcmp(tsi_prop->name, TSI_SECURITY_LEVEL_PEER_PROPERTY) == 0) { 
+      grpc_auth_context_add_property( 
+          ctx.get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME, 
+          tsi_prop->value.data, tsi_prop->value.length); 
+    } 
   }
   if (!grpc_auth_context_peer_is_authenticated(ctx.get())) {
     gpr_log(GPR_ERROR, "Invalid unauthenticated peer.");
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/fake/fake_security_connector.cc b/contrib/libs/grpc/src/core/lib/security/security_connector/fake/fake_security_connector.cc
index efbf6d231c..6101c2d8e7 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/fake/fake_security_connector.cc
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/fake/fake_security_connector.cc
@@ -22,15 +22,15 @@
 
 #include <stdbool.h>
 
-#include "y_absl/strings/str_cat.h"
-
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.h"
 #include "src/core/ext/transport/chttp2/alpn/alpn.h"
-#include "src/core/ext/xds/xds_channel_args.h"
+#include "src/core/ext/xds/xds_channel_args.h" 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/handshaker.h"
 #include "src/core/lib/gpr/string.h"
@@ -56,9 +56,9 @@ class grpc_fake_channel_security_connector final
         target_(gpr_strdup(target)),
         expected_targets_(
             gpr_strdup(grpc_fake_transport_get_expected_targets(args))),
-        is_lb_channel_(grpc_channel_args_find(
-                           args, GRPC_ARG_ADDRESS_IS_GRPCLB_LOAD_BALANCER) !=
-                       nullptr) {
+        is_lb_channel_(grpc_channel_args_find( 
+                           args, GRPC_ARG_ADDRESS_IS_GRPCLB_LOAD_BALANCER) != 
+                       nullptr) { 
     const grpc_arg* target_name_override_arg =
         grpc_channel_args_find(args, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
     if (target_name_override_arg != nullptr) {
@@ -102,20 +102,20 @@ class grpc_fake_channel_security_connector final
         tsi_create_fake_handshaker(/*is_client=*/true), this, args));
   }
 
-  bool check_call_host(y_absl::string_view host,
+  bool check_call_host(y_absl::string_view host, 
                        grpc_auth_context* /*auth_context*/,
                        grpc_closure* /*on_call_host_checked*/,
                        grpc_error** /*error*/) override {
-    y_absl::string_view authority_hostname;
-    y_absl::string_view authority_ignored_port;
-    y_absl::string_view target_hostname;
-    y_absl::string_view target_ignored_port;
+    y_absl::string_view authority_hostname; 
+    y_absl::string_view authority_ignored_port; 
+    y_absl::string_view target_hostname; 
+    y_absl::string_view target_ignored_port; 
     grpc_core::SplitHostPort(host, &authority_hostname,
                              &authority_ignored_port);
     grpc_core::SplitHostPort(target_, &target_hostname, &target_ignored_port);
     if (target_name_override_ != nullptr) {
-      y_absl::string_view fake_security_target_name_override_hostname;
-      y_absl::string_view fake_security_target_name_override_ignored_port;
+      y_absl::string_view fake_security_target_name_override_hostname; 
+      y_absl::string_view fake_security_target_name_override_ignored_port; 
       grpc_core::SplitHostPort(
           target_name_override_, &fake_security_target_name_override_hostname,
           &fake_security_target_name_override_ignored_port);
@@ -145,7 +145,7 @@ class grpc_fake_channel_security_connector final
   char* target_name_override() const { return target_name_override_; }
 
  private:
-  bool fake_check_target(const char* target, const char* set_str) const {
+  bool fake_check_target(const char* target, const char* set_str) const { 
     GPR_ASSERT(target != nullptr);
     char** set = nullptr;
     size_t set_size = 0;
@@ -181,14 +181,14 @@ class grpc_fake_channel_security_connector final
                 expected_targets_);
         goto done;
       }
-      if (!fake_check_target(target_, lbs_and_backends[1])) {
+      if (!fake_check_target(target_, lbs_and_backends[1])) { 
         gpr_log(GPR_ERROR, "LB target '%s' not found in expected set '%s'",
                 target_, lbs_and_backends[1]);
         goto done;
       }
       success = true;
     } else {
-      if (!fake_check_target(target_, lbs_and_backends[0])) {
+      if (!fake_check_target(target_, lbs_and_backends[0])) { 
         gpr_log(GPR_ERROR, "Backend target '%s' not found in expected set '%s'",
                 target_, lbs_and_backends[0]);
         goto done;
@@ -216,18 +216,18 @@ static void fake_check_peer(
   const char* prop_name;
   grpc_error* error = GRPC_ERROR_NONE;
   *auth_context = nullptr;
-  if (peer.property_count != 2) {
+  if (peer.property_count != 2) { 
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Fake peers should only have 2 properties.");
+        "Fake peers should only have 2 properties."); 
     goto end;
   }
   prop_name = peer.properties[0].name;
   if (prop_name == nullptr ||
       strcmp(prop_name, TSI_CERTIFICATE_TYPE_PEER_PROPERTY)) {
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat("Unexpected property in fake peer: ",
-                     prop_name == nullptr ? "<EMPTY>" : prop_name)
-            .c_str());
+    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat("Unexpected property in fake peer: ", 
+                     prop_name == nullptr ? "<EMPTY>" : prop_name) 
+            .c_str()); 
     goto end;
   }
   if (strncmp(peer.properties[0].value.data, TSI_FAKE_CERTIFICATE_TYPE,
@@ -236,29 +236,29 @@ static void fake_check_peer(
         "Invalid value for cert type property.");
     goto end;
   }
-  prop_name = peer.properties[1].name;
-  if (prop_name == nullptr ||
-      strcmp(prop_name, TSI_SECURITY_LEVEL_PEER_PROPERTY) != 0) {
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat("Unexpected property in fake peer: ",
-                     prop_name == nullptr ? "<EMPTY>" : prop_name)
-            .c_str());
-    goto end;
-  }
-  if (strncmp(peer.properties[1].value.data, TSI_FAKE_SECURITY_LEVEL,
-              peer.properties[1].value.length) != 0) {
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Invalid value for security level property.");
-    goto end;
-  }
-
+  prop_name = peer.properties[1].name; 
+  if (prop_name == nullptr || 
+      strcmp(prop_name, TSI_SECURITY_LEVEL_PEER_PROPERTY) != 0) { 
+    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat("Unexpected property in fake peer: ", 
+                     prop_name == nullptr ? "<EMPTY>" : prop_name) 
+            .c_str()); 
+    goto end; 
+  } 
+  if (strncmp(peer.properties[1].value.data, TSI_FAKE_SECURITY_LEVEL, 
+              peer.properties[1].value.length) != 0) { 
+    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING( 
+        "Invalid value for security level property."); 
+    goto end; 
+  } 
+ 
   *auth_context = grpc_core::MakeRefCounted<grpc_auth_context>(nullptr);
   grpc_auth_context_add_cstring_property(
       auth_context->get(), GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME,
       GRPC_FAKE_TRANSPORT_SECURITY_TYPE);
-  grpc_auth_context_add_cstring_property(
-      auth_context->get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME,
-      TSI_FAKE_SECURITY_LEVEL);
+  grpc_auth_context_add_cstring_property( 
+      auth_context->get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME, 
+      TSI_FAKE_SECURITY_LEVEL); 
 end:
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
   tsi_peer_destruct(&peer);
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/load_system_roots_fallback.cc b/contrib/libs/grpc/src/core/lib/security/security_connector/load_system_roots_fallback.cc
index f04d0ed225..c7e31c136d 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/load_system_roots_fallback.cc
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/load_system_roots_fallback.cc
@@ -21,7 +21,7 @@
 #include <grpc/slice_buffer.h>
 #include "src/core/lib/security/security_connector/load_system_roots.h"
 
-#if !defined(GPR_LINUX) && !defined(GPR_ANDROID)
+#if !defined(GPR_LINUX) && !defined(GPR_ANDROID) 
 
 namespace grpc_core {
 
@@ -29,4 +29,4 @@ grpc_slice LoadSystemRootCerts() { return grpc_empty_slice(); }
 
 }  // namespace grpc_core
 
-#endif /* !(GPR_LINUX || GPR_ANDROID) */
+#endif /* !(GPR_LINUX || GPR_ANDROID) */ 
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/load_system_roots_linux.cc b/contrib/libs/grpc/src/core/lib/security/security_connector/load_system_roots_linux.cc
index c0b6d5d727..374ad04620 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/load_system_roots_linux.cc
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/load_system_roots_linux.cc
@@ -21,7 +21,7 @@
 #include <grpc/slice_buffer.h>
 #include "src/core/lib/security/security_connector/load_system_roots_linux.h"
 
-#if defined(GPR_LINUX) || defined(GPR_ANDROID)
+#if defined(GPR_LINUX) || defined(GPR_ANDROID) 
 
 #include "src/core/lib/security/security_connector/load_system_roots.h"
 
@@ -34,8 +34,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include "y_absl/container/inlined_vector.h"
-
+#include "y_absl/container/inlined_vector.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -101,7 +101,7 @@ grpc_slice CreateRootCertsBundle(const char* certs_directory) {
     char path[MAXPATHLEN];
     off_t size;
   };
-  y_absl::InlinedVector<FileData, 2> roots_filenames;
+  y_absl::InlinedVector<FileData, 2> roots_filenames; 
   size_t total_bundle_size = 0;
   struct dirent* directory_entry;
   while ((directory_entry = readdir(ca_directory)) != nullptr) {
@@ -168,4 +168,4 @@ grpc_slice LoadSystemRootCerts() {
 
 }  // namespace grpc_core
 
-#endif /* GPR_LINUX || GPR_ANDROID */
+#endif /* GPR_LINUX || GPR_ANDROID */ 
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/local/local_security_connector.cc b/contrib/libs/grpc/src/core/lib/security/security_connector/local/local_security_connector.cc
index 8f622d4c22..7df71b2d4d 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/local/local_security_connector.cc
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/local/local_security_connector.cc
@@ -46,8 +46,8 @@
 
 namespace {
 
-grpc_core::RefCountedPtr<grpc_auth_context> local_auth_context_create(
-    const tsi_peer* peer) {
+grpc_core::RefCountedPtr<grpc_auth_context> local_auth_context_create( 
+    const tsi_peer* peer) { 
   /* Create auth context. */
   grpc_core::RefCountedPtr<grpc_auth_context> ctx =
       grpc_core::MakeRefCounted<grpc_auth_context>(nullptr);
@@ -56,17 +56,17 @@ grpc_core::RefCountedPtr<grpc_auth_context> local_auth_context_create(
       GRPC_LOCAL_TRANSPORT_SECURITY_TYPE);
   GPR_ASSERT(grpc_auth_context_set_peer_identity_property_name(
                  ctx.get(), GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME) == 1);
-  GPR_ASSERT(peer->property_count == 1);
-  const tsi_peer_property* prop = &peer->properties[0];
-  GPR_ASSERT(prop != nullptr);
-  GPR_ASSERT(strcmp(prop->name, TSI_SECURITY_LEVEL_PEER_PROPERTY) == 0);
-  grpc_auth_context_add_property(ctx.get(),
-                                 GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME,
-                                 prop->value.data, prop->value.length);
+  GPR_ASSERT(peer->property_count == 1); 
+  const tsi_peer_property* prop = &peer->properties[0]; 
+  GPR_ASSERT(prop != nullptr); 
+  GPR_ASSERT(strcmp(prop->name, TSI_SECURITY_LEVEL_PEER_PROPERTY) == 0); 
+  grpc_auth_context_add_property(ctx.get(), 
+                                 GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME, 
+                                 prop->value.data, prop->value.length); 
   return ctx;
 }
 
-void local_check_peer(tsi_peer peer, grpc_endpoint* ep,
+void local_check_peer(tsi_peer peer, grpc_endpoint* ep, 
                       grpc_core::RefCountedPtr<grpc_auth_context>* auth_context,
                       grpc_closure* on_peer_checked,
                       grpc_local_connect_type type) {
@@ -110,30 +110,30 @@ void local_check_peer(tsi_peer peer, grpc_endpoint* ep,
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
     return;
   }
-  // Add TSI_SECURITY_LEVEL_PEER_PROPERTY type peer property.
-  size_t new_property_count = peer.property_count + 1;
-  tsi_peer_property* new_properties = static_cast<tsi_peer_property*>(
-      gpr_zalloc(sizeof(*new_properties) * new_property_count));
-  for (size_t i = 0; i < peer.property_count; i++) {
-    new_properties[i] = peer.properties[i];
-  }
-  if (peer.properties != nullptr) gpr_free(peer.properties);
-  peer.properties = new_properties;
-  // TODO(yihuazhang): Set security level of local TCP to TSI_SECURITY_NONE.
-  const char* security_level =
-      tsi_security_level_to_string(TSI_PRIVACY_AND_INTEGRITY);
-  tsi_result result = tsi_construct_string_peer_property_from_cstring(
-      TSI_SECURITY_LEVEL_PEER_PROPERTY, security_level,
-      &peer.properties[peer.property_count]);
-  if (result != TSI_OK) return;
-  peer.property_count++;
+  // Add TSI_SECURITY_LEVEL_PEER_PROPERTY type peer property. 
+  size_t new_property_count = peer.property_count + 1; 
+  tsi_peer_property* new_properties = static_cast<tsi_peer_property*>( 
+      gpr_zalloc(sizeof(*new_properties) * new_property_count)); 
+  for (size_t i = 0; i < peer.property_count; i++) { 
+    new_properties[i] = peer.properties[i]; 
+  } 
+  if (peer.properties != nullptr) gpr_free(peer.properties); 
+  peer.properties = new_properties; 
+  // TODO(yihuazhang): Set security level of local TCP to TSI_SECURITY_NONE. 
+  const char* security_level = 
+      tsi_security_level_to_string(TSI_PRIVACY_AND_INTEGRITY); 
+  tsi_result result = tsi_construct_string_peer_property_from_cstring( 
+      TSI_SECURITY_LEVEL_PEER_PROPERTY, security_level, 
+      &peer.properties[peer.property_count]); 
+  if (result != TSI_OK) return; 
+  peer.property_count++; 
   /* Create an auth context which is necessary to pass the santiy check in
    * {client, server}_auth_filter that verifies if the peer's auth context is
    * obtained during handshakes. The auth context is only checked for its
    * existence and not actually used.
    */
-  *auth_context = local_auth_context_create(&peer);
-  tsi_peer_destruct(&peer);
+  *auth_context = local_auth_context_create(&peer); 
+  tsi_peer_destruct(&peer); 
   error = *auth_context != nullptr ? GRPC_ERROR_NONE
                                    : GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                                          "Could not create local auth context");
@@ -177,11 +177,11 @@ class grpc_local_channel_security_connector final
                   grpc_closure* on_peer_checked) override {
     grpc_local_credentials* creds =
         reinterpret_cast<grpc_local_credentials*>(mutable_channel_creds());
-    local_check_peer(peer, ep, auth_context, on_peer_checked,
+    local_check_peer(peer, ep, auth_context, on_peer_checked, 
                      creds->connect_type());
   }
 
-  bool check_call_host(y_absl::string_view host,
+  bool check_call_host(y_absl::string_view host, 
                        grpc_auth_context* /*auth_context*/,
                        grpc_closure* /*on_call_host_checked*/,
                        grpc_error** error) override {
@@ -226,7 +226,7 @@ class grpc_local_server_security_connector final
                   grpc_closure* on_peer_checked) override {
     grpc_local_server_credentials* creds =
         static_cast<grpc_local_server_credentials*>(mutable_server_creds());
-    local_check_peer(peer, ep, auth_context, on_peer_checked,
+    local_check_peer(peer, ep, auth_context, on_peer_checked, 
                      creds->connect_type());
   }
 
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/security_connector.cc b/contrib/libs/grpc/src/core/lib/security/security_connector/security_connector.cc
index 0400ad6fb8..83e033f52f 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/security_connector.cc
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/security_connector.cc
@@ -46,8 +46,8 @@ grpc_server_security_connector::grpc_server_security_connector(
     : grpc_security_connector(url_scheme),
       server_creds_(std::move(server_creds)) {}
 
-grpc_server_security_connector::~grpc_server_security_connector() = default;
-
+grpc_server_security_connector::~grpc_server_security_connector() = default; 
+ 
 grpc_channel_security_connector::grpc_channel_security_connector(
     const char* url_scheme,
     grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds,
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/security_connector.h b/contrib/libs/grpc/src/core/lib/security/security_connector/security_connector.h
index 74d04600b2..b457b9f5a4 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/security_connector.h
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/security_connector.h
@@ -98,7 +98,7 @@ class grpc_channel_security_connector : public grpc_security_connector {
   /// Returns true if completed synchronously, in which case \a error will
   /// be set to indicate the result.  Otherwise, \a on_call_host_checked
   /// will be invoked when complete.
-  virtual bool check_call_host(y_absl::string_view host,
+  virtual bool check_call_host(y_absl::string_view host, 
                                grpc_auth_context* auth_context,
                                grpc_closure* on_call_host_checked,
                                grpc_error** error) = 0;
@@ -151,7 +151,7 @@ class grpc_server_security_connector : public grpc_security_connector {
   grpc_server_security_connector(
       const char* url_scheme,
       grpc_core::RefCountedPtr<grpc_server_credentials> server_creds);
-  ~grpc_server_security_connector() override;
+  ~grpc_server_security_connector() override; 
 
   virtual void add_handshakers(const grpc_channel_args* args,
                                grpc_pollset_set* interested_parties,
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/ssl/ssl_security_connector.cc b/contrib/libs/grpc/src/core/lib/security/security_connector/ssl/ssl_security_connector.cc
index b5e78ddbbb..8b334b12dd 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/ssl/ssl_security_connector.cc
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/ssl/ssl_security_connector.cc
@@ -22,10 +22,10 @@
 
 #include <stdbool.h>
 
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/string_view.h"
-
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/string_view.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -34,7 +34,7 @@
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/sync.h" 
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/ssl/ssl_credentials.h"
@@ -54,9 +54,9 @@ grpc_error* ssl_check_peer(
   }
   /* Check the peer name if specified. */
   if (peer_name != nullptr && !grpc_ssl_host_matches_name(peer, peer_name)) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat("Peer name ", peer_name, " is not in peer certificate")
-            .c_str());
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat("Peer name ", peer_name, " is not in peer certificate") 
+            .c_str()); 
   }
   *auth_context =
       grpc_ssl_peer_to_auth_context(peer, GRPC_SSL_TRANSPORT_SECURITY_TYPE);
@@ -74,13 +74,13 @@ class grpc_ssl_channel_security_connector final
       : grpc_channel_security_connector(GRPC_SSL_URL_SCHEME,
                                         std::move(channel_creds),
                                         std::move(request_metadata_creds)),
-        overridden_target_name_(
-            overridden_target_name == nullptr ? "" : overridden_target_name),
+        overridden_target_name_( 
+            overridden_target_name == nullptr ? "" : overridden_target_name), 
         verify_options_(&config->verify_options) {
-    y_absl::string_view host;
-    y_absl::string_view port;
+    y_absl::string_view host; 
+    y_absl::string_view port; 
     grpc_core::SplitHostPort(target_name, &host, &port);
-    target_name_ = TString(host);
+    target_name_ = TString(host); 
   }
 
   ~grpc_ssl_channel_security_connector() override {
@@ -106,8 +106,8 @@ class grpc_ssl_channel_security_connector final
     }
     options.cipher_suites = grpc_get_ssl_cipher_suites();
     options.session_cache = ssl_session_cache;
-    options.min_tls_version = grpc_get_tsi_tls_version(config->min_tls_version);
-    options.max_tls_version = grpc_get_tsi_tls_version(config->max_tls_version);
+    options.min_tls_version = grpc_get_tsi_tls_version(config->min_tls_version); 
+    options.max_tls_version = grpc_get_tsi_tls_version(config->max_tls_version); 
     const tsi_result result =
         tsi_create_ssl_client_handshaker_factory_with_options(
             &options, &client_handshaker_factory_);
@@ -127,8 +127,8 @@ class grpc_ssl_channel_security_connector final
     tsi_handshaker* tsi_hs = nullptr;
     tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
         client_handshaker_factory_,
-        overridden_target_name_.empty() ? target_name_.c_str()
-                                        : overridden_target_name_.c_str(),
+        overridden_target_name_.empty() ? target_name_.c_str() 
+                                        : overridden_target_name_.c_str(), 
         &tsi_hs);
     if (result != TSI_OK) {
       gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.",
@@ -142,9 +142,9 @@ class grpc_ssl_channel_security_connector final
   void check_peer(tsi_peer peer, grpc_endpoint* /*ep*/,
                   grpc_core::RefCountedPtr<grpc_auth_context>* auth_context,
                   grpc_closure* on_peer_checked) override {
-    const char* target_name = overridden_target_name_.empty()
-                                  ? target_name_.c_str()
-                                  : overridden_target_name_.c_str();
+    const char* target_name = overridden_target_name_.empty() 
+                                  ? target_name_.c_str() 
+                                  : overridden_target_name_.c_str(); 
     grpc_error* error = ssl_check_peer(target_name, &peer, auth_context);
     if (error == GRPC_ERROR_NONE &&
         verify_options_->verify_peer_callback != nullptr) {
@@ -162,10 +162,10 @@ class grpc_ssl_channel_security_connector final
             verify_options_->verify_peer_callback_userdata);
         gpr_free(peer_pem);
         if (callback_status) {
-          error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-              y_absl::StrFormat("Verify peer callback returned a failure (%d)",
-                              callback_status)
-                  .c_str());
+          error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+              y_absl::StrFormat("Verify peer callback returned a failure (%d)", 
+                              callback_status) 
+                  .c_str()); 
         }
       }
     }
@@ -178,17 +178,17 @@ class grpc_ssl_channel_security_connector final
         reinterpret_cast<const grpc_ssl_channel_security_connector*>(other_sc);
     int c = channel_security_connector_cmp(other);
     if (c != 0) return c;
-    c = target_name_.compare(other->target_name_);
+    c = target_name_.compare(other->target_name_); 
     if (c != 0) return c;
-    return overridden_target_name_.compare(other->overridden_target_name_);
+    return overridden_target_name_.compare(other->overridden_target_name_); 
   }
 
-  bool check_call_host(y_absl::string_view host, grpc_auth_context* auth_context,
+  bool check_call_host(y_absl::string_view host, grpc_auth_context* auth_context, 
                        grpc_closure* /*on_call_host_checked*/,
                        grpc_error** error) override {
-    return grpc_ssl_check_call_host(host, target_name_.c_str(),
-                                    overridden_target_name_.c_str(),
-                                    auth_context, error);
+    return grpc_ssl_check_call_host(host, target_name_.c_str(), 
+                                    overridden_target_name_.c_str(), 
+                                    auth_context, error); 
   }
 
   void cancel_check_call_host(grpc_closure* /*on_call_host_checked*/,
@@ -198,8 +198,8 @@ class grpc_ssl_channel_security_connector final
 
  private:
   tsi_ssl_client_handshaker_factory* client_handshaker_factory_;
-  TString target_name_;
-  TString overridden_target_name_;
+  TString target_name_; 
+  TString overridden_target_name_; 
   const verify_peer_options* verify_options_;
 };
 
@@ -251,10 +251,10 @@ class grpc_ssl_server_security_connector
       options.cipher_suites = grpc_get_ssl_cipher_suites();
       options.alpn_protocols = alpn_protocol_strings;
       options.num_alpn_protocols = static_cast<uint16_t>(num_alpn_protocols);
-      options.min_tls_version = grpc_get_tsi_tls_version(
-          server_credentials->config().min_tls_version);
-      options.max_tls_version = grpc_get_tsi_tls_version(
-          server_credentials->config().max_tls_version);
+      options.min_tls_version = grpc_get_tsi_tls_version( 
+          server_credentials->config().min_tls_version); 
+      options.max_tls_version = grpc_get_tsi_tls_version( 
+          server_credentials->config().max_tls_version); 
       const tsi_result result =
           tsi_create_ssl_server_handshaker_factory_with_options(
               &options, &server_handshaker_factory_);
@@ -307,7 +307,7 @@ class grpc_ssl_server_security_connector
     bool status;
     if (!has_cert_config_fetcher()) return false;
 
-    grpc_core::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(&mu_); 
     grpc_ssl_server_credentials* server_creds =
         static_cast<grpc_ssl_server_credentials*>(this->mutable_server_creds());
     grpc_ssl_certificate_config_reload_status cb_result =
@@ -387,7 +387,7 @@ class grpc_ssl_server_security_connector
     server_handshaker_factory_ = new_factory;
   }
 
-  grpc_core::Mutex mu_;
+  grpc_core::Mutex mu_; 
   tsi_ssl_server_handshaker_factory* server_handshaker_factory_ = nullptr;
 };
 }  // namespace
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/ssl/ssl_security_connector.h b/contrib/libs/grpc/src/core/lib/security/security_connector/ssl/ssl_security_connector.h
index 04c32bb2a8..e8369afbea 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/ssl/ssl_security_connector.h
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/ssl/ssl_security_connector.h
@@ -33,10 +33,10 @@ struct grpc_ssl_config {
   tsi_ssl_pem_key_cert_pair* pem_key_cert_pair;
   char* pem_root_certs;
   verify_peer_options verify_options;
-  grpc_tls_version min_tls_version = grpc_tls_version::TLS1_2;
-  grpc_tls_version max_tls_version = grpc_tls_version::TLS1_3;
+  grpc_tls_version min_tls_version = grpc_tls_version::TLS1_2; 
+  grpc_tls_version max_tls_version = grpc_tls_version::TLS1_3; 
 };
-
+ 
 /* Creates an SSL channel_security_connector.
    - request_metadata_creds is the credentials object which metadata
      will be sent with each request. This parameter can be NULL.
@@ -65,8 +65,8 @@ struct grpc_ssl_server_config {
   char* pem_root_certs = nullptr;
   grpc_ssl_client_certificate_request_type client_certificate_request =
       GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE;
-  grpc_tls_version min_tls_version = grpc_tls_version::TLS1_2;
-  grpc_tls_version max_tls_version = grpc_tls_version::TLS1_3;
+  grpc_tls_version min_tls_version = grpc_tls_version::TLS1_2; 
+  grpc_tls_version max_tls_version = grpc_tls_version::TLS1_3; 
 };
 /* Creates an SSL server_security_connector.
    - config is the SSL config to be used for the SSL channel establishment.
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/ssl_utils.cc b/contrib/libs/grpc/src/core/lib/security/security_connector/ssl_utils.cc
index 6c83968f8e..89caff5dd8 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/ssl_utils.cc
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/ssl_utils.cc
@@ -20,10 +20,10 @@
 
 #include "src/core/lib/security/security_connector/ssl_utils.h"
 
-#include <vector>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <vector> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -70,9 +70,9 @@ static const char* cipher_suites = nullptr;
 // All cipher suites for default are compliant with HTTP2.
 GPR_GLOBAL_CONFIG_DEFINE_STRING(
     grpc_ssl_cipher_suites,
-    "TLS_AES_128_GCM_SHA256:"
-    "TLS_AES_256_GCM_SHA384:"
-    "TLS_CHACHA20_POLY1305_SHA256:"
+    "TLS_AES_128_GCM_SHA256:" 
+    "TLS_AES_256_GCM_SHA384:" 
+    "TLS_CHACHA20_POLY1305_SHA256:" 
     "ECDHE-ECDSA-AES128-GCM-SHA256:"
     "ECDHE-ECDSA-AES256-GCM-SHA384:"
     "ECDHE-RSA-AES128-GCM-SHA256:"
@@ -92,30 +92,30 @@ const char* grpc_get_ssl_cipher_suites(void) {
   return cipher_suites;
 }
 
-grpc_security_level grpc_tsi_security_level_string_to_enum(
-    const char* security_level) {
-  if (strcmp(security_level, "TSI_INTEGRITY_ONLY") == 0) {
-    return GRPC_INTEGRITY_ONLY;
-  } else if (strcmp(security_level, "TSI_PRIVACY_AND_INTEGRITY") == 0) {
-    return GRPC_PRIVACY_AND_INTEGRITY;
-  }
-  return GRPC_SECURITY_NONE;
-}
-
-const char* grpc_security_level_to_string(grpc_security_level security_level) {
-  if (security_level == GRPC_PRIVACY_AND_INTEGRITY) {
-    return "GRPC_PRIVACY_AND_INTEGRITY";
-  } else if (security_level == GRPC_INTEGRITY_ONLY) {
-    return "GRPC_INTEGRITY_ONLY";
-  }
-  return "GRPC_SECURITY_NONE";
-}
-
-bool grpc_check_security_level(grpc_security_level channel_level,
-                               grpc_security_level call_cred_level) {
-  return static_cast<int>(channel_level) >= static_cast<int>(call_cred_level);
-}
-
+grpc_security_level grpc_tsi_security_level_string_to_enum( 
+    const char* security_level) { 
+  if (strcmp(security_level, "TSI_INTEGRITY_ONLY") == 0) { 
+    return GRPC_INTEGRITY_ONLY; 
+  } else if (strcmp(security_level, "TSI_PRIVACY_AND_INTEGRITY") == 0) { 
+    return GRPC_PRIVACY_AND_INTEGRITY; 
+  } 
+  return GRPC_SECURITY_NONE; 
+} 
+ 
+const char* grpc_security_level_to_string(grpc_security_level security_level) { 
+  if (security_level == GRPC_PRIVACY_AND_INTEGRITY) { 
+    return "GRPC_PRIVACY_AND_INTEGRITY"; 
+  } else if (security_level == GRPC_INTEGRITY_ONLY) { 
+    return "GRPC_INTEGRITY_ONLY"; 
+  } 
+  return "GRPC_SECURITY_NONE"; 
+} 
+ 
+bool grpc_check_security_level(grpc_security_level channel_level, 
+                               grpc_security_level call_cred_level) { 
+  return static_cast<int>(channel_level) >= static_cast<int>(call_cred_level); 
+} 
+ 
 tsi_client_certificate_request_type
 grpc_get_tsi_client_certificate_request_type(
     grpc_ssl_client_certificate_request_type grpc_request_type) {
@@ -140,18 +140,18 @@ grpc_get_tsi_client_certificate_request_type(
   }
 }
 
-tsi_tls_version grpc_get_tsi_tls_version(grpc_tls_version tls_version) {
-  switch (tls_version) {
-    case grpc_tls_version::TLS1_2:
-      return tsi_tls_version::TSI_TLS1_2;
-    case grpc_tls_version::TLS1_3:
-      return tsi_tls_version::TSI_TLS1_3;
-    default:
-      gpr_log(GPR_INFO, "Falling back to TLS 1.2.");
-      return tsi_tls_version::TSI_TLS1_2;
-  }
-}
-
+tsi_tls_version grpc_get_tsi_tls_version(grpc_tls_version tls_version) { 
+  switch (tls_version) { 
+    case grpc_tls_version::TLS1_2: 
+      return tsi_tls_version::TSI_TLS1_2; 
+    case grpc_tls_version::TLS1_3: 
+      return tsi_tls_version::TSI_TLS1_3; 
+    default: 
+      gpr_log(GPR_INFO, "Falling back to TLS 1.2."); 
+      return tsi_tls_version::TSI_TLS1_2; 
+  } 
+} 
+ 
 grpc_error* grpc_ssl_check_alpn(const tsi_peer* peer) {
 #if TSI_OPENSSL_ALPN_SUPPORT
   /* Check the ALPN if ALPN is supported. */
@@ -169,28 +169,28 @@ grpc_error* grpc_ssl_check_alpn(const tsi_peer* peer) {
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_ssl_check_peer_name(y_absl::string_view peer_name,
+grpc_error* grpc_ssl_check_peer_name(y_absl::string_view peer_name, 
                                      const tsi_peer* peer) {
   /* Check the peer name if specified. */
   if (!peer_name.empty() && !grpc_ssl_host_matches_name(peer, peer_name)) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat("Peer name ", peer_name, " is not in peer certificate")
-            .c_str());
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat("Peer name ", peer_name, " is not in peer certificate") 
+            .c_str()); 
   }
   return GRPC_ERROR_NONE;
 }
 
-bool grpc_ssl_check_call_host(y_absl::string_view host,
-                              y_absl::string_view target_name,
-                              y_absl::string_view overridden_target_name,
+bool grpc_ssl_check_call_host(y_absl::string_view host, 
+                              y_absl::string_view target_name, 
+                              y_absl::string_view overridden_target_name, 
                               grpc_auth_context* auth_context,
                               grpc_error** error) {
   grpc_security_status status = GRPC_SECURITY_ERROR;
   tsi_peer peer = grpc_shallow_peer_from_ssl_auth_context(auth_context);
   if (grpc_ssl_host_matches_name(&peer, host)) status = GRPC_SECURITY_OK;
-  /* If the target name was overridden, then the original target_name was
-   'checked' transitively during the previous peer check at the end of the
-   handshake. */
+  /* If the target name was overridden, then the original target_name was 
+   'checked' transitively during the previous peer check at the end of the 
+   handshake. */ 
   if (!overridden_target_name.empty() && host == target_name) {
     status = GRPC_SECURITY_OK;
   }
@@ -214,50 +214,50 @@ const char** grpc_fill_alpn_protocol_strings(size_t* num_alpn_protocols) {
 }
 
 int grpc_ssl_host_matches_name(const tsi_peer* peer,
-                               y_absl::string_view peer_name) {
-  y_absl::string_view allocated_name;
-  y_absl::string_view ignored_port;
+                               y_absl::string_view peer_name) { 
+  y_absl::string_view allocated_name; 
+  y_absl::string_view ignored_port; 
   grpc_core::SplitHostPort(peer_name, &allocated_name, &ignored_port);
   if (allocated_name.empty()) return 0;
 
   // IPv6 zone-id should not be included in comparisons.
   const size_t zone_id = allocated_name.find('%');
-  if (zone_id != y_absl::string_view::npos) {
+  if (zone_id != y_absl::string_view::npos) { 
     allocated_name.remove_suffix(allocated_name.size() - zone_id);
   }
   return tsi_ssl_peer_matches_name(peer, allocated_name);
 }
 
-int grpc_ssl_cmp_target_name(y_absl::string_view target_name,
-                             y_absl::string_view other_target_name,
-                             y_absl::string_view overridden_target_name,
-                             y_absl::string_view other_overridden_target_name) {
-  int c = target_name.compare(other_target_name);
+int grpc_ssl_cmp_target_name(y_absl::string_view target_name, 
+                             y_absl::string_view other_target_name, 
+                             y_absl::string_view overridden_target_name, 
+                             y_absl::string_view other_overridden_target_name) { 
+  int c = target_name.compare(other_target_name); 
   if (c != 0) return c;
-  return overridden_target_name.compare(other_overridden_target_name);
-}
-
-static bool IsSpiffeId(y_absl::string_view uri) {
-  // Return false without logging for a non-spiffe uri scheme.
-  if (!y_absl::StartsWith(uri, "spiffe://")) {
-    return false;
-  };
-  if (uri.size() > 2048) {
-    gpr_log(GPR_INFO, "Invalid SPIFFE ID: ID longer than 2048 bytes.");
-    return false;
-  }
-  std::vector<y_absl::string_view> splits = y_absl::StrSplit(uri, '/');
-  if (splits.size() < 4 || splits[3] == "") {
-    gpr_log(GPR_INFO, "Invalid SPIFFE ID: workload id is empty.");
-    return false;
-  }
-  if (splits[2].size() > 255) {
-    gpr_log(GPR_INFO, "Invalid SPIFFE ID: domain longer than 255 characters.");
-    return false;
-  }
-  return true;
-}
-
+  return overridden_target_name.compare(other_overridden_target_name); 
+}
+
+static bool IsSpiffeId(y_absl::string_view uri) { 
+  // Return false without logging for a non-spiffe uri scheme. 
+  if (!y_absl::StartsWith(uri, "spiffe://")) { 
+    return false; 
+  }; 
+  if (uri.size() > 2048) { 
+    gpr_log(GPR_INFO, "Invalid SPIFFE ID: ID longer than 2048 bytes."); 
+    return false; 
+  } 
+  std::vector<y_absl::string_view> splits = y_absl::StrSplit(uri, '/'); 
+  if (splits.size() < 4 || splits[3] == "") { 
+    gpr_log(GPR_INFO, "Invalid SPIFFE ID: workload id is empty."); 
+    return false; 
+  } 
+  if (splits[2].size() > 255) { 
+    gpr_log(GPR_INFO, "Invalid SPIFFE ID: domain longer than 255 characters."); 
+    return false; 
+  } 
+  return true; 
+} 
+ 
 grpc_core::RefCountedPtr<grpc_auth_context> grpc_ssl_peer_to_auth_context(
     const tsi_peer* peer, const char* transport_security_type) {
   size_t i;
@@ -270,10 +270,10 @@ grpc_core::RefCountedPtr<grpc_auth_context> grpc_ssl_peer_to_auth_context(
   grpc_auth_context_add_cstring_property(
       ctx.get(), GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME,
       transport_security_type);
-  const char* spiffe_data = nullptr;
-  size_t spiffe_length = 0;
-  int uri_count = 0;
-  bool has_spiffe_id = false;
+  const char* spiffe_data = nullptr; 
+  size_t spiffe_length = 0; 
+  int uri_count = 0; 
+  bool has_spiffe_id = false; 
   for (i = 0; i < peer->property_count; i++) {
     const tsi_peer_property* prop = &peer->properties[i];
     if (prop->name == nullptr) continue;
@@ -293,44 +293,44 @@ grpc_core::RefCountedPtr<grpc_auth_context> grpc_ssl_peer_to_auth_context(
       grpc_auth_context_add_property(ctx.get(),
                                      GRPC_X509_PEM_CERT_PROPERTY_NAME,
                                      prop->value.data, prop->value.length);
-    } else if (strcmp(prop->name, TSI_X509_PEM_CERT_CHAIN_PROPERTY) == 0) {
-      grpc_auth_context_add_property(ctx.get(),
-                                     GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME,
-                                     prop->value.data, prop->value.length);
+    } else if (strcmp(prop->name, TSI_X509_PEM_CERT_CHAIN_PROPERTY) == 0) { 
+      grpc_auth_context_add_property(ctx.get(), 
+                                     GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME, 
+                                     prop->value.data, prop->value.length); 
     } else if (strcmp(prop->name, TSI_SSL_SESSION_REUSED_PEER_PROPERTY) == 0) {
       grpc_auth_context_add_property(ctx.get(),
                                      GRPC_SSL_SESSION_REUSED_PROPERTY,
                                      prop->value.data, prop->value.length);
-    } else if (strcmp(prop->name, TSI_SECURITY_LEVEL_PEER_PROPERTY) == 0) {
-      grpc_auth_context_add_property(
-          ctx.get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME,
-          prop->value.data, prop->value.length);
-    } else if (strcmp(prop->name, TSI_X509_URI_PEER_PROPERTY) == 0) {
-      uri_count++;
-      y_absl::string_view spiffe_id(prop->value.data, prop->value.length);
-      if (IsSpiffeId(spiffe_id)) {
-        spiffe_data = prop->value.data;
-        spiffe_length = prop->value.length;
-        has_spiffe_id = true;
-      }
+    } else if (strcmp(prop->name, TSI_SECURITY_LEVEL_PEER_PROPERTY) == 0) { 
+      grpc_auth_context_add_property( 
+          ctx.get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME, 
+          prop->value.data, prop->value.length); 
+    } else if (strcmp(prop->name, TSI_X509_URI_PEER_PROPERTY) == 0) { 
+      uri_count++; 
+      y_absl::string_view spiffe_id(prop->value.data, prop->value.length); 
+      if (IsSpiffeId(spiffe_id)) { 
+        spiffe_data = prop->value.data; 
+        spiffe_length = prop->value.length; 
+        has_spiffe_id = true; 
+      } 
     }
   }
   if (peer_identity_property_name != nullptr) {
     GPR_ASSERT(grpc_auth_context_set_peer_identity_property_name(
                    ctx.get(), peer_identity_property_name) == 1);
   }
-  // A valid SPIFFE certificate can only have exact one URI SAN field.
-  if (has_spiffe_id) {
-    if (uri_count == 1) {
-      GPR_ASSERT(spiffe_length > 0);
-      GPR_ASSERT(spiffe_data != nullptr);
-      grpc_auth_context_add_property(ctx.get(),
-                                     GRPC_PEER_SPIFFE_ID_PROPERTY_NAME,
-                                     spiffe_data, spiffe_length);
-    } else {
-      gpr_log(GPR_INFO, "Invalid SPIFFE ID: multiple URI SANs.");
-    }
-  }
+  // A valid SPIFFE certificate can only have exact one URI SAN field. 
+  if (has_spiffe_id) { 
+    if (uri_count == 1) { 
+      GPR_ASSERT(spiffe_length > 0); 
+      GPR_ASSERT(spiffe_data != nullptr); 
+      grpc_auth_context_add_property(ctx.get(), 
+                                     GRPC_PEER_SPIFFE_ID_PROPERTY_NAME, 
+                                     spiffe_data, spiffe_length); 
+    } else { 
+      gpr_log(GPR_INFO, "Invalid SPIFFE ID: multiple URI SANs."); 
+    } 
+  } 
   return ctx;
 }
 
@@ -368,17 +368,17 @@ tsi_peer grpc_shallow_peer_from_ssl_auth_context(
       } else if (strcmp(prop->name, GRPC_X509_PEM_CERT_PROPERTY_NAME) == 0) {
         add_shallow_auth_property_to_peer(&peer, prop,
                                           TSI_X509_PEM_CERT_PROPERTY);
-      } else if (strcmp(prop->name,
-                        GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME) == 0) {
-        add_shallow_auth_property_to_peer(&peer, prop,
-                                          TSI_SECURITY_LEVEL_PEER_PROPERTY);
-      } else if (strcmp(prop->name, GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME) ==
-                 0) {
-        add_shallow_auth_property_to_peer(&peer, prop,
-                                          TSI_X509_PEM_CERT_CHAIN_PROPERTY);
-      } else if (strcmp(prop->name, GRPC_PEER_SPIFFE_ID_PROPERTY_NAME) == 0) {
-        add_shallow_auth_property_to_peer(&peer, prop,
-                                          TSI_X509_URI_PEER_PROPERTY);
+      } else if (strcmp(prop->name, 
+                        GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME) == 0) { 
+        add_shallow_auth_property_to_peer(&peer, prop, 
+                                          TSI_SECURITY_LEVEL_PEER_PROPERTY); 
+      } else if (strcmp(prop->name, GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME) == 
+                 0) { 
+        add_shallow_auth_property_to_peer(&peer, prop, 
+                                          TSI_X509_PEM_CERT_CHAIN_PROPERTY); 
+      } else if (strcmp(prop->name, GRPC_PEER_SPIFFE_ID_PROPERTY_NAME) == 0) { 
+        add_shallow_auth_property_to_peer(&peer, prop, 
+                                          TSI_X509_URI_PEER_PROPERTY); 
       }
     }
   }
@@ -391,8 +391,8 @@ void grpc_shallow_peer_destruct(tsi_peer* peer) {
 
 grpc_security_status grpc_ssl_tsi_client_handshaker_factory_init(
     tsi_ssl_pem_key_cert_pair* pem_key_cert_pair, const char* pem_root_certs,
-    bool skip_server_certificate_verification, tsi_tls_version min_tls_version,
-    tsi_tls_version max_tls_version, tsi_ssl_session_cache* ssl_session_cache,
+    bool skip_server_certificate_verification, tsi_tls_version min_tls_version, 
+    tsi_tls_version max_tls_version, tsi_ssl_session_cache* ssl_session_cache, 
     tsi_ssl_client_handshaker_factory** handshaker_factory) {
   const char* root_certs;
   const tsi_ssl_root_certs_store* root_store;
@@ -422,10 +422,10 @@ grpc_security_status grpc_ssl_tsi_client_handshaker_factory_init(
   }
   options.cipher_suites = grpc_get_ssl_cipher_suites();
   options.session_cache = ssl_session_cache;
-  options.skip_server_certificate_verification =
-      skip_server_certificate_verification;
-  options.min_tls_version = min_tls_version;
-  options.max_tls_version = max_tls_version;
+  options.skip_server_certificate_verification = 
+      skip_server_certificate_verification; 
+  options.min_tls_version = min_tls_version; 
+  options.max_tls_version = max_tls_version; 
   const tsi_result result =
       tsi_create_ssl_client_handshaker_factory_with_options(&options,
                                                             handshaker_factory);
@@ -442,7 +442,7 @@ grpc_security_status grpc_ssl_tsi_server_handshaker_factory_init(
     tsi_ssl_pem_key_cert_pair* pem_key_cert_pairs, size_t num_key_cert_pairs,
     const char* pem_root_certs,
     grpc_ssl_client_certificate_request_type client_certificate_request,
-    tsi_tls_version min_tls_version, tsi_tls_version max_tls_version,
+    tsi_tls_version min_tls_version, tsi_tls_version max_tls_version, 
     tsi_ssl_server_handshaker_factory** handshaker_factory) {
   size_t num_alpn_protocols = 0;
   const char** alpn_protocol_strings =
@@ -456,8 +456,8 @@ grpc_security_status grpc_ssl_tsi_server_handshaker_factory_init(
   options.cipher_suites = grpc_get_ssl_cipher_suites();
   options.alpn_protocols = alpn_protocol_strings;
   options.num_alpn_protocols = static_cast<uint16_t>(num_alpn_protocols);
-  options.min_tls_version = min_tls_version;
-  options.max_tls_version = max_tls_version;
+  options.min_tls_version = min_tls_version; 
+  options.max_tls_version = max_tls_version; 
   const tsi_result result =
       tsi_create_ssl_server_handshaker_factory_with_options(&options,
                                                             handshaker_factory);
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/ssl_utils.h b/contrib/libs/grpc/src/core/lib/security/security_connector/ssl_utils.h
index 6141f8d9cb..769276c3fd 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/ssl_utils.h
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/ssl_utils.h
@@ -23,9 +23,9 @@
 
 #include <stdbool.h>
 
-#include "y_absl/strings/str_split.h"
-#include "y_absl/strings/string_view.h"
-
+#include "y_absl/strings/str_split.h" 
+#include "y_absl/strings/string_view.h" 
+ 
 #include <grpc/grpc_security.h>
 #include <grpc/slice_buffer.h>
 
@@ -47,17 +47,17 @@
 grpc_error* grpc_ssl_check_alpn(const tsi_peer* peer);
 
 /* Check peer name information returned from SSL handshakes. */
-grpc_error* grpc_ssl_check_peer_name(y_absl::string_view peer_name,
+grpc_error* grpc_ssl_check_peer_name(y_absl::string_view peer_name, 
                                      const tsi_peer* peer);
 /* Compare targer_name information extracted from SSL security connectors. */
-int grpc_ssl_cmp_target_name(y_absl::string_view target_name,
-                             y_absl::string_view other_target_name,
-                             y_absl::string_view overridden_target_name,
-                             y_absl::string_view other_overridden_target_name);
+int grpc_ssl_cmp_target_name(y_absl::string_view target_name, 
+                             y_absl::string_view other_target_name, 
+                             y_absl::string_view overridden_target_name, 
+                             y_absl::string_view other_overridden_target_name); 
 /* Check the host that will be set for a call is acceptable.*/
-bool grpc_ssl_check_call_host(y_absl::string_view host,
-                              y_absl::string_view target_name,
-                              y_absl::string_view overridden_target_name,
+bool grpc_ssl_check_call_host(y_absl::string_view host, 
+                              y_absl::string_view target_name, 
+                              y_absl::string_view overridden_target_name, 
                               grpc_auth_context* auth_context,
                               grpc_error** error);
 /* Return HTTP2-compliant cipher suites that gRPC accepts by default. */
@@ -69,35 +69,35 @@ tsi_client_certificate_request_type
 grpc_get_tsi_client_certificate_request_type(
     grpc_ssl_client_certificate_request_type grpc_request_type);
 
-/* Map tsi_security_level string to grpc_security_level enum. */
-grpc_security_level grpc_tsi_security_level_string_to_enum(
-    const char* security_level);
-
-/* Map grpc_tls_version to tsi_tls_version. */
-tsi_tls_version grpc_get_tsi_tls_version(grpc_tls_version tls_version);
-
-/* Map grpc_security_level enum to a string. */
-const char* grpc_security_level_to_string(grpc_security_level security_level);
-
-/* Check security level of channel and call credential.*/
-bool grpc_check_security_level(grpc_security_level channel_level,
-                               grpc_security_level call_cred_level);
-
+/* Map tsi_security_level string to grpc_security_level enum. */ 
+grpc_security_level grpc_tsi_security_level_string_to_enum( 
+    const char* security_level); 
+ 
+/* Map grpc_tls_version to tsi_tls_version. */ 
+tsi_tls_version grpc_get_tsi_tls_version(grpc_tls_version tls_version); 
+ 
+/* Map grpc_security_level enum to a string. */ 
+const char* grpc_security_level_to_string(grpc_security_level security_level); 
+ 
+/* Check security level of channel and call credential.*/ 
+bool grpc_check_security_level(grpc_security_level channel_level, 
+                               grpc_security_level call_cred_level); 
+ 
 /* Return an array of strings containing alpn protocols. */
 const char** grpc_fill_alpn_protocol_strings(size_t* num_alpn_protocols);
 
 /* Initialize TSI SSL server/client handshaker factory. */
 grpc_security_status grpc_ssl_tsi_client_handshaker_factory_init(
     tsi_ssl_pem_key_cert_pair* key_cert_pair, const char* pem_root_certs,
-    bool skip_server_certificate_verification, tsi_tls_version min_tls_version,
-    tsi_tls_version max_tls_version, tsi_ssl_session_cache* ssl_session_cache,
+    bool skip_server_certificate_verification, tsi_tls_version min_tls_version, 
+    tsi_tls_version max_tls_version, tsi_ssl_session_cache* ssl_session_cache, 
     tsi_ssl_client_handshaker_factory** handshaker_factory);
 
 grpc_security_status grpc_ssl_tsi_server_handshaker_factory_init(
     tsi_ssl_pem_key_cert_pair* key_cert_pairs, size_t num_key_cert_pairs,
     const char* pem_root_certs,
     grpc_ssl_client_certificate_request_type client_certificate_request,
-    tsi_tls_version min_tls_version, tsi_tls_version max_tls_version,
+    tsi_tls_version min_tls_version, tsi_tls_version max_tls_version, 
     tsi_ssl_server_handshaker_factory** handshaker_factory);
 
 /* Exposed for testing only. */
@@ -107,7 +107,7 @@ tsi_peer grpc_shallow_peer_from_ssl_auth_context(
     const grpc_auth_context* auth_context);
 void grpc_shallow_peer_destruct(tsi_peer* peer);
 int grpc_ssl_host_matches_name(const tsi_peer* peer,
-                               y_absl::string_view peer_name);
+                               y_absl::string_view peer_name); 
 
 /* --- Default SSL Root Store. --- */
 namespace grpc_core {
@@ -174,11 +174,11 @@ class PemKeyCertPair {
     return *this;
   }
 
-  bool operator==(const PemKeyCertPair& other) const {
-    return std::strcmp(this->private_key(), other.private_key()) == 0 &&
-           std::strcmp(this->cert_chain(), other.cert_chain()) == 0;
-  }
-
+  bool operator==(const PemKeyCertPair& other) const { 
+    return std::strcmp(this->private_key(), other.private_key()) == 0 && 
+           std::strcmp(this->cert_chain(), other.cert_chain()) == 0; 
+  } 
+ 
   char* private_key() const { return private_key_.get(); }
   char* cert_chain() const { return cert_chain_.get(); }
 
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/tls/tls_security_connector.cc b/contrib/libs/grpc/src/core/lib/security/security_connector/tls/tls_security_connector.cc
index 4abcb75a08..e81c5d5fc0 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/tls/tls_security_connector.cc
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/tls/tls_security_connector.cc
@@ -1,606 +1,606 @@
-/*
- *
- * 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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/security/security_connector/tls/tls_security_connector.h"
-
-#include <stdbool.h>
-#include <string.h>
-
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/string_view.h"
-
-#include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/security/credentials/ssl/ssl_credentials.h"
-#include "src/core/lib/security/credentials/tls/tls_credentials.h"
-#include "src/core/lib/security/security_connector/ssl_utils.h"
-#include "src/core/lib/security/transport/security_handshaker.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/transport/transport.h"
-#include "src/core/tsi/ssl_transport_security.h"
-#include "src/core/tsi/transport_security.h"
-
-namespace grpc_core {
-
-namespace {
-
-tsi_ssl_pem_key_cert_pair* ConvertToTsiPemKeyCertPair(
-    const grpc_tls_key_materials_config::PemKeyCertPairList& cert_pair_list) {
-  tsi_ssl_pem_key_cert_pair* tsi_pairs = nullptr;
-  size_t num_key_cert_pairs = cert_pair_list.size();
-  if (num_key_cert_pairs > 0) {
-    GPR_ASSERT(cert_pair_list.data() != nullptr);
-    tsi_pairs = static_cast<tsi_ssl_pem_key_cert_pair*>(
-        gpr_zalloc(num_key_cert_pairs * sizeof(tsi_ssl_pem_key_cert_pair)));
-  }
-  for (size_t i = 0; i < num_key_cert_pairs; i++) {
-    GPR_ASSERT(cert_pair_list[i].private_key() != nullptr);
-    GPR_ASSERT(cert_pair_list[i].cert_chain() != nullptr);
-    tsi_pairs[i].cert_chain = gpr_strdup(cert_pair_list[i].cert_chain());
-    tsi_pairs[i].private_key = gpr_strdup(cert_pair_list[i].private_key());
-  }
-  return tsi_pairs;
-}
-
-}  // namespace
-
-grpc_status_code TlsFetchKeyMaterials(
-    const grpc_core::RefCountedPtr<grpc_tls_key_materials_config>&
-        key_materials_config,
-    const grpc_tls_credentials_options& options, bool is_server,
-    grpc_ssl_certificate_config_reload_status* status) {
-  GPR_ASSERT(key_materials_config != nullptr);
-  GPR_ASSERT(status != nullptr);
-  bool is_key_materials_empty =
-      key_materials_config->pem_key_cert_pair_list().empty();
-  grpc_tls_credential_reload_config* credential_reload_config =
-      options.credential_reload_config();
-  /** If there are no key materials and no credential reload config and the
-   *  caller is a server, then return an error. We do not require that a client
-   *  always provision certificates. **/
-  if (credential_reload_config == nullptr && is_key_materials_empty &&
-      is_server) {
-    gpr_log(GPR_ERROR,
-            "Either credential reload config or key materials should be "
-            "provisioned.");
-    return GRPC_STATUS_FAILED_PRECONDITION;
-  }
-  grpc_status_code reload_status = GRPC_STATUS_OK;
-  /** Use |credential_reload_config| to update |key_materials_config|. **/
-  if (credential_reload_config != nullptr) {
-    grpc_tls_credential_reload_arg* arg = new grpc_tls_credential_reload_arg();
-    arg->key_materials_config = key_materials_config.get();
-    arg->error_details = new grpc_tls_error_details();
-    int result = credential_reload_config->Schedule(arg);
-    if (result) {
-      /** Credential reloading is performed async. This is not yet supported.
-       * **/
-      gpr_log(GPR_ERROR, "Async credential reload is unsupported now.");
-      *status = GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED;
-      reload_status =
-          is_key_materials_empty ? GRPC_STATUS_UNIMPLEMENTED : GRPC_STATUS_OK;
-    } else {
-      /** Credential reloading is performed sync. **/
-      *status = arg->status;
-      if (arg->status == GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED) {
-        /* Key materials is not empty. */
-        gpr_log(GPR_DEBUG, "Credential does not change after reload.");
-      } else if (arg->status == GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL) {
-        gpr_log(GPR_ERROR, "Credential reload failed with an error:");
-        if (arg->error_details != nullptr) {
-          gpr_log(GPR_ERROR, "%s", arg->error_details->error_details().c_str());
-        }
-        reload_status =
-            is_key_materials_empty ? GRPC_STATUS_INTERNAL : GRPC_STATUS_OK;
-      }
-    }
-    delete arg->error_details;
-    /** If the credential reload config was constructed via a wrapped language,
-     *  then |arg->context| and |arg->destroy_context| will not be nullptr. In
-     *  this case, we must destroy |arg->context|, which stores the wrapped
-     *  language-version of the credential reload arg. **/
-    if (arg->destroy_context != nullptr) {
-      arg->destroy_context(arg->context);
-    }
-    delete arg;
-  }
-  return reload_status;
-}
-
-grpc_error* TlsCheckHostName(const char* peer_name, const tsi_peer* peer) {
-  /* Check the peer name if specified. */
-  if (peer_name != nullptr && !grpc_ssl_host_matches_name(peer, peer_name)) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat("Peer name ", peer_name, " is not in peer certificate")
-            .c_str());
-  }
-  return GRPC_ERROR_NONE;
-}
-
-TlsChannelSecurityConnector::TlsChannelSecurityConnector(
-    grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds,
-    grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds,
-    const char* target_name, const char* overridden_target_name)
-    : grpc_channel_security_connector(GRPC_SSL_URL_SCHEME,
-                                      std::move(channel_creds),
-                                      std::move(request_metadata_creds)),
-      overridden_target_name_(
-          overridden_target_name == nullptr ? "" : overridden_target_name) {
-  key_materials_config_ = grpc_tls_key_materials_config_create()->Ref();
-  check_arg_ = ServerAuthorizationCheckArgCreate(this);
-  y_absl::string_view host;
-  y_absl::string_view port;
-  grpc_core::SplitHostPort(target_name, &host, &port);
-  target_name_ = TString(host);
-}
-
-TlsChannelSecurityConnector::~TlsChannelSecurityConnector() {
-  if (client_handshaker_factory_ != nullptr) {
-    tsi_ssl_client_handshaker_factory_unref(client_handshaker_factory_);
-  }
-  if (key_materials_config_.get() != nullptr) {
-    key_materials_config_.get()->Unref();
-  }
-  ServerAuthorizationCheckArgDestroy(check_arg_);
-}
-
-void TlsChannelSecurityConnector::add_handshakers(
-    const grpc_channel_args* args, grpc_pollset_set* /*interested_parties*/,
-    grpc_core::HandshakeManager* handshake_mgr) {
-  if (RefreshHandshakerFactory() != GRPC_SECURITY_OK) {
-    gpr_log(GPR_ERROR, "Handshaker factory refresh failed.");
-    return;
-  }
-  // Instantiate TSI handshaker.
-  tsi_handshaker* tsi_hs = nullptr;
-  tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
-      client_handshaker_factory_,
-      overridden_target_name_.empty() ? target_name_.c_str()
-                                      : overridden_target_name_.c_str(),
-      &tsi_hs);
-  if (result != TSI_OK) {
-    gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.",
-            tsi_result_to_string(result));
-    return;
-  }
-  // Create handshakers.
-  handshake_mgr->Add(grpc_core::SecurityHandshakerCreate(tsi_hs, this, args));
-}
-
-void TlsChannelSecurityConnector::check_peer(
-    tsi_peer peer, grpc_endpoint* /*ep*/,
-    grpc_core::RefCountedPtr<grpc_auth_context>* auth_context,
-    grpc_closure* on_peer_checked) {
-  const char* target_name = overridden_target_name_.empty()
-                                ? target_name_.c_str()
-                                : overridden_target_name_.c_str();
-  grpc_error* error = grpc_ssl_check_alpn(&peer);
-  if (error != GRPC_ERROR_NONE) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
-    tsi_peer_destruct(&peer);
-    return;
-  }
-  *auth_context =
-      grpc_ssl_peer_to_auth_context(&peer, GRPC_TLS_TRANSPORT_SECURITY_TYPE);
-  const TlsCredentials* creds =
-      static_cast<const TlsCredentials*>(channel_creds());
-  if (creds->options().server_verification_option() ==
-      GRPC_TLS_SERVER_VERIFICATION) {
-    /* Do the default host name check if specifying the target name. */
-    error = TlsCheckHostName(target_name, &peer);
-    if (error != GRPC_ERROR_NONE) {
-      grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
-      tsi_peer_destruct(&peer);
-      return;
-    }
-  }
-  /* Do the custom server authorization check, if specified by the user. */
-  const grpc_tls_server_authorization_check_config* config =
-      creds->options().server_authorization_check_config();
-  /* If server authorization config is not null, use it to perform
-   * server authorization check. */
-  if (config != nullptr) {
-    const tsi_peer_property* p =
-        tsi_peer_get_property_by_name(&peer, TSI_X509_PEM_CERT_PROPERTY);
-    if (p == nullptr) {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "Cannot check peer: missing pem cert property.");
-    } else {
-      char* peer_pem = static_cast<char*>(gpr_zalloc(p->value.length + 1));
-      memcpy(peer_pem, p->value.data, p->value.length);
-      GPR_ASSERT(check_arg_ != nullptr);
-      check_arg_->peer_cert = check_arg_->peer_cert == nullptr
-                                  ? gpr_strdup(peer_pem)
-                                  : check_arg_->peer_cert;
-      check_arg_->target_name = check_arg_->target_name == nullptr
-                                    ? gpr_strdup(target_name)
-                                    : check_arg_->target_name;
-      on_peer_checked_ = on_peer_checked;
-      gpr_free(peer_pem);
-      const tsi_peer_property* chain = tsi_peer_get_property_by_name(
-          &peer, TSI_X509_PEM_CERT_CHAIN_PROPERTY);
-      if (chain != nullptr) {
-        char* peer_pem_chain =
-            static_cast<char*>(gpr_zalloc(chain->value.length + 1));
-        memcpy(peer_pem_chain, chain->value.data, chain->value.length);
-        check_arg_->peer_cert_full_chain =
-            check_arg_->peer_cert_full_chain == nullptr
-                ? gpr_strdup(peer_pem_chain)
-                : check_arg_->peer_cert_full_chain;
-        gpr_free(peer_pem_chain);
-      }
-      int callback_status = config->Schedule(check_arg_);
-      /* Server authorization check is handled asynchronously. */
-      if (callback_status) {
-        tsi_peer_destruct(&peer);
-        return;
-      }
-      /* Server authorization check is handled synchronously. */
-      error = ProcessServerAuthorizationCheckResult(check_arg_);
-    }
-  }
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
-  tsi_peer_destruct(&peer);
-}
-
-int TlsChannelSecurityConnector::cmp(
-    const grpc_security_connector* other_sc) const {
-  auto* other = reinterpret_cast<const TlsChannelSecurityConnector*>(other_sc);
-  int c = channel_security_connector_cmp(other);
-  if (c != 0) {
-    return c;
-  }
-  return grpc_ssl_cmp_target_name(
-      target_name_.c_str(), other->target_name_.c_str(),
-      overridden_target_name_.c_str(), other->overridden_target_name_.c_str());
-}
-
-bool TlsChannelSecurityConnector::check_call_host(
-    y_absl::string_view host, grpc_auth_context* auth_context,
-    grpc_closure* /*on_call_host_checked*/, grpc_error** error) {
-  return grpc_ssl_check_call_host(host, target_name_.c_str(),
-                                  overridden_target_name_.c_str(), auth_context,
-                                  error);
-}
-
-void TlsChannelSecurityConnector::cancel_check_call_host(
-    grpc_closure* /*on_call_host_checked*/, grpc_error* error) {
-  GRPC_ERROR_UNREF(error);
-}
-
-grpc_core::RefCountedPtr<grpc_channel_security_connector>
-TlsChannelSecurityConnector::CreateTlsChannelSecurityConnector(
-    grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds,
-    grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds,
-    const char* target_name, const char* overridden_target_name,
-    tsi_ssl_session_cache* ssl_session_cache) {
-  if (channel_creds == nullptr) {
-    gpr_log(GPR_ERROR,
-            "channel_creds is nullptr in "
-            "TlsChannelSecurityConnectorCreate()");
-    return nullptr;
-  }
-  if (target_name == nullptr) {
-    gpr_log(GPR_ERROR,
-            "target_name is nullptr in "
-            "TlsChannelSecurityConnectorCreate()");
-    return nullptr;
-  }
-  grpc_core::RefCountedPtr<TlsChannelSecurityConnector> c =
-      grpc_core::MakeRefCounted<TlsChannelSecurityConnector>(
-          std::move(channel_creds), std::move(request_metadata_creds),
-          target_name, overridden_target_name);
-  if (c->InitializeHandshakerFactory(ssl_session_cache) != GRPC_SECURITY_OK) {
-    gpr_log(GPR_ERROR, "Could not initialize client handshaker factory.");
-    return nullptr;
-  }
-  return c;
-}
-
-grpc_security_status TlsChannelSecurityConnector::ReplaceHandshakerFactory(
-    tsi_ssl_session_cache* ssl_session_cache) {
-  const TlsCredentials* creds =
-      static_cast<const TlsCredentials*>(channel_creds());
-  bool skip_server_certificate_verification =
-      creds->options().server_verification_option() ==
-      GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION;
-  /* Free the client handshaker factory if exists. */
-  if (client_handshaker_factory_) {
-    tsi_ssl_client_handshaker_factory_unref(client_handshaker_factory_);
-  }
-  tsi_ssl_pem_key_cert_pair* pem_key_cert_pair = ConvertToTsiPemKeyCertPair(
-      key_materials_config_->pem_key_cert_pair_list());
-  grpc_security_status status = grpc_ssl_tsi_client_handshaker_factory_init(
-      pem_key_cert_pair, key_materials_config_->pem_root_certs(),
-      skip_server_certificate_verification,
-      grpc_get_tsi_tls_version(creds->options().min_tls_version()),
-      grpc_get_tsi_tls_version(creds->options().max_tls_version()),
-      ssl_session_cache, &client_handshaker_factory_);
-  /* Free memory. */
-  grpc_tsi_ssl_pem_key_cert_pairs_destroy(pem_key_cert_pair, 1);
-  return status;
-}
-
-grpc_security_status TlsChannelSecurityConnector::InitializeHandshakerFactory(
-    tsi_ssl_session_cache* ssl_session_cache) {
-  grpc_core::MutexLock lock(&mu_);
-  const TlsCredentials* creds =
-      static_cast<const TlsCredentials*>(channel_creds());
-  grpc_tls_key_materials_config* key_materials_config =
-      creds->options().key_materials_config();
-  // key_materials_config_->set_key_materials will handle the copying of the key
-  // materials users provided
-  if (key_materials_config != nullptr) {
-    key_materials_config_->set_key_materials(
-        key_materials_config->pem_root_certs(),
-        key_materials_config->pem_key_cert_pair_list());
-  }
-  grpc_ssl_certificate_config_reload_status reload_status =
-      GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED;
-  /** If |creds->options()| has a credential reload config, then the call to
-   *  |TlsFetchKeyMaterials| will use it to update the root cert and
-   *  pem-key-cert-pair list stored in |key_materials_config_|. **/
-  if (TlsFetchKeyMaterials(key_materials_config_, creds->options(), false,
-                           &reload_status) != GRPC_STATUS_OK) {
-    /* Raise an error if key materials are not populated. */
-    return GRPC_SECURITY_ERROR;
-  }
-  return ReplaceHandshakerFactory(ssl_session_cache);
-}
-
-grpc_security_status TlsChannelSecurityConnector::RefreshHandshakerFactory() {
-  grpc_core::MutexLock lock(&mu_);
-  const TlsCredentials* creds =
-      static_cast<const TlsCredentials*>(channel_creds());
-  grpc_ssl_certificate_config_reload_status reload_status =
-      GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED;
-  /** If |creds->options()| has a credential reload config, then the call to
-   *  |TlsFetchKeyMaterials| will use it to update the root cert and
-   *  pem-key-cert-pair list stored in |key_materials_config_|. **/
-  if (TlsFetchKeyMaterials(key_materials_config_, creds->options(), false,
-                           &reload_status) != GRPC_STATUS_OK) {
-    return GRPC_SECURITY_ERROR;
-  }
-  if (reload_status != GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW) {
-    // Re-use existing handshaker factory.
-    return GRPC_SECURITY_OK;
-  } else {
-    return ReplaceHandshakerFactory(nullptr);
-  }
-}
-
-void TlsChannelSecurityConnector::ServerAuthorizationCheckDone(
-    grpc_tls_server_authorization_check_arg* arg) {
-  GPR_ASSERT(arg != nullptr);
-  grpc_core::ExecCtx exec_ctx;
-  grpc_error* error = ProcessServerAuthorizationCheckResult(arg);
-  TlsChannelSecurityConnector* connector =
-      static_cast<TlsChannelSecurityConnector*>(arg->cb_user_data);
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, connector->on_peer_checked_, error);
-}
-
-grpc_error* TlsChannelSecurityConnector::ProcessServerAuthorizationCheckResult(
-    grpc_tls_server_authorization_check_arg* arg) {
-  grpc_error* error = GRPC_ERROR_NONE;
-  /* Server authorization check is cancelled by caller. */
-  if (arg->status == GRPC_STATUS_CANCELLED) {
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat("Server authorization check is cancelled by the caller "
-                     "with error: ",
-                     arg->error_details->error_details())
-            .c_str());
-  } else if (arg->status == GRPC_STATUS_OK) {
-    /* Server authorization check completed successfully but returned check
-     * failure. */
-    if (!arg->success) {
-      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          y_absl::StrCat("Server authorization check failed with error: ",
-                       arg->error_details->error_details())
-              .c_str());
-    }
-    /* Server authorization check did not complete correctly. */
-  } else {
-    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        y_absl::StrCat(
-            "Server authorization check did not finish correctly with error: ",
-            arg->error_details->error_details())
-            .c_str());
-  }
-  return error;
-}
-
-grpc_tls_server_authorization_check_arg*
-TlsChannelSecurityConnector::ServerAuthorizationCheckArgCreate(
-    void* user_data) {
-  grpc_tls_server_authorization_check_arg* arg =
-      new grpc_tls_server_authorization_check_arg();
-  arg->error_details = new grpc_tls_error_details();
-  arg->cb = ServerAuthorizationCheckDone;
-  arg->cb_user_data = user_data;
-  arg->status = GRPC_STATUS_OK;
-  return arg;
-}
-
-void TlsChannelSecurityConnector::ServerAuthorizationCheckArgDestroy(
-    grpc_tls_server_authorization_check_arg* arg) {
-  if (arg == nullptr) {
-    return;
-  }
-  gpr_free((void*)arg->target_name);
-  gpr_free((void*)arg->peer_cert);
-  if (arg->peer_cert_full_chain) gpr_free((void*)arg->peer_cert_full_chain);
-  delete arg->error_details;
-  if (arg->destroy_context != nullptr) {
-    arg->destroy_context(arg->context);
-  }
-  delete arg;
-}
-
-TlsServerSecurityConnector::TlsServerSecurityConnector(
-    grpc_core::RefCountedPtr<grpc_server_credentials> server_creds)
-    : grpc_server_security_connector(GRPC_SSL_URL_SCHEME,
-                                     std::move(server_creds)) {
-  key_materials_config_ = grpc_tls_key_materials_config_create()->Ref();
-}
-
-TlsServerSecurityConnector::~TlsServerSecurityConnector() {
-  if (server_handshaker_factory_ != nullptr) {
-    tsi_ssl_server_handshaker_factory_unref(server_handshaker_factory_);
-  }
-  if (key_materials_config_.get() != nullptr) {
-    key_materials_config_.get()->Unref();
-  }
-}
-
-void TlsServerSecurityConnector::add_handshakers(
-    const grpc_channel_args* args, grpc_pollset_set* /*interested_parties*/,
-    grpc_core::HandshakeManager* handshake_mgr) {
-  /* Refresh handshaker factory if needed. */
-  if (RefreshHandshakerFactory() != GRPC_SECURITY_OK) {
-    gpr_log(GPR_ERROR, "Handshaker factory refresh failed.");
-    return;
-  }
-  /* Create a TLS TSI handshaker for server. */
-  tsi_handshaker* tsi_hs = nullptr;
-  tsi_result result = tsi_ssl_server_handshaker_factory_create_handshaker(
-      server_handshaker_factory_, &tsi_hs);
-  if (result != TSI_OK) {
-    gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.",
-            tsi_result_to_string(result));
-    return;
-  }
-  handshake_mgr->Add(grpc_core::SecurityHandshakerCreate(tsi_hs, this, args));
-}
-
-void TlsServerSecurityConnector::check_peer(
-    tsi_peer peer, grpc_endpoint* /*ep*/,
-    grpc_core::RefCountedPtr<grpc_auth_context>* auth_context,
-    grpc_closure* on_peer_checked) {
-  grpc_error* error = grpc_ssl_check_alpn(&peer);
-  *auth_context =
-      grpc_ssl_peer_to_auth_context(&peer, GRPC_TLS_TRANSPORT_SECURITY_TYPE);
-  tsi_peer_destruct(&peer);
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
-}
-
-int TlsServerSecurityConnector::cmp(
-    const grpc_security_connector* other) const {
-  return server_security_connector_cmp(
-      static_cast<const grpc_server_security_connector*>(other));
-}
-
-grpc_core::RefCountedPtr<grpc_server_security_connector>
-TlsServerSecurityConnector::CreateTlsServerSecurityConnector(
-    grpc_core::RefCountedPtr<grpc_server_credentials> server_creds) {
-  if (server_creds == nullptr) {
-    gpr_log(GPR_ERROR,
-            "server_creds is nullptr in "
-            "TlsServerSecurityConnectorCreate()");
-    return nullptr;
-  }
-  grpc_core::RefCountedPtr<TlsServerSecurityConnector> c =
-      grpc_core::MakeRefCounted<TlsServerSecurityConnector>(
-          std::move(server_creds));
-  if (c->InitializeHandshakerFactory() != GRPC_SECURITY_OK) {
-    gpr_log(GPR_ERROR, "Could not initialize server handshaker factory.");
-    return nullptr;
-  }
-  return c;
-}
-
-grpc_security_status TlsServerSecurityConnector::ReplaceHandshakerFactory() {
-  const TlsServerCredentials* creds =
-      static_cast<const TlsServerCredentials*>(server_creds());
-  /* Free the server handshaker factory if exists. */
-  if (server_handshaker_factory_) {
-    tsi_ssl_server_handshaker_factory_unref(server_handshaker_factory_);
-  }
-  GPR_ASSERT(!key_materials_config_->pem_key_cert_pair_list().empty());
-  tsi_ssl_pem_key_cert_pair* pem_key_cert_pairs = ConvertToTsiPemKeyCertPair(
-      key_materials_config_->pem_key_cert_pair_list());
-  size_t num_key_cert_pairs =
-      key_materials_config_->pem_key_cert_pair_list().size();
-  grpc_security_status status = grpc_ssl_tsi_server_handshaker_factory_init(
-      pem_key_cert_pairs, num_key_cert_pairs,
-      key_materials_config_->pem_root_certs(),
-      creds->options().cert_request_type(),
-      grpc_get_tsi_tls_version(creds->options().min_tls_version()),
-      grpc_get_tsi_tls_version(creds->options().max_tls_version()),
-      &server_handshaker_factory_);
-  /* Free memory. */
-  grpc_tsi_ssl_pem_key_cert_pairs_destroy(pem_key_cert_pairs,
-                                          num_key_cert_pairs);
-  return status;
-}
-
-grpc_security_status TlsServerSecurityConnector::InitializeHandshakerFactory() {
-  grpc_core::MutexLock lock(&mu_);
-  const TlsServerCredentials* creds =
-      static_cast<const TlsServerCredentials*>(server_creds());
-  grpc_tls_key_materials_config* key_materials_config =
-      creds->options().key_materials_config();
-  if (key_materials_config != nullptr) {
-    key_materials_config_->set_key_materials(
-        key_materials_config->pem_root_certs(),
-        key_materials_config->pem_key_cert_pair_list());
-  }
-  grpc_ssl_certificate_config_reload_status reload_status =
-      GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED;
-  /** If |creds->options()| has a credential reload config, then the call to
-   *  |TlsFetchKeyMaterials| will use it to update the root cert and
-   *  pem-key-cert-pair list stored in |key_materials_config_|. Otherwise, it
-   *  will return |GRPC_STATUS_OK| if |key_materials_config_| already has
-   *  credentials, and an error code if not. **/
-  if (TlsFetchKeyMaterials(key_materials_config_, creds->options(), true,
-                           &reload_status) != GRPC_STATUS_OK) {
-    /* Raise an error if key materials are not populated. */
-    return GRPC_SECURITY_ERROR;
-  }
-  return ReplaceHandshakerFactory();
-}
-
-grpc_security_status TlsServerSecurityConnector::RefreshHandshakerFactory() {
-  grpc_core::MutexLock lock(&mu_);
-  const TlsServerCredentials* creds =
-      static_cast<const TlsServerCredentials*>(server_creds());
-  grpc_ssl_certificate_config_reload_status reload_status =
-      GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED;
-  /** If |creds->options()| has a credential reload config, then the call to
-   *  |TlsFetchKeyMaterials| will use it to update the root cert and
-   *  pem-key-cert-pair list stored in |key_materials_config_|. Otherwise, it
-   *  will return |GRPC_STATUS_OK| if |key_materials_config_| already has
-   *  credentials, and an error code if not. **/
-  if (TlsFetchKeyMaterials(key_materials_config_, creds->options(), true,
-                           &reload_status) != GRPC_STATUS_OK) {
-    return GRPC_SECURITY_ERROR;
-  }
-  if (reload_status != GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW) {
-    /* At this point, we should have key materials populated. */
-    return GRPC_SECURITY_OK;
-  } else {
-    return ReplaceHandshakerFactory();
-  }
-}
-
-}  // namespace grpc_core
+/* 
+ * 
+ * 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. 
+ * 
+ */ 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/security/security_connector/tls/tls_security_connector.h" 
+ 
+#include <stdbool.h> 
+#include <string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/string_view.h" 
+ 
+#include <grpc/grpc.h> 
+#include <grpc/support/alloc.h> 
+#include <grpc/support/log.h> 
+#include <grpc/support/string_util.h> 
+ 
+#include "src/core/lib/gprpp/host_port.h" 
+#include "src/core/lib/security/credentials/ssl/ssl_credentials.h" 
+#include "src/core/lib/security/credentials/tls/tls_credentials.h" 
+#include "src/core/lib/security/security_connector/ssl_utils.h" 
+#include "src/core/lib/security/transport/security_handshaker.h" 
+#include "src/core/lib/slice/slice_internal.h" 
+#include "src/core/lib/transport/transport.h" 
+#include "src/core/tsi/ssl_transport_security.h" 
+#include "src/core/tsi/transport_security.h" 
+ 
+namespace grpc_core { 
+ 
+namespace { 
+ 
+tsi_ssl_pem_key_cert_pair* ConvertToTsiPemKeyCertPair( 
+    const grpc_tls_key_materials_config::PemKeyCertPairList& cert_pair_list) { 
+  tsi_ssl_pem_key_cert_pair* tsi_pairs = nullptr; 
+  size_t num_key_cert_pairs = cert_pair_list.size(); 
+  if (num_key_cert_pairs > 0) { 
+    GPR_ASSERT(cert_pair_list.data() != nullptr); 
+    tsi_pairs = static_cast<tsi_ssl_pem_key_cert_pair*>( 
+        gpr_zalloc(num_key_cert_pairs * sizeof(tsi_ssl_pem_key_cert_pair))); 
+  } 
+  for (size_t i = 0; i < num_key_cert_pairs; i++) { 
+    GPR_ASSERT(cert_pair_list[i].private_key() != nullptr); 
+    GPR_ASSERT(cert_pair_list[i].cert_chain() != nullptr); 
+    tsi_pairs[i].cert_chain = gpr_strdup(cert_pair_list[i].cert_chain()); 
+    tsi_pairs[i].private_key = gpr_strdup(cert_pair_list[i].private_key()); 
+  } 
+  return tsi_pairs; 
+} 
+ 
+}  // namespace 
+ 
+grpc_status_code TlsFetchKeyMaterials( 
+    const grpc_core::RefCountedPtr<grpc_tls_key_materials_config>& 
+        key_materials_config, 
+    const grpc_tls_credentials_options& options, bool is_server, 
+    grpc_ssl_certificate_config_reload_status* status) { 
+  GPR_ASSERT(key_materials_config != nullptr); 
+  GPR_ASSERT(status != nullptr); 
+  bool is_key_materials_empty = 
+      key_materials_config->pem_key_cert_pair_list().empty(); 
+  grpc_tls_credential_reload_config* credential_reload_config = 
+      options.credential_reload_config(); 
+  /** If there are no key materials and no credential reload config and the 
+   *  caller is a server, then return an error. We do not require that a client 
+   *  always provision certificates. **/ 
+  if (credential_reload_config == nullptr && is_key_materials_empty && 
+      is_server) { 
+    gpr_log(GPR_ERROR, 
+            "Either credential reload config or key materials should be " 
+            "provisioned."); 
+    return GRPC_STATUS_FAILED_PRECONDITION; 
+  } 
+  grpc_status_code reload_status = GRPC_STATUS_OK; 
+  /** Use |credential_reload_config| to update |key_materials_config|. **/ 
+  if (credential_reload_config != nullptr) { 
+    grpc_tls_credential_reload_arg* arg = new grpc_tls_credential_reload_arg(); 
+    arg->key_materials_config = key_materials_config.get(); 
+    arg->error_details = new grpc_tls_error_details(); 
+    int result = credential_reload_config->Schedule(arg); 
+    if (result) { 
+      /** Credential reloading is performed async. This is not yet supported. 
+       * **/ 
+      gpr_log(GPR_ERROR, "Async credential reload is unsupported now."); 
+      *status = GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED; 
+      reload_status = 
+          is_key_materials_empty ? GRPC_STATUS_UNIMPLEMENTED : GRPC_STATUS_OK; 
+    } else { 
+      /** Credential reloading is performed sync. **/ 
+      *status = arg->status; 
+      if (arg->status == GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED) { 
+        /* Key materials is not empty. */ 
+        gpr_log(GPR_DEBUG, "Credential does not change after reload."); 
+      } else if (arg->status == GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL) { 
+        gpr_log(GPR_ERROR, "Credential reload failed with an error:"); 
+        if (arg->error_details != nullptr) { 
+          gpr_log(GPR_ERROR, "%s", arg->error_details->error_details().c_str()); 
+        } 
+        reload_status = 
+            is_key_materials_empty ? GRPC_STATUS_INTERNAL : GRPC_STATUS_OK; 
+      } 
+    } 
+    delete arg->error_details; 
+    /** If the credential reload config was constructed via a wrapped language, 
+     *  then |arg->context| and |arg->destroy_context| will not be nullptr. In 
+     *  this case, we must destroy |arg->context|, which stores the wrapped 
+     *  language-version of the credential reload arg. **/ 
+    if (arg->destroy_context != nullptr) { 
+      arg->destroy_context(arg->context); 
+    } 
+    delete arg; 
+  } 
+  return reload_status; 
+} 
+ 
+grpc_error* TlsCheckHostName(const char* peer_name, const tsi_peer* peer) { 
+  /* Check the peer name if specified. */ 
+  if (peer_name != nullptr && !grpc_ssl_host_matches_name(peer, peer_name)) { 
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat("Peer name ", peer_name, " is not in peer certificate") 
+            .c_str()); 
+  } 
+  return GRPC_ERROR_NONE; 
+} 
+ 
+TlsChannelSecurityConnector::TlsChannelSecurityConnector( 
+    grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds, 
+    grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds, 
+    const char* target_name, const char* overridden_target_name) 
+    : grpc_channel_security_connector(GRPC_SSL_URL_SCHEME, 
+                                      std::move(channel_creds), 
+                                      std::move(request_metadata_creds)), 
+      overridden_target_name_( 
+          overridden_target_name == nullptr ? "" : overridden_target_name) { 
+  key_materials_config_ = grpc_tls_key_materials_config_create()->Ref(); 
+  check_arg_ = ServerAuthorizationCheckArgCreate(this); 
+  y_absl::string_view host; 
+  y_absl::string_view port; 
+  grpc_core::SplitHostPort(target_name, &host, &port); 
+  target_name_ = TString(host); 
+} 
+ 
+TlsChannelSecurityConnector::~TlsChannelSecurityConnector() { 
+  if (client_handshaker_factory_ != nullptr) { 
+    tsi_ssl_client_handshaker_factory_unref(client_handshaker_factory_); 
+  } 
+  if (key_materials_config_.get() != nullptr) { 
+    key_materials_config_.get()->Unref(); 
+  } 
+  ServerAuthorizationCheckArgDestroy(check_arg_); 
+} 
+ 
+void TlsChannelSecurityConnector::add_handshakers( 
+    const grpc_channel_args* args, grpc_pollset_set* /*interested_parties*/, 
+    grpc_core::HandshakeManager* handshake_mgr) { 
+  if (RefreshHandshakerFactory() != GRPC_SECURITY_OK) { 
+    gpr_log(GPR_ERROR, "Handshaker factory refresh failed."); 
+    return; 
+  } 
+  // Instantiate TSI handshaker. 
+  tsi_handshaker* tsi_hs = nullptr; 
+  tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker( 
+      client_handshaker_factory_, 
+      overridden_target_name_.empty() ? target_name_.c_str() 
+                                      : overridden_target_name_.c_str(), 
+      &tsi_hs); 
+  if (result != TSI_OK) { 
+    gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.", 
+            tsi_result_to_string(result)); 
+    return; 
+  } 
+  // Create handshakers. 
+  handshake_mgr->Add(grpc_core::SecurityHandshakerCreate(tsi_hs, this, args)); 
+} 
+ 
+void TlsChannelSecurityConnector::check_peer( 
+    tsi_peer peer, grpc_endpoint* /*ep*/, 
+    grpc_core::RefCountedPtr<grpc_auth_context>* auth_context, 
+    grpc_closure* on_peer_checked) { 
+  const char* target_name = overridden_target_name_.empty() 
+                                ? target_name_.c_str() 
+                                : overridden_target_name_.c_str(); 
+  grpc_error* error = grpc_ssl_check_alpn(&peer); 
+  if (error != GRPC_ERROR_NONE) { 
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error); 
+    tsi_peer_destruct(&peer); 
+    return; 
+  } 
+  *auth_context = 
+      grpc_ssl_peer_to_auth_context(&peer, GRPC_TLS_TRANSPORT_SECURITY_TYPE); 
+  const TlsCredentials* creds = 
+      static_cast<const TlsCredentials*>(channel_creds()); 
+  if (creds->options().server_verification_option() == 
+      GRPC_TLS_SERVER_VERIFICATION) { 
+    /* Do the default host name check if specifying the target name. */ 
+    error = TlsCheckHostName(target_name, &peer); 
+    if (error != GRPC_ERROR_NONE) { 
+      grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error); 
+      tsi_peer_destruct(&peer); 
+      return; 
+    } 
+  } 
+  /* Do the custom server authorization check, if specified by the user. */ 
+  const grpc_tls_server_authorization_check_config* config = 
+      creds->options().server_authorization_check_config(); 
+  /* If server authorization config is not null, use it to perform 
+   * server authorization check. */ 
+  if (config != nullptr) { 
+    const tsi_peer_property* p = 
+        tsi_peer_get_property_by_name(&peer, TSI_X509_PEM_CERT_PROPERTY); 
+    if (p == nullptr) { 
+      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING( 
+          "Cannot check peer: missing pem cert property."); 
+    } else { 
+      char* peer_pem = static_cast<char*>(gpr_zalloc(p->value.length + 1)); 
+      memcpy(peer_pem, p->value.data, p->value.length); 
+      GPR_ASSERT(check_arg_ != nullptr); 
+      check_arg_->peer_cert = check_arg_->peer_cert == nullptr 
+                                  ? gpr_strdup(peer_pem) 
+                                  : check_arg_->peer_cert; 
+      check_arg_->target_name = check_arg_->target_name == nullptr 
+                                    ? gpr_strdup(target_name) 
+                                    : check_arg_->target_name; 
+      on_peer_checked_ = on_peer_checked; 
+      gpr_free(peer_pem); 
+      const tsi_peer_property* chain = tsi_peer_get_property_by_name( 
+          &peer, TSI_X509_PEM_CERT_CHAIN_PROPERTY); 
+      if (chain != nullptr) { 
+        char* peer_pem_chain = 
+            static_cast<char*>(gpr_zalloc(chain->value.length + 1)); 
+        memcpy(peer_pem_chain, chain->value.data, chain->value.length); 
+        check_arg_->peer_cert_full_chain = 
+            check_arg_->peer_cert_full_chain == nullptr 
+                ? gpr_strdup(peer_pem_chain) 
+                : check_arg_->peer_cert_full_chain; 
+        gpr_free(peer_pem_chain); 
+      } 
+      int callback_status = config->Schedule(check_arg_); 
+      /* Server authorization check is handled asynchronously. */ 
+      if (callback_status) { 
+        tsi_peer_destruct(&peer); 
+        return; 
+      } 
+      /* Server authorization check is handled synchronously. */ 
+      error = ProcessServerAuthorizationCheckResult(check_arg_); 
+    } 
+  } 
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error); 
+  tsi_peer_destruct(&peer); 
+} 
+ 
+int TlsChannelSecurityConnector::cmp( 
+    const grpc_security_connector* other_sc) const { 
+  auto* other = reinterpret_cast<const TlsChannelSecurityConnector*>(other_sc); 
+  int c = channel_security_connector_cmp(other); 
+  if (c != 0) { 
+    return c; 
+  } 
+  return grpc_ssl_cmp_target_name( 
+      target_name_.c_str(), other->target_name_.c_str(), 
+      overridden_target_name_.c_str(), other->overridden_target_name_.c_str()); 
+} 
+ 
+bool TlsChannelSecurityConnector::check_call_host( 
+    y_absl::string_view host, grpc_auth_context* auth_context, 
+    grpc_closure* /*on_call_host_checked*/, grpc_error** error) { 
+  return grpc_ssl_check_call_host(host, target_name_.c_str(), 
+                                  overridden_target_name_.c_str(), auth_context, 
+                                  error); 
+} 
+ 
+void TlsChannelSecurityConnector::cancel_check_call_host( 
+    grpc_closure* /*on_call_host_checked*/, grpc_error* error) { 
+  GRPC_ERROR_UNREF(error); 
+} 
+ 
+grpc_core::RefCountedPtr<grpc_channel_security_connector> 
+TlsChannelSecurityConnector::CreateTlsChannelSecurityConnector( 
+    grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds, 
+    grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds, 
+    const char* target_name, const char* overridden_target_name, 
+    tsi_ssl_session_cache* ssl_session_cache) { 
+  if (channel_creds == nullptr) { 
+    gpr_log(GPR_ERROR, 
+            "channel_creds is nullptr in " 
+            "TlsChannelSecurityConnectorCreate()"); 
+    return nullptr; 
+  } 
+  if (target_name == nullptr) { 
+    gpr_log(GPR_ERROR, 
+            "target_name is nullptr in " 
+            "TlsChannelSecurityConnectorCreate()"); 
+    return nullptr; 
+  } 
+  grpc_core::RefCountedPtr<TlsChannelSecurityConnector> c = 
+      grpc_core::MakeRefCounted<TlsChannelSecurityConnector>( 
+          std::move(channel_creds), std::move(request_metadata_creds), 
+          target_name, overridden_target_name); 
+  if (c->InitializeHandshakerFactory(ssl_session_cache) != GRPC_SECURITY_OK) { 
+    gpr_log(GPR_ERROR, "Could not initialize client handshaker factory."); 
+    return nullptr; 
+  } 
+  return c; 
+} 
+ 
+grpc_security_status TlsChannelSecurityConnector::ReplaceHandshakerFactory( 
+    tsi_ssl_session_cache* ssl_session_cache) { 
+  const TlsCredentials* creds = 
+      static_cast<const TlsCredentials*>(channel_creds()); 
+  bool skip_server_certificate_verification = 
+      creds->options().server_verification_option() == 
+      GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION; 
+  /* Free the client handshaker factory if exists. */ 
+  if (client_handshaker_factory_) { 
+    tsi_ssl_client_handshaker_factory_unref(client_handshaker_factory_); 
+  } 
+  tsi_ssl_pem_key_cert_pair* pem_key_cert_pair = ConvertToTsiPemKeyCertPair( 
+      key_materials_config_->pem_key_cert_pair_list()); 
+  grpc_security_status status = grpc_ssl_tsi_client_handshaker_factory_init( 
+      pem_key_cert_pair, key_materials_config_->pem_root_certs(), 
+      skip_server_certificate_verification, 
+      grpc_get_tsi_tls_version(creds->options().min_tls_version()), 
+      grpc_get_tsi_tls_version(creds->options().max_tls_version()), 
+      ssl_session_cache, &client_handshaker_factory_); 
+  /* Free memory. */ 
+  grpc_tsi_ssl_pem_key_cert_pairs_destroy(pem_key_cert_pair, 1); 
+  return status; 
+} 
+ 
+grpc_security_status TlsChannelSecurityConnector::InitializeHandshakerFactory( 
+    tsi_ssl_session_cache* ssl_session_cache) { 
+  grpc_core::MutexLock lock(&mu_); 
+  const TlsCredentials* creds = 
+      static_cast<const TlsCredentials*>(channel_creds()); 
+  grpc_tls_key_materials_config* key_materials_config = 
+      creds->options().key_materials_config(); 
+  // key_materials_config_->set_key_materials will handle the copying of the key 
+  // materials users provided 
+  if (key_materials_config != nullptr) { 
+    key_materials_config_->set_key_materials( 
+        key_materials_config->pem_root_certs(), 
+        key_materials_config->pem_key_cert_pair_list()); 
+  } 
+  grpc_ssl_certificate_config_reload_status reload_status = 
+      GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED; 
+  /** If |creds->options()| has a credential reload config, then the call to 
+   *  |TlsFetchKeyMaterials| will use it to update the root cert and 
+   *  pem-key-cert-pair list stored in |key_materials_config_|. **/ 
+  if (TlsFetchKeyMaterials(key_materials_config_, creds->options(), false, 
+                           &reload_status) != GRPC_STATUS_OK) { 
+    /* Raise an error if key materials are not populated. */ 
+    return GRPC_SECURITY_ERROR; 
+  } 
+  return ReplaceHandshakerFactory(ssl_session_cache); 
+} 
+ 
+grpc_security_status TlsChannelSecurityConnector::RefreshHandshakerFactory() { 
+  grpc_core::MutexLock lock(&mu_); 
+  const TlsCredentials* creds = 
+      static_cast<const TlsCredentials*>(channel_creds()); 
+  grpc_ssl_certificate_config_reload_status reload_status = 
+      GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED; 
+  /** If |creds->options()| has a credential reload config, then the call to 
+   *  |TlsFetchKeyMaterials| will use it to update the root cert and 
+   *  pem-key-cert-pair list stored in |key_materials_config_|. **/ 
+  if (TlsFetchKeyMaterials(key_materials_config_, creds->options(), false, 
+                           &reload_status) != GRPC_STATUS_OK) { 
+    return GRPC_SECURITY_ERROR; 
+  } 
+  if (reload_status != GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW) { 
+    // Re-use existing handshaker factory. 
+    return GRPC_SECURITY_OK; 
+  } else { 
+    return ReplaceHandshakerFactory(nullptr); 
+  } 
+} 
+ 
+void TlsChannelSecurityConnector::ServerAuthorizationCheckDone( 
+    grpc_tls_server_authorization_check_arg* arg) { 
+  GPR_ASSERT(arg != nullptr); 
+  grpc_core::ExecCtx exec_ctx; 
+  grpc_error* error = ProcessServerAuthorizationCheckResult(arg); 
+  TlsChannelSecurityConnector* connector = 
+      static_cast<TlsChannelSecurityConnector*>(arg->cb_user_data); 
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, connector->on_peer_checked_, error); 
+} 
+ 
+grpc_error* TlsChannelSecurityConnector::ProcessServerAuthorizationCheckResult( 
+    grpc_tls_server_authorization_check_arg* arg) { 
+  grpc_error* error = GRPC_ERROR_NONE; 
+  /* Server authorization check is cancelled by caller. */ 
+  if (arg->status == GRPC_STATUS_CANCELLED) { 
+    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat("Server authorization check is cancelled by the caller " 
+                     "with error: ", 
+                     arg->error_details->error_details()) 
+            .c_str()); 
+  } else if (arg->status == GRPC_STATUS_OK) { 
+    /* Server authorization check completed successfully but returned check 
+     * failure. */ 
+    if (!arg->success) { 
+      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+          y_absl::StrCat("Server authorization check failed with error: ", 
+                       arg->error_details->error_details()) 
+              .c_str()); 
+    } 
+    /* Server authorization check did not complete correctly. */ 
+  } else { 
+    error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+        y_absl::StrCat( 
+            "Server authorization check did not finish correctly with error: ", 
+            arg->error_details->error_details()) 
+            .c_str()); 
+  } 
+  return error; 
+} 
+ 
+grpc_tls_server_authorization_check_arg* 
+TlsChannelSecurityConnector::ServerAuthorizationCheckArgCreate( 
+    void* user_data) { 
+  grpc_tls_server_authorization_check_arg* arg = 
+      new grpc_tls_server_authorization_check_arg(); 
+  arg->error_details = new grpc_tls_error_details(); 
+  arg->cb = ServerAuthorizationCheckDone; 
+  arg->cb_user_data = user_data; 
+  arg->status = GRPC_STATUS_OK; 
+  return arg; 
+} 
+ 
+void TlsChannelSecurityConnector::ServerAuthorizationCheckArgDestroy( 
+    grpc_tls_server_authorization_check_arg* arg) { 
+  if (arg == nullptr) { 
+    return; 
+  } 
+  gpr_free((void*)arg->target_name); 
+  gpr_free((void*)arg->peer_cert); 
+  if (arg->peer_cert_full_chain) gpr_free((void*)arg->peer_cert_full_chain); 
+  delete arg->error_details; 
+  if (arg->destroy_context != nullptr) { 
+    arg->destroy_context(arg->context); 
+  } 
+  delete arg; 
+} 
+ 
+TlsServerSecurityConnector::TlsServerSecurityConnector( 
+    grpc_core::RefCountedPtr<grpc_server_credentials> server_creds) 
+    : grpc_server_security_connector(GRPC_SSL_URL_SCHEME, 
+                                     std::move(server_creds)) { 
+  key_materials_config_ = grpc_tls_key_materials_config_create()->Ref(); 
+} 
+ 
+TlsServerSecurityConnector::~TlsServerSecurityConnector() { 
+  if (server_handshaker_factory_ != nullptr) { 
+    tsi_ssl_server_handshaker_factory_unref(server_handshaker_factory_); 
+  } 
+  if (key_materials_config_.get() != nullptr) { 
+    key_materials_config_.get()->Unref(); 
+  } 
+} 
+ 
+void TlsServerSecurityConnector::add_handshakers( 
+    const grpc_channel_args* args, grpc_pollset_set* /*interested_parties*/, 
+    grpc_core::HandshakeManager* handshake_mgr) { 
+  /* Refresh handshaker factory if needed. */ 
+  if (RefreshHandshakerFactory() != GRPC_SECURITY_OK) { 
+    gpr_log(GPR_ERROR, "Handshaker factory refresh failed."); 
+    return; 
+  } 
+  /* Create a TLS TSI handshaker for server. */ 
+  tsi_handshaker* tsi_hs = nullptr; 
+  tsi_result result = tsi_ssl_server_handshaker_factory_create_handshaker( 
+      server_handshaker_factory_, &tsi_hs); 
+  if (result != TSI_OK) { 
+    gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.", 
+            tsi_result_to_string(result)); 
+    return; 
+  } 
+  handshake_mgr->Add(grpc_core::SecurityHandshakerCreate(tsi_hs, this, args)); 
+} 
+ 
+void TlsServerSecurityConnector::check_peer( 
+    tsi_peer peer, grpc_endpoint* /*ep*/, 
+    grpc_core::RefCountedPtr<grpc_auth_context>* auth_context, 
+    grpc_closure* on_peer_checked) { 
+  grpc_error* error = grpc_ssl_check_alpn(&peer); 
+  *auth_context = 
+      grpc_ssl_peer_to_auth_context(&peer, GRPC_TLS_TRANSPORT_SECURITY_TYPE); 
+  tsi_peer_destruct(&peer); 
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error); 
+} 
+ 
+int TlsServerSecurityConnector::cmp( 
+    const grpc_security_connector* other) const { 
+  return server_security_connector_cmp( 
+      static_cast<const grpc_server_security_connector*>(other)); 
+} 
+ 
+grpc_core::RefCountedPtr<grpc_server_security_connector> 
+TlsServerSecurityConnector::CreateTlsServerSecurityConnector( 
+    grpc_core::RefCountedPtr<grpc_server_credentials> server_creds) { 
+  if (server_creds == nullptr) { 
+    gpr_log(GPR_ERROR, 
+            "server_creds is nullptr in " 
+            "TlsServerSecurityConnectorCreate()"); 
+    return nullptr; 
+  } 
+  grpc_core::RefCountedPtr<TlsServerSecurityConnector> c = 
+      grpc_core::MakeRefCounted<TlsServerSecurityConnector>( 
+          std::move(server_creds)); 
+  if (c->InitializeHandshakerFactory() != GRPC_SECURITY_OK) { 
+    gpr_log(GPR_ERROR, "Could not initialize server handshaker factory."); 
+    return nullptr; 
+  } 
+  return c; 
+} 
+ 
+grpc_security_status TlsServerSecurityConnector::ReplaceHandshakerFactory() { 
+  const TlsServerCredentials* creds = 
+      static_cast<const TlsServerCredentials*>(server_creds()); 
+  /* Free the server handshaker factory if exists. */ 
+  if (server_handshaker_factory_) { 
+    tsi_ssl_server_handshaker_factory_unref(server_handshaker_factory_); 
+  } 
+  GPR_ASSERT(!key_materials_config_->pem_key_cert_pair_list().empty()); 
+  tsi_ssl_pem_key_cert_pair* pem_key_cert_pairs = ConvertToTsiPemKeyCertPair( 
+      key_materials_config_->pem_key_cert_pair_list()); 
+  size_t num_key_cert_pairs = 
+      key_materials_config_->pem_key_cert_pair_list().size(); 
+  grpc_security_status status = grpc_ssl_tsi_server_handshaker_factory_init( 
+      pem_key_cert_pairs, num_key_cert_pairs, 
+      key_materials_config_->pem_root_certs(), 
+      creds->options().cert_request_type(), 
+      grpc_get_tsi_tls_version(creds->options().min_tls_version()), 
+      grpc_get_tsi_tls_version(creds->options().max_tls_version()), 
+      &server_handshaker_factory_); 
+  /* Free memory. */ 
+  grpc_tsi_ssl_pem_key_cert_pairs_destroy(pem_key_cert_pairs, 
+                                          num_key_cert_pairs); 
+  return status; 
+} 
+ 
+grpc_security_status TlsServerSecurityConnector::InitializeHandshakerFactory() { 
+  grpc_core::MutexLock lock(&mu_); 
+  const TlsServerCredentials* creds = 
+      static_cast<const TlsServerCredentials*>(server_creds()); 
+  grpc_tls_key_materials_config* key_materials_config = 
+      creds->options().key_materials_config(); 
+  if (key_materials_config != nullptr) { 
+    key_materials_config_->set_key_materials( 
+        key_materials_config->pem_root_certs(), 
+        key_materials_config->pem_key_cert_pair_list()); 
+  } 
+  grpc_ssl_certificate_config_reload_status reload_status = 
+      GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED; 
+  /** If |creds->options()| has a credential reload config, then the call to 
+   *  |TlsFetchKeyMaterials| will use it to update the root cert and 
+   *  pem-key-cert-pair list stored in |key_materials_config_|. Otherwise, it 
+   *  will return |GRPC_STATUS_OK| if |key_materials_config_| already has 
+   *  credentials, and an error code if not. **/ 
+  if (TlsFetchKeyMaterials(key_materials_config_, creds->options(), true, 
+                           &reload_status) != GRPC_STATUS_OK) { 
+    /* Raise an error if key materials are not populated. */ 
+    return GRPC_SECURITY_ERROR; 
+  } 
+  return ReplaceHandshakerFactory(); 
+} 
+ 
+grpc_security_status TlsServerSecurityConnector::RefreshHandshakerFactory() { 
+  grpc_core::MutexLock lock(&mu_); 
+  const TlsServerCredentials* creds = 
+      static_cast<const TlsServerCredentials*>(server_creds()); 
+  grpc_ssl_certificate_config_reload_status reload_status = 
+      GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED; 
+  /** If |creds->options()| has a credential reload config, then the call to 
+   *  |TlsFetchKeyMaterials| will use it to update the root cert and 
+   *  pem-key-cert-pair list stored in |key_materials_config_|. Otherwise, it 
+   *  will return |GRPC_STATUS_OK| if |key_materials_config_| already has 
+   *  credentials, and an error code if not. **/ 
+  if (TlsFetchKeyMaterials(key_materials_config_, creds->options(), true, 
+                           &reload_status) != GRPC_STATUS_OK) { 
+    return GRPC_SECURITY_ERROR; 
+  } 
+  if (reload_status != GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW) { 
+    /* At this point, we should have key materials populated. */ 
+    return GRPC_SECURITY_OK; 
+  } else { 
+    return ReplaceHandshakerFactory(); 
+  } 
+} 
+ 
+}  // namespace grpc_core 
diff --git a/contrib/libs/grpc/src/core/lib/security/security_connector/tls/tls_security_connector.h b/contrib/libs/grpc/src/core/lib/security/security_connector/tls/tls_security_connector.h
index f50d916589..c7b438c84e 100644
--- a/contrib/libs/grpc/src/core/lib/security/security_connector/tls/tls_security_connector.h
+++ b/contrib/libs/grpc/src/core/lib/security/security_connector/tls/tls_security_connector.h
@@ -1,183 +1,183 @@
-/*
- *
- * 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_CORE_LIB_SECURITY_SECURITY_CONNECTOR_TLS_TLS_SECURITY_CONNECTOR_H
-#define GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_TLS_TLS_SECURITY_CONNECTOR_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/security/context/security_context.h"
-#include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h"
-
-#define GRPC_TLS_TRANSPORT_SECURITY_TYPE "tls"
-
-namespace grpc_core {
-
-// TLS channel security connector.
-class TlsChannelSecurityConnector final
-    : public grpc_channel_security_connector {
- public:
-  // static factory method to create a TLS channel security connector.
-  static grpc_core::RefCountedPtr<grpc_channel_security_connector>
-  CreateTlsChannelSecurityConnector(
-      grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds,
-      grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds,
-      const char* target_name, const char* overridden_target_name,
-      tsi_ssl_session_cache* ssl_session_cache);
-
-  TlsChannelSecurityConnector(
-      grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds,
-      grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds,
-      const char* target_name, const char* overridden_target_name);
-  ~TlsChannelSecurityConnector() override;
-
-  void add_handshakers(const grpc_channel_args* args,
-                       grpc_pollset_set* interested_parties,
-                       grpc_core::HandshakeManager* handshake_mgr) override;
-
-  void check_peer(tsi_peer peer, grpc_endpoint* ep,
-                  grpc_core::RefCountedPtr<grpc_auth_context>* auth_context,
-                  grpc_closure* on_peer_checked) override;
-
-  int cmp(const grpc_security_connector* other_sc) const override;
-
-  bool check_call_host(y_absl::string_view host, grpc_auth_context* auth_context,
-                       grpc_closure* on_call_host_checked,
-                       grpc_error** error) override;
-
-  void cancel_check_call_host(grpc_closure* on_call_host_checked,
-                              grpc_error* error) override;
-
- private:
-  // Initialize SSL TSI client handshaker factory.
-  grpc_security_status InitializeHandshakerFactory(
-      tsi_ssl_session_cache* ssl_session_cache);
-
-  // A util function to create a new client handshaker factory to replace
-  // the existing one if exists.
-  grpc_security_status ReplaceHandshakerFactory(
-      tsi_ssl_session_cache* ssl_session_cache);
-
-  // gRPC-provided callback executed by application, which servers to bring the
-  // control back to gRPC core.
-  static void ServerAuthorizationCheckDone(
-      grpc_tls_server_authorization_check_arg* arg);
-
-  // A util function to process server authorization check result.
-  static grpc_error* ProcessServerAuthorizationCheckResult(
-      grpc_tls_server_authorization_check_arg* arg);
-
-  // A util function to create a server authorization check arg instance.
-  static grpc_tls_server_authorization_check_arg*
-  ServerAuthorizationCheckArgCreate(void* user_data);
-
-  // A util function to destroy a server authorization check arg instance.
-  static void ServerAuthorizationCheckArgDestroy(
-      grpc_tls_server_authorization_check_arg* arg);
-
-  // A util function to refresh SSL TSI client handshaker factory with a valid
-  // credential.
-  grpc_security_status RefreshHandshakerFactory();
-
-  grpc_core::Mutex mu_;
-  grpc_closure* on_peer_checked_;
-  TString target_name_;
-  TString overridden_target_name_;
-  tsi_ssl_client_handshaker_factory* client_handshaker_factory_ = nullptr;
-  grpc_tls_server_authorization_check_arg* check_arg_;
-  grpc_core::RefCountedPtr<grpc_tls_key_materials_config> key_materials_config_;
-};
-
-// TLS server security connector.
-class TlsServerSecurityConnector final : public grpc_server_security_connector {
- public:
-  // static factory method to create a TLS server security connector.
-  static grpc_core::RefCountedPtr<grpc_server_security_connector>
-  CreateTlsServerSecurityConnector(
-      grpc_core::RefCountedPtr<grpc_server_credentials> server_creds);
-
-  explicit TlsServerSecurityConnector(
-      grpc_core::RefCountedPtr<grpc_server_credentials> server_creds);
-  ~TlsServerSecurityConnector() override;
-
-  void add_handshakers(const grpc_channel_args* args,
-                       grpc_pollset_set* interested_parties,
-                       grpc_core::HandshakeManager* handshake_mgr) override;
-
-  void check_peer(tsi_peer peer, grpc_endpoint* ep,
-                  grpc_core::RefCountedPtr<grpc_auth_context>* auth_context,
-                  grpc_closure* on_peer_checked) override;
-
-  int cmp(const grpc_security_connector* other) const override;
-
- private:
-  // Initialize SSL TSI server handshaker factory.
-  grpc_security_status InitializeHandshakerFactory();
-
-  // A util function to create a new server handshaker factory to replace the
-  // existing once if exists.
-  grpc_security_status ReplaceHandshakerFactory();
-
-  // A util function to refresh SSL TSI server handshaker factory with a valid
-  // credential.
-  grpc_security_status RefreshHandshakerFactory();
-
-  grpc_core::Mutex mu_;
-  tsi_ssl_server_handshaker_factory* server_handshaker_factory_ = nullptr;
-  grpc_core::RefCountedPtr<grpc_tls_key_materials_config> key_materials_config_;
-};
-
-// ---- Functions below are exposed for testing only -----------------------
-
-/** The |TlsFetchKeyMaterials| API ensures that |key_materials_config| has a
- *  non-empty pem-key-cert pair list. This is done as follows:
- *  - if |options| is equipped with a credential reload config, then this
- *    methods uses credential reloading to populate |key_materials_config|, and
- *    afterwards it populates |reload_status| with the status of this operation.
- *    In particular, any data stored in |key_materials_config| is overwritten.
- *  - if |options| has no credential reload config, then:
- *    - if |key_materials_config| already has a non-empty pem-key-cert pair
- *      list or is called by a client, then the method returns |GRPC_STATUS_OK|.
- *    - if |key_materials_config| has an empty pem-key-cert pair list and is
- *      called by a server, then the method return an error code.
- *
- *  The arguments are detailed below:
- *  - key_materials_config: a key materials config that will be populated by the
- *    method on success; the caller should not pass in nullptr. Any data held by
- *    the config will be overwritten.
- *  - options: the TLS credentials options whose credential reloading config
- *    will be used to populate |key_materials_config|.
- *  - is_server: true denotes that this method is called by a server, and
- *    false denotes that this method is called by a client.
- *  - status: the status of the credential reloading after the method
- *    returns; the caller should not pass in nullptr. **/
-grpc_status_code TlsFetchKeyMaterials(
-    const grpc_core::RefCountedPtr<grpc_tls_key_materials_config>&
-        key_materials_config,
-    const grpc_tls_credentials_options& options, bool is_server,
-    grpc_ssl_certificate_config_reload_status* status);
-
-// TlsCheckHostName checks if |peer_name| matches the identity information
-// contained in |peer|. This is AKA hostname check.
-grpc_error* TlsCheckHostName(const char* peer_name, const tsi_peer* peer);
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_TLS_TLS_SECURITY_CONNECTOR_H \
-        */
+/* 
+ * 
+ * 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_CORE_LIB_SECURITY_SECURITY_CONNECTOR_TLS_TLS_SECURITY_CONNECTOR_H 
+#define GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_TLS_TLS_SECURITY_CONNECTOR_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/gprpp/sync.h" 
+#include "src/core/lib/security/context/security_context.h" 
+#include "src/core/lib/security/credentials/tls/grpc_tls_credentials_options.h" 
+ 
+#define GRPC_TLS_TRANSPORT_SECURITY_TYPE "tls" 
+ 
+namespace grpc_core { 
+ 
+// TLS channel security connector. 
+class TlsChannelSecurityConnector final 
+    : public grpc_channel_security_connector { 
+ public: 
+  // static factory method to create a TLS channel security connector. 
+  static grpc_core::RefCountedPtr<grpc_channel_security_connector> 
+  CreateTlsChannelSecurityConnector( 
+      grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds, 
+      grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds, 
+      const char* target_name, const char* overridden_target_name, 
+      tsi_ssl_session_cache* ssl_session_cache); 
+ 
+  TlsChannelSecurityConnector( 
+      grpc_core::RefCountedPtr<grpc_channel_credentials> channel_creds, 
+      grpc_core::RefCountedPtr<grpc_call_credentials> request_metadata_creds, 
+      const char* target_name, const char* overridden_target_name); 
+  ~TlsChannelSecurityConnector() override; 
+ 
+  void add_handshakers(const grpc_channel_args* args, 
+                       grpc_pollset_set* interested_parties, 
+                       grpc_core::HandshakeManager* handshake_mgr) override; 
+ 
+  void check_peer(tsi_peer peer, grpc_endpoint* ep, 
+                  grpc_core::RefCountedPtr<grpc_auth_context>* auth_context, 
+                  grpc_closure* on_peer_checked) override; 
+ 
+  int cmp(const grpc_security_connector* other_sc) const override; 
+ 
+  bool check_call_host(y_absl::string_view host, grpc_auth_context* auth_context, 
+                       grpc_closure* on_call_host_checked, 
+                       grpc_error** error) override; 
+ 
+  void cancel_check_call_host(grpc_closure* on_call_host_checked, 
+                              grpc_error* error) override; 
+ 
+ private: 
+  // Initialize SSL TSI client handshaker factory. 
+  grpc_security_status InitializeHandshakerFactory( 
+      tsi_ssl_session_cache* ssl_session_cache); 
+ 
+  // A util function to create a new client handshaker factory to replace 
+  // the existing one if exists. 
+  grpc_security_status ReplaceHandshakerFactory( 
+      tsi_ssl_session_cache* ssl_session_cache); 
+ 
+  // gRPC-provided callback executed by application, which servers to bring the 
+  // control back to gRPC core. 
+  static void ServerAuthorizationCheckDone( 
+      grpc_tls_server_authorization_check_arg* arg); 
+ 
+  // A util function to process server authorization check result. 
+  static grpc_error* ProcessServerAuthorizationCheckResult( 
+      grpc_tls_server_authorization_check_arg* arg); 
+ 
+  // A util function to create a server authorization check arg instance. 
+  static grpc_tls_server_authorization_check_arg* 
+  ServerAuthorizationCheckArgCreate(void* user_data); 
+ 
+  // A util function to destroy a server authorization check arg instance. 
+  static void ServerAuthorizationCheckArgDestroy( 
+      grpc_tls_server_authorization_check_arg* arg); 
+ 
+  // A util function to refresh SSL TSI client handshaker factory with a valid 
+  // credential. 
+  grpc_security_status RefreshHandshakerFactory(); 
+ 
+  grpc_core::Mutex mu_; 
+  grpc_closure* on_peer_checked_; 
+  TString target_name_; 
+  TString overridden_target_name_; 
+  tsi_ssl_client_handshaker_factory* client_handshaker_factory_ = nullptr; 
+  grpc_tls_server_authorization_check_arg* check_arg_; 
+  grpc_core::RefCountedPtr<grpc_tls_key_materials_config> key_materials_config_; 
+}; 
+ 
+// TLS server security connector. 
+class TlsServerSecurityConnector final : public grpc_server_security_connector { 
+ public: 
+  // static factory method to create a TLS server security connector. 
+  static grpc_core::RefCountedPtr<grpc_server_security_connector> 
+  CreateTlsServerSecurityConnector( 
+      grpc_core::RefCountedPtr<grpc_server_credentials> server_creds); 
+ 
+  explicit TlsServerSecurityConnector( 
+      grpc_core::RefCountedPtr<grpc_server_credentials> server_creds); 
+  ~TlsServerSecurityConnector() override; 
+ 
+  void add_handshakers(const grpc_channel_args* args, 
+                       grpc_pollset_set* interested_parties, 
+                       grpc_core::HandshakeManager* handshake_mgr) override; 
+ 
+  void check_peer(tsi_peer peer, grpc_endpoint* ep, 
+                  grpc_core::RefCountedPtr<grpc_auth_context>* auth_context, 
+                  grpc_closure* on_peer_checked) override; 
+ 
+  int cmp(const grpc_security_connector* other) const override; 
+ 
+ private: 
+  // Initialize SSL TSI server handshaker factory. 
+  grpc_security_status InitializeHandshakerFactory(); 
+ 
+  // A util function to create a new server handshaker factory to replace the 
+  // existing once if exists. 
+  grpc_security_status ReplaceHandshakerFactory(); 
+ 
+  // A util function to refresh SSL TSI server handshaker factory with a valid 
+  // credential. 
+  grpc_security_status RefreshHandshakerFactory(); 
+ 
+  grpc_core::Mutex mu_; 
+  tsi_ssl_server_handshaker_factory* server_handshaker_factory_ = nullptr; 
+  grpc_core::RefCountedPtr<grpc_tls_key_materials_config> key_materials_config_; 
+}; 
+ 
+// ---- Functions below are exposed for testing only ----------------------- 
+ 
+/** The |TlsFetchKeyMaterials| API ensures that |key_materials_config| has a 
+ *  non-empty pem-key-cert pair list. This is done as follows: 
+ *  - if |options| is equipped with a credential reload config, then this 
+ *    methods uses credential reloading to populate |key_materials_config|, and 
+ *    afterwards it populates |reload_status| with the status of this operation. 
+ *    In particular, any data stored in |key_materials_config| is overwritten. 
+ *  - if |options| has no credential reload config, then: 
+ *    - if |key_materials_config| already has a non-empty pem-key-cert pair 
+ *      list or is called by a client, then the method returns |GRPC_STATUS_OK|. 
+ *    - if |key_materials_config| has an empty pem-key-cert pair list and is 
+ *      called by a server, then the method return an error code. 
+ * 
+ *  The arguments are detailed below: 
+ *  - key_materials_config: a key materials config that will be populated by the 
+ *    method on success; the caller should not pass in nullptr. Any data held by 
+ *    the config will be overwritten. 
+ *  - options: the TLS credentials options whose credential reloading config 
+ *    will be used to populate |key_materials_config|. 
+ *  - is_server: true denotes that this method is called by a server, and 
+ *    false denotes that this method is called by a client. 
+ *  - status: the status of the credential reloading after the method 
+ *    returns; the caller should not pass in nullptr. **/ 
+grpc_status_code TlsFetchKeyMaterials( 
+    const grpc_core::RefCountedPtr<grpc_tls_key_materials_config>& 
+        key_materials_config, 
+    const grpc_tls_credentials_options& options, bool is_server, 
+    grpc_ssl_certificate_config_reload_status* status); 
+ 
+// TlsCheckHostName checks if |peer_name| matches the identity information 
+// contained in |peer|. This is AKA hostname check. 
+grpc_error* TlsCheckHostName(const char* peer_name, const tsi_peer* peer); 
+ 
+}  // namespace grpc_core 
+ 
+#endif /* GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_TLS_TLS_SECURITY_CONNECTOR_H \ 
+        */ 
diff --git a/contrib/libs/grpc/src/core/lib/security/transport/client_auth_filter.cc b/contrib/libs/grpc/src/core/lib/security/transport/client_auth_filter.cc
index b1a9d3f938..bf059cb203 100644
--- a/contrib/libs/grpc/src/core/lib/security/transport/client_auth_filter.cc
+++ b/contrib/libs/grpc/src/core/lib/security/transport/client_auth_filter.cc
@@ -22,10 +22,10 @@
 
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -270,39 +270,39 @@ static void send_security_metadata(grpc_call_element* elem,
         call_creds_has_md ? ctx->creds->Ref() : channel_call_creds->Ref();
   }
 
-  /* Check security level of call credential and channel, and do not send
-   * metadata if the check fails. */
-  grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
-      chand->auth_context.get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME);
-  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
-  if (prop == nullptr) {
-    grpc_transport_stream_op_batch_finish_with_failure(
-        batch,
-        grpc_error_set_int(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "Established channel does not have an auth property "
-                "representing a security level."),
-            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAUTHENTICATED),
-        calld->call_combiner);
-    return;
-  }
-  grpc_security_level call_cred_security_level =
-      calld->creds->min_security_level();
-  int is_security_level_ok = grpc_check_security_level(
-      grpc_tsi_security_level_string_to_enum(prop->value),
-      call_cred_security_level);
-  if (!is_security_level_ok) {
-    grpc_transport_stream_op_batch_finish_with_failure(
-        batch,
-        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                               "Established channel does not have a sufficient "
-                               "security level to transfer call credential."),
-                           GRPC_ERROR_INT_GRPC_STATUS,
-                           GRPC_STATUS_UNAUTHENTICATED),
-        calld->call_combiner);
-    return;
-  }
-
+  /* Check security level of call credential and channel, and do not send 
+   * metadata if the check fails. */ 
+  grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name( 
+      chand->auth_context.get(), GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME); 
+  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it); 
+  if (prop == nullptr) { 
+    grpc_transport_stream_op_batch_finish_with_failure( 
+        batch, 
+        grpc_error_set_int( 
+            GRPC_ERROR_CREATE_FROM_STATIC_STRING( 
+                "Established channel does not have an auth property " 
+                "representing a security level."), 
+            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAUTHENTICATED), 
+        calld->call_combiner); 
+    return; 
+  } 
+  grpc_security_level call_cred_security_level = 
+      calld->creds->min_security_level(); 
+  int is_security_level_ok = grpc_check_security_level( 
+      grpc_tsi_security_level_string_to_enum(prop->value), 
+      call_cred_security_level); 
+  if (!is_security_level_ok) { 
+    grpc_transport_stream_op_batch_finish_with_failure( 
+        batch, 
+        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING( 
+                               "Established channel does not have a sufficient " 
+                               "security level to transfer call credential."), 
+                           GRPC_ERROR_INT_GRPC_STATUS, 
+                           GRPC_STATUS_UNAUTHENTICATED), 
+        calld->call_combiner); 
+    return; 
+  } 
+ 
   grpc_auth_metadata_context_build(
       chand->security_connector->url_scheme(), calld->host, calld->method,
       chand->auth_context.get(), &calld->auth_md_context);
@@ -335,14 +335,14 @@ static void on_host_checked(void* arg, grpc_error* error) {
   if (error == GRPC_ERROR_NONE) {
     send_security_metadata(elem, batch);
   } else {
-    TString error_msg = y_absl::StrCat(
-        "Invalid host ", grpc_core::StringViewFromSlice(calld->host),
-        " set in :authority metadata.");
+    TString error_msg = y_absl::StrCat( 
+        "Invalid host ", grpc_core::StringViewFromSlice(calld->host), 
+        " set in :authority metadata."); 
     grpc_transport_stream_op_batch_finish_with_failure(
         batch,
-        grpc_error_set_int(
-            GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg.c_str()),
-            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAUTHENTICATED),
+        grpc_error_set_int( 
+            GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg.c_str()), 
+            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAUTHENTICATED), 
         calld->call_combiner);
   }
   GRPC_CALL_STACK_UNREF(calld->owning_call, "check_call_host");
@@ -380,7 +380,7 @@ static void client_auth_start_transport_stream_op_batch(
       GRPC_CALL_STACK_REF(calld->owning_call, "check_call_host");
       GRPC_CLOSURE_INIT(&calld->async_result_closure, on_host_checked, batch,
                         grpc_schedule_on_exec_ctx);
-      y_absl::string_view call_host(grpc_core::StringViewFromSlice(calld->host));
+      y_absl::string_view call_host(grpc_core::StringViewFromSlice(calld->host)); 
       grpc_error* error = GRPC_ERROR_NONE;
       if (chand->security_connector->check_call_host(
               call_host, chand->auth_context.get(),
diff --git a/contrib/libs/grpc/src/core/lib/security/transport/secure_endpoint.cc b/contrib/libs/grpc/src/core/lib/security/transport/secure_endpoint.cc
index e79184fac1..2a192185ce 100644
--- a/contrib/libs/grpc/src/core/lib/security/transport/secure_endpoint.cc
+++ b/contrib/libs/grpc/src/core/lib/security/transport/secure_endpoint.cc
@@ -401,16 +401,16 @@ static void endpoint_delete_from_pollset_set(grpc_endpoint* secure_ep,
   grpc_endpoint_delete_from_pollset_set(ep->wrapped_ep, pollset_set);
 }
 
-static y_absl::string_view endpoint_get_peer(grpc_endpoint* secure_ep) {
+static y_absl::string_view endpoint_get_peer(grpc_endpoint* secure_ep) { 
   secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   return grpc_endpoint_get_peer(ep->wrapped_ep);
 }
 
-static y_absl::string_view endpoint_get_local_address(grpc_endpoint* secure_ep) {
-  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
-  return grpc_endpoint_get_local_address(ep->wrapped_ep);
-}
-
+static y_absl::string_view endpoint_get_local_address(grpc_endpoint* secure_ep) { 
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep); 
+  return grpc_endpoint_get_local_address(ep->wrapped_ep); 
+} 
+ 
 static int endpoint_get_fd(grpc_endpoint* secure_ep) {
   secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   return grpc_endpoint_get_fd(ep->wrapped_ep);
@@ -436,7 +436,7 @@ static const grpc_endpoint_vtable vtable = {endpoint_read,
                                             endpoint_destroy,
                                             endpoint_get_resource_user,
                                             endpoint_get_peer,
-                                            endpoint_get_local_address,
+                                            endpoint_get_local_address, 
                                             endpoint_get_fd,
                                             endpoint_can_track_err};
 
diff --git a/contrib/libs/grpc/src/core/lib/security/transport/security_handshaker.cc b/contrib/libs/grpc/src/core/lib/security/transport/security_handshaker.cc
index 079b49c95a..9b3a320252 100644
--- a/contrib/libs/grpc/src/core/lib/security/transport/security_handshaker.cc
+++ b/contrib/libs/grpc/src/core/lib/security/transport/security_handshaker.cc
@@ -559,10 +559,10 @@ RefCountedPtr<Handshaker> SecurityHandshakerCreate(
 void SecurityRegisterHandshakerFactories() {
   HandshakerRegistry::RegisterHandshakerFactory(
       false /* at_start */, HANDSHAKER_CLIENT,
-      y_absl::make_unique<ClientSecurityHandshakerFactory>());
+      y_absl::make_unique<ClientSecurityHandshakerFactory>()); 
   HandshakerRegistry::RegisterHandshakerFactory(
       false /* at_start */, HANDSHAKER_SERVER,
-      y_absl::make_unique<ServerSecurityHandshakerFactory>());
+      y_absl::make_unique<ServerSecurityHandshakerFactory>()); 
 }
 
 }  // namespace grpc_core
diff --git a/contrib/libs/grpc/src/core/lib/security/util/json_util.cc b/contrib/libs/grpc/src/core/lib/security/util/json_util.cc
index 70ed064841..b4427b6769 100644
--- a/contrib/libs/grpc/src/core/lib/security/util/json_util.cc
+++ b/contrib/libs/grpc/src/core/lib/security/util/json_util.cc
@@ -20,46 +20,46 @@
 
 #include <string.h>
 
-#include "y_absl/strings/str_cat.h"
-
+#include "y_absl/strings/str_cat.h" 
+ 
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/security/util/json_util.h"
-
-const char* grpc_json_get_string_property(const grpc_core::Json& json,
+#include "src/core/lib/iomgr/error.h" 
+#include "src/core/lib/security/util/json_util.h" 
+ 
+const char* grpc_json_get_string_property(const grpc_core::Json& json, 
                                           const char* prop_name,
                                           grpc_error** error) {
-  if (json.type() != grpc_core::Json::Type::OBJECT) {
-    if (error != nullptr) {
-      *error =
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON value is not an object");
-    }
-    return nullptr;
-  }
-  auto it = json.object_value().find(prop_name);
-  if (it == json.object_value().end()) {
-    if (error != nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          y_absl::StrCat("Property ", prop_name, " not found in JSON object.")
-              .c_str());
+  if (json.type() != grpc_core::Json::Type::OBJECT) { 
+    if (error != nullptr) { 
+      *error = 
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("JSON value is not an object"); 
     }
-    return nullptr;
+    return nullptr; 
   }
-  if (it->second.type() != grpc_core::Json::Type::STRING) {
+  auto it = json.object_value().find(prop_name); 
+  if (it == json.object_value().end()) { 
     if (error != nullptr) {
-      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-          y_absl::StrCat("Property ", prop_name,
-                       " n JSON object is not a string.")
-              .c_str());
+      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+          y_absl::StrCat("Property ", prop_name, " not found in JSON object.") 
+              .c_str()); 
     }
     return nullptr;
   }
-  return it->second.string_value().c_str();
+  if (it->second.type() != grpc_core::Json::Type::STRING) { 
+    if (error != nullptr) { 
+      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+          y_absl::StrCat("Property ", prop_name, 
+                       " n JSON object is not a string.") 
+              .c_str()); 
+    } 
+    return nullptr; 
+  } 
+  return it->second.string_value().c_str(); 
 }
 
-bool grpc_copy_json_string_property(const grpc_core::Json& json,
+bool grpc_copy_json_string_property(const grpc_core::Json& json, 
                                     const char* prop_name,
                                     char** copied_value) {
   grpc_error* error = GRPC_ERROR_NONE;
diff --git a/contrib/libs/grpc/src/core/lib/security/util/json_util.h b/contrib/libs/grpc/src/core/lib/security/util/json_util.h
index 42f7005e00..95129b12bd 100644
--- a/contrib/libs/grpc/src/core/lib/security/util/json_util.h
+++ b/contrib/libs/grpc/src/core/lib/security/util/json_util.h
@@ -32,13 +32,13 @@
 #define GRPC_AUTH_JSON_TYPE_AUTHORIZED_USER "authorized_user"
 
 // Gets a child property from a json node.
-const char* grpc_json_get_string_property(const grpc_core::Json& json,
+const char* grpc_json_get_string_property(const grpc_core::Json& json, 
                                           const char* prop_name,
                                           grpc_error** error);
 
 // Copies the value of the json child property specified by prop_name.
 // Returns false if the property was not found.
-bool grpc_copy_json_string_property(const grpc_core::Json& json,
+bool grpc_copy_json_string_property(const grpc_core::Json& json, 
                                     const char* prop_name, char** copied_value);
 
 #endif /* GRPC_CORE_LIB_SECURITY_UTIL_JSON_UTIL_H */
diff --git a/contrib/libs/grpc/src/core/lib/slice/slice.cc b/contrib/libs/grpc/src/core/lib/slice/slice.cc
index 838cf4ba49..2fbe1f8673 100644
--- a/contrib/libs/grpc/src/core/lib/slice/slice.cc
+++ b/contrib/libs/grpc/src/core/lib/slice/slice.cc
@@ -156,7 +156,7 @@ class NewWithLenSliceRefcount {
 /** grpc_slice_from_moved_(string|buffer) ref count .*/
 class MovedStringSliceRefCount {
  public:
-  explicit MovedStringSliceRefCount(grpc_core::UniquePtr<char>&& str)
+  explicit MovedStringSliceRefCount(grpc_core::UniquePtr<char>&& str) 
       : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
               &base_),
         str_(std::move(str)) {}
@@ -173,26 +173,26 @@ class MovedStringSliceRefCount {
   grpc_core::UniquePtr<char> str_;
 };
 
-// grpc_slice_from_cpp_string() ref count.
-class MovedCppStringSliceRefCount {
- public:
-  explicit MovedCppStringSliceRefCount(TString&& str)
-      : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
-              &base_),
-        str_(std::move(str)) {}
-
-  grpc_slice_refcount* base_refcount() { return &base_; }
-
- private:
-  static void Destroy(void* arg) {
-    delete static_cast<MovedCppStringSliceRefCount*>(arg);
-  }
-
-  grpc_slice_refcount base_;
-  grpc_core::RefCount refs_;
-  TString str_;
-};
-
+// grpc_slice_from_cpp_string() ref count. 
+class MovedCppStringSliceRefCount { 
+ public: 
+  explicit MovedCppStringSliceRefCount(TString&& str) 
+      : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this, 
+              &base_), 
+        str_(std::move(str)) {} 
+ 
+  grpc_slice_refcount* base_refcount() { return &base_; } 
+ 
+ private: 
+  static void Destroy(void* arg) { 
+    delete static_cast<MovedCppStringSliceRefCount*>(arg); 
+  } 
+ 
+  grpc_slice_refcount base_; 
+  grpc_core::RefCount refs_; 
+  TString str_; 
+}; 
+ 
 }  // namespace grpc_core
 
 grpc_slice grpc_slice_new_with_len(void* p, size_t len,
@@ -252,23 +252,23 @@ grpc_slice grpc_slice_from_moved_string(grpc_core::UniquePtr<char> p) {
   return grpc_slice_from_moved_buffer(std::move(p), len);
 }
 
-grpc_slice grpc_slice_from_cpp_string(TString str) {
-  grpc_slice slice;
-  if (str.size() <= sizeof(slice.data.inlined.bytes)) {
-    slice.refcount = nullptr;
-    slice.data.inlined.length = str.size();
-    memcpy(GRPC_SLICE_START_PTR(slice), str.data(), str.size());
-  } else {
-    slice.data.refcounted.bytes =
-        reinterpret_cast<uint8_t*>(const_cast<char*>(str.data()));
-    slice.data.refcounted.length = str.size();
-    slice.refcount =
-        (new grpc_core::MovedCppStringSliceRefCount(std::move(str)))
-            ->base_refcount();
-  }
-  return slice;
-}
-
+grpc_slice grpc_slice_from_cpp_string(TString str) { 
+  grpc_slice slice; 
+  if (str.size() <= sizeof(slice.data.inlined.bytes)) { 
+    slice.refcount = nullptr; 
+    slice.data.inlined.length = str.size(); 
+    memcpy(GRPC_SLICE_START_PTR(slice), str.data(), str.size()); 
+  } else { 
+    slice.data.refcounted.bytes = 
+        reinterpret_cast<uint8_t*>(const_cast<char*>(str.data())); 
+    slice.data.refcounted.length = str.size(); 
+    slice.refcount = 
+        (new grpc_core::MovedCppStringSliceRefCount(std::move(str))) 
+            ->base_refcount(); 
+  } 
+  return slice; 
+} 
+ 
 namespace {
 
 class MallocRefCount {
diff --git a/contrib/libs/grpc/src/core/lib/slice/slice_internal.h b/contrib/libs/grpc/src/core/lib/slice/slice_internal.h
index 8a17b6e72e..9738a712c1 100644
--- a/contrib/libs/grpc/src/core/lib/slice/slice_internal.h
+++ b/contrib/libs/grpc/src/core/lib/slice/slice_internal.h
@@ -338,7 +338,7 @@ inline uint32_t grpc_slice_hash_internal(const grpc_slice& s) {
 grpc_slice grpc_slice_from_moved_buffer(grpc_core::UniquePtr<char> p,
                                         size_t len);
 grpc_slice grpc_slice_from_moved_string(grpc_core::UniquePtr<char> p);
-grpc_slice grpc_slice_from_cpp_string(TString str);
+grpc_slice grpc_slice_from_cpp_string(TString str); 
 
 // Returns the memory used by this slice, not counting the slice structure
 // itself. This means that inlined and slices from static strings will return
@@ -348,18 +348,18 @@ size_t grpc_slice_memory_usage(grpc_slice s);
 grpc_core::UnmanagedMemorySlice grpc_slice_sub_no_ref(
     const grpc_core::UnmanagedMemorySlice& source, size_t begin, size_t end);
 
-namespace grpc_core {
-
-struct SliceHash {
-  std::size_t operator()(const grpc_slice& slice) const {
-    return grpc_slice_hash_internal(slice);
-  }
-};
-
-}  // namespace grpc_core
-
-inline bool operator==(const grpc_slice& s1, const grpc_slice& s2) {
-  return grpc_slice_eq(s1, s2);
-}
-
+namespace grpc_core { 
+ 
+struct SliceHash { 
+  std::size_t operator()(const grpc_slice& slice) const { 
+    return grpc_slice_hash_internal(slice); 
+  } 
+}; 
+ 
+}  // namespace grpc_core 
+ 
+inline bool operator==(const grpc_slice& s1, const grpc_slice& s2) { 
+  return grpc_slice_eq(s1, s2); 
+} 
+ 
 #endif /* GRPC_CORE_LIB_SLICE_SLICE_INTERNAL_H */
diff --git a/contrib/libs/grpc/src/core/lib/slice/slice_utils.h b/contrib/libs/grpc/src/core/lib/slice/slice_utils.h
index 95cef73a4f..3636e38ccf 100644
--- a/contrib/libs/grpc/src/core/lib/slice/slice_utils.h
+++ b/contrib/libs/grpc/src/core/lib/slice/slice_utils.h
@@ -23,8 +23,8 @@
 
 #include <cstring>
 
-#include "y_absl/strings/string_view.h"
-
+#include "y_absl/strings/string_view.h" 
+ 
 #include <grpc/slice.h>
 
 #include "src/core/lib/gpr/murmur_hash.h"
@@ -188,13 +188,13 @@ struct InternedSlice : public ManagedMemorySlice {
   explicit InternedSlice(InternedSliceRefcount* s);
 };
 
-// Converts grpc_slice to y_absl::string_view.
-inline y_absl::string_view StringViewFromSlice(const grpc_slice& slice) {
-  return y_absl::string_view(
-      reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(slice)),
-      GRPC_SLICE_LENGTH(slice));
-}
-
+// Converts grpc_slice to y_absl::string_view. 
+inline y_absl::string_view StringViewFromSlice(const grpc_slice& slice) { 
+  return y_absl::string_view( 
+      reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(slice)), 
+      GRPC_SLICE_LENGTH(slice)); 
+} 
+ 
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_SLICE_SLICE_UTILS_H */
diff --git a/contrib/libs/grpc/src/core/lib/surface/byte_buffer_reader.cc b/contrib/libs/grpc/src/core/lib/surface/byte_buffer_reader.cc
index 3689c79455..2f398be47e 100644
--- a/contrib/libs/grpc/src/core/lib/surface/byte_buffer_reader.cc
+++ b/contrib/libs/grpc/src/core/lib/surface/byte_buffer_reader.cc
@@ -35,7 +35,7 @@ int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
   reader->buffer_in = buffer;
   switch (reader->buffer_in->type) {
     case GRPC_BB_RAW:
-      reader->buffer_out = reader->buffer_in;
+      reader->buffer_out = reader->buffer_in; 
       reader->current.index = 0;
       break;
   }
@@ -43,7 +43,7 @@ int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
 }
 
 void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader* reader) {
-  reader->buffer_out = nullptr;
+  reader->buffer_out = nullptr; 
 }
 
 int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader,
diff --git a/contrib/libs/grpc/src/core/lib/surface/call.cc b/contrib/libs/grpc/src/core/lib/surface/call.cc
index fe4c774c52..a2ef755ddf 100644
--- a/contrib/libs/grpc/src/core/lib/surface/call.cc
+++ b/contrib/libs/grpc/src/core/lib/surface/call.cc
@@ -24,11 +24,11 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_format.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/compression.h>
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
@@ -232,9 +232,9 @@ struct grpc_call {
   grpc_closure receiving_initial_metadata_ready;
   grpc_closure receiving_trailing_metadata_ready;
   uint32_t test_only_last_message_flags = 0;
-  // Status about operation of call
-  bool sent_server_trailing_metadata = false;
-  gpr_atm cancelled_with_error = 0;
+  // Status about operation of call 
+  bool sent_server_trailing_metadata = false; 
+  gpr_atm cancelled_with_error = 0; 
 
   grpc_closure release_call;
 
@@ -247,7 +247,7 @@ struct grpc_call {
     struct {
       int* cancelled;
       // backpointer to owning server if this is a server side call.
-      grpc_core::Server* core_server;
+      grpc_core::Server* core_server; 
     } server;
   } final_op;
   gpr_atm status_error = 0;
@@ -376,7 +376,7 @@ grpc_error* grpc_call_create(const grpc_call_create_args* args,
   } else {
     GRPC_STATS_INC_SERVER_CALLS_CREATED();
     call->final_op.server.cancelled = nullptr;
-    call->final_op.server.core_server = args->server;
+    call->final_op.server.core_server = args->server; 
     GPR_ASSERT(args->add_initial_metadata_count == 0);
     call->send_extra_metadata_count = 0;
   }
@@ -478,11 +478,11 @@ grpc_error* grpc_call_create(const grpc_call_create_args* args,
     if (channelz_channel != nullptr) {
       channelz_channel->RecordCallStarted();
     }
-  } else if (call->final_op.server.core_server != nullptr) {
-    grpc_core::channelz::ServerNode* channelz_node =
-        call->final_op.server.core_server->channelz_node();
-    if (channelz_node != nullptr) {
-      channelz_node->RecordCallStarted();
+  } else if (call->final_op.server.core_server != nullptr) { 
+    grpc_core::channelz::ServerNode* channelz_node = 
+        call->final_op.server.core_server->channelz_node(); 
+    if (channelz_node != nullptr) { 
+      channelz_node->RecordCallStarted(); 
     }
   }
 
@@ -695,7 +695,7 @@ static void done_termination(void* arg, grpc_error* /*error*/) {
 }
 
 static void cancel_with_error(grpc_call* c, grpc_error* error) {
-  if (!gpr_atm_rel_cas(&c->cancelled_with_error, 0, 1)) {
+  if (!gpr_atm_rel_cas(&c->cancelled_with_error, 0, 1)) { 
     GRPC_ERROR_UNREF(error);
     return;
   }
@@ -760,16 +760,16 @@ static void set_final_status(grpc_call* call, grpc_error* error) {
     }
   } else {
     *call->final_op.server.cancelled =
-        error != GRPC_ERROR_NONE || !call->sent_server_trailing_metadata;
-    grpc_core::channelz::ServerNode* channelz_node =
-        call->final_op.server.core_server->channelz_node();
-    if (channelz_node != nullptr) {
-      if (*call->final_op.server.cancelled ||
-          reinterpret_cast<grpc_error*>(
-              gpr_atm_acq_load(&call->status_error)) != GRPC_ERROR_NONE) {
-        channelz_node->RecordCallFailed();
+        error != GRPC_ERROR_NONE || !call->sent_server_trailing_metadata; 
+    grpc_core::channelz::ServerNode* channelz_node = 
+        call->final_op.server.core_server->channelz_node(); 
+    if (channelz_node != nullptr) { 
+      if (*call->final_op.server.cancelled || 
+          reinterpret_cast<grpc_error*>( 
+              gpr_atm_acq_load(&call->status_error)) != GRPC_ERROR_NONE) { 
+        channelz_node->RecordCallFailed(); 
       } else {
-        channelz_node->RecordCallSucceeded();
+        channelz_node->RecordCallSucceeded(); 
       }
     }
     GRPC_ERROR_UNREF(error);
@@ -1059,10 +1059,10 @@ static void recv_trailing_filter(void* args, grpc_metadata_batch* b,
     grpc_error* error = GRPC_ERROR_NONE;
     if (status_code != GRPC_STATUS_OK) {
       char* peer = grpc_call_get_peer(call);
-      error = grpc_error_set_int(
-          GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-              y_absl::StrCat("Error received from peer ", peer).c_str()),
-          GRPC_ERROR_INT_GRPC_STATUS, static_cast<intptr_t>(status_code));
+      error = grpc_error_set_int( 
+          GRPC_ERROR_CREATE_FROM_COPIED_STRING( 
+              y_absl::StrCat("Error received from peer ", peer).c_str()), 
+          GRPC_ERROR_INT_GRPC_STATUS, static_cast<intptr_t>(status_code)); 
       gpr_free(peer);
     }
     if (b->idx.named.grpc_message != nullptr) {
@@ -1374,41 +1374,41 @@ static void receiving_stream_ready_in_call_combiner(void* bctlp,
 
 static void GPR_ATTRIBUTE_NOINLINE
 handle_both_stream_and_msg_compression_set(grpc_call* call) {
-  TString error_msg = y_absl::StrFormat(
-      "Incoming stream has both stream compression (%d) and message "
-      "compression (%d).",
-      call->incoming_stream_compression_algorithm,
-      call->incoming_message_compression_algorithm);
-  gpr_log(GPR_ERROR, "%s", error_msg.c_str());
-  cancel_with_status(call, GRPC_STATUS_INTERNAL, error_msg.c_str());
+  TString error_msg = y_absl::StrFormat( 
+      "Incoming stream has both stream compression (%d) and message " 
+      "compression (%d).", 
+      call->incoming_stream_compression_algorithm, 
+      call->incoming_message_compression_algorithm); 
+  gpr_log(GPR_ERROR, "%s", error_msg.c_str()); 
+  cancel_with_status(call, GRPC_STATUS_INTERNAL, error_msg.c_str()); 
 }
 
 static void GPR_ATTRIBUTE_NOINLINE
 handle_error_parsing_compression_algorithm(grpc_call* call) {
-  TString error_msg = y_absl::StrFormat(
-      "Error in incoming message compression (%d) or stream "
-      "compression (%d).",
-      call->incoming_stream_compression_algorithm,
-      call->incoming_message_compression_algorithm);
-  cancel_with_status(call, GRPC_STATUS_INTERNAL, error_msg.c_str());
+  TString error_msg = y_absl::StrFormat( 
+      "Error in incoming message compression (%d) or stream " 
+      "compression (%d).", 
+      call->incoming_stream_compression_algorithm, 
+      call->incoming_message_compression_algorithm); 
+  cancel_with_status(call, GRPC_STATUS_INTERNAL, error_msg.c_str()); 
 }
 
 static void GPR_ATTRIBUTE_NOINLINE handle_invalid_compression(
     grpc_call* call, grpc_compression_algorithm compression_algorithm) {
-  TString error_msg = y_absl::StrFormat(
-      "Invalid compression algorithm value '%d'.", compression_algorithm);
-  gpr_log(GPR_ERROR, "%s", error_msg.c_str());
-  cancel_with_status(call, GRPC_STATUS_UNIMPLEMENTED, error_msg.c_str());
+  TString error_msg = y_absl::StrFormat( 
+      "Invalid compression algorithm value '%d'.", compression_algorithm); 
+  gpr_log(GPR_ERROR, "%s", error_msg.c_str()); 
+  cancel_with_status(call, GRPC_STATUS_UNIMPLEMENTED, error_msg.c_str()); 
 }
 
 static void GPR_ATTRIBUTE_NOINLINE handle_compression_algorithm_disabled(
     grpc_call* call, grpc_compression_algorithm compression_algorithm) {
   const char* algo_name = nullptr;
   grpc_compression_algorithm_name(compression_algorithm, &algo_name);
-  TString error_msg =
-      y_absl::StrFormat("Compression algorithm '%s' is disabled.", algo_name);
-  gpr_log(GPR_ERROR, "%s", error_msg.c_str());
-  cancel_with_status(call, GRPC_STATUS_UNIMPLEMENTED, error_msg.c_str());
+  TString error_msg = 
+      y_absl::StrFormat("Compression algorithm '%s' is disabled.", algo_name); 
+  gpr_log(GPR_ERROR, "%s", error_msg.c_str()); 
+  cancel_with_status(call, GRPC_STATUS_UNIMPLEMENTED, error_msg.c_str()); 
 }
 
 static void GPR_ATTRIBUTE_NOINLINE handle_compression_algorithm_not_accepted(
@@ -1790,8 +1790,8 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
         }
         stream_op_payload->send_trailing_metadata.send_trailing_metadata =
             &call->metadata_batch[0 /* is_receiving */][1 /* is_trailing */];
-        stream_op_payload->send_trailing_metadata.sent =
-            &call->sent_server_trailing_metadata;
+        stream_op_payload->send_trailing_metadata.sent = 
+            &call->sent_server_trailing_metadata; 
         has_send_ops = true;
         break;
       }
diff --git a/contrib/libs/grpc/src/core/lib/surface/call.h b/contrib/libs/grpc/src/core/lib/surface/call.h
index 34d01db902..b6ebd08e18 100644
--- a/contrib/libs/grpc/src/core/lib/surface/call.h
+++ b/contrib/libs/grpc/src/core/lib/surface/call.h
@@ -25,7 +25,7 @@
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/arena.h"
 #include "src/core/lib/surface/api_trace.h"
-#include "src/core/lib/surface/server.h"
+#include "src/core/lib/surface/server.h" 
 
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/compression_types.h>
@@ -35,7 +35,7 @@ typedef void (*grpc_ioreq_completion_func)(grpc_call* call, int success,
 
 typedef struct grpc_call_create_args {
   grpc_channel* channel;
-  grpc_core::Server* server;
+  grpc_core::Server* server; 
 
   grpc_call* parent;
   uint32_t propagation_mask;
diff --git a/contrib/libs/grpc/src/core/lib/surface/call_log_batch.cc b/contrib/libs/grpc/src/core/lib/surface/call_log_batch.cc
index c4f78821ab..5371ef4ad7 100644
--- a/contrib/libs/grpc/src/core/lib/surface/call_log_batch.cc
+++ b/contrib/libs/grpc/src/core/lib/surface/call_log_batch.cc
@@ -22,90 +22,90 @@
 
 #include <inttypes.h>
 
-#include <vector>
-
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/str_join.h"
-
+#include <vector> 
+ 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/str_join.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
-static void add_metadata(const grpc_metadata* md, size_t count,
-                         std::vector<TString>* b) {
+static void add_metadata(const grpc_metadata* md, size_t count, 
+                         std::vector<TString>* b) { 
   if (md == nullptr) {
-    b->push_back("(nil)");
+    b->push_back("(nil)"); 
     return;
   }
-  for (size_t i = 0; i < count; i++) {
-    b->push_back("\nkey=");
-    b->push_back(TString(grpc_core::StringViewFromSlice(md[i].key)));
-    b->push_back(" value=");
-    char* dump = grpc_dump_slice(md[i].value, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    b->push_back(dump);
-    gpr_free(dump);
+  for (size_t i = 0; i < count; i++) { 
+    b->push_back("\nkey="); 
+    b->push_back(TString(grpc_core::StringViewFromSlice(md[i].key))); 
+    b->push_back(" value="); 
+    char* dump = grpc_dump_slice(md[i].value, GPR_DUMP_HEX | GPR_DUMP_ASCII); 
+    b->push_back(dump); 
+    gpr_free(dump); 
   }
 }
 
-static TString grpc_op_string(const grpc_op* op) {
-  std::vector<TString> parts;
+static TString grpc_op_string(const grpc_op* op) { 
+  std::vector<TString> parts; 
   switch (op->op) {
     case GRPC_OP_SEND_INITIAL_METADATA:
-      parts.push_back("SEND_INITIAL_METADATA");
-      add_metadata(op->data.send_initial_metadata.metadata,
-                   op->data.send_initial_metadata.count, &parts);
+      parts.push_back("SEND_INITIAL_METADATA"); 
+      add_metadata(op->data.send_initial_metadata.metadata, 
+                   op->data.send_initial_metadata.count, &parts); 
       break;
     case GRPC_OP_SEND_MESSAGE:
-      parts.push_back(y_absl::StrFormat("SEND_MESSAGE ptr=%p",
-                                      op->data.send_message.send_message));
+      parts.push_back(y_absl::StrFormat("SEND_MESSAGE ptr=%p", 
+                                      op->data.send_message.send_message)); 
       break;
     case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
-      parts.push_back("SEND_CLOSE_FROM_CLIENT");
+      parts.push_back("SEND_CLOSE_FROM_CLIENT"); 
       break;
     case GRPC_OP_SEND_STATUS_FROM_SERVER:
-      parts.push_back(
-          y_absl::StrFormat("SEND_STATUS_FROM_SERVER status=%d details=",
-                          op->data.send_status_from_server.status));
+      parts.push_back( 
+          y_absl::StrFormat("SEND_STATUS_FROM_SERVER status=%d details=", 
+                          op->data.send_status_from_server.status)); 
       if (op->data.send_status_from_server.status_details != nullptr) {
-        char* dump = grpc_dump_slice(
-            *op->data.send_status_from_server.status_details, GPR_DUMP_ASCII);
-        parts.push_back(dump);
-        gpr_free(dump);
+        char* dump = grpc_dump_slice( 
+            *op->data.send_status_from_server.status_details, GPR_DUMP_ASCII); 
+        parts.push_back(dump); 
+        gpr_free(dump); 
       } else {
-        parts.push_back("(null)");
+        parts.push_back("(null)"); 
       }
-      add_metadata(op->data.send_status_from_server.trailing_metadata,
-                   op->data.send_status_from_server.trailing_metadata_count,
-                   &parts);
+      add_metadata(op->data.send_status_from_server.trailing_metadata, 
+                   op->data.send_status_from_server.trailing_metadata_count, 
+                   &parts); 
       break;
     case GRPC_OP_RECV_INITIAL_METADATA:
-      parts.push_back(y_absl::StrFormat(
-          "RECV_INITIAL_METADATA ptr=%p",
-          op->data.recv_initial_metadata.recv_initial_metadata));
+      parts.push_back(y_absl::StrFormat( 
+          "RECV_INITIAL_METADATA ptr=%p", 
+          op->data.recv_initial_metadata.recv_initial_metadata)); 
       break;
     case GRPC_OP_RECV_MESSAGE:
-      parts.push_back(y_absl::StrFormat("RECV_MESSAGE ptr=%p",
-                                      op->data.recv_message.recv_message));
+      parts.push_back(y_absl::StrFormat("RECV_MESSAGE ptr=%p", 
+                                      op->data.recv_message.recv_message)); 
       break;
     case GRPC_OP_RECV_STATUS_ON_CLIENT:
-      parts.push_back(y_absl::StrFormat(
-          "RECV_STATUS_ON_CLIENT metadata=%p status=%p details=%p",
-          op->data.recv_status_on_client.trailing_metadata,
-          op->data.recv_status_on_client.status,
-          op->data.recv_status_on_client.status_details));
+      parts.push_back(y_absl::StrFormat( 
+          "RECV_STATUS_ON_CLIENT metadata=%p status=%p details=%p", 
+          op->data.recv_status_on_client.trailing_metadata, 
+          op->data.recv_status_on_client.status, 
+          op->data.recv_status_on_client.status_details)); 
       break;
     case GRPC_OP_RECV_CLOSE_ON_SERVER:
-      parts.push_back(y_absl::StrFormat("RECV_CLOSE_ON_SERVER cancelled=%p",
-                                      op->data.recv_close_on_server.cancelled));
+      parts.push_back(y_absl::StrFormat("RECV_CLOSE_ON_SERVER cancelled=%p", 
+                                      op->data.recv_close_on_server.cancelled)); 
   }
-  return y_absl::StrJoin(parts, "");
+  return y_absl::StrJoin(parts, ""); 
 }
 
 void grpc_call_log_batch(const char* file, int line, gpr_log_severity severity,
                          const grpc_op* ops, size_t nops) {
-  for (size_t i = 0; i < nops; i++) {
-    gpr_log(file, line, severity, "ops[%" PRIuPTR "]: %s", i,
-            grpc_op_string(&ops[i]).c_str());
+  for (size_t i = 0; i < nops; i++) { 
+    gpr_log(file, line, severity, "ops[%" PRIuPTR "]: %s", i, 
+            grpc_op_string(&ops[i]).c_str()); 
   }
 }
diff --git a/contrib/libs/grpc/src/core/lib/surface/channel.cc b/contrib/libs/grpc/src/core/lib/surface/channel.cc
index 28df8e61ee..4d892b3e49 100644
--- a/contrib/libs/grpc/src/core/lib/surface/channel.cc
+++ b/contrib/libs/grpc/src/core/lib/surface/channel.cc
@@ -84,7 +84,7 @@ grpc_channel* grpc_channel_create_with_builder(
   channel->target = target;
   channel->resource_user = resource_user;
   channel->is_client = grpc_channel_stack_type_is_client(channel_stack_type);
-  channel->registration_table.Init();
+  channel->registration_table.Init(); 
 
   gpr_atm_no_barrier_store(
       &channel->call_size_estimate,
@@ -183,30 +183,30 @@ void CreateChannelzNode(grpc_channel_stack_builder* builder) {
   const grpc_channel_args* args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   // Check whether channelz is enabled.
-  const bool channelz_enabled = grpc_channel_args_find_bool(
-      args, GRPC_ARG_ENABLE_CHANNELZ, GRPC_ENABLE_CHANNELZ_DEFAULT);
+  const bool channelz_enabled = grpc_channel_args_find_bool( 
+      args, GRPC_ARG_ENABLE_CHANNELZ, GRPC_ENABLE_CHANNELZ_DEFAULT); 
   if (!channelz_enabled) return;
   // Get parameters needed to create the channelz node.
-  const size_t channel_tracer_max_memory = grpc_channel_args_find_integer(
-      args, GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE,
+  const size_t channel_tracer_max_memory = grpc_channel_args_find_integer( 
+      args, GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE, 
       {GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT, 0, INT_MAX});
-  const bool is_internal_channel = grpc_channel_args_find_bool(
-      args, GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, false);
+  const bool is_internal_channel = grpc_channel_args_find_bool( 
+      args, GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, false); 
   // Create the channelz node.
   const char* target = grpc_channel_stack_builder_get_target(builder);
   grpc_core::RefCountedPtr<grpc_core::channelz::ChannelNode> channelz_node =
       grpc_core::MakeRefCounted<grpc_core::channelz::ChannelNode>(
           target != nullptr ? target : "", channel_tracer_max_memory,
-          is_internal_channel);
+          is_internal_channel); 
   channelz_node->AddTraceEvent(
       grpc_core::channelz::ChannelTrace::Severity::Info,
       grpc_slice_from_static_string("Channel created"));
   // Add channelz node to channel args.
-  // We remove the is_internal_channel arg, since we no longer need it.
+  // We remove the is_internal_channel arg, since we no longer need it. 
   grpc_arg new_arg = grpc_channel_arg_pointer_create(
       const_cast<char*>(GRPC_ARG_CHANNELZ_CHANNEL_NODE), channelz_node.get(),
       &channelz_node_arg_vtable);
-  const char* args_to_remove[] = {GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL};
+  const char* args_to_remove[] = {GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL}; 
   grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
       args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove), &new_arg, 1);
   grpc_channel_stack_builder_set_channel_arguments(builder, new_args);
@@ -317,7 +317,7 @@ char* grpc_channel_get_target(grpc_channel* channel) {
 
 void grpc_channel_get_info(grpc_channel* channel,
                            const grpc_channel_info* channel_info) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx; 
   grpc_core::ExecCtx exec_ctx;
   grpc_channel_element* elem =
       grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0);
@@ -325,7 +325,7 @@ void grpc_channel_get_info(grpc_channel* channel,
 }
 
 void grpc_channel_reset_connect_backoff(grpc_channel* channel) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx; 
   grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE("grpc_channel_reset_connect_backoff(channel=%p)", 1,
                  (channel));
@@ -376,7 +376,7 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
                                     grpc_slice method, const grpc_slice* host,
                                     gpr_timespec deadline, void* reserved) {
   GPR_ASSERT(!reserved);
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx; 
   grpc_core::ExecCtx exec_ctx;
   grpc_call* call = grpc_channel_create_call_internal(
       channel, parent_call, propagation_mask, cq, nullptr,
@@ -401,74 +401,74 @@ grpc_call* grpc_channel_create_pollset_set_call(
       deadline);
 }
 
-namespace grpc_core {
-
-RegisteredCall::RegisteredCall(const char* method_arg, const char* host_arg)
-    : method(method_arg != nullptr ? method_arg : ""),
-      host(host_arg != nullptr ? host_arg : ""),
-      path(grpc_mdelem_from_slices(
-          GRPC_MDSTR_PATH, grpc_core::ExternallyManagedSlice(method.c_str()))),
-      authority(!host.empty()
-                    ? grpc_mdelem_from_slices(
-                          GRPC_MDSTR_AUTHORITY,
-                          grpc_core::ExternallyManagedSlice(host.c_str()))
-                    : GRPC_MDNULL) {}
-
-// TODO(vjpai): Delete copy-constructor when allowed by all supported compilers.
-RegisteredCall::RegisteredCall(const RegisteredCall& other)
-    : RegisteredCall(other.method.c_str(), other.host.c_str()) {}
-
-RegisteredCall::RegisteredCall(RegisteredCall&& other) noexcept
-    : method(std::move(other.method)),
-      host(std::move(other.host)),
-      path(grpc_mdelem_from_slices(
-          GRPC_MDSTR_PATH, grpc_core::ExternallyManagedSlice(method.c_str()))),
-      authority(!host.empty()
-                    ? grpc_mdelem_from_slices(
-                          GRPC_MDSTR_AUTHORITY,
-                          grpc_core::ExternallyManagedSlice(host.c_str()))
-                    : GRPC_MDNULL) {
-  GRPC_MDELEM_UNREF(other.path);
-  GRPC_MDELEM_UNREF(other.authority);
-  other.path = GRPC_MDNULL;
-  other.authority = GRPC_MDNULL;
-}
-
-RegisteredCall::~RegisteredCall() {
-  GRPC_MDELEM_UNREF(path);
-  GRPC_MDELEM_UNREF(authority);
-}
-
-}  // namespace grpc_core
-
+namespace grpc_core { 
+ 
+RegisteredCall::RegisteredCall(const char* method_arg, const char* host_arg) 
+    : method(method_arg != nullptr ? method_arg : ""), 
+      host(host_arg != nullptr ? host_arg : ""), 
+      path(grpc_mdelem_from_slices( 
+          GRPC_MDSTR_PATH, grpc_core::ExternallyManagedSlice(method.c_str()))), 
+      authority(!host.empty() 
+                    ? grpc_mdelem_from_slices( 
+                          GRPC_MDSTR_AUTHORITY, 
+                          grpc_core::ExternallyManagedSlice(host.c_str())) 
+                    : GRPC_MDNULL) {} 
+ 
+// TODO(vjpai): Delete copy-constructor when allowed by all supported compilers. 
+RegisteredCall::RegisteredCall(const RegisteredCall& other) 
+    : RegisteredCall(other.method.c_str(), other.host.c_str()) {} 
+ 
+RegisteredCall::RegisteredCall(RegisteredCall&& other) noexcept 
+    : method(std::move(other.method)), 
+      host(std::move(other.host)), 
+      path(grpc_mdelem_from_slices( 
+          GRPC_MDSTR_PATH, grpc_core::ExternallyManagedSlice(method.c_str()))), 
+      authority(!host.empty() 
+                    ? grpc_mdelem_from_slices( 
+                          GRPC_MDSTR_AUTHORITY, 
+                          grpc_core::ExternallyManagedSlice(host.c_str())) 
+                    : GRPC_MDNULL) { 
+  GRPC_MDELEM_UNREF(other.path); 
+  GRPC_MDELEM_UNREF(other.authority); 
+  other.path = GRPC_MDNULL; 
+  other.authority = GRPC_MDNULL; 
+} 
+ 
+RegisteredCall::~RegisteredCall() { 
+  GRPC_MDELEM_UNREF(path); 
+  GRPC_MDELEM_UNREF(authority); 
+} 
+ 
+}  // namespace grpc_core 
+ 
 void* grpc_channel_register_call(grpc_channel* channel, const char* method,
                                  const char* host, void* reserved) {
   GRPC_API_TRACE(
       "grpc_channel_register_call(channel=%p, method=%s, host=%s, reserved=%p)",
       4, (channel, method, host, reserved));
   GPR_ASSERT(!reserved);
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx; 
   grpc_core::ExecCtx exec_ctx;
 
-  grpc_core::MutexLock lock(&channel->registration_table->mu);
-  channel->registration_table->method_registration_attempts++;
-  auto key = std::make_pair(TString(host != nullptr ? host : ""),
-                            TString(method != nullptr ? method : ""));
-  auto rc_posn = channel->registration_table->map.find(key);
-  if (rc_posn != channel->registration_table->map.end()) {
-    return &rc_posn->second;
-  }
-  auto insertion_result = channel->registration_table->map.insert(
-      {std::move(key), grpc_core::RegisteredCall(method, host)});
-  return &insertion_result.first->second;
+  grpc_core::MutexLock lock(&channel->registration_table->mu); 
+  channel->registration_table->method_registration_attempts++; 
+  auto key = std::make_pair(TString(host != nullptr ? host : ""), 
+                            TString(method != nullptr ? method : "")); 
+  auto rc_posn = channel->registration_table->map.find(key); 
+  if (rc_posn != channel->registration_table->map.end()) { 
+    return &rc_posn->second; 
+  } 
+  auto insertion_result = channel->registration_table->map.insert( 
+      {std::move(key), grpc_core::RegisteredCall(method, host)}); 
+  return &insertion_result.first->second; 
 }
 
 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) {
-  grpc_core::RegisteredCall* rc =
-      static_cast<grpc_core::RegisteredCall*>(registered_call_handle);
+  grpc_core::RegisteredCall* rc = 
+      static_cast<grpc_core::RegisteredCall*>(registered_call_handle); 
   GRPC_API_TRACE(
       "grpc_channel_create_registered_call("
       "channel=%p, parent_call=%p, propagation_mask=%x, completion_queue=%p, "
@@ -481,7 +481,7 @@ grpc_call* grpc_channel_create_registered_call(
        registered_call_handle, deadline.tv_sec, deadline.tv_nsec,
        (int)deadline.clock_type, reserved));
   GPR_ASSERT(!reserved);
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx; 
   grpc_core::ExecCtx exec_ctx;
   grpc_call* call = grpc_channel_create_call_internal(
       channel, parent_call, propagation_mask, completion_queue, nullptr,
@@ -500,7 +500,7 @@ static void destroy_channel(void* arg, grpc_error* /*error*/) {
     channel->channelz_node.reset();
   }
   grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CHANNEL(channel));
-  channel->registration_table.Destroy();
+  channel->registration_table.Destroy(); 
   if (channel->resource_user != nullptr) {
     grpc_resource_user_free(channel->resource_user,
                             GRPC_RESOURCE_QUOTA_CHANNEL_SIZE);
@@ -523,7 +523,7 @@ void grpc_channel_destroy_internal(grpc_channel* channel) {
 }
 
 void grpc_channel_destroy(grpc_channel* channel) {
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx; 
   grpc_core::ExecCtx exec_ctx;
   grpc_channel_destroy_internal(channel);
 }
diff --git a/contrib/libs/grpc/src/core/lib/surface/channel.h b/contrib/libs/grpc/src/core/lib/surface/channel.h
index e49b9261f7..b9ead2c1eb 100644
--- a/contrib/libs/grpc/src/core/lib/surface/channel.h
+++ b/contrib/libs/grpc/src/core/lib/surface/channel.h
@@ -21,14 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <map>
-
+#include <map> 
+ 
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
+#include "src/core/lib/gprpp/manual_constructor.h" 
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/metadata.h"
+#include "src/core/lib/transport/metadata.h" 
 
 grpc_channel* grpc_channel_create(const char* target,
                                   const grpc_channel_args* args,
@@ -66,40 +66,40 @@ grpc_core::channelz::ChannelNode* grpc_channel_get_channelz_node(
 size_t grpc_channel_get_call_size_estimate(grpc_channel* channel);
 void grpc_channel_update_call_size_estimate(grpc_channel* channel, size_t size);
 
-namespace grpc_core {
-
-struct RegisteredCall {
-  // The method and host are kept as part of this struct just to manage their
-  // lifetime since they must outlive the mdelem contents.
-  TString method;
-  TString host;
-
-  grpc_mdelem path;
-  grpc_mdelem authority;
-
-  explicit RegisteredCall(const char* method_arg, const char* host_arg);
-  // TODO(vjpai): delete copy constructor once all supported compilers allow
-  //              std::map value_type to be MoveConstructible.
-  RegisteredCall(const RegisteredCall& other);
-  RegisteredCall(RegisteredCall&& other) noexcept;
-  RegisteredCall& operator=(const RegisteredCall&) = delete;
-  RegisteredCall& operator=(RegisteredCall&&) = delete;
-
-  ~RegisteredCall();
-};
-
-struct CallRegistrationTable {
-  grpc_core::Mutex mu;
-  // The map key should be owned strings rather than unowned char*'s to
-  // guarantee that it outlives calls on the core channel (which may outlast the
-  // C++ or other wrapped language Channel that registered these calls).
-  std::map<std::pair<TString, TString>, RegisteredCall>
-      map /* GUARDED_BY(mu) */;
-  int method_registration_attempts /* GUARDED_BY(mu) */ = 0;
-};
-
-}  // namespace grpc_core
-
+namespace grpc_core { 
+ 
+struct RegisteredCall { 
+  // The method and host are kept as part of this struct just to manage their 
+  // lifetime since they must outlive the mdelem contents. 
+  TString method; 
+  TString host; 
+ 
+  grpc_mdelem path; 
+  grpc_mdelem authority; 
+ 
+  explicit RegisteredCall(const char* method_arg, const char* host_arg); 
+  // TODO(vjpai): delete copy constructor once all supported compilers allow 
+  //              std::map value_type to be MoveConstructible. 
+  RegisteredCall(const RegisteredCall& other); 
+  RegisteredCall(RegisteredCall&& other) noexcept; 
+  RegisteredCall& operator=(const RegisteredCall&) = delete; 
+  RegisteredCall& operator=(RegisteredCall&&) = delete; 
+ 
+  ~RegisteredCall(); 
+}; 
+ 
+struct CallRegistrationTable { 
+  grpc_core::Mutex mu; 
+  // The map key should be owned strings rather than unowned char*'s to 
+  // guarantee that it outlives calls on the core channel (which may outlast the 
+  // C++ or other wrapped language Channel that registered these calls). 
+  std::map<std::pair<TString, TString>, RegisteredCall> 
+      map /* GUARDED_BY(mu) */; 
+  int method_registration_attempts /* GUARDED_BY(mu) */ = 0; 
+}; 
+ 
+}  // namespace grpc_core 
+ 
 struct grpc_channel {
   int is_client;
   grpc_compression_options compression_options;
@@ -107,13 +107,13 @@ struct grpc_channel {
   gpr_atm call_size_estimate;
   grpc_resource_user* resource_user;
 
-  // TODO(vjpai): Once the grpc_channel is allocated via new rather than malloc,
-  //              expand the members of the CallRegistrationTable directly into
-  //              the grpc_channel. For now it is kept separate so that all the
-  //              manual constructing can be done with a single call rather than
-  //              a separate manual construction for each field.
-  grpc_core::ManualConstructor<grpc_core::CallRegistrationTable>
-      registration_table;
+  // TODO(vjpai): Once the grpc_channel is allocated via new rather than malloc, 
+  //              expand the members of the CallRegistrationTable directly into 
+  //              the grpc_channel. For now it is kept separate so that all the 
+  //              manual constructing can be done with a single call rather than 
+  //              a separate manual construction for each field. 
+  grpc_core::ManualConstructor<grpc_core::CallRegistrationTable> 
+      registration_table; 
   grpc_core::RefCountedPtr<grpc_core::channelz::ChannelNode> channelz_node;
 
   char* target;
@@ -161,13 +161,13 @@ inline void grpc_channel_internal_unref(grpc_channel* channel) {
   grpc_channel_internal_unref(channel)
 #endif
 
-// Return the channel's compression options.
+// Return the channel's compression options. 
 grpc_compression_options grpc_channel_compression_options(
     const grpc_channel* channel);
 
-// Ping the channels peer (load balanced channels will select one sub-channel to
-// ping); if the channel is not connected, posts a failed.
-void grpc_channel_ping(grpc_channel* channel, grpc_completion_queue* cq,
-                       void* tag, void* reserved);
-
+// Ping the channels peer (load balanced channels will select one sub-channel to 
+// ping); if the channel is not connected, posts a failed. 
+void grpc_channel_ping(grpc_channel* channel, grpc_completion_queue* cq, 
+                       void* tag, void* reserved); 
+ 
 #endif /* GRPC_CORE_LIB_SURFACE_CHANNEL_H */
diff --git a/contrib/libs/grpc/src/core/lib/surface/completion_queue.cc b/contrib/libs/grpc/src/core/lib/surface/completion_queue.cc
index 0f50906734..49d2ff99bc 100644
--- a/contrib/libs/grpc/src/core/lib/surface/completion_queue.cc
+++ b/contrib/libs/grpc/src/core/lib/surface/completion_queue.cc
@@ -23,11 +23,11 @@
 #include <stdio.h>
 #include <string.h>
 
-#include <vector>
-
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/str_join.h"
-
+#include <vector> 
+ 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/str_join.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
@@ -243,14 +243,14 @@ class CqEventQueue {
 };
 
 struct cq_next_data {
-  ~cq_next_data() {
-    GPR_ASSERT(queue.num_items() == 0);
-#ifndef NDEBUG
-    if (pending_events.Load(grpc_core::MemoryOrder::ACQUIRE) != 0) {
-      gpr_log(GPR_ERROR, "Destroying CQ without draining it fully.");
-    }
-#endif
-  }
+  ~cq_next_data() { 
+    GPR_ASSERT(queue.num_items() == 0); 
+#ifndef NDEBUG 
+    if (pending_events.Load(grpc_core::MemoryOrder::ACQUIRE) != 0) { 
+      gpr_log(GPR_ERROR, "Destroying CQ without draining it fully."); 
+    } 
+#endif 
+  } 
 
   /** Completed events for completion-queues of type GRPC_CQ_NEXT */
   CqEventQueue queue;
@@ -276,11 +276,11 @@ struct cq_pluck_data {
   ~cq_pluck_data() {
     GPR_ASSERT(completed_head.next ==
                reinterpret_cast<uintptr_t>(&completed_head));
-#ifndef NDEBUG
-    if (pending_events.Load(grpc_core::MemoryOrder::ACQUIRE) != 0) {
-      gpr_log(GPR_ERROR, "Destroying CQ without draining it fully.");
-    }
-#endif
+#ifndef NDEBUG 
+    if (pending_events.Load(grpc_core::MemoryOrder::ACQUIRE) != 0) { 
+      gpr_log(GPR_ERROR, "Destroying CQ without draining it fully."); 
+    } 
+#endif 
   }
 
   /** Completed events for completion-queues of type GRPC_CQ_PLUCK */
@@ -312,15 +312,15 @@ struct cq_callback_data {
   cq_callback_data(
       grpc_experimental_completion_queue_functor* shutdown_callback)
       : shutdown_callback(shutdown_callback) {}
-
-  ~cq_callback_data() {
-#ifndef NDEBUG
-    if (pending_events.Load(grpc_core::MemoryOrder::ACQUIRE) != 0) {
-      gpr_log(GPR_ERROR, "Destroying CQ without draining it fully.");
-    }
-#endif
-  }
-
+ 
+  ~cq_callback_data() { 
+#ifndef NDEBUG 
+    if (pending_events.Load(grpc_core::MemoryOrder::ACQUIRE) != 0) { 
+      gpr_log(GPR_ERROR, "Destroying CQ without draining it fully."); 
+    } 
+#endif 
+  } 
+ 
   /** No actual completed events queue, unlike other types */
 
   /** Number of pending events (+1 if we're not shutdown).
@@ -428,14 +428,14 @@ static const cq_vtable g_cq_vtable[] = {
 
 grpc_core::TraceFlag grpc_cq_pluck_trace(false, "queue_pluck");
 
-#define GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, event)     \
-  do {                                                   \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace) &&       \
-        (GRPC_TRACE_FLAG_ENABLED(grpc_cq_pluck_trace) || \
-         (event)->type != GRPC_QUEUE_TIMEOUT)) {         \
-      gpr_log(GPR_INFO, "RETURN_EVENT[%p]: %s", cq,      \
-              grpc_event_string(event).c_str());         \
-    }                                                    \
+#define GRPC_SURFACE_TRACE_RETURNED_EVENT(cq, event)     \ 
+  do {                                                   \ 
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_api_trace) &&       \ 
+        (GRPC_TRACE_FLAG_ENABLED(grpc_cq_pluck_trace) || \ 
+         (event)->type != GRPC_QUEUE_TIMEOUT)) {         \ 
+      gpr_log(GPR_INFO, "RETURN_EVENT[%p]: %s", cq,      \ 
+              grpc_event_string(event).c_str());         \ 
+    }                                                    \ 
   } while (0)
 
 static void on_pollset_shutdown_done(void* cq, grpc_error* error);
@@ -870,15 +870,15 @@ static void cq_end_op_for_callback(
     cq_finish_shutdown_callback(cq);
   }
 
-  // If possible, schedule the callback onto an existing thread-local
-  // ApplicationCallbackExecCtx, which is a work queue. This is possible for:
-  // 1. The callback is internally-generated and there is an ACEC available
-  // 2. The callback is marked inlineable and there is an ACEC available
-  // 3. We are already running in a background poller thread (which always has
-  //    an ACEC available at the base of the stack).
+  // If possible, schedule the callback onto an existing thread-local 
+  // ApplicationCallbackExecCtx, which is a work queue. This is possible for: 
+  // 1. The callback is internally-generated and there is an ACEC available 
+  // 2. The callback is marked inlineable and there is an ACEC available 
+  // 3. We are already running in a background poller thread (which always has 
+  //    an ACEC available at the base of the stack). 
   auto* functor = static_cast<grpc_experimental_completion_queue_functor*>(tag);
-  if (((internal || functor->inlineable) &&
-       grpc_core::ApplicationCallbackExecCtx::Available()) ||
+  if (((internal || functor->inlineable) && 
+       grpc_core::ApplicationCallbackExecCtx::Available()) || 
       grpc_iomgr_is_any_background_poller_thread()) {
     grpc_core::ApplicationCallbackExecCtx::Enqueue(functor,
                                                    (error == GRPC_ERROR_NONE));
@@ -946,14 +946,14 @@ class ExecCtxNext : public grpc_core::ExecCtx {
 #ifndef NDEBUG
 static void dump_pending_tags(grpc_completion_queue* cq) {
   if (!GRPC_TRACE_FLAG_ENABLED(grpc_trace_pending_tags)) return;
-  std::vector<TString> parts;
-  parts.push_back("PENDING TAGS:");
+  std::vector<TString> parts; 
+  parts.push_back("PENDING TAGS:"); 
   gpr_mu_lock(cq->mu);
   for (size_t i = 0; i < cq->outstanding_tag_count; i++) {
-    parts.push_back(y_absl::StrFormat(" %p", cq->outstanding_tags[i]));
+    parts.push_back(y_absl::StrFormat(" %p", cq->outstanding_tags[i])); 
   }
   gpr_mu_unlock(cq->mu);
-  gpr_log(GPR_DEBUG, "%s", y_absl::StrJoin(parts, "").c_str());
+  gpr_log(GPR_DEBUG, "%s", y_absl::StrJoin(parts, "").c_str()); 
 }
 #else
 static void dump_pending_tags(grpc_completion_queue* /*cq*/) {}
diff --git a/contrib/libs/grpc/src/core/lib/surface/event_string.cc b/contrib/libs/grpc/src/core/lib/surface/event_string.cc
index d69aac6dee..4af497bad2 100644
--- a/contrib/libs/grpc/src/core/lib/surface/event_string.cc
+++ b/contrib/libs/grpc/src/core/lib/surface/event_string.cc
@@ -22,40 +22,40 @@
 
 #include <stdio.h>
 
-#include <vector>
-
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/str_join.h"
-
+#include <vector> 
+ 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/str_join.h" 
+ 
 #include <grpc/byte_buffer.h>
 #include <grpc/support/string_util.h>
 #include "src/core/lib/gpr/string.h"
 
-static void addhdr(grpc_event* ev, std::vector<TString>* buf) {
-  buf->push_back(y_absl::StrFormat("tag:%p", ev->tag));
+static void addhdr(grpc_event* ev, std::vector<TString>* buf) { 
+  buf->push_back(y_absl::StrFormat("tag:%p", ev->tag)); 
 }
 
 static const char* errstr(int success) { return success ? "OK" : "ERROR"; }
 
-static void adderr(int success, std::vector<TString>* buf) {
-  buf->push_back(y_absl::StrFormat(" %s", errstr(success)));
+static void adderr(int success, std::vector<TString>* buf) { 
+  buf->push_back(y_absl::StrFormat(" %s", errstr(success))); 
 }
 
-TString grpc_event_string(grpc_event* ev) {
-  if (ev == nullptr) return "null";
-  std::vector<TString> out;
+TString grpc_event_string(grpc_event* ev) { 
+  if (ev == nullptr) return "null"; 
+  std::vector<TString> out; 
   switch (ev->type) {
     case GRPC_QUEUE_TIMEOUT:
-      out.push_back("QUEUE_TIMEOUT");
+      out.push_back("QUEUE_TIMEOUT"); 
       break;
     case GRPC_QUEUE_SHUTDOWN:
-      out.push_back("QUEUE_SHUTDOWN");
+      out.push_back("QUEUE_SHUTDOWN"); 
       break;
     case GRPC_OP_COMPLETE:
-      out.push_back("OP_COMPLETE: ");
-      addhdr(ev, &out);
-      adderr(ev->success, &out);
+      out.push_back("OP_COMPLETE: "); 
+      addhdr(ev, &out); 
+      adderr(ev->success, &out); 
       break;
   }
-  return y_absl::StrJoin(out, "");
+  return y_absl::StrJoin(out, ""); 
 }
diff --git a/contrib/libs/grpc/src/core/lib/surface/event_string.h b/contrib/libs/grpc/src/core/lib/surface/event_string.h
index f4ad847b3c..76a0f5152d 100644
--- a/contrib/libs/grpc/src/core/lib/surface/event_string.h
+++ b/contrib/libs/grpc/src/core/lib/surface/event_string.h
@@ -21,11 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <util/generic/string.h>
-
+#include <util/generic/string.h> 
+ 
 #include <grpc/grpc.h>
 
 /* Returns a string describing an event. Must be later freed with gpr_free() */
-TString grpc_event_string(grpc_event* ev);
+TString grpc_event_string(grpc_event* ev); 
 
 #endif /* GRPC_CORE_LIB_SURFACE_EVENT_STRING_H */
diff --git a/contrib/libs/grpc/src/core/lib/surface/init.cc b/contrib/libs/grpc/src/core/lib/surface/init.cc
index 7b79ba426b..41342e84d0 100644
--- a/contrib/libs/grpc/src/core/lib/surface/init.cc
+++ b/contrib/libs/grpc/src/core/lib/surface/init.cc
@@ -18,8 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/surface/init.h"
-
+#include "src/core/lib/surface/init.h" 
+ 
 #include <limits.h>
 #include <memory.h>
 
@@ -28,7 +28,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
-
+ 
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channelz_registry.h"
 #include "src/core/lib/channel/connected_channel.h"
@@ -40,7 +40,7 @@
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/combiner.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/exec_ctx.h" 
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/resource_quota.h"
@@ -105,7 +105,7 @@ static void register_builtin_channel_init() {
                                    GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
                                    append_filter, (void*)&grpc_lame_filter);
   grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL, INT_MAX, prepend_filter,
-                                   (void*)&grpc_core::Server::kServerTopFilter);
+                                   (void*)&grpc_core::Server::kServerTopFilter); 
 }
 
 typedef struct grpc_plugin {
@@ -214,29 +214,29 @@ void grpc_shutdown_internal(void* /*ignored*/) {
 void grpc_shutdown(void) {
   GRPC_API_TRACE("grpc_shutdown(void)", 0, ());
   grpc_core::MutexLock lock(&g_init_mu);
-
+ 
   if (--g_initializations == 0) {
-    grpc_core::ApplicationCallbackExecCtx* acec =
-        grpc_core::ApplicationCallbackExecCtx::Get();
-    if (!grpc_iomgr_is_any_background_poller_thread() &&
-        (acec == nullptr ||
-         (acec->Flags() & GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD) ==
-             0)) {
-      // just run clean-up when this is called on non-executor thread.
-      gpr_log(GPR_DEBUG, "grpc_shutdown starts clean-up now");
-      g_shutting_down = true;
-      grpc_shutdown_internal_locked();
-    } else {
-      // spawn a detached thread to do the actual clean up in case we are
-      // currently in an executor thread.
-      gpr_log(GPR_DEBUG, "grpc_shutdown spawns clean-up thread");
-      g_initializations++;
-      g_shutting_down = true;
-      grpc_core::Thread cleanup_thread(
-          "grpc_shutdown", grpc_shutdown_internal, nullptr, nullptr,
-          grpc_core::Thread::Options().set_joinable(false).set_tracked(false));
-      cleanup_thread.Start();
-    }
+    grpc_core::ApplicationCallbackExecCtx* acec = 
+        grpc_core::ApplicationCallbackExecCtx::Get(); 
+    if (!grpc_iomgr_is_any_background_poller_thread() && 
+        (acec == nullptr || 
+         (acec->Flags() & GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD) == 
+             0)) { 
+      // just run clean-up when this is called on non-executor thread. 
+      gpr_log(GPR_DEBUG, "grpc_shutdown starts clean-up now"); 
+      g_shutting_down = true; 
+      grpc_shutdown_internal_locked(); 
+    } else { 
+      // spawn a detached thread to do the actual clean up in case we are 
+      // currently in an executor thread. 
+      gpr_log(GPR_DEBUG, "grpc_shutdown spawns clean-up thread"); 
+      g_initializations++; 
+      g_shutting_down = true; 
+      grpc_core::Thread cleanup_thread( 
+          "grpc_shutdown", grpc_shutdown_internal, nullptr, nullptr, 
+          grpc_core::Thread::Options().set_joinable(false).set_tracked(false)); 
+      cleanup_thread.Start(); 
+    } 
   }
 }
 
diff --git a/contrib/libs/grpc/src/core/lib/surface/init_secure.cc b/contrib/libs/grpc/src/core/lib/surface/init_secure.cc
index 428c5815c9..4826f12132 100644
--- a/contrib/libs/grpc/src/core/lib/surface/init_secure.cc
+++ b/contrib/libs/grpc/src/core/lib/surface/init_secure.cc
@@ -78,4 +78,4 @@ void grpc_register_security_filters(void) {
                                    maybe_prepend_server_auth_filter, nullptr);
 }
 
-void grpc_security_init() { grpc_core::SecurityRegisterHandshakerFactories(); }
+void grpc_security_init() { grpc_core::SecurityRegisterHandshakerFactories(); } 
diff --git a/contrib/libs/grpc/src/core/lib/surface/server.cc b/contrib/libs/grpc/src/core/lib/surface/server.cc
index 0775c6ee4c..4d5f1a56d5 100644
--- a/contrib/libs/grpc/src/core/lib/surface/server.cc
+++ b/contrib/libs/grpc/src/core/lib/surface/server.cc
@@ -1,18 +1,18 @@
-//
-// 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.
-//
+// 
+// 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. 
+// 
 
 #include <grpc/support/port_platform.h>
 
@@ -22,16 +22,16 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <algorithm>
-#include <atomic>
-#include <iterator>
-#include <list>
-#include <queue>
-#include <utility>
-#include <vector>
-
-#include "y_absl/types/optional.h"
-
+#include <algorithm> 
+#include <atomic> 
+#include <iterator> 
+#include <list> 
+#include <queue> 
+#include <utility> 
+#include <vector> 
+ 
+#include "y_absl/types/optional.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -54,1044 +54,1044 @@
 #include "src/core/lib/transport/metadata.h"
 #include "src/core/lib/transport/static_metadata.h"
 
-namespace grpc_core {
-
-TraceFlag grpc_server_channel_trace(false, "server_channel");
-
-//
-// Server::RequestedCall
-//
-
-struct Server::RequestedCall {
-  enum class Type { BATCH_CALL, REGISTERED_CALL };
-
-  RequestedCall(void* tag_arg, grpc_completion_queue* call_cq,
-                grpc_call** call_arg, grpc_metadata_array* initial_md,
-                grpc_call_details* details)
-      : type(Type::BATCH_CALL),
-        tag(tag_arg),
-        cq_bound_to_call(call_cq),
-        call(call_arg),
-        initial_metadata(initial_md) {
-    details->reserved = nullptr;
-    data.batch.details = details;
-  }
-
-  RequestedCall(void* tag_arg, grpc_completion_queue* call_cq,
-                grpc_call** call_arg, grpc_metadata_array* initial_md,
-                RegisteredMethod* rm, gpr_timespec* deadline,
-                grpc_byte_buffer** optional_payload)
-      : type(Type::REGISTERED_CALL),
-        tag(tag_arg),
-        cq_bound_to_call(call_cq),
-        call(call_arg),
-        initial_metadata(initial_md) {
-    data.registered.method = rm;
-    data.registered.deadline = deadline;
-    data.registered.optional_payload = optional_payload;
-  }
-
-  MultiProducerSingleConsumerQueue::Node mpscq_node;
-  const Type type;
-  void* const tag;
-  grpc_completion_queue* const cq_bound_to_call;
-  grpc_call** const call;
+namespace grpc_core { 
+
+TraceFlag grpc_server_channel_trace(false, "server_channel"); 
+
+// 
+// Server::RequestedCall 
+// 
+
+struct Server::RequestedCall { 
+  enum class Type { BATCH_CALL, REGISTERED_CALL }; 
+ 
+  RequestedCall(void* tag_arg, grpc_completion_queue* call_cq, 
+                grpc_call** call_arg, grpc_metadata_array* initial_md, 
+                grpc_call_details* details) 
+      : type(Type::BATCH_CALL), 
+        tag(tag_arg), 
+        cq_bound_to_call(call_cq), 
+        call(call_arg), 
+        initial_metadata(initial_md) { 
+    details->reserved = nullptr; 
+    data.batch.details = details; 
+  } 
+ 
+  RequestedCall(void* tag_arg, grpc_completion_queue* call_cq, 
+                grpc_call** call_arg, grpc_metadata_array* initial_md, 
+                RegisteredMethod* rm, gpr_timespec* deadline, 
+                grpc_byte_buffer** optional_payload) 
+      : type(Type::REGISTERED_CALL), 
+        tag(tag_arg), 
+        cq_bound_to_call(call_cq), 
+        call(call_arg), 
+        initial_metadata(initial_md) { 
+    data.registered.method = rm; 
+    data.registered.deadline = deadline; 
+    data.registered.optional_payload = optional_payload; 
+  } 
+ 
+  MultiProducerSingleConsumerQueue::Node mpscq_node; 
+  const Type type; 
+  void* const tag; 
+  grpc_completion_queue* const cq_bound_to_call; 
+  grpc_call** const call; 
   grpc_cq_completion completion;
-  grpc_metadata_array* const initial_metadata;
+  grpc_metadata_array* const initial_metadata; 
   union {
     struct {
       grpc_call_details* details;
     } batch;
     struct {
-      RegisteredMethod* method;
+      RegisteredMethod* method; 
       gpr_timespec* deadline;
       grpc_byte_buffer** optional_payload;
     } registered;
   } data;
 };
 
-//
-// Server::RegisteredMethod
-//
-
-struct Server::RegisteredMethod {
-  RegisteredMethod(
-      const char* method_arg, const char* host_arg,
-      grpc_server_register_method_payload_handling payload_handling_arg,
-      uint32_t flags_arg)
-      : method(method_arg == nullptr ? "" : method_arg),
-        host(host_arg == nullptr ? "" : host_arg),
-        payload_handling(payload_handling_arg),
-        flags(flags_arg) {}
-
-  ~RegisteredMethod() = default;
-
-  const TString method;
-  const TString host;
-  const grpc_server_register_method_payload_handling payload_handling;
-  const uint32_t flags;
-  // One request matcher per method.
-  std::unique_ptr<RequestMatcherInterface> matcher;
-};
-
-//
-// Server::RequestMatcherInterface
-//
-
-// RPCs that come in from the transport must be matched against RPC requests
-// from the application. An incoming request from the application can be matched
-// to an RPC that has already arrived or can be queued up for later use.
-// Likewise, an RPC coming in from the transport can either be matched to a
-// request that already arrived from the application or can be queued up for
-// later use (marked pending). If there is a match, the request's tag is posted
-// on the request's notification CQ.
-//
-// RequestMatcherInterface is the base class to provide this functionality.
-class Server::RequestMatcherInterface {
- public:
-  virtual ~RequestMatcherInterface() {}
-
-  // Unref the calls associated with any incoming RPCs in the pending queue (not
-  // yet matched to an application-requested RPC).
-  virtual void ZombifyPending() = 0;
-
-  // Mark all application-requested RPCs failed if they have not been matched to
-  // an incoming RPC. The error parameter indicates why the RPCs are being
-  // failed (always server shutdown in all current implementations).
-  virtual void KillRequests(grpc_error* error) = 0;
-
-  // How many request queues are supported by this matcher. This is an abstract
-  // concept that essentially maps to gRPC completion queues.
-  virtual size_t request_queue_count() const = 0;
-
-  // This function is invoked when the application requests a new RPC whose
-  // information is in the call parameter. The request_queue_index marks the
-  // queue onto which to place this RPC, and is typically associated with a gRPC
-  // CQ. If there are pending RPCs waiting to be matched, publish one (match it
-  // and notify the CQ).
-  virtual void RequestCallWithPossiblePublish(size_t request_queue_index,
-                                              RequestedCall* call) = 0;
-
-  // This function is invoked on an incoming RPC, represented by the calld
-  // object. The RequestMatcher will try to match it against an
-  // application-requested RPC if possible or will place it in the pending queue
-  // otherwise. To enable some measure of fairness between server CQs, the match
-  // is done starting at the start_request_queue_index parameter in a cyclic
-  // order rather than always starting at 0.
-  virtual void MatchOrQueue(size_t start_request_queue_index,
-                            CallData* calld) = 0;
-
-  // Returns the server associated with this request matcher
-  virtual Server* server() const = 0;
-};
-
-// The RealRequestMatcher is an implementation of RequestMatcherInterface that
-// actually uses all the features of RequestMatcherInterface: expecting the
-// application to explicitly request RPCs and then matching those to incoming
-// RPCs, along with a slow path by which incoming RPCs are put on a locked
-// pending list if they aren't able to be matched to an application request.
-class Server::RealRequestMatcher : public RequestMatcherInterface {
- public:
-  explicit RealRequestMatcher(Server* server)
-      : server_(server), requests_per_cq_(server->cqs_.size()) {}
-
-  ~RealRequestMatcher() override {
-    for (LockedMultiProducerSingleConsumerQueue& queue : requests_per_cq_) {
-      GPR_ASSERT(queue.Pop() == nullptr);
-    }
-  }
-
-  void ZombifyPending() override {
-    while (!pending_.empty()) {
-      CallData* calld = pending_.front();
-      calld->SetState(CallData::CallState::ZOMBIED);
-      calld->KillZombie();
-      pending_.pop();
-    }
-  }
-
-  void KillRequests(grpc_error* error) override {
-    for (size_t i = 0; i < requests_per_cq_.size(); i++) {
-      RequestedCall* rc;
-      while ((rc = reinterpret_cast<RequestedCall*>(
-                  requests_per_cq_[i].Pop())) != nullptr) {
-        server_->FailCall(i, rc, GRPC_ERROR_REF(error));
-      }
-    }
-    GRPC_ERROR_UNREF(error);
-  }
-
-  size_t request_queue_count() const override {
-    return requests_per_cq_.size();
-  }
-
-  void RequestCallWithPossiblePublish(size_t request_queue_index,
-                                      RequestedCall* call) override {
-    if (requests_per_cq_[request_queue_index].Push(&call->mpscq_node)) {
-      /* this was the first queued request: we need to lock and start
-         matching calls */
-      struct PendingCall {
-        RequestedCall* rc = nullptr;
-        CallData* calld;
-      };
-      auto pop_next_pending = [this, request_queue_index] {
-        PendingCall pending_call;
-        {
-          MutexLock lock(&server_->mu_call_);
-          if (!pending_.empty()) {
-            pending_call.rc = reinterpret_cast<RequestedCall*>(
-                requests_per_cq_[request_queue_index].Pop());
-            if (pending_call.rc != nullptr) {
-              pending_call.calld = pending_.front();
-              pending_.pop();
-            }
-          }
-        }
-        return pending_call;
-      };
-      while (true) {
-        PendingCall next_pending = pop_next_pending();
-        if (next_pending.rc == nullptr) break;
-        if (!next_pending.calld->MaybeActivate()) {
-          // Zombied Call
-          next_pending.calld->KillZombie();
-        } else {
-          next_pending.calld->Publish(request_queue_index, next_pending.rc);
-        }
-      }
-    }
-  }
-
-  void MatchOrQueue(size_t start_request_queue_index,
-                    CallData* calld) override {
-    for (size_t i = 0; i < requests_per_cq_.size(); i++) {
-      size_t cq_idx = (start_request_queue_index + i) % requests_per_cq_.size();
-      RequestedCall* rc =
-          reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].TryPop());
-      if (rc != nullptr) {
-        GRPC_STATS_INC_SERVER_CQS_CHECKED(i);
-        calld->SetState(CallData::CallState::ACTIVATED);
-        calld->Publish(cq_idx, rc);
-        return;
-      }
-    }
-    // No cq to take the request found; queue it on the slow list.
-    GRPC_STATS_INC_SERVER_SLOWPATH_REQUESTS_QUEUED();
-    // We need to ensure that all the queues are empty.  We do this under
-    // the server mu_call_ lock to ensure that if something is added to
-    // an empty request queue, it will block until the call is actually
-    // added to the pending list.
-    RequestedCall* rc = nullptr;
-    size_t cq_idx = 0;
-    size_t loop_count;
-    {
-      MutexLock lock(&server_->mu_call_);
-      for (loop_count = 0; loop_count < requests_per_cq_.size(); loop_count++) {
-        cq_idx =
-            (start_request_queue_index + loop_count) % requests_per_cq_.size();
-        rc = reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].Pop());
-        if (rc != nullptr) {
-          break;
-        }
-      }
-      if (rc == nullptr) {
-        calld->SetState(CallData::CallState::PENDING);
-        pending_.push(calld);
-        return;
-      }
-    }
-    GRPC_STATS_INC_SERVER_CQS_CHECKED(loop_count + requests_per_cq_.size());
-    calld->SetState(CallData::CallState::ACTIVATED);
-    calld->Publish(cq_idx, rc);
-  }
-
-  Server* server() const override { return server_; }
-
- private:
-  Server* const server_;
-  std::queue<CallData*> pending_;
-  std::vector<LockedMultiProducerSingleConsumerQueue> requests_per_cq_;
-};
-
-// AllocatingRequestMatchers don't allow the application to request an RPC in
-// advance or queue up any incoming RPC for later match. Instead, MatchOrQueue
-// will call out to an allocation function passed in at the construction of the
-// object. These request matchers are designed for the C++ callback API, so they
-// only support 1 completion queue (passed in at the constructor).
-class Server::AllocatingRequestMatcherBase : public RequestMatcherInterface {
- public:
-  AllocatingRequestMatcherBase(Server* server, grpc_completion_queue* cq)
-      : server_(server), cq_(cq) {
-    size_t idx;
-    for (idx = 0; idx < server->cqs_.size(); idx++) {
-      if (server->cqs_[idx] == cq) {
-        break;
-      }
-    }
-    GPR_ASSERT(idx < server->cqs_.size());
-    cq_idx_ = idx;
-  }
-
-  void ZombifyPending() override {}
-
-  void KillRequests(grpc_error* error) override { GRPC_ERROR_UNREF(error); }
-
-  size_t request_queue_count() const override { return 0; }
-
-  void RequestCallWithPossiblePublish(size_t /*request_queue_index*/,
-                                      RequestedCall* /*call*/) final {
-    GPR_ASSERT(false);
-  }
-
-  Server* server() const override { return server_; }
-
-  // Supply the completion queue related to this request matcher
-  grpc_completion_queue* cq() const { return cq_; }
-
-  // Supply the completion queue's index relative to the server.
-  size_t cq_idx() const { return cq_idx_; }
-
- private:
-  Server* const server_;
-  grpc_completion_queue* const cq_;
-  size_t cq_idx_;
-};
-
-// An allocating request matcher for non-registered methods (used for generic
-// API and unimplemented RPCs).
-class Server::AllocatingRequestMatcherBatch
-    : public AllocatingRequestMatcherBase {
- public:
-  AllocatingRequestMatcherBatch(Server* server, grpc_completion_queue* cq,
-                                std::function<BatchCallAllocation()> allocator)
-      : AllocatingRequestMatcherBase(server, cq),
-        allocator_(std::move(allocator)) {}
-
-  void MatchOrQueue(size_t /*start_request_queue_index*/,
-                    CallData* calld) override {
-    BatchCallAllocation call_info = allocator_();
-    GPR_ASSERT(server()->ValidateServerRequest(
-                   cq(), static_cast<void*>(call_info.tag), nullptr, nullptr) ==
-               GRPC_CALL_OK);
-    RequestedCall* rc = new RequestedCall(
-        static_cast<void*>(call_info.tag), cq(), call_info.call,
-        call_info.initial_metadata, call_info.details);
-    calld->SetState(CallData::CallState::ACTIVATED);
-    calld->Publish(cq_idx(), rc);
-  }
-
- private:
-  std::function<BatchCallAllocation()> allocator_;
-};
-
-// An allocating request matcher for registered methods.
-class Server::AllocatingRequestMatcherRegistered
-    : public AllocatingRequestMatcherBase {
- public:
-  AllocatingRequestMatcherRegistered(
-      Server* server, grpc_completion_queue* cq, RegisteredMethod* rm,
-      std::function<RegisteredCallAllocation()> allocator)
-      : AllocatingRequestMatcherBase(server, cq),
-        registered_method_(rm),
-        allocator_(std::move(allocator)) {}
-
-  void MatchOrQueue(size_t /*start_request_queue_index*/,
-                    CallData* calld) override {
-    RegisteredCallAllocation call_info = allocator_();
-    GPR_ASSERT(
-        server()->ValidateServerRequest(cq(), static_cast<void*>(call_info.tag),
-                                        call_info.optional_payload,
-                                        registered_method_) == GRPC_CALL_OK);
-    RequestedCall* rc = new RequestedCall(
-        static_cast<void*>(call_info.tag), cq(), call_info.call,
-        call_info.initial_metadata, registered_method_, call_info.deadline,
-        call_info.optional_payload);
-    calld->SetState(CallData::CallState::ACTIVATED);
-    calld->Publish(cq_idx(), rc);
-  }
-
- private:
-  RegisteredMethod* const registered_method_;
-  std::function<RegisteredCallAllocation()> allocator_;
-};
-
-//
-// ChannelBroadcaster
-//
-
-namespace {
-
-class ChannelBroadcaster {
- public:
-  // This can have an empty constructor and destructor since we want to control
-  // when the actual setup and shutdown broadcast take place.
-
-  // Copies over the channels from the locked server.
-  void FillChannelsLocked(std::vector<grpc_channel*> channels) {
-    GPR_DEBUG_ASSERT(channels_.empty());
-    channels_ = std::move(channels);
-  }
-
-  // Broadcasts a shutdown on each channel.
-  void BroadcastShutdown(bool send_goaway, grpc_error* force_disconnect) {
-    for (grpc_channel* channel : channels_) {
-      SendShutdown(channel, send_goaway, GRPC_ERROR_REF(force_disconnect));
-      GRPC_CHANNEL_INTERNAL_UNREF(channel, "broadcast");
-    }
-    channels_.clear();  // just for safety against double broadcast
-    GRPC_ERROR_UNREF(force_disconnect);
-  }
-
- private:
-  struct ShutdownCleanupArgs {
-    grpc_closure closure;
-    grpc_slice slice;
-  };
-
-  static void ShutdownCleanup(void* arg, grpc_error* /*error*/) {
-    ShutdownCleanupArgs* a = static_cast<ShutdownCleanupArgs*>(arg);
-    grpc_slice_unref_internal(a->slice);
-    delete a;
-  }
-
-  static void SendShutdown(grpc_channel* channel, bool send_goaway,
-                           grpc_error* send_disconnect) {
-    ShutdownCleanupArgs* sc = new ShutdownCleanupArgs;
-    GRPC_CLOSURE_INIT(&sc->closure, ShutdownCleanup, sc,
-                      grpc_schedule_on_exec_ctx);
-    grpc_transport_op* op = grpc_make_transport_op(&sc->closure);
-    grpc_channel_element* elem;
-    op->goaway_error =
-        send_goaway
-            ? grpc_error_set_int(
-                  GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server shutdown"),
-                  GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_OK)
-            : GRPC_ERROR_NONE;
-    op->set_accept_stream = true;
-    sc->slice = grpc_slice_from_copied_string("Server shutdown");
-    op->disconnect_with_error = send_disconnect;
-    elem =
-        grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
-    elem->filter->start_transport_op(elem, op);
-  }
-
-  std::vector<grpc_channel*> channels_;
-};
-
-}  // namespace
-
-//
-// Server
-//
-
-const grpc_channel_filter Server::kServerTopFilter = {
-    Server::CallData::StartTransportStreamOpBatch,
-    grpc_channel_next_op,
-    sizeof(Server::CallData),
-    Server::CallData::InitCallElement,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    Server::CallData::DestroyCallElement,
-    sizeof(Server::ChannelData),
-    Server::ChannelData::InitChannelElement,
-    Server::ChannelData::DestroyChannelElement,
-    grpc_channel_next_get_info,
-    "server",
-};
-
-namespace {
-
-grpc_resource_user* CreateDefaultResourceUser(const grpc_channel_args* args) {
-  if (args != nullptr) {
-    grpc_resource_quota* resource_quota =
-        grpc_resource_quota_from_channel_args(args, false /* create */);
-    if (resource_quota != nullptr) {
-      return grpc_resource_user_create(resource_quota, "default");
-    }
-  }
-  return nullptr;
-}
-
-RefCountedPtr<channelz::ServerNode> CreateChannelzNode(
-    Server* server, const grpc_channel_args* args) {
-  RefCountedPtr<channelz::ServerNode> channelz_node;
-  if (grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_CHANNELZ,
-                                  GRPC_ENABLE_CHANNELZ_DEFAULT)) {
-    size_t channel_tracer_max_memory = grpc_channel_args_find_integer(
-        args, GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE,
-        {GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT, 0, INT_MAX});
-    channelz_node =
-        MakeRefCounted<channelz::ServerNode>(channel_tracer_max_memory);
-    channelz_node->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string("Server created"));
-  }
-  return channelz_node;
-}
-
-}  // namespace
-
-Server::Server(const grpc_channel_args* args)
-    : channel_args_(grpc_channel_args_copy(args)),
-      default_resource_user_(CreateDefaultResourceUser(args)),
-      channelz_node_(CreateChannelzNode(this, args)) {}
-
-Server::~Server() {
-  grpc_channel_args_destroy(channel_args_);
-  for (size_t i = 0; i < cqs_.size(); i++) {
-    GRPC_CQ_INTERNAL_UNREF(cqs_[i], "server");
-  }
-}
-
-void Server::AddListener(OrphanablePtr<ListenerInterface> listener) {
-  channelz::ListenSocketNode* listen_socket_node =
-      listener->channelz_listen_socket_node();
-  if (listen_socket_node != nullptr && channelz_node_ != nullptr) {
-    channelz_node_->AddChildListenSocket(listen_socket_node->Ref());
-  }
-  listeners_.emplace_back(std::move(listener));
-}
-
-void Server::Start() {
-  started_ = true;
-  for (grpc_completion_queue* cq : cqs_) {
-    if (grpc_cq_can_listen(cq)) {
-      pollsets_.push_back(grpc_cq_pollset(cq));
-    }
-  }
-  if (unregistered_request_matcher_ == nullptr) {
-    unregistered_request_matcher_ = y_absl::make_unique<RealRequestMatcher>(this);
-  }
-  for (std::unique_ptr<RegisteredMethod>& rm : registered_methods_) {
-    if (rm->matcher == nullptr) {
-      rm->matcher = y_absl::make_unique<RealRequestMatcher>(this);
+// 
+// Server::RegisteredMethod 
+// 
+
+struct Server::RegisteredMethod { 
+  RegisteredMethod( 
+      const char* method_arg, const char* host_arg, 
+      grpc_server_register_method_payload_handling payload_handling_arg, 
+      uint32_t flags_arg) 
+      : method(method_arg == nullptr ? "" : method_arg), 
+        host(host_arg == nullptr ? "" : host_arg), 
+        payload_handling(payload_handling_arg), 
+        flags(flags_arg) {} 
+
+  ~RegisteredMethod() = default; 
+
+  const TString method; 
+  const TString host; 
+  const grpc_server_register_method_payload_handling payload_handling; 
+  const uint32_t flags; 
+  // One request matcher per method. 
+  std::unique_ptr<RequestMatcherInterface> matcher; 
+}; 
+
+// 
+// Server::RequestMatcherInterface 
+// 
+
+// RPCs that come in from the transport must be matched against RPC requests 
+// from the application. An incoming request from the application can be matched 
+// to an RPC that has already arrived or can be queued up for later use. 
+// Likewise, an RPC coming in from the transport can either be matched to a 
+// request that already arrived from the application or can be queued up for 
+// later use (marked pending). If there is a match, the request's tag is posted 
+// on the request's notification CQ. 
+// 
+// RequestMatcherInterface is the base class to provide this functionality. 
+class Server::RequestMatcherInterface { 
+ public: 
+  virtual ~RequestMatcherInterface() {} 
+ 
+  // Unref the calls associated with any incoming RPCs in the pending queue (not 
+  // yet matched to an application-requested RPC). 
+  virtual void ZombifyPending() = 0; 
+ 
+  // Mark all application-requested RPCs failed if they have not been matched to 
+  // an incoming RPC. The error parameter indicates why the RPCs are being 
+  // failed (always server shutdown in all current implementations). 
+  virtual void KillRequests(grpc_error* error) = 0; 
+ 
+  // How many request queues are supported by this matcher. This is an abstract 
+  // concept that essentially maps to gRPC completion queues. 
+  virtual size_t request_queue_count() const = 0; 
+ 
+  // This function is invoked when the application requests a new RPC whose 
+  // information is in the call parameter. The request_queue_index marks the 
+  // queue onto which to place this RPC, and is typically associated with a gRPC 
+  // CQ. If there are pending RPCs waiting to be matched, publish one (match it 
+  // and notify the CQ). 
+  virtual void RequestCallWithPossiblePublish(size_t request_queue_index, 
+                                              RequestedCall* call) = 0; 
+ 
+  // This function is invoked on an incoming RPC, represented by the calld 
+  // object. The RequestMatcher will try to match it against an 
+  // application-requested RPC if possible or will place it in the pending queue 
+  // otherwise. To enable some measure of fairness between server CQs, the match 
+  // is done starting at the start_request_queue_index parameter in a cyclic 
+  // order rather than always starting at 0. 
+  virtual void MatchOrQueue(size_t start_request_queue_index, 
+                            CallData* calld) = 0; 
+ 
+  // Returns the server associated with this request matcher 
+  virtual Server* server() const = 0; 
+}; 
+ 
+// The RealRequestMatcher is an implementation of RequestMatcherInterface that 
+// actually uses all the features of RequestMatcherInterface: expecting the 
+// application to explicitly request RPCs and then matching those to incoming 
+// RPCs, along with a slow path by which incoming RPCs are put on a locked 
+// pending list if they aren't able to be matched to an application request. 
+class Server::RealRequestMatcher : public RequestMatcherInterface { 
+ public: 
+  explicit RealRequestMatcher(Server* server) 
+      : server_(server), requests_per_cq_(server->cqs_.size()) {} 
+ 
+  ~RealRequestMatcher() override { 
+    for (LockedMultiProducerSingleConsumerQueue& queue : requests_per_cq_) { 
+      GPR_ASSERT(queue.Pop() == nullptr); 
+    } 
+  }
+
+  void ZombifyPending() override { 
+    while (!pending_.empty()) { 
+      CallData* calld = pending_.front(); 
+      calld->SetState(CallData::CallState::ZOMBIED); 
+      calld->KillZombie(); 
+      pending_.pop(); 
+    } 
+  }
+
+  void KillRequests(grpc_error* error) override { 
+    for (size_t i = 0; i < requests_per_cq_.size(); i++) { 
+      RequestedCall* rc; 
+      while ((rc = reinterpret_cast<RequestedCall*>( 
+                  requests_per_cq_[i].Pop())) != nullptr) { 
+        server_->FailCall(i, rc, GRPC_ERROR_REF(error)); 
+      } 
+    } 
+    GRPC_ERROR_UNREF(error); 
+  } 
+
+  size_t request_queue_count() const override { 
+    return requests_per_cq_.size(); 
+  }
+
+  void RequestCallWithPossiblePublish(size_t request_queue_index, 
+                                      RequestedCall* call) override { 
+    if (requests_per_cq_[request_queue_index].Push(&call->mpscq_node)) { 
+      /* this was the first queued request: we need to lock and start 
+         matching calls */ 
+      struct PendingCall { 
+        RequestedCall* rc = nullptr; 
+        CallData* calld; 
+      }; 
+      auto pop_next_pending = [this, request_queue_index] { 
+        PendingCall pending_call; 
+        { 
+          MutexLock lock(&server_->mu_call_); 
+          if (!pending_.empty()) { 
+            pending_call.rc = reinterpret_cast<RequestedCall*>( 
+                requests_per_cq_[request_queue_index].Pop()); 
+            if (pending_call.rc != nullptr) { 
+              pending_call.calld = pending_.front(); 
+              pending_.pop(); 
+            } 
+          } 
+        } 
+        return pending_call; 
+      }; 
+      while (true) { 
+        PendingCall next_pending = pop_next_pending(); 
+        if (next_pending.rc == nullptr) break; 
+        if (!next_pending.calld->MaybeActivate()) { 
+          // Zombied Call 
+          next_pending.calld->KillZombie(); 
+        } else { 
+          next_pending.calld->Publish(request_queue_index, next_pending.rc); 
+        } 
+      } 
     }
   }
-  {
-    MutexLock lock(&mu_global_);
-    starting_ = true;
-  }
-  for (auto& listener : listeners_) {
-    listener.listener->Start(this, &pollsets_);
-  }
-  MutexLock lock(&mu_global_);
-  starting_ = false;
-  starting_cv_.Signal();
-}
 
-void Server::SetupTransport(
-    grpc_transport* transport, grpc_pollset* accepting_pollset,
-    const grpc_channel_args* args,
-    const RefCountedPtr<grpc_core::channelz::SocketNode>& socket_node,
-    grpc_resource_user* resource_user) {
-  // Create channel.
-  grpc_channel* channel = grpc_channel_create(
-      nullptr, args, GRPC_SERVER_CHANNEL, transport, resource_user);
-  ChannelData* chand = static_cast<ChannelData*>(
-      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0)
-          ->channel_data);
-  // Set up CQs.
-  size_t cq_idx;
-  for (cq_idx = 0; cq_idx < cqs_.size(); cq_idx++) {
-    if (grpc_cq_pollset(cqs_[cq_idx]) == accepting_pollset) break;
-  }
-  if (cq_idx == cqs_.size()) {
-    // Completion queue not found.  Pick a random one to publish new calls to.
-    cq_idx = static_cast<size_t>(rand()) % cqs_.size();
-  }
-  // Set up channelz node.
-  intptr_t channelz_socket_uuid = 0;
-  if (socket_node != nullptr) {
-    channelz_socket_uuid = socket_node->uuid();
-    channelz_node_->AddChildSocket(socket_node);
-  }
-  // Initialize chand.
-  chand->InitTransport(Ref(), channel, cq_idx, transport, channelz_socket_uuid);
+  void MatchOrQueue(size_t start_request_queue_index, 
+                    CallData* calld) override { 
+    for (size_t i = 0; i < requests_per_cq_.size(); i++) { 
+      size_t cq_idx = (start_request_queue_index + i) % requests_per_cq_.size(); 
+      RequestedCall* rc = 
+          reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].TryPop()); 
+      if (rc != nullptr) { 
+        GRPC_STATS_INC_SERVER_CQS_CHECKED(i); 
+        calld->SetState(CallData::CallState::ACTIVATED); 
+        calld->Publish(cq_idx, rc); 
+        return; 
+      } 
+    } 
+    // No cq to take the request found; queue it on the slow list. 
+    GRPC_STATS_INC_SERVER_SLOWPATH_REQUESTS_QUEUED(); 
+    // We need to ensure that all the queues are empty.  We do this under 
+    // the server mu_call_ lock to ensure that if something is added to 
+    // an empty request queue, it will block until the call is actually 
+    // added to the pending list. 
+    RequestedCall* rc = nullptr; 
+    size_t cq_idx = 0; 
+    size_t loop_count; 
+    { 
+      MutexLock lock(&server_->mu_call_); 
+      for (loop_count = 0; loop_count < requests_per_cq_.size(); loop_count++) { 
+        cq_idx = 
+            (start_request_queue_index + loop_count) % requests_per_cq_.size(); 
+        rc = reinterpret_cast<RequestedCall*>(requests_per_cq_[cq_idx].Pop()); 
+        if (rc != nullptr) { 
+          break; 
+        } 
+      } 
+      if (rc == nullptr) { 
+        calld->SetState(CallData::CallState::PENDING); 
+        pending_.push(calld); 
+        return; 
+      } 
+    } 
+    GRPC_STATS_INC_SERVER_CQS_CHECKED(loop_count + requests_per_cq_.size()); 
+    calld->SetState(CallData::CallState::ACTIVATED); 
+    calld->Publish(cq_idx, rc); 
+  } 
+ 
+  Server* server() const override { return server_; } 
+ 
+ private: 
+  Server* const server_; 
+  std::queue<CallData*> pending_; 
+  std::vector<LockedMultiProducerSingleConsumerQueue> requests_per_cq_; 
+}; 
+ 
+// AllocatingRequestMatchers don't allow the application to request an RPC in 
+// advance or queue up any incoming RPC for later match. Instead, MatchOrQueue 
+// will call out to an allocation function passed in at the construction of the 
+// object. These request matchers are designed for the C++ callback API, so they 
+// only support 1 completion queue (passed in at the constructor). 
+class Server::AllocatingRequestMatcherBase : public RequestMatcherInterface { 
+ public: 
+  AllocatingRequestMatcherBase(Server* server, grpc_completion_queue* cq) 
+      : server_(server), cq_(cq) { 
+    size_t idx; 
+    for (idx = 0; idx < server->cqs_.size(); idx++) { 
+      if (server->cqs_[idx] == cq) { 
+        break; 
+      } 
+    } 
+    GPR_ASSERT(idx < server->cqs_.size()); 
+    cq_idx_ = idx; 
+  } 
+ 
+  void ZombifyPending() override {} 
+ 
+  void KillRequests(grpc_error* error) override { GRPC_ERROR_UNREF(error); } 
+ 
+  size_t request_queue_count() const override { return 0; } 
+ 
+  void RequestCallWithPossiblePublish(size_t /*request_queue_index*/, 
+                                      RequestedCall* /*call*/) final { 
+    GPR_ASSERT(false); 
+  } 
+ 
+  Server* server() const override { return server_; } 
+ 
+  // Supply the completion queue related to this request matcher 
+  grpc_completion_queue* cq() const { return cq_; } 
+ 
+  // Supply the completion queue's index relative to the server. 
+  size_t cq_idx() const { return cq_idx_; } 
+ 
+ private: 
+  Server* const server_; 
+  grpc_completion_queue* const cq_; 
+  size_t cq_idx_; 
+}; 
+ 
+// An allocating request matcher for non-registered methods (used for generic 
+// API and unimplemented RPCs). 
+class Server::AllocatingRequestMatcherBatch 
+    : public AllocatingRequestMatcherBase { 
+ public: 
+  AllocatingRequestMatcherBatch(Server* server, grpc_completion_queue* cq, 
+                                std::function<BatchCallAllocation()> allocator) 
+      : AllocatingRequestMatcherBase(server, cq), 
+        allocator_(std::move(allocator)) {} 
+ 
+  void MatchOrQueue(size_t /*start_request_queue_index*/, 
+                    CallData* calld) override { 
+    BatchCallAllocation call_info = allocator_(); 
+    GPR_ASSERT(server()->ValidateServerRequest( 
+                   cq(), static_cast<void*>(call_info.tag), nullptr, nullptr) == 
+               GRPC_CALL_OK); 
+    RequestedCall* rc = new RequestedCall( 
+        static_cast<void*>(call_info.tag), cq(), call_info.call, 
+        call_info.initial_metadata, call_info.details); 
+    calld->SetState(CallData::CallState::ACTIVATED); 
+    calld->Publish(cq_idx(), rc); 
+  } 
+ 
+ private: 
+  std::function<BatchCallAllocation()> allocator_; 
+}; 
+ 
+// An allocating request matcher for registered methods. 
+class Server::AllocatingRequestMatcherRegistered 
+    : public AllocatingRequestMatcherBase { 
+ public: 
+  AllocatingRequestMatcherRegistered( 
+      Server* server, grpc_completion_queue* cq, RegisteredMethod* rm, 
+      std::function<RegisteredCallAllocation()> allocator) 
+      : AllocatingRequestMatcherBase(server, cq), 
+        registered_method_(rm), 
+        allocator_(std::move(allocator)) {} 
+ 
+  void MatchOrQueue(size_t /*start_request_queue_index*/, 
+                    CallData* calld) override { 
+    RegisteredCallAllocation call_info = allocator_(); 
+    GPR_ASSERT( 
+        server()->ValidateServerRequest(cq(), static_cast<void*>(call_info.tag), 
+                                        call_info.optional_payload, 
+                                        registered_method_) == GRPC_CALL_OK); 
+    RequestedCall* rc = new RequestedCall( 
+        static_cast<void*>(call_info.tag), cq(), call_info.call, 
+        call_info.initial_metadata, registered_method_, call_info.deadline, 
+        call_info.optional_payload); 
+    calld->SetState(CallData::CallState::ACTIVATED); 
+    calld->Publish(cq_idx(), rc); 
+  } 
+ 
+ private: 
+  RegisteredMethod* const registered_method_; 
+  std::function<RegisteredCallAllocation()> allocator_; 
+}; 
+ 
+// 
+// ChannelBroadcaster 
+// 
+
+namespace { 
+
+class ChannelBroadcaster { 
+ public: 
+  // This can have an empty constructor and destructor since we want to control 
+  // when the actual setup and shutdown broadcast take place. 
+ 
+  // Copies over the channels from the locked server. 
+  void FillChannelsLocked(std::vector<grpc_channel*> channels) { 
+    GPR_DEBUG_ASSERT(channels_.empty()); 
+    channels_ = std::move(channels); 
+  }
+ 
+  // Broadcasts a shutdown on each channel. 
+  void BroadcastShutdown(bool send_goaway, grpc_error* force_disconnect) { 
+    for (grpc_channel* channel : channels_) { 
+      SendShutdown(channel, send_goaway, GRPC_ERROR_REF(force_disconnect)); 
+      GRPC_CHANNEL_INTERNAL_UNREF(channel, "broadcast"); 
+    } 
+    channels_.clear();  // just for safety against double broadcast 
+    GRPC_ERROR_UNREF(force_disconnect); 
+  }
+ 
+ private: 
+  struct ShutdownCleanupArgs { 
+    grpc_closure closure; 
+    grpc_slice slice; 
+  }; 
+ 
+  static void ShutdownCleanup(void* arg, grpc_error* /*error*/) { 
+    ShutdownCleanupArgs* a = static_cast<ShutdownCleanupArgs*>(arg); 
+    grpc_slice_unref_internal(a->slice); 
+    delete a; 
+  } 
+ 
+  static void SendShutdown(grpc_channel* channel, bool send_goaway, 
+                           grpc_error* send_disconnect) { 
+    ShutdownCleanupArgs* sc = new ShutdownCleanupArgs; 
+    GRPC_CLOSURE_INIT(&sc->closure, ShutdownCleanup, sc, 
+                      grpc_schedule_on_exec_ctx); 
+    grpc_transport_op* op = grpc_make_transport_op(&sc->closure); 
+    grpc_channel_element* elem; 
+    op->goaway_error = 
+        send_goaway 
+            ? grpc_error_set_int( 
+                  GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server shutdown"), 
+                  GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_OK) 
+            : GRPC_ERROR_NONE; 
+    op->set_accept_stream = true; 
+    sc->slice = grpc_slice_from_copied_string("Server shutdown"); 
+    op->disconnect_with_error = send_disconnect; 
+    elem = 
+        grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0); 
+    elem->filter->start_transport_op(elem, op); 
+  } 
+ 
+  std::vector<grpc_channel*> channels_; 
+}; 
+ 
+}  // namespace 
+ 
+// 
+// Server 
+// 
+ 
+const grpc_channel_filter Server::kServerTopFilter = { 
+    Server::CallData::StartTransportStreamOpBatch, 
+    grpc_channel_next_op, 
+    sizeof(Server::CallData), 
+    Server::CallData::InitCallElement, 
+    grpc_call_stack_ignore_set_pollset_or_pollset_set, 
+    Server::CallData::DestroyCallElement, 
+    sizeof(Server::ChannelData), 
+    Server::ChannelData::InitChannelElement, 
+    Server::ChannelData::DestroyChannelElement, 
+    grpc_channel_next_get_info, 
+    "server", 
+}; 
+ 
+namespace { 
+ 
+grpc_resource_user* CreateDefaultResourceUser(const grpc_channel_args* args) { 
+  if (args != nullptr) { 
+    grpc_resource_quota* resource_quota = 
+        grpc_resource_quota_from_channel_args(args, false /* create */); 
+    if (resource_quota != nullptr) { 
+      return grpc_resource_user_create(resource_quota, "default"); 
+    } 
+  } 
+  return nullptr; 
 }
 
-bool Server::HasOpenConnections() {
-  MutexLock lock(&mu_global_);
-  return !channels_.empty();
+RefCountedPtr<channelz::ServerNode> CreateChannelzNode( 
+    Server* server, const grpc_channel_args* args) { 
+  RefCountedPtr<channelz::ServerNode> channelz_node; 
+  if (grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_CHANNELZ, 
+                                  GRPC_ENABLE_CHANNELZ_DEFAULT)) { 
+    size_t channel_tracer_max_memory = grpc_channel_args_find_integer( 
+        args, GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE, 
+        {GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT, 0, INT_MAX}); 
+    channelz_node = 
+        MakeRefCounted<channelz::ServerNode>(channel_tracer_max_memory); 
+    channelz_node->AddTraceEvent( 
+        channelz::ChannelTrace::Severity::Info, 
+        grpc_slice_from_static_string("Server created")); 
+  }
+  return channelz_node; 
 }
 
-void Server::SetRegisteredMethodAllocator(
-    grpc_completion_queue* cq, void* method_tag,
-    std::function<RegisteredCallAllocation()> allocator) {
-  RegisteredMethod* rm = static_cast<RegisteredMethod*>(method_tag);
-  rm->matcher = y_absl::make_unique<AllocatingRequestMatcherRegistered>(
-      this, cq, rm, std::move(allocator));
+}  // namespace 
+
+Server::Server(const grpc_channel_args* args) 
+    : channel_args_(grpc_channel_args_copy(args)), 
+      default_resource_user_(CreateDefaultResourceUser(args)), 
+      channelz_node_(CreateChannelzNode(this, args)) {} 
+ 
+Server::~Server() { 
+  grpc_channel_args_destroy(channel_args_); 
+  for (size_t i = 0; i < cqs_.size(); i++) { 
+    GRPC_CQ_INTERNAL_UNREF(cqs_[i], "server"); 
+  } 
 }
 
-void Server::SetBatchMethodAllocator(
-    grpc_completion_queue* cq, std::function<BatchCallAllocation()> allocator) {
-  GPR_DEBUG_ASSERT(unregistered_request_matcher_ == nullptr);
-  unregistered_request_matcher_ =
-      y_absl::make_unique<AllocatingRequestMatcherBatch>(this, cq,
-                                                       std::move(allocator));
+void Server::AddListener(OrphanablePtr<ListenerInterface> listener) { 
+  channelz::ListenSocketNode* listen_socket_node = 
+      listener->channelz_listen_socket_node(); 
+  if (listen_socket_node != nullptr && channelz_node_ != nullptr) { 
+    channelz_node_->AddChildListenSocket(listen_socket_node->Ref()); 
+  } 
+  listeners_.emplace_back(std::move(listener)); 
 }
 
-void Server::RegisterCompletionQueue(grpc_completion_queue* cq) {
-  for (grpc_completion_queue* queue : cqs_) {
-    if (queue == cq) return;
-  }
-  GRPC_CQ_INTERNAL_REF(cq, "server");
-  cqs_.push_back(cq);
+void Server::Start() { 
+  started_ = true; 
+  for (grpc_completion_queue* cq : cqs_) { 
+    if (grpc_cq_can_listen(cq)) { 
+      pollsets_.push_back(grpc_cq_pollset(cq)); 
+    } 
+  } 
+  if (unregistered_request_matcher_ == nullptr) { 
+    unregistered_request_matcher_ = y_absl::make_unique<RealRequestMatcher>(this); 
+  } 
+  for (std::unique_ptr<RegisteredMethod>& rm : registered_methods_) { 
+    if (rm->matcher == nullptr) { 
+      rm->matcher = y_absl::make_unique<RealRequestMatcher>(this); 
+    } 
+  } 
+  { 
+    MutexLock lock(&mu_global_); 
+    starting_ = true; 
+  } 
+  for (auto& listener : listeners_) { 
+    listener.listener->Start(this, &pollsets_); 
+  } 
+  MutexLock lock(&mu_global_); 
+  starting_ = false; 
+  starting_cv_.Signal(); 
+} 
+
+void Server::SetupTransport( 
+    grpc_transport* transport, grpc_pollset* accepting_pollset, 
+    const grpc_channel_args* args, 
+    const RefCountedPtr<grpc_core::channelz::SocketNode>& socket_node, 
+    grpc_resource_user* resource_user) { 
+  // Create channel. 
+  grpc_channel* channel = grpc_channel_create( 
+      nullptr, args, GRPC_SERVER_CHANNEL, transport, resource_user); 
+  ChannelData* chand = static_cast<ChannelData*>( 
+      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0) 
+          ->channel_data); 
+  // Set up CQs. 
+  size_t cq_idx; 
+  for (cq_idx = 0; cq_idx < cqs_.size(); cq_idx++) { 
+    if (grpc_cq_pollset(cqs_[cq_idx]) == accepting_pollset) break; 
+  }
+  if (cq_idx == cqs_.size()) { 
+    // Completion queue not found.  Pick a random one to publish new calls to. 
+    cq_idx = static_cast<size_t>(rand()) % cqs_.size(); 
+  } 
+  // Set up channelz node. 
+  intptr_t channelz_socket_uuid = 0; 
+  if (socket_node != nullptr) { 
+    channelz_socket_uuid = socket_node->uuid(); 
+    channelz_node_->AddChildSocket(socket_node); 
+  } 
+  // Initialize chand. 
+  chand->InitTransport(Ref(), channel, cq_idx, transport, channelz_socket_uuid); 
+} 
+
+bool Server::HasOpenConnections() { 
+  MutexLock lock(&mu_global_); 
+  return !channels_.empty(); 
 }
 
-namespace {
-
-bool streq(const TString& a, const char* b) {
-  return (a.empty() && b == nullptr) ||
-         ((b != nullptr) && !strcmp(a.c_str(), b));
+void Server::SetRegisteredMethodAllocator( 
+    grpc_completion_queue* cq, void* method_tag, 
+    std::function<RegisteredCallAllocation()> allocator) { 
+  RegisteredMethod* rm = static_cast<RegisteredMethod*>(method_tag); 
+  rm->matcher = y_absl::make_unique<AllocatingRequestMatcherRegistered>( 
+      this, cq, rm, std::move(allocator)); 
 }
 
-}  // namespace
-
-Server::RegisteredMethod* Server::RegisterMethod(
-    const char* method, const char* host,
-    grpc_server_register_method_payload_handling payload_handling,
-    uint32_t flags) {
-  if (!method) {
-    gpr_log(GPR_ERROR,
-            "grpc_server_register_method method string cannot be NULL");
-    return nullptr;
-  }
-  for (std::unique_ptr<RegisteredMethod>& m : registered_methods_) {
-    if (streq(m->method, method) && streq(m->host, host)) {
-      gpr_log(GPR_ERROR, "duplicate registration for %s@%s", method,
-              host ? host : "*");
-      return nullptr;
-    }
-  }
-  if ((flags & ~GRPC_INITIAL_METADATA_USED_MASK) != 0) {
-    gpr_log(GPR_ERROR, "grpc_server_register_method invalid flags 0x%08x",
-            flags);
-    return nullptr;
-  }
-  registered_methods_.emplace_back(y_absl::make_unique<RegisteredMethod>(
-      method, host, payload_handling, flags));
-  return registered_methods_.back().get();
-}
-
-void Server::DoneRequestEvent(void* req, grpc_cq_completion* /*c*/) {
-  delete static_cast<RequestedCall*>(req);
+void Server::SetBatchMethodAllocator( 
+    grpc_completion_queue* cq, std::function<BatchCallAllocation()> allocator) { 
+  GPR_DEBUG_ASSERT(unregistered_request_matcher_ == nullptr); 
+  unregistered_request_matcher_ = 
+      y_absl::make_unique<AllocatingRequestMatcherBatch>(this, cq, 
+                                                       std::move(allocator)); 
+} 
+ 
+void Server::RegisterCompletionQueue(grpc_completion_queue* cq) { 
+  for (grpc_completion_queue* queue : cqs_) { 
+    if (queue == cq) return; 
+  }
+  GRPC_CQ_INTERNAL_REF(cq, "server"); 
+  cqs_.push_back(cq); 
+} 
+
+namespace { 
+ 
+bool streq(const TString& a, const char* b) { 
+  return (a.empty() && b == nullptr) || 
+         ((b != nullptr) && !strcmp(a.c_str(), b)); 
 }
 
-void Server::FailCall(size_t cq_idx, RequestedCall* rc, grpc_error* error) {
-  *rc->call = nullptr;
-  rc->initial_metadata->count = 0;
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
-  grpc_cq_end_op(cqs_[cq_idx], rc->tag, error, DoneRequestEvent, rc,
-                 &rc->completion);
+}  // namespace 
+
+Server::RegisteredMethod* Server::RegisterMethod( 
+    const char* method, const char* host, 
+    grpc_server_register_method_payload_handling payload_handling, 
+    uint32_t flags) { 
+  if (!method) { 
+    gpr_log(GPR_ERROR, 
+            "grpc_server_register_method method string cannot be NULL"); 
+    return nullptr; 
+  }
+  for (std::unique_ptr<RegisteredMethod>& m : registered_methods_) { 
+    if (streq(m->method, method) && streq(m->host, host)) { 
+      gpr_log(GPR_ERROR, "duplicate registration for %s@%s", method, 
+              host ? host : "*"); 
+      return nullptr; 
+    } 
+  } 
+  if ((flags & ~GRPC_INITIAL_METADATA_USED_MASK) != 0) { 
+    gpr_log(GPR_ERROR, "grpc_server_register_method invalid flags 0x%08x", 
+            flags); 
+    return nullptr; 
+  } 
+  registered_methods_.emplace_back(y_absl::make_unique<RegisteredMethod>( 
+      method, host, payload_handling, flags)); 
+  return registered_methods_.back().get(); 
+} 
+
+void Server::DoneRequestEvent(void* req, grpc_cq_completion* /*c*/) { 
+  delete static_cast<RequestedCall*>(req); 
 }
 
-// Before calling MaybeFinishShutdown(), we must hold mu_global_ and not
-// hold mu_call_.
-void Server::MaybeFinishShutdown() {
-  if (!shutdown_flag_.load(std::memory_order_acquire) || shutdown_published_) {
+void Server::FailCall(size_t cq_idx, RequestedCall* rc, grpc_error* error) { 
+  *rc->call = nullptr; 
+  rc->initial_metadata->count = 0; 
+  GPR_ASSERT(error != GRPC_ERROR_NONE); 
+  grpc_cq_end_op(cqs_[cq_idx], rc->tag, error, DoneRequestEvent, rc, 
+                 &rc->completion); 
+} 
+
+// Before calling MaybeFinishShutdown(), we must hold mu_global_ and not 
+// hold mu_call_. 
+void Server::MaybeFinishShutdown() { 
+  if (!shutdown_flag_.load(std::memory_order_acquire) || shutdown_published_) { 
     return;
   }
-  {
-    MutexLock lock(&mu_call_);
-    KillPendingWorkLocked(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
-  }
-  if (!channels_.empty() || listeners_destroyed_ < listeners_.size()) {
-    if (gpr_time_cmp(gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME),
-                                  last_shutdown_message_time_),
-                     gpr_time_from_seconds(1, GPR_TIMESPAN)) >= 0) {
-      last_shutdown_message_time_ = gpr_now(GPR_CLOCK_REALTIME);
-      gpr_log(GPR_DEBUG,
-              "Waiting for %" PRIuPTR " channels and %" PRIuPTR "/%" PRIuPTR
-              " listeners to be destroyed before shutting down server",
-              channels_.size(), listeners_.size() - listeners_destroyed_,
-              listeners_.size());
-    }
-    return;
-  }
-  shutdown_published_ = true;
-  for (auto& shutdown_tag : shutdown_tags_) {
-    Ref().release();
-    grpc_cq_end_op(shutdown_tag.cq, shutdown_tag.tag, GRPC_ERROR_NONE,
-                   DoneShutdownEvent, this, &shutdown_tag.completion);
-  }
-}
-
-void Server::KillPendingWorkLocked(grpc_error* error) {
-  if (started_) {
-    unregistered_request_matcher_->KillRequests(GRPC_ERROR_REF(error));
-    unregistered_request_matcher_->ZombifyPending();
-    for (std::unique_ptr<RegisteredMethod>& rm : registered_methods_) {
-      rm->matcher->KillRequests(GRPC_ERROR_REF(error));
-      rm->matcher->ZombifyPending();
+  { 
+    MutexLock lock(&mu_call_); 
+    KillPendingWorkLocked( 
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown")); 
+  } 
+  if (!channels_.empty() || listeners_destroyed_ < listeners_.size()) { 
+    if (gpr_time_cmp(gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), 
+                                  last_shutdown_message_time_), 
+                     gpr_time_from_seconds(1, GPR_TIMESPAN)) >= 0) { 
+      last_shutdown_message_time_ = gpr_now(GPR_CLOCK_REALTIME); 
+      gpr_log(GPR_DEBUG, 
+              "Waiting for %" PRIuPTR " channels and %" PRIuPTR "/%" PRIuPTR 
+              " listeners to be destroyed before shutting down server", 
+              channels_.size(), listeners_.size() - listeners_destroyed_, 
+              listeners_.size()); 
+    } 
+    return; 
+  } 
+  shutdown_published_ = true; 
+  for (auto& shutdown_tag : shutdown_tags_) { 
+    Ref().release(); 
+    grpc_cq_end_op(shutdown_tag.cq, shutdown_tag.tag, GRPC_ERROR_NONE, 
+                   DoneShutdownEvent, this, &shutdown_tag.completion); 
+  } 
+} 
+
+void Server::KillPendingWorkLocked(grpc_error* error) { 
+  if (started_) { 
+    unregistered_request_matcher_->KillRequests(GRPC_ERROR_REF(error)); 
+    unregistered_request_matcher_->ZombifyPending(); 
+    for (std::unique_ptr<RegisteredMethod>& rm : registered_methods_) { 
+      rm->matcher->KillRequests(GRPC_ERROR_REF(error)); 
+      rm->matcher->ZombifyPending(); 
     }
   }
-  GRPC_ERROR_UNREF(error);
-}
-
-std::vector<grpc_channel*> Server::GetChannelsLocked() const {
-  std::vector<grpc_channel*> channels;
-  channels.reserve(channels_.size());
-  for (const ChannelData* chand : channels_) {
-    channels.push_back(chand->channel());
-    GRPC_CHANNEL_INTERNAL_REF(chand->channel(), "broadcast");
-  }
-  return channels;
+  GRPC_ERROR_UNREF(error); 
 }
 
-void Server::ListenerDestroyDone(void* arg, grpc_error* /*error*/) {
-  Server* server = static_cast<Server*>(arg);
-  MutexLock lock(&server->mu_global_);
-  server->listeners_destroyed_++;
-  server->MaybeFinishShutdown();
-}
-
-namespace {
-
-void DonePublishedShutdown(void* /*done_arg*/, grpc_cq_completion* storage) {
-  delete storage;
-}
-
-}  // namespace
-
-// - Kills all pending requests-for-incoming-RPC-calls (i.e., the requests made
-//   via grpc_server_request_call() and grpc_server_request_registered_call()
-//   will now be cancelled). See KillPendingWorkLocked().
-//
-// - Shuts down the listeners (i.e., the server will no longer listen on the
-//   port for new incoming channels).
-//
-// - Iterates through all channels on the server and sends shutdown msg (see
-//   ChannelBroadcaster::BroadcastShutdown() for details) to the clients via
-//   the transport layer. The transport layer then guarantees the following:
-//    -- Sends shutdown to the client (e.g., HTTP2 transport sends GOAWAY).
-//    -- If the server has outstanding calls that are in the process, the
-//       connection is NOT closed until the server is done with all those calls.
-//    -- Once there are no more calls in progress, the channel is closed.
-void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
-  ChannelBroadcaster broadcaster;
-  {
-    // Wait for startup to be finished.  Locks mu_global.
-    MutexLock lock(&mu_global_);
-    starting_cv_.WaitUntil(&mu_global_, [this] { return !starting_; });
-    // Stay locked, and gather up some stuff to do.
-    GPR_ASSERT(grpc_cq_begin_op(cq, tag));
-    if (shutdown_published_) {
-      grpc_cq_end_op(cq, tag, GRPC_ERROR_NONE, DonePublishedShutdown, nullptr,
-                     new grpc_cq_completion);
+std::vector<grpc_channel*> Server::GetChannelsLocked() const { 
+  std::vector<grpc_channel*> channels; 
+  channels.reserve(channels_.size()); 
+  for (const ChannelData* chand : channels_) { 
+    channels.push_back(chand->channel()); 
+    GRPC_CHANNEL_INTERNAL_REF(chand->channel(), "broadcast"); 
+  } 
+  return channels; 
+} 
+
+void Server::ListenerDestroyDone(void* arg, grpc_error* /*error*/) { 
+  Server* server = static_cast<Server*>(arg); 
+  MutexLock lock(&server->mu_global_); 
+  server->listeners_destroyed_++; 
+  server->MaybeFinishShutdown(); 
+} 
+ 
+namespace { 
+ 
+void DonePublishedShutdown(void* /*done_arg*/, grpc_cq_completion* storage) { 
+  delete storage; 
+} 
+ 
+}  // namespace 
+ 
+// - Kills all pending requests-for-incoming-RPC-calls (i.e., the requests made 
+//   via grpc_server_request_call() and grpc_server_request_registered_call() 
+//   will now be cancelled). See KillPendingWorkLocked(). 
+// 
+// - Shuts down the listeners (i.e., the server will no longer listen on the 
+//   port for new incoming channels). 
+// 
+// - Iterates through all channels on the server and sends shutdown msg (see 
+//   ChannelBroadcaster::BroadcastShutdown() for details) to the clients via 
+//   the transport layer. The transport layer then guarantees the following: 
+//    -- Sends shutdown to the client (e.g., HTTP2 transport sends GOAWAY). 
+//    -- If the server has outstanding calls that are in the process, the 
+//       connection is NOT closed until the server is done with all those calls. 
+//    -- Once there are no more calls in progress, the channel is closed. 
+void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) { 
+  ChannelBroadcaster broadcaster; 
+  { 
+    // Wait for startup to be finished.  Locks mu_global. 
+    MutexLock lock(&mu_global_); 
+    starting_cv_.WaitUntil(&mu_global_, [this] { return !starting_; }); 
+    // Stay locked, and gather up some stuff to do. 
+    GPR_ASSERT(grpc_cq_begin_op(cq, tag)); 
+    if (shutdown_published_) { 
+      grpc_cq_end_op(cq, tag, GRPC_ERROR_NONE, DonePublishedShutdown, nullptr, 
+                     new grpc_cq_completion); 
       return;
     }
-    shutdown_tags_.emplace_back(tag, cq);
-    if (shutdown_flag_.load(std::memory_order_acquire)) {
+    shutdown_tags_.emplace_back(tag, cq); 
+    if (shutdown_flag_.load(std::memory_order_acquire)) { 
       return;
     }
-    last_shutdown_message_time_ = gpr_now(GPR_CLOCK_REALTIME);
-    broadcaster.FillChannelsLocked(GetChannelsLocked());
-    shutdown_flag_.store(true, std::memory_order_release);
-    // Collect all unregistered then registered calls.
-    {
-      MutexLock lock(&mu_call_);
-      KillPendingWorkLocked(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
-    }
-    MaybeFinishShutdown();
-  }
-  // Shutdown listeners.
-  for (auto& listener : listeners_) {
-    channelz::ListenSocketNode* channelz_listen_socket_node =
-        listener.listener->channelz_listen_socket_node();
-    if (channelz_node_ != nullptr && channelz_listen_socket_node != nullptr) {
-      channelz_node_->RemoveChildListenSocket(
-          channelz_listen_socket_node->uuid());
-    }
-    GRPC_CLOSURE_INIT(&listener.destroy_done, ListenerDestroyDone, this,
-                      grpc_schedule_on_exec_ctx);
-    listener.listener->SetOnDestroyDone(&listener.destroy_done);
-    listener.listener.reset();
-  }
-  broadcaster.BroadcastShutdown(/*send_goaway=*/true, GRPC_ERROR_NONE);
+    last_shutdown_message_time_ = gpr_now(GPR_CLOCK_REALTIME); 
+    broadcaster.FillChannelsLocked(GetChannelsLocked()); 
+    shutdown_flag_.store(true, std::memory_order_release); 
+    // Collect all unregistered then registered calls. 
+    { 
+      MutexLock lock(&mu_call_); 
+      KillPendingWorkLocked( 
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown")); 
+    } 
+    MaybeFinishShutdown(); 
+  }
+  // Shutdown listeners. 
+  for (auto& listener : listeners_) { 
+    channelz::ListenSocketNode* channelz_listen_socket_node = 
+        listener.listener->channelz_listen_socket_node(); 
+    if (channelz_node_ != nullptr && channelz_listen_socket_node != nullptr) { 
+      channelz_node_->RemoveChildListenSocket( 
+          channelz_listen_socket_node->uuid()); 
+    } 
+    GRPC_CLOSURE_INIT(&listener.destroy_done, ListenerDestroyDone, this, 
+                      grpc_schedule_on_exec_ctx); 
+    listener.listener->SetOnDestroyDone(&listener.destroy_done); 
+    listener.listener.reset(); 
+  } 
+  broadcaster.BroadcastShutdown(/*send_goaway=*/true, GRPC_ERROR_NONE); 
 }
 
-void Server::CancelAllCalls() {
-  ChannelBroadcaster broadcaster;
-  {
-    MutexLock lock(&mu_global_);
-    broadcaster.FillChannelsLocked(GetChannelsLocked());
+void Server::CancelAllCalls() { 
+  ChannelBroadcaster broadcaster; 
+  { 
+    MutexLock lock(&mu_global_); 
+    broadcaster.FillChannelsLocked(GetChannelsLocked()); 
   }
-  broadcaster.BroadcastShutdown(
-      /*send_goaway=*/false,
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Cancelling all calls"));
+  broadcaster.BroadcastShutdown( 
+      /*send_goaway=*/false, 
+      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Cancelling all calls")); 
 }
 
-void Server::Orphan() {
-  {
-    MutexLock lock(&mu_global_);
-    GPR_ASSERT(shutdown_flag_.load(std::memory_order_acquire) ||
-               listeners_.empty());
-    GPR_ASSERT(listeners_destroyed_ == listeners_.size());
-  }
-  if (default_resource_user_ != nullptr) {
-    grpc_resource_quota_unref(grpc_resource_user_quota(default_resource_user_));
-    grpc_resource_user_shutdown(default_resource_user_);
-    grpc_resource_user_unref(default_resource_user_);
-  }
-  Unref();
+void Server::Orphan() { 
+  { 
+    MutexLock lock(&mu_global_); 
+    GPR_ASSERT(shutdown_flag_.load(std::memory_order_acquire) || 
+               listeners_.empty()); 
+    GPR_ASSERT(listeners_destroyed_ == listeners_.size()); 
+  } 
+  if (default_resource_user_ != nullptr) { 
+    grpc_resource_quota_unref(grpc_resource_user_quota(default_resource_user_)); 
+    grpc_resource_user_shutdown(default_resource_user_); 
+    grpc_resource_user_unref(default_resource_user_); 
+  } 
+  Unref(); 
 }
 
-grpc_call_error Server::ValidateServerRequest(
-    grpc_completion_queue* cq_for_notification, void* tag,
-    grpc_byte_buffer** optional_payload, RegisteredMethod* rm) {
-  if ((rm == nullptr && optional_payload != nullptr) ||
-      ((rm != nullptr) && ((optional_payload == nullptr) !=
-                           (rm->payload_handling == GRPC_SRM_PAYLOAD_NONE)))) {
-    return GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH;
-  }
-  if (grpc_cq_begin_op(cq_for_notification, tag) == false) {
-    return GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN;
-  }
-  return GRPC_CALL_OK;
+grpc_call_error Server::ValidateServerRequest( 
+    grpc_completion_queue* cq_for_notification, void* tag, 
+    grpc_byte_buffer** optional_payload, RegisteredMethod* rm) { 
+  if ((rm == nullptr && optional_payload != nullptr) || 
+      ((rm != nullptr) && ((optional_payload == nullptr) != 
+                           (rm->payload_handling == GRPC_SRM_PAYLOAD_NONE)))) { 
+    return GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH; 
+  }
+  if (grpc_cq_begin_op(cq_for_notification, tag) == false) { 
+    return GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN; 
+  } 
+  return GRPC_CALL_OK; 
 }
 
-grpc_call_error Server::ValidateServerRequestAndCq(
-    size_t* cq_idx, grpc_completion_queue* cq_for_notification, void* tag,
-    grpc_byte_buffer** optional_payload, RegisteredMethod* rm) {
-  size_t idx;
-  for (idx = 0; idx < cqs_.size(); idx++) {
-    if (cqs_[idx] == cq_for_notification) {
-      break;
+grpc_call_error Server::ValidateServerRequestAndCq( 
+    size_t* cq_idx, grpc_completion_queue* cq_for_notification, void* tag, 
+    grpc_byte_buffer** optional_payload, RegisteredMethod* rm) { 
+  size_t idx; 
+  for (idx = 0; idx < cqs_.size(); idx++) { 
+    if (cqs_[idx] == cq_for_notification) { 
+      break; 
     }
   }
-  if (idx == cqs_.size()) {
-    return GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
-  }
-  grpc_call_error error =
-      ValidateServerRequest(cq_for_notification, tag, optional_payload, rm);
-  if (error != GRPC_CALL_OK) {
-    return error;
-  }
-  *cq_idx = idx;
-  return GRPC_CALL_OK;
-}
-
-grpc_call_error Server::QueueRequestedCall(size_t cq_idx, RequestedCall* rc) {
-  if (shutdown_flag_.load(std::memory_order_acquire)) {
-    FailCall(cq_idx, rc,
-             GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown"));
-    return GRPC_CALL_OK;
-  }
-  RequestMatcherInterface* rm;
-  switch (rc->type) {
-    case RequestedCall::Type::BATCH_CALL:
-      rm = unregistered_request_matcher_.get();
-      break;
-    case RequestedCall::Type::REGISTERED_CALL:
-      rm = rc->data.registered.method->matcher.get();
-      break;
-  }
-  rm->RequestCallWithPossiblePublish(cq_idx, rc);
-  return GRPC_CALL_OK;
+  if (idx == cqs_.size()) { 
+    return GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE; 
+  } 
+  grpc_call_error error = 
+      ValidateServerRequest(cq_for_notification, tag, optional_payload, rm); 
+  if (error != GRPC_CALL_OK) { 
+    return error; 
+  } 
+  *cq_idx = idx; 
+  return GRPC_CALL_OK; 
 }
 
-grpc_call_error Server::RequestCall(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) {
-  size_t cq_idx;
-  grpc_call_error error = ValidateServerRequestAndCq(
-      &cq_idx, cq_for_notification, tag, nullptr, nullptr);
-  if (error != GRPC_CALL_OK) {
-    return error;
-  }
-  RequestedCall* rc =
-      new RequestedCall(tag, cq_bound_to_call, call, request_metadata, details);
-  return QueueRequestedCall(cq_idx, rc);
+grpc_call_error Server::QueueRequestedCall(size_t cq_idx, RequestedCall* rc) { 
+  if (shutdown_flag_.load(std::memory_order_acquire)) { 
+    FailCall(cq_idx, rc, 
+             GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server Shutdown")); 
+    return GRPC_CALL_OK; 
+  }
+  RequestMatcherInterface* rm; 
+  switch (rc->type) { 
+    case RequestedCall::Type::BATCH_CALL: 
+      rm = unregistered_request_matcher_.get(); 
+      break; 
+    case RequestedCall::Type::REGISTERED_CALL: 
+      rm = rc->data.registered.method->matcher.get(); 
+      break; 
+  } 
+  rm->RequestCallWithPossiblePublish(cq_idx, rc); 
+  return GRPC_CALL_OK; 
+} 
+
+grpc_call_error Server::RequestCall(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) { 
+  size_t cq_idx; 
+  grpc_call_error error = ValidateServerRequestAndCq( 
+      &cq_idx, cq_for_notification, tag, nullptr, nullptr); 
+  if (error != GRPC_CALL_OK) { 
+    return error; 
+  } 
+  RequestedCall* rc = 
+      new RequestedCall(tag, cq_bound_to_call, call, request_metadata, details); 
+  return QueueRequestedCall(cq_idx, rc); 
+} 
+
+grpc_call_error Server::RequestRegisteredCall( 
+    RegisteredMethod* rm, 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) { 
+  size_t cq_idx; 
+  grpc_call_error error = ValidateServerRequestAndCq( 
+      &cq_idx, cq_for_notification, tag_new, optional_payload, rm); 
+  if (error != GRPC_CALL_OK) { 
+    return error; 
+  }
+  RequestedCall* rc = 
+      new RequestedCall(tag_new, cq_bound_to_call, call, request_metadata, rm, 
+                        deadline, optional_payload); 
+  return QueueRequestedCall(cq_idx, rc); 
 }
 
-grpc_call_error Server::RequestRegisteredCall(
-    RegisteredMethod* rm, 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) {
-  size_t cq_idx;
-  grpc_call_error error = ValidateServerRequestAndCq(
-      &cq_idx, cq_for_notification, tag_new, optional_payload, rm);
-  if (error != GRPC_CALL_OK) {
-    return error;
-  }
-  RequestedCall* rc =
-      new RequestedCall(tag_new, cq_bound_to_call, call, request_metadata, rm,
-                        deadline, optional_payload);
-  return QueueRequestedCall(cq_idx, rc);
-}
-
-//
-// Server::ChannelData::ConnectivityWatcher
-//
-
-class Server::ChannelData::ConnectivityWatcher
-    : public AsyncConnectivityStateWatcherInterface {
- public:
-  explicit ConnectivityWatcher(ChannelData* chand) : chand_(chand) {
-    GRPC_CHANNEL_INTERNAL_REF(chand_->channel_, "connectivity");
-  }
-
-  ~ConnectivityWatcher() {
-    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel_, "connectivity");
-  }
-
- private:
-  void OnConnectivityStateChange(grpc_connectivity_state new_state,
-                                 const y_absl::Status& /*status*/) override {
-    // Don't do anything until we are being shut down.
-    if (new_state != GRPC_CHANNEL_SHUTDOWN) return;
-    // Shut down channel.
-    MutexLock lock(&chand_->server_->mu_global_);
-    chand_->Destroy();
-  }
-
-  ChannelData* chand_;
-};
-
-//
-// Server::ChannelData
-//
-
-Server::ChannelData::~ChannelData() {
-  if (registered_methods_ != nullptr) {
-    for (const ChannelRegisteredMethod& crm : *registered_methods_) {
-      grpc_slice_unref_internal(crm.method);
-      GPR_DEBUG_ASSERT(crm.method.refcount == &kNoopRefcount ||
-                       crm.method.refcount == nullptr);
-      if (crm.has_host) {
-        grpc_slice_unref_internal(crm.host);
-        GPR_DEBUG_ASSERT(crm.host.refcount == &kNoopRefcount ||
-                         crm.host.refcount == nullptr);
-      }
-    }
-    registered_methods_.reset();
-  }
-  if (server_ != nullptr) {
-    if (server_->channelz_node_ != nullptr && channelz_socket_uuid_ != 0) {
-      server_->channelz_node_->RemoveChildSocket(channelz_socket_uuid_);
-    }
-    {
-      MutexLock lock(&server_->mu_global_);
-      if (list_position_.has_value()) {
-        server_->channels_.erase(*list_position_);
-        list_position_.reset();
-      }
-      server_->MaybeFinishShutdown();
-    }
+// 
+// Server::ChannelData::ConnectivityWatcher 
+// 
+
+class Server::ChannelData::ConnectivityWatcher 
+    : public AsyncConnectivityStateWatcherInterface { 
+ public: 
+  explicit ConnectivityWatcher(ChannelData* chand) : chand_(chand) { 
+    GRPC_CHANNEL_INTERNAL_REF(chand_->channel_, "connectivity"); 
+  }
+ 
+  ~ConnectivityWatcher() { 
+    GRPC_CHANNEL_INTERNAL_UNREF(chand_->channel_, "connectivity"); 
+  }
+
+ private: 
+  void OnConnectivityStateChange(grpc_connectivity_state new_state, 
+                                 const y_absl::Status& /*status*/) override { 
+    // Don't do anything until we are being shut down. 
+    if (new_state != GRPC_CHANNEL_SHUTDOWN) return; 
+    // Shut down channel. 
+    MutexLock lock(&chand_->server_->mu_global_); 
+    chand_->Destroy(); 
+  }
+
+  ChannelData* chand_; 
+}; 
+
+// 
+// Server::ChannelData 
+// 
+ 
+Server::ChannelData::~ChannelData() { 
+  if (registered_methods_ != nullptr) { 
+    for (const ChannelRegisteredMethod& crm : *registered_methods_) { 
+      grpc_slice_unref_internal(crm.method); 
+      GPR_DEBUG_ASSERT(crm.method.refcount == &kNoopRefcount || 
+                       crm.method.refcount == nullptr); 
+      if (crm.has_host) { 
+        grpc_slice_unref_internal(crm.host); 
+        GPR_DEBUG_ASSERT(crm.host.refcount == &kNoopRefcount || 
+                         crm.host.refcount == nullptr); 
+      } 
+    } 
+    registered_methods_.reset(); 
+  }
+  if (server_ != nullptr) { 
+    if (server_->channelz_node_ != nullptr && channelz_socket_uuid_ != 0) { 
+      server_->channelz_node_->RemoveChildSocket(channelz_socket_uuid_); 
+    } 
+    { 
+      MutexLock lock(&server_->mu_global_); 
+      if (list_position_.has_value()) { 
+        server_->channels_.erase(*list_position_); 
+        list_position_.reset(); 
+      } 
+      server_->MaybeFinishShutdown(); 
+    } 
   }
 }
 
-void Server::ChannelData::InitTransport(RefCountedPtr<Server> server,
-                                        grpc_channel* channel, size_t cq_idx,
-                                        grpc_transport* transport,
-                                        intptr_t channelz_socket_uuid) {
-  server_ = std::move(server);
-  channel_ = channel;
-  cq_idx_ = cq_idx;
-  channelz_socket_uuid_ = channelz_socket_uuid;
-  // Build a lookup table phrased in terms of mdstr's in this channels context
-  // to quickly find registered methods.
-  size_t num_registered_methods = server_->registered_methods_.size();
-  if (num_registered_methods > 0) {
-    uint32_t max_probes = 0;
-    size_t slots = 2 * num_registered_methods;
-    registered_methods_.reset(new std::vector<ChannelRegisteredMethod>(slots));
-    for (std::unique_ptr<RegisteredMethod>& rm : server_->registered_methods_) {
-      ExternallyManagedSlice host;
-      ExternallyManagedSlice method(rm->method.c_str());
-      const bool has_host = !rm->host.empty();
-      if (has_host) {
-        host = ExternallyManagedSlice(rm->host.c_str());
-      }
-      uint32_t hash =
-          GRPC_MDSTR_KV_HASH(has_host ? host.Hash() : 0, method.Hash());
-      uint32_t probes = 0;
-      for (probes = 0; (*registered_methods_)[(hash + probes) % slots]
-                           .server_registered_method != nullptr;
-           probes++) {
-      }
-      if (probes > max_probes) max_probes = probes;
-      ChannelRegisteredMethod* crm =
-          &(*registered_methods_)[(hash + probes) % slots];
-      crm->server_registered_method = rm.get();
-      crm->flags = rm->flags;
-      crm->has_host = has_host;
-      if (has_host) {
-        crm->host = host;
-      }
-      crm->method = method;
-    }
-    GPR_ASSERT(slots <= UINT32_MAX);
-    registered_method_max_probes_ = max_probes;
-  }
-  // Publish channel.
-  {
-    MutexLock lock(&server_->mu_global_);
-    server_->channels_.push_front(this);
-    list_position_ = server_->channels_.begin();
-  }
-  // Start accept_stream transport op.
-  grpc_transport_op* op = grpc_make_transport_op(nullptr);
-  op->set_accept_stream = true;
-  op->set_accept_stream_fn = AcceptStream;
-  op->set_accept_stream_user_data = this;
-  op->start_connectivity_watch = MakeOrphanable<ConnectivityWatcher>(this);
-  if (server_->shutdown_flag_.load(std::memory_order_acquire)) {
-    op->disconnect_with_error =
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server shutdown");
-  }
-  grpc_transport_perform_op(transport, op);
+void Server::ChannelData::InitTransport(RefCountedPtr<Server> server, 
+                                        grpc_channel* channel, size_t cq_idx, 
+                                        grpc_transport* transport, 
+                                        intptr_t channelz_socket_uuid) { 
+  server_ = std::move(server); 
+  channel_ = channel; 
+  cq_idx_ = cq_idx; 
+  channelz_socket_uuid_ = channelz_socket_uuid; 
+  // Build a lookup table phrased in terms of mdstr's in this channels context 
+  // to quickly find registered methods. 
+  size_t num_registered_methods = server_->registered_methods_.size(); 
+  if (num_registered_methods > 0) { 
+    uint32_t max_probes = 0; 
+    size_t slots = 2 * num_registered_methods; 
+    registered_methods_.reset(new std::vector<ChannelRegisteredMethod>(slots)); 
+    for (std::unique_ptr<RegisteredMethod>& rm : server_->registered_methods_) { 
+      ExternallyManagedSlice host; 
+      ExternallyManagedSlice method(rm->method.c_str()); 
+      const bool has_host = !rm->host.empty(); 
+      if (has_host) { 
+        host = ExternallyManagedSlice(rm->host.c_str()); 
+      } 
+      uint32_t hash = 
+          GRPC_MDSTR_KV_HASH(has_host ? host.Hash() : 0, method.Hash()); 
+      uint32_t probes = 0; 
+      for (probes = 0; (*registered_methods_)[(hash + probes) % slots] 
+                           .server_registered_method != nullptr; 
+           probes++) { 
+      } 
+      if (probes > max_probes) max_probes = probes; 
+      ChannelRegisteredMethod* crm = 
+          &(*registered_methods_)[(hash + probes) % slots]; 
+      crm->server_registered_method = rm.get(); 
+      crm->flags = rm->flags; 
+      crm->has_host = has_host; 
+      if (has_host) { 
+        crm->host = host; 
+      } 
+      crm->method = method; 
+    } 
+    GPR_ASSERT(slots <= UINT32_MAX); 
+    registered_method_max_probes_ = max_probes; 
+  } 
+  // Publish channel. 
+  { 
+    MutexLock lock(&server_->mu_global_); 
+    server_->channels_.push_front(this); 
+    list_position_ = server_->channels_.begin(); 
+  } 
+  // Start accept_stream transport op. 
+  grpc_transport_op* op = grpc_make_transport_op(nullptr); 
+  op->set_accept_stream = true; 
+  op->set_accept_stream_fn = AcceptStream; 
+  op->set_accept_stream_user_data = this; 
+  op->start_connectivity_watch = MakeOrphanable<ConnectivityWatcher>(this); 
+  if (server_->shutdown_flag_.load(std::memory_order_acquire)) { 
+    op->disconnect_with_error = 
+        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Server shutdown"); 
+  } 
+  grpc_transport_perform_op(transport, op); 
 }
 
-Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod(
-    const grpc_slice& host, const grpc_slice& path, bool is_idempotent) {
-  if (registered_methods_ == nullptr) return nullptr;
-  /* TODO(ctiller): unify these two searches */
-  /* check for an exact match with host */
-  uint32_t hash = GRPC_MDSTR_KV_HASH(grpc_slice_hash_internal(host),
-                                     grpc_slice_hash_internal(path));
-  for (size_t i = 0; i <= registered_method_max_probes_; i++) {
-    ChannelRegisteredMethod* rm =
-        &(*registered_methods_)[(hash + i) % registered_methods_->size()];
-    if (rm->server_registered_method == nullptr) break;
-    if (!rm->has_host) continue;
-    if (rm->host != host) continue;
-    if (rm->method != path) continue;
-    if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
-        !is_idempotent) {
-      continue;
-    }
-    return rm;
-  }
-  /* check for a wildcard method definition (no host set) */
-  hash = GRPC_MDSTR_KV_HASH(0, grpc_slice_hash_internal(path));
-  for (size_t i = 0; i <= registered_method_max_probes_; i++) {
-    ChannelRegisteredMethod* rm =
-        &(*registered_methods_)[(hash + i) % registered_methods_->size()];
-    if (rm->server_registered_method == nullptr) break;
-    if (rm->has_host) continue;
-    if (rm->method != path) continue;
-    if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) &&
-        !is_idempotent) {
-      continue;
+Server::ChannelRegisteredMethod* Server::ChannelData::GetRegisteredMethod( 
+    const grpc_slice& host, const grpc_slice& path, bool is_idempotent) { 
+  if (registered_methods_ == nullptr) return nullptr; 
+  /* TODO(ctiller): unify these two searches */ 
+  /* check for an exact match with host */ 
+  uint32_t hash = GRPC_MDSTR_KV_HASH(grpc_slice_hash_internal(host), 
+                                     grpc_slice_hash_internal(path)); 
+  for (size_t i = 0; i <= registered_method_max_probes_; i++) { 
+    ChannelRegisteredMethod* rm = 
+        &(*registered_methods_)[(hash + i) % registered_methods_->size()]; 
+    if (rm->server_registered_method == nullptr) break; 
+    if (!rm->has_host) continue; 
+    if (rm->host != host) continue; 
+    if (rm->method != path) continue; 
+    if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) && 
+        !is_idempotent) { 
+      continue; 
     }
-    return rm;
-  }
-  return nullptr;
+    return rm; 
+  }
+  /* check for a wildcard method definition (no host set) */ 
+  hash = GRPC_MDSTR_KV_HASH(0, grpc_slice_hash_internal(path)); 
+  for (size_t i = 0; i <= registered_method_max_probes_; i++) { 
+    ChannelRegisteredMethod* rm = 
+        &(*registered_methods_)[(hash + i) % registered_methods_->size()]; 
+    if (rm->server_registered_method == nullptr) break; 
+    if (rm->has_host) continue; 
+    if (rm->method != path) continue; 
+    if ((rm->flags & GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) && 
+        !is_idempotent) { 
+      continue; 
+    } 
+    return rm; 
+  } 
+  return nullptr; 
 }
 
-void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
-                                       const void* transport_server_data) {
-  auto* chand = static_cast<Server::ChannelData*>(arg);
+void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/, 
+                                       const void* transport_server_data) { 
+  auto* chand = static_cast<Server::ChannelData*>(arg); 
   /* create a call */
   grpc_call_create_args args;
-  args.channel = chand->channel_;
-  args.server = chand->server_.get();
+  args.channel = chand->channel_; 
+  args.server = chand->server_.get(); 
   args.parent = nullptr;
   args.propagation_mask = 0;
   args.cq = nullptr;
@@ -1104,361 +1104,361 @@ void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
   grpc_error* error = grpc_call_create(&args, &call);
   grpc_call_element* elem =
       grpc_call_stack_element(grpc_call_get_call_stack(call), 0);
-  auto* calld = static_cast<Server::CallData*>(elem->call_data);
+  auto* calld = static_cast<Server::CallData*>(elem->call_data); 
   if (error != GRPC_ERROR_NONE) {
     GRPC_ERROR_UNREF(error);
-    calld->FailCallCreation();
+    calld->FailCallCreation(); 
     return;
   }
-  calld->Start(elem);
+  calld->Start(elem); 
 }
 
-void Server::ChannelData::FinishDestroy(void* cd, grpc_error* /*error*/) {
-  auto* chand = static_cast<Server::ChannelData*>(cd);
-  Server* server = chand->server_.get();
-  GRPC_CHANNEL_INTERNAL_UNREF(chand->channel_, "server");
-  server->Unref();
+void Server::ChannelData::FinishDestroy(void* cd, grpc_error* /*error*/) { 
+  auto* chand = static_cast<Server::ChannelData*>(cd); 
+  Server* server = chand->server_.get(); 
+  GRPC_CHANNEL_INTERNAL_UNREF(chand->channel_, "server"); 
+  server->Unref(); 
 }
 
-void Server::ChannelData::Destroy() {
-  if (!list_position_.has_value()) return;
-  GPR_ASSERT(server_ != nullptr);
-  server_->channels_.erase(*list_position_);
-  list_position_.reset();
-  server_->Ref().release();
-  server_->MaybeFinishShutdown();
-  GRPC_CLOSURE_INIT(&finish_destroy_channel_closure_, FinishDestroy, this,
-                    grpc_schedule_on_exec_ctx);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_server_channel_trace)) {
-    gpr_log(GPR_INFO, "Disconnected client");
-  }
-  grpc_transport_op* op =
-      grpc_make_transport_op(&finish_destroy_channel_closure_);
-  op->set_accept_stream = true;
-  grpc_channel_next_op(
-      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel_), 0),
-      op);
+void Server::ChannelData::Destroy() { 
+  if (!list_position_.has_value()) return; 
+  GPR_ASSERT(server_ != nullptr); 
+  server_->channels_.erase(*list_position_); 
+  list_position_.reset(); 
+  server_->Ref().release(); 
+  server_->MaybeFinishShutdown(); 
+  GRPC_CLOSURE_INIT(&finish_destroy_channel_closure_, FinishDestroy, this, 
+                    grpc_schedule_on_exec_ctx); 
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_server_channel_trace)) { 
+    gpr_log(GPR_INFO, "Disconnected client"); 
+  } 
+  grpc_transport_op* op = 
+      grpc_make_transport_op(&finish_destroy_channel_closure_); 
+  op->set_accept_stream = true; 
+  grpc_channel_next_op( 
+      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel_), 0), 
+      op); 
 }
 
-grpc_error* Server::ChannelData::InitChannelElement(
-    grpc_channel_element* elem, grpc_channel_element_args* args) {
+grpc_error* Server::ChannelData::InitChannelElement( 
+    grpc_channel_element* elem, grpc_channel_element_args* args) { 
   GPR_ASSERT(args->is_first);
   GPR_ASSERT(!args->is_last);
-  new (elem->channel_data) ChannelData();
-  return GRPC_ERROR_NONE;
-}
-
-void Server::ChannelData::DestroyChannelElement(grpc_channel_element* elem) {
-  auto* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->~ChannelData();
-}
-
-//
-// Server::CallData
-//
-
-Server::CallData::CallData(grpc_call_element* elem,
-                           const grpc_call_element_args& args,
-                           RefCountedPtr<Server> server)
-    : server_(std::move(server)),
-      call_(grpc_call_from_top_element(elem)),
-      call_combiner_(args.call_combiner) {
-  GRPC_CLOSURE_INIT(&recv_initial_metadata_ready_, RecvInitialMetadataReady,
-                    elem, grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_, RecvTrailingMetadataReady,
-                    elem, grpc_schedule_on_exec_ctx);
-}
-
-Server::CallData::~CallData() {
-  GPR_ASSERT(state_.Load(MemoryOrder::RELAXED) != CallState::PENDING);
-  GRPC_ERROR_UNREF(recv_initial_metadata_error_);
-  if (host_.has_value()) {
-    grpc_slice_unref_internal(*host_);
-  }
-  if (path_.has_value()) {
-    grpc_slice_unref_internal(*path_);
-  }
-  grpc_metadata_array_destroy(&initial_metadata_);
-  grpc_byte_buffer_destroy(payload_);
-}
-
-void Server::CallData::SetState(CallState state) {
-  state_.Store(state, MemoryOrder::RELAXED);
-}
-
-bool Server::CallData::MaybeActivate() {
-  CallState expected = CallState::PENDING;
-  return state_.CompareExchangeStrong(&expected, CallState::ACTIVATED,
-                                      MemoryOrder::ACQ_REL,
-                                      MemoryOrder::RELAXED);
-}
-
-void Server::CallData::FailCallCreation() {
-  CallState expected_not_started = CallState::NOT_STARTED;
-  CallState expected_pending = CallState::PENDING;
-  if (state_.CompareExchangeStrong(&expected_not_started, CallState::ZOMBIED,
-                                   MemoryOrder::ACQ_REL,
-                                   MemoryOrder::ACQUIRE)) {
-    KillZombie();
-  } else if (state_.CompareExchangeStrong(&expected_pending, CallState::ZOMBIED,
-                                          MemoryOrder::ACQ_REL,
-                                          MemoryOrder::RELAXED)) {
-    // Zombied call will be destroyed when it's removed from the pending
-    // queue... later.
-  }
-}
-
-void Server::CallData::Start(grpc_call_element* elem) {
-  grpc_op op;
-  op.op = GRPC_OP_RECV_INITIAL_METADATA;
-  op.flags = 0;
-  op.reserved = nullptr;
-  op.data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_;
-  GRPC_CLOSURE_INIT(&recv_initial_metadata_batch_complete_,
-                    RecvInitialMetadataBatchComplete, elem,
-                    grpc_schedule_on_exec_ctx);
-  grpc_call_start_batch_and_execute(call_, &op, 1,
-                                    &recv_initial_metadata_batch_complete_);
-}
-
-void Server::CallData::Publish(size_t cq_idx, RequestedCall* rc) {
-  grpc_call_set_completion_queue(call_, rc->cq_bound_to_call);
-  *rc->call = call_;
-  cq_new_ = server_->cqs_[cq_idx];
-  GPR_SWAP(grpc_metadata_array, *rc->initial_metadata, initial_metadata_);
-  switch (rc->type) {
-    case RequestedCall::Type::BATCH_CALL:
-      GPR_ASSERT(host_.has_value());
-      GPR_ASSERT(path_.has_value());
-      rc->data.batch.details->host = grpc_slice_ref_internal(*host_);
-      rc->data.batch.details->method = grpc_slice_ref_internal(*path_);
-      rc->data.batch.details->deadline =
-          grpc_millis_to_timespec(deadline_, GPR_CLOCK_MONOTONIC);
-      rc->data.batch.details->flags = recv_initial_metadata_flags_;
-      break;
-    case RequestedCall::Type::REGISTERED_CALL:
-      *rc->data.registered.deadline =
-          grpc_millis_to_timespec(deadline_, GPR_CLOCK_MONOTONIC);
-      if (rc->data.registered.optional_payload != nullptr) {
-        *rc->data.registered.optional_payload = payload_;
-        payload_ = nullptr;
-      }
-      break;
-    default:
-      GPR_UNREACHABLE_CODE(return );
-  }
-  grpc_cq_end_op(cq_new_, rc->tag, GRPC_ERROR_NONE, Server::DoneRequestEvent,
-                 rc, &rc->completion, true);
-}
-
-void Server::CallData::PublishNewRpc(void* arg, grpc_error* error) {
-  grpc_call_element* call_elem = static_cast<grpc_call_element*>(arg);
-  auto* calld = static_cast<Server::CallData*>(call_elem->call_data);
-  auto* chand = static_cast<Server::ChannelData*>(call_elem->channel_data);
-  RequestMatcherInterface* rm = calld->matcher_;
-  Server* server = rm->server();
-  if (error != GRPC_ERROR_NONE ||
-      server->shutdown_flag_.load(std::memory_order_acquire)) {
-    calld->state_.Store(CallState::ZOMBIED, MemoryOrder::RELAXED);
-    calld->KillZombie();
-    return;
-  }
-  rm->MatchOrQueue(chand->cq_idx(), calld);
-}
-
-namespace {
-
-void KillZombieClosure(void* call, grpc_error* /*error*/) {
-  grpc_call_unref(static_cast<grpc_call*>(call));
-}
-
-}  // namespace
-
-void Server::CallData::KillZombie() {
-  GRPC_CLOSURE_INIT(&kill_zombie_closure_, KillZombieClosure, call_,
-                    grpc_schedule_on_exec_ctx);
-  ExecCtx::Run(DEBUG_LOCATION, &kill_zombie_closure_, GRPC_ERROR_NONE);
-}
-
-void Server::CallData::StartNewRpc(grpc_call_element* elem) {
-  auto* chand = static_cast<ChannelData*>(elem->channel_data);
-  if (server_->shutdown_flag_.load(std::memory_order_acquire)) {
-    state_.Store(CallState::ZOMBIED, MemoryOrder::RELAXED);
-    KillZombie();
-    return;
-  }
-  // Find request matcher.
-  matcher_ = server_->unregistered_request_matcher_.get();
-  grpc_server_register_method_payload_handling payload_handling =
-      GRPC_SRM_PAYLOAD_NONE;
-  if (path_.has_value() && host_.has_value()) {
-    ChannelRegisteredMethod* rm =
-        chand->GetRegisteredMethod(*host_, *path_,
-                                   (recv_initial_metadata_flags_ &
-                                    GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST));
-    if (rm != nullptr) {
-      matcher_ = rm->server_registered_method->matcher.get();
-      payload_handling = rm->server_registered_method->payload_handling;
-    }
-  }
-  // Start recv_message op if needed.
-  switch (payload_handling) {
-    case GRPC_SRM_PAYLOAD_NONE:
-      PublishNewRpc(elem, GRPC_ERROR_NONE);
-      break;
-    case GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER: {
-      grpc_op op;
-      op.op = GRPC_OP_RECV_MESSAGE;
-      op.flags = 0;
-      op.reserved = nullptr;
-      op.data.recv_message.recv_message = &payload_;
-      GRPC_CLOSURE_INIT(&publish_, PublishNewRpc, elem,
-                        grpc_schedule_on_exec_ctx);
-      grpc_call_start_batch_and_execute(call_, &op, 1, &publish_);
-      break;
-    }
-  }
-}
-
-void Server::CallData::RecvInitialMetadataBatchComplete(void* arg,
-                                                        grpc_error* error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
-  auto* calld = static_cast<Server::CallData*>(elem->call_data);
-  if (error != GRPC_ERROR_NONE) {
-    calld->FailCallCreation();
-    return;
-  }
-  calld->StartNewRpc(elem);
-}
-
-void Server::CallData::StartTransportStreamOpBatchImpl(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
-  if (batch->recv_initial_metadata) {
-    GPR_ASSERT(batch->payload->recv_initial_metadata.recv_flags == nullptr);
-    recv_initial_metadata_ =
-        batch->payload->recv_initial_metadata.recv_initial_metadata;
-    original_recv_initial_metadata_ready_ =
-        batch->payload->recv_initial_metadata.recv_initial_metadata_ready;
-    batch->payload->recv_initial_metadata.recv_initial_metadata_ready =
-        &recv_initial_metadata_ready_;
-    batch->payload->recv_initial_metadata.recv_flags =
-        &recv_initial_metadata_flags_;
-  }
-  if (batch->recv_trailing_metadata) {
-    original_recv_trailing_metadata_ready_ =
-        batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready;
-    batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready =
-        &recv_trailing_metadata_ready_;
-  }
-  grpc_call_next_op(elem, batch);
-}
-
-void Server::CallData::RecvInitialMetadataReady(void* ptr, grpc_error* error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(ptr);
-  CallData* calld = static_cast<CallData*>(elem->call_data);
-  grpc_millis op_deadline;
-  if (error == GRPC_ERROR_NONE) {
-    GPR_DEBUG_ASSERT(calld->recv_initial_metadata_->idx.named.path != nullptr);
-    GPR_DEBUG_ASSERT(calld->recv_initial_metadata_->idx.named.authority !=
-                     nullptr);
-    calld->path_.emplace(grpc_slice_ref_internal(
-        GRPC_MDVALUE(calld->recv_initial_metadata_->idx.named.path->md)));
-    calld->host_.emplace(grpc_slice_ref_internal(
-        GRPC_MDVALUE(calld->recv_initial_metadata_->idx.named.authority->md)));
-    grpc_metadata_batch_remove(calld->recv_initial_metadata_, GRPC_BATCH_PATH);
-    grpc_metadata_batch_remove(calld->recv_initial_metadata_,
-                               GRPC_BATCH_AUTHORITY);
-  } else {
-    GRPC_ERROR_REF(error);
-  }
-  op_deadline = calld->recv_initial_metadata_->deadline;
-  if (op_deadline != GRPC_MILLIS_INF_FUTURE) {
-    calld->deadline_ = op_deadline;
-  }
-  if (calld->host_.has_value() && calld->path_.has_value()) {
-    /* do nothing */
-  } else {
-    /* Pass the error reference to calld->recv_initial_metadata_error */
-    grpc_error* src_error = error;
-    error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-        "Missing :authority or :path", &src_error, 1);
-    GRPC_ERROR_UNREF(src_error);
-    calld->recv_initial_metadata_error_ = GRPC_ERROR_REF(error);
-  }
-  grpc_closure* closure = calld->original_recv_initial_metadata_ready_;
-  calld->original_recv_initial_metadata_ready_ = nullptr;
-  if (calld->seen_recv_trailing_metadata_ready_) {
-    GRPC_CALL_COMBINER_START(calld->call_combiner_,
-                             &calld->recv_trailing_metadata_ready_,
-                             calld->recv_trailing_metadata_error_,
-                             "continue server recv_trailing_metadata_ready");
-  }
-  Closure::Run(DEBUG_LOCATION, closure, error);
-}
-
-void Server::CallData::RecvTrailingMetadataReady(void* user_data,
-                                                 grpc_error* error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  CallData* calld = static_cast<CallData*>(elem->call_data);
-  if (calld->original_recv_initial_metadata_ready_ != nullptr) {
-    calld->recv_trailing_metadata_error_ = GRPC_ERROR_REF(error);
-    calld->seen_recv_trailing_metadata_ready_ = true;
-    GRPC_CLOSURE_INIT(&calld->recv_trailing_metadata_ready_,
-                      RecvTrailingMetadataReady, elem,
-                      grpc_schedule_on_exec_ctx);
-    GRPC_CALL_COMBINER_STOP(calld->call_combiner_,
-                            "deferring server recv_trailing_metadata_ready "
-                            "until after recv_initial_metadata_ready");
-    return;
-  }
-  error =
-      grpc_error_add_child(GRPC_ERROR_REF(error),
-                           GRPC_ERROR_REF(calld->recv_initial_metadata_error_));
-  Closure::Run(DEBUG_LOCATION, calld->original_recv_trailing_metadata_ready_,
-               error);
-}
-
-grpc_error* Server::CallData::InitCallElement(
-    grpc_call_element* elem, const grpc_call_element_args* args) {
-  auto* chand = static_cast<ChannelData*>(elem->channel_data);
-  new (elem->call_data) Server::CallData(elem, *args, chand->server());
+  new (elem->channel_data) ChannelData(); 
   return GRPC_ERROR_NONE;
 }
 
-void Server::CallData::DestroyCallElement(
-    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
-    grpc_closure* /*ignored*/) {
-  auto* calld = static_cast<CallData*>(elem->call_data);
-  calld->~CallData();
-}
-
-void Server::CallData::StartTransportStreamOpBatch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
-  auto* calld = static_cast<CallData*>(elem->call_data);
-  calld->StartTransportStreamOpBatchImpl(elem, batch);
-}
-
-}  // namespace grpc_core
-
-//
-// C-core API
-//
-
-grpc_server* grpc_server_create(const grpc_channel_args* args, void* reserved) {
-  grpc_core::ExecCtx exec_ctx;
-  GRPC_API_TRACE("grpc_server_create(%p, %p)", 2, (args, reserved));
-  grpc_server* c_server = new grpc_server;
-  c_server->core_server = grpc_core::MakeOrphanable<grpc_core::Server>(args);
-  return c_server;
+void Server::ChannelData::DestroyChannelElement(grpc_channel_element* elem) { 
+  auto* chand = static_cast<ChannelData*>(elem->channel_data); 
+  chand->~ChannelData(); 
+} 
+ 
+// 
+// Server::CallData 
+// 
+ 
+Server::CallData::CallData(grpc_call_element* elem, 
+                           const grpc_call_element_args& args, 
+                           RefCountedPtr<Server> server) 
+    : server_(std::move(server)), 
+      call_(grpc_call_from_top_element(elem)), 
+      call_combiner_(args.call_combiner) { 
+  GRPC_CLOSURE_INIT(&recv_initial_metadata_ready_, RecvInitialMetadataReady, 
+                    elem, grpc_schedule_on_exec_ctx); 
+  GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_, RecvTrailingMetadataReady, 
+                    elem, grpc_schedule_on_exec_ctx); 
+} 
+ 
+Server::CallData::~CallData() { 
+  GPR_ASSERT(state_.Load(MemoryOrder::RELAXED) != CallState::PENDING); 
+  GRPC_ERROR_UNREF(recv_initial_metadata_error_); 
+  if (host_.has_value()) { 
+    grpc_slice_unref_internal(*host_); 
+  }
+  if (path_.has_value()) { 
+    grpc_slice_unref_internal(*path_); 
+  }
+  grpc_metadata_array_destroy(&initial_metadata_); 
+  grpc_byte_buffer_destroy(payload_); 
 }
 
+void Server::CallData::SetState(CallState state) { 
+  state_.Store(state, MemoryOrder::RELAXED); 
+} 
+ 
+bool Server::CallData::MaybeActivate() { 
+  CallState expected = CallState::PENDING; 
+  return state_.CompareExchangeStrong(&expected, CallState::ACTIVATED, 
+                                      MemoryOrder::ACQ_REL, 
+                                      MemoryOrder::RELAXED); 
+} 
+ 
+void Server::CallData::FailCallCreation() { 
+  CallState expected_not_started = CallState::NOT_STARTED; 
+  CallState expected_pending = CallState::PENDING; 
+  if (state_.CompareExchangeStrong(&expected_not_started, CallState::ZOMBIED, 
+                                   MemoryOrder::ACQ_REL, 
+                                   MemoryOrder::ACQUIRE)) { 
+    KillZombie(); 
+  } else if (state_.CompareExchangeStrong(&expected_pending, CallState::ZOMBIED, 
+                                          MemoryOrder::ACQ_REL, 
+                                          MemoryOrder::RELAXED)) { 
+    // Zombied call will be destroyed when it's removed from the pending 
+    // queue... later. 
+  } 
+} 
+ 
+void Server::CallData::Start(grpc_call_element* elem) { 
+  grpc_op op; 
+  op.op = GRPC_OP_RECV_INITIAL_METADATA; 
+  op.flags = 0; 
+  op.reserved = nullptr; 
+  op.data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_; 
+  GRPC_CLOSURE_INIT(&recv_initial_metadata_batch_complete_, 
+                    RecvInitialMetadataBatchComplete, elem, 
+                    grpc_schedule_on_exec_ctx); 
+  grpc_call_start_batch_and_execute(call_, &op, 1, 
+                                    &recv_initial_metadata_batch_complete_); 
+} 
+ 
+void Server::CallData::Publish(size_t cq_idx, RequestedCall* rc) { 
+  grpc_call_set_completion_queue(call_, rc->cq_bound_to_call); 
+  *rc->call = call_; 
+  cq_new_ = server_->cqs_[cq_idx]; 
+  GPR_SWAP(grpc_metadata_array, *rc->initial_metadata, initial_metadata_); 
+  switch (rc->type) { 
+    case RequestedCall::Type::BATCH_CALL: 
+      GPR_ASSERT(host_.has_value()); 
+      GPR_ASSERT(path_.has_value()); 
+      rc->data.batch.details->host = grpc_slice_ref_internal(*host_); 
+      rc->data.batch.details->method = grpc_slice_ref_internal(*path_); 
+      rc->data.batch.details->deadline = 
+          grpc_millis_to_timespec(deadline_, GPR_CLOCK_MONOTONIC); 
+      rc->data.batch.details->flags = recv_initial_metadata_flags_; 
+      break; 
+    case RequestedCall::Type::REGISTERED_CALL: 
+      *rc->data.registered.deadline = 
+          grpc_millis_to_timespec(deadline_, GPR_CLOCK_MONOTONIC); 
+      if (rc->data.registered.optional_payload != nullptr) { 
+        *rc->data.registered.optional_payload = payload_; 
+        payload_ = nullptr; 
+      } 
+      break; 
+    default: 
+      GPR_UNREACHABLE_CODE(return ); 
+  } 
+  grpc_cq_end_op(cq_new_, rc->tag, GRPC_ERROR_NONE, Server::DoneRequestEvent, 
+                 rc, &rc->completion, true); 
+} 
+ 
+void Server::CallData::PublishNewRpc(void* arg, grpc_error* error) { 
+  grpc_call_element* call_elem = static_cast<grpc_call_element*>(arg); 
+  auto* calld = static_cast<Server::CallData*>(call_elem->call_data); 
+  auto* chand = static_cast<Server::ChannelData*>(call_elem->channel_data); 
+  RequestMatcherInterface* rm = calld->matcher_; 
+  Server* server = rm->server(); 
+  if (error != GRPC_ERROR_NONE || 
+      server->shutdown_flag_.load(std::memory_order_acquire)) { 
+    calld->state_.Store(CallState::ZOMBIED, MemoryOrder::RELAXED); 
+    calld->KillZombie(); 
+    return; 
+  } 
+  rm->MatchOrQueue(chand->cq_idx(), calld); 
+} 
+ 
+namespace { 
+ 
+void KillZombieClosure(void* call, grpc_error* /*error*/) { 
+  grpc_call_unref(static_cast<grpc_call*>(call)); 
+} 
+ 
+}  // namespace 
+ 
+void Server::CallData::KillZombie() { 
+  GRPC_CLOSURE_INIT(&kill_zombie_closure_, KillZombieClosure, call_, 
+                    grpc_schedule_on_exec_ctx); 
+  ExecCtx::Run(DEBUG_LOCATION, &kill_zombie_closure_, GRPC_ERROR_NONE); 
+} 
+ 
+void Server::CallData::StartNewRpc(grpc_call_element* elem) { 
+  auto* chand = static_cast<ChannelData*>(elem->channel_data); 
+  if (server_->shutdown_flag_.load(std::memory_order_acquire)) { 
+    state_.Store(CallState::ZOMBIED, MemoryOrder::RELAXED); 
+    KillZombie(); 
+    return; 
+  } 
+  // Find request matcher. 
+  matcher_ = server_->unregistered_request_matcher_.get(); 
+  grpc_server_register_method_payload_handling payload_handling = 
+      GRPC_SRM_PAYLOAD_NONE; 
+  if (path_.has_value() && host_.has_value()) { 
+    ChannelRegisteredMethod* rm = 
+        chand->GetRegisteredMethod(*host_, *path_, 
+                                   (recv_initial_metadata_flags_ & 
+                                    GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST)); 
+    if (rm != nullptr) { 
+      matcher_ = rm->server_registered_method->matcher.get(); 
+      payload_handling = rm->server_registered_method->payload_handling; 
+    } 
+  } 
+  // Start recv_message op if needed. 
+  switch (payload_handling) { 
+    case GRPC_SRM_PAYLOAD_NONE: 
+      PublishNewRpc(elem, GRPC_ERROR_NONE); 
+      break; 
+    case GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER: { 
+      grpc_op op; 
+      op.op = GRPC_OP_RECV_MESSAGE; 
+      op.flags = 0; 
+      op.reserved = nullptr; 
+      op.data.recv_message.recv_message = &payload_; 
+      GRPC_CLOSURE_INIT(&publish_, PublishNewRpc, elem, 
+                        grpc_schedule_on_exec_ctx); 
+      grpc_call_start_batch_and_execute(call_, &op, 1, &publish_); 
+      break; 
+    } 
+  } 
+} 
+ 
+void Server::CallData::RecvInitialMetadataBatchComplete(void* arg, 
+                                                        grpc_error* error) { 
+  grpc_call_element* elem = static_cast<grpc_call_element*>(arg); 
+  auto* calld = static_cast<Server::CallData*>(elem->call_data); 
+  if (error != GRPC_ERROR_NONE) { 
+    calld->FailCallCreation(); 
+    return; 
+  } 
+  calld->StartNewRpc(elem); 
+} 
+ 
+void Server::CallData::StartTransportStreamOpBatchImpl( 
+    grpc_call_element* elem, grpc_transport_stream_op_batch* batch) { 
+  if (batch->recv_initial_metadata) { 
+    GPR_ASSERT(batch->payload->recv_initial_metadata.recv_flags == nullptr); 
+    recv_initial_metadata_ = 
+        batch->payload->recv_initial_metadata.recv_initial_metadata; 
+    original_recv_initial_metadata_ready_ = 
+        batch->payload->recv_initial_metadata.recv_initial_metadata_ready; 
+    batch->payload->recv_initial_metadata.recv_initial_metadata_ready = 
+        &recv_initial_metadata_ready_; 
+    batch->payload->recv_initial_metadata.recv_flags = 
+        &recv_initial_metadata_flags_; 
+  } 
+  if (batch->recv_trailing_metadata) { 
+    original_recv_trailing_metadata_ready_ = 
+        batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready; 
+    batch->payload->recv_trailing_metadata.recv_trailing_metadata_ready = 
+        &recv_trailing_metadata_ready_; 
+  } 
+  grpc_call_next_op(elem, batch); 
+} 
+ 
+void Server::CallData::RecvInitialMetadataReady(void* ptr, grpc_error* error) { 
+  grpc_call_element* elem = static_cast<grpc_call_element*>(ptr); 
+  CallData* calld = static_cast<CallData*>(elem->call_data); 
+  grpc_millis op_deadline; 
+  if (error == GRPC_ERROR_NONE) { 
+    GPR_DEBUG_ASSERT(calld->recv_initial_metadata_->idx.named.path != nullptr); 
+    GPR_DEBUG_ASSERT(calld->recv_initial_metadata_->idx.named.authority != 
+                     nullptr); 
+    calld->path_.emplace(grpc_slice_ref_internal( 
+        GRPC_MDVALUE(calld->recv_initial_metadata_->idx.named.path->md))); 
+    calld->host_.emplace(grpc_slice_ref_internal( 
+        GRPC_MDVALUE(calld->recv_initial_metadata_->idx.named.authority->md))); 
+    grpc_metadata_batch_remove(calld->recv_initial_metadata_, GRPC_BATCH_PATH); 
+    grpc_metadata_batch_remove(calld->recv_initial_metadata_, 
+                               GRPC_BATCH_AUTHORITY); 
+  } else { 
+    GRPC_ERROR_REF(error); 
+  } 
+  op_deadline = calld->recv_initial_metadata_->deadline; 
+  if (op_deadline != GRPC_MILLIS_INF_FUTURE) { 
+    calld->deadline_ = op_deadline; 
+  } 
+  if (calld->host_.has_value() && calld->path_.has_value()) { 
+    /* do nothing */ 
+  } else { 
+    /* Pass the error reference to calld->recv_initial_metadata_error */ 
+    grpc_error* src_error = error; 
+    error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( 
+        "Missing :authority or :path", &src_error, 1); 
+    GRPC_ERROR_UNREF(src_error); 
+    calld->recv_initial_metadata_error_ = GRPC_ERROR_REF(error); 
+  } 
+  grpc_closure* closure = calld->original_recv_initial_metadata_ready_; 
+  calld->original_recv_initial_metadata_ready_ = nullptr; 
+  if (calld->seen_recv_trailing_metadata_ready_) { 
+    GRPC_CALL_COMBINER_START(calld->call_combiner_, 
+                             &calld->recv_trailing_metadata_ready_, 
+                             calld->recv_trailing_metadata_error_, 
+                             "continue server recv_trailing_metadata_ready"); 
+  } 
+  Closure::Run(DEBUG_LOCATION, closure, error); 
+} 
+ 
+void Server::CallData::RecvTrailingMetadataReady(void* user_data, 
+                                                 grpc_error* error) { 
+  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data); 
+  CallData* calld = static_cast<CallData*>(elem->call_data); 
+  if (calld->original_recv_initial_metadata_ready_ != nullptr) { 
+    calld->recv_trailing_metadata_error_ = GRPC_ERROR_REF(error); 
+    calld->seen_recv_trailing_metadata_ready_ = true; 
+    GRPC_CLOSURE_INIT(&calld->recv_trailing_metadata_ready_, 
+                      RecvTrailingMetadataReady, elem, 
+                      grpc_schedule_on_exec_ctx); 
+    GRPC_CALL_COMBINER_STOP(calld->call_combiner_, 
+                            "deferring server recv_trailing_metadata_ready " 
+                            "until after recv_initial_metadata_ready"); 
+    return; 
+  } 
+  error = 
+      grpc_error_add_child(GRPC_ERROR_REF(error), 
+                           GRPC_ERROR_REF(calld->recv_initial_metadata_error_)); 
+  Closure::Run(DEBUG_LOCATION, calld->original_recv_trailing_metadata_ready_, 
+               error); 
+} 
+ 
+grpc_error* Server::CallData::InitCallElement( 
+    grpc_call_element* elem, const grpc_call_element_args* args) { 
+  auto* chand = static_cast<ChannelData*>(elem->channel_data); 
+  new (elem->call_data) Server::CallData(elem, *args, chand->server()); 
+  return GRPC_ERROR_NONE; 
+} 
+ 
+void Server::CallData::DestroyCallElement( 
+    grpc_call_element* elem, const grpc_call_final_info* /*final_info*/, 
+    grpc_closure* /*ignored*/) { 
+  auto* calld = static_cast<CallData*>(elem->call_data); 
+  calld->~CallData(); 
+} 
+ 
+void Server::CallData::StartTransportStreamOpBatch( 
+    grpc_call_element* elem, grpc_transport_stream_op_batch* batch) { 
+  auto* calld = static_cast<CallData*>(elem->call_data); 
+  calld->StartTransportStreamOpBatchImpl(elem, batch); 
+} 
+
+}  // namespace grpc_core 
+ 
+// 
+// C-core API 
+// 
+ 
+grpc_server* grpc_server_create(const grpc_channel_args* args, void* reserved) { 
+  grpc_core::ExecCtx exec_ctx; 
+  GRPC_API_TRACE("grpc_server_create(%p, %p)", 2, (args, reserved)); 
+  grpc_server* c_server = new grpc_server; 
+  c_server->core_server = grpc_core::MakeOrphanable<grpc_core::Server>(args); 
+  return c_server; 
+} 
+ 
 void grpc_server_register_completion_queue(grpc_server* server,
                                            grpc_completion_queue* cq,
                                            void* reserved) {
   GRPC_API_TRACE(
       "grpc_server_register_completion_queue(server=%p, cq=%p, reserved=%p)", 3,
       (server, cq, reserved));
-  GPR_ASSERT(!reserved);
+  GPR_ASSERT(!reserved); 
   auto cq_type = grpc_get_cq_completion_type(cq);
   if (cq_type != GRPC_CQ_NEXT && cq_type != GRPC_CQ_CALLBACK) {
     gpr_log(GPR_INFO,
@@ -1468,7 +1468,7 @@ void grpc_server_register_completion_queue(grpc_server* server,
     /* Ideally we should log an error and abort but ruby-wrapped-language API
        calls grpc_completion_queue_pluck() on server completion queues */
   }
-  server->core_server->RegisterCompletionQueue(cq);
+  server->core_server->RegisterCompletionQueue(cq); 
 }
 
 void* grpc_server_register_method(
@@ -1479,14 +1479,14 @@ void* grpc_server_register_method(
       "grpc_server_register_method(server=%p, method=%s, host=%s, "
       "flags=0x%08x)",
       4, (server, method, host, flags));
-  return server->core_server->RegisterMethod(method, host, payload_handling,
-                                             flags);
+  return server->core_server->RegisterMethod(method, host, payload_handling, 
+                                             flags); 
 }
 
 void grpc_server_start(grpc_server* server) {
   grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE("grpc_server_start(server=%p)", 1, (server));
-  server->core_server->Start();
+  server->core_server->Start(); 
 }
 
 void grpc_server_shutdown_and_notify(grpc_server* server,
@@ -1495,26 +1495,26 @@ void grpc_server_shutdown_and_notify(grpc_server* server,
   grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE("grpc_server_shutdown_and_notify(server=%p, cq=%p, tag=%p)", 3,
                  (server, cq, tag));
-  server->core_server->ShutdownAndNotify(cq, tag);
+  server->core_server->ShutdownAndNotify(cq, tag); 
 }
 
 void grpc_server_cancel_all_calls(grpc_server* server) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE("grpc_server_cancel_all_calls(server=%p)", 1, (server));
-  server->core_server->CancelAllCalls();
+  server->core_server->CancelAllCalls(); 
 }
 
 void grpc_server_destroy(grpc_server* server) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE("grpc_server_destroy(server=%p)", 1, (server));
-  delete server;
+  delete server; 
 }
 
 grpc_call_error grpc_server_request_call(
     grpc_server* server, grpc_call** call, grpc_call_details* details,
-    grpc_metadata_array* request_metadata,
+    grpc_metadata_array* request_metadata, 
     grpc_completion_queue* cq_bound_to_call,
     grpc_completion_queue* cq_for_notification, void* tag) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
@@ -1525,31 +1525,31 @@ grpc_call_error grpc_server_request_call(
       "server=%p, call=%p, details=%p, initial_metadata=%p, "
       "cq_bound_to_call=%p, cq_for_notification=%p, tag=%p)",
       7,
-      (server, call, details, request_metadata, cq_bound_to_call,
+      (server, call, details, request_metadata, cq_bound_to_call, 
        cq_for_notification, tag));
-  return server->core_server->RequestCall(call, details, request_metadata,
-                                          cq_bound_to_call, cq_for_notification,
-                                          tag);
+  return server->core_server->RequestCall(call, details, request_metadata, 
+                                          cq_bound_to_call, cq_for_notification, 
+                                          tag); 
 }
 
 grpc_call_error grpc_server_request_registered_call(
     grpc_server* server, void* rmp, grpc_call** call, gpr_timespec* deadline,
-    grpc_metadata_array* request_metadata, grpc_byte_buffer** optional_payload,
+    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) {
+    grpc_completion_queue* cq_for_notification, void* tag_new) { 
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   GRPC_STATS_INC_SERVER_REQUESTED_CALLS();
-  auto* rm = static_cast<grpc_core::Server::RegisteredMethod*>(rmp);
+  auto* rm = static_cast<grpc_core::Server::RegisteredMethod*>(rmp); 
   GRPC_API_TRACE(
       "grpc_server_request_registered_call("
-      "server=%p, rmp=%p, call=%p, deadline=%p, request_metadata=%p, "
+      "server=%p, rmp=%p, call=%p, deadline=%p, request_metadata=%p, " 
       "optional_payload=%p, cq_bound_to_call=%p, cq_for_notification=%p, "
       "tag=%p)",
       9,
-      (server, rmp, call, deadline, request_metadata, optional_payload,
-       cq_bound_to_call, cq_for_notification, tag_new));
-  return server->core_server->RequestRegisteredCall(
-      rm, call, deadline, request_metadata, optional_payload, cq_bound_to_call,
-      cq_for_notification, tag_new);
+      (server, rmp, call, deadline, request_metadata, optional_payload, 
+       cq_bound_to_call, cq_for_notification, tag_new)); 
+  return server->core_server->RequestRegisteredCall( 
+      rm, call, deadline, request_metadata, optional_payload, cq_bound_to_call, 
+      cq_for_notification, tag_new); 
 }
diff --git a/contrib/libs/grpc/src/core/lib/surface/server.h b/contrib/libs/grpc/src/core/lib/surface/server.h
index f4f4ff6449..9eeca08dc4 100644
--- a/contrib/libs/grpc/src/core/lib/surface/server.h
+++ b/contrib/libs/grpc/src/core/lib/surface/server.h
@@ -1,397 +1,397 @@
-//
-// 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.
-//
+// 
+// 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_CORE_LIB_SURFACE_SERVER_H
 #define GRPC_CORE_LIB_SURFACE_SERVER_H
 
 #include <grpc/support/port_platform.h>
 
-#include <list>
-#include <vector>
-
-#include "y_absl/types/optional.h"
-
+#include <list> 
+#include <vector> 
+ 
+#include "y_absl/types/optional.h" 
+ 
 #include <grpc/grpc.h>
-
-#include "src/core/lib/channel/channel_args.h"
+ 
+#include "src/core/lib/channel/channel_args.h" 
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/atomic.h"
-#include "src/core/lib/surface/completion_queue.h"
+#include "src/core/lib/gprpp/atomic.h" 
+#include "src/core/lib/surface/completion_queue.h" 
 #include "src/core/lib/transport/transport.h"
 
-namespace grpc_core {
-
-extern TraceFlag grpc_server_channel_trace;
-
-class Server : public InternallyRefCounted<Server> {
- public:
-  // Filter vtable.
-  static const grpc_channel_filter kServerTopFilter;
-
-  // Opaque type used for registered methods.
-  struct RegisteredMethod;
-
-  // An object to represent the most relevant characteristics of a
-  // newly-allocated call object when using an AllocatingRequestMatcherBatch.
-  struct BatchCallAllocation {
-    grpc_experimental_completion_queue_functor* tag;
-    grpc_call** call;
-    grpc_metadata_array* initial_metadata;
-    grpc_call_details* details;
-  };
-
-  // An object to represent the most relevant characteristics of a
-  // newly-allocated call object when using an
-  // AllocatingRequestMatcherRegistered.
-  struct RegisteredCallAllocation {
-    grpc_experimental_completion_queue_functor* tag;
-    grpc_call** call;
-    grpc_metadata_array* initial_metadata;
-    gpr_timespec* deadline;
-    grpc_byte_buffer** optional_payload;
-  };
-
-  /// Interface for listeners.
-  /// Implementations must override the Orphan() method, which should stop
-  /// listening and initiate destruction of the listener.
-  class ListenerInterface : public Orphanable {
-   public:
-    virtual ~ListenerInterface() = default;
-
-    /// Starts listening. This listener may refer to the pollset object beyond
-    /// this call, so it is a pointer rather than a reference.
-    virtual void Start(Server* server,
-                       const std::vector<grpc_pollset*>* pollsets) = 0;
-
-    /// Returns the channelz node for the listen socket, or null if not
-    /// supported.
-    virtual channelz::ListenSocketNode* channelz_listen_socket_node() const = 0;
-
-    /// Sets a closure to be invoked by the listener when its destruction
-    /// is complete.
-    virtual void SetOnDestroyDone(grpc_closure* on_destroy_done) = 0;
-  };
-
-  explicit Server(const grpc_channel_args* args);
-  ~Server();
-
-  void Orphan() override;
-
-  const grpc_channel_args* channel_args() const { return channel_args_; }
-  grpc_resource_user* default_resource_user() const {
-    return default_resource_user_;
-  }
-  channelz::ServerNode* channelz_node() const { return channelz_node_.get(); }
-
-  // Do not call this before Start(). Returns the pollsets. The
-  // vector itself is immutable, but the pollsets inside are mutable. The
-  // result is valid for the lifetime of the server.
-  const std::vector<grpc_pollset*>& pollsets() const { return pollsets_; }
-
-  bool HasOpenConnections();
-
-  // Adds a listener to the server.  When the server starts, it will call
-  // the listener's Start() method, and when it shuts down, it will orphan
-  // the listener.
-  void AddListener(OrphanablePtr<ListenerInterface> listener);
-
-  // Starts listening for connections.
-  void Start();
-
-  // Sets up a transport.  Creates a channel stack and binds the transport to
-  // the server.  Called from the listener when a new connection is accepted.
-  void SetupTransport(grpc_transport* transport,
-                      grpc_pollset* accepting_pollset,
-                      const grpc_channel_args* args,
-                      const RefCountedPtr<channelz::SocketNode>& socket_node,
-                      grpc_resource_user* resource_user = nullptr);
-
-  void RegisterCompletionQueue(grpc_completion_queue* cq);
-
-  // Functions to specify that a specific registered method or the unregistered
-  // collection should use a specific allocator for request matching.
-  void SetRegisteredMethodAllocator(
-      grpc_completion_queue* cq, void* method_tag,
-      std::function<RegisteredCallAllocation()> allocator);
-  void SetBatchMethodAllocator(grpc_completion_queue* cq,
-                               std::function<BatchCallAllocation()> allocator);
-
-  RegisteredMethod* RegisterMethod(
-      const char* method, const char* host,
-      grpc_server_register_method_payload_handling payload_handling,
-      uint32_t flags);
-
-  grpc_call_error RequestCall(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);
-
-  grpc_call_error RequestRegisteredCall(
-      RegisteredMethod* rm, 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);
-
-  void ShutdownAndNotify(grpc_completion_queue* cq, void* tag);
-
-  void CancelAllCalls();
-
- private:
-  struct RequestedCall;
-
-  struct ChannelRegisteredMethod {
-    RegisteredMethod* server_registered_method = nullptr;
-    uint32_t flags;
-    bool has_host;
-    ExternallyManagedSlice method;
-    ExternallyManagedSlice host;
-  };
-
-  class RequestMatcherInterface;
-  class RealRequestMatcher;
-  class AllocatingRequestMatcherBase;
-  class AllocatingRequestMatcherBatch;
-  class AllocatingRequestMatcherRegistered;
-
-  class ChannelData {
-   public:
-    ChannelData() = default;
-    ~ChannelData();
-
-    void InitTransport(RefCountedPtr<Server> server, grpc_channel* channel,
-                       size_t cq_idx, grpc_transport* transport,
-                       intptr_t channelz_socket_uuid);
-
-    RefCountedPtr<Server> server() const { return server_; }
-    grpc_channel* channel() const { return channel_; }
-    size_t cq_idx() const { return cq_idx_; }
-
-    ChannelRegisteredMethod* GetRegisteredMethod(const grpc_slice& host,
-                                                 const grpc_slice& path,
-                                                 bool is_idempotent);
-
-    // Filter vtable functions.
-    static grpc_error* InitChannelElement(grpc_channel_element* elem,
-                                          grpc_channel_element_args* args);
-    static void DestroyChannelElement(grpc_channel_element* elem);
-
-   private:
-    class ConnectivityWatcher;
-
-    static void AcceptStream(void* arg, grpc_transport* /*transport*/,
-                             const void* transport_server_data);
-
-    void Destroy();
-
-    static void FinishDestroy(void* arg, grpc_error* error);
-
-    RefCountedPtr<Server> server_;
-    grpc_channel* channel_;
-    // The index into Server::cqs_ of the CQ used as a starting point for
-    // where to publish new incoming calls.
-    size_t cq_idx_;
-    y_absl::optional<std::list<ChannelData*>::iterator> list_position_;
-    // A hash-table of the methods and hosts of the registered methods.
-    // TODO(vjpai): Convert this to an STL map type as opposed to a direct
-    // bucket implementation. (Consider performance impact, hash function to
-    // use, etc.)
-    std::unique_ptr<std::vector<ChannelRegisteredMethod>> registered_methods_;
-    uint32_t registered_method_max_probes_;
-    grpc_closure finish_destroy_channel_closure_;
-    intptr_t channelz_socket_uuid_;
-  };
-
-  class CallData {
-   public:
-    enum class CallState {
-      NOT_STARTED,  // Waiting for metadata.
-      PENDING,      // Initial metadata read, not flow controlled in yet.
-      ACTIVATED,    // Flow controlled in, on completion queue.
-      ZOMBIED,      // Cancelled before being queued.
-    };
-
-    CallData(grpc_call_element* elem, const grpc_call_element_args& args,
-             RefCountedPtr<Server> server);
-    ~CallData();
-
-    // Starts the recv_initial_metadata batch on the call.
-    // Invoked from ChannelData::AcceptStream().
-    void Start(grpc_call_element* elem);
-
-    void SetState(CallState state);
-
-    // Attempts to move from PENDING to ACTIVATED state.  Returns true
-    // on success.
-    bool MaybeActivate();
-
-    // Publishes an incoming call to the application after it has been
-    // matched.
-    void Publish(size_t cq_idx, RequestedCall* rc);
-
-    void KillZombie();
-
-    void FailCallCreation();
-
-    // Filter vtable functions.
-    static grpc_error* InitCallElement(grpc_call_element* elem,
-                                       const grpc_call_element_args* args);
-    static void DestroyCallElement(grpc_call_element* elem,
-                                   const grpc_call_final_info* /*final_info*/,
-                                   grpc_closure* /*ignored*/);
-    static void StartTransportStreamOpBatch(
-        grpc_call_element* elem, grpc_transport_stream_op_batch* batch);
-
-   private:
-    // Helper functions for handling calls at the top of the call stack.
-    static void RecvInitialMetadataBatchComplete(void* arg, grpc_error* error);
-    void StartNewRpc(grpc_call_element* elem);
-    static void PublishNewRpc(void* arg, grpc_error* error);
-
-    // Functions used inside the call stack.
-    void StartTransportStreamOpBatchImpl(grpc_call_element* elem,
-                                         grpc_transport_stream_op_batch* batch);
-    static void RecvInitialMetadataReady(void* arg, grpc_error* error);
-    static void RecvTrailingMetadataReady(void* arg, grpc_error* error);
-
-    RefCountedPtr<Server> server_;
-
-    grpc_call* call_;
-
-    Atomic<CallState> state_{CallState::NOT_STARTED};
-
-    y_absl::optional<grpc_slice> path_;
-    y_absl::optional<grpc_slice> host_;
-    grpc_millis deadline_ = GRPC_MILLIS_INF_FUTURE;
-
-    grpc_completion_queue* cq_new_ = nullptr;
-
-    RequestMatcherInterface* matcher_ = nullptr;
-    grpc_byte_buffer* payload_ = nullptr;
-
-    grpc_closure kill_zombie_closure_;
-
-    grpc_metadata_array initial_metadata_ =
-        grpc_metadata_array();  // Zero-initialize the C struct.
-    grpc_closure recv_initial_metadata_batch_complete_;
-
-    grpc_metadata_batch* recv_initial_metadata_ = nullptr;
-    uint32_t recv_initial_metadata_flags_ = 0;
-    grpc_closure recv_initial_metadata_ready_;
-    grpc_closure* original_recv_initial_metadata_ready_;
-    grpc_error* recv_initial_metadata_error_ = GRPC_ERROR_NONE;
-
-    bool seen_recv_trailing_metadata_ready_ = false;
-    grpc_closure recv_trailing_metadata_ready_;
-    grpc_closure* original_recv_trailing_metadata_ready_;
-    grpc_error* recv_trailing_metadata_error_ = GRPC_ERROR_NONE;
-
-    grpc_closure publish_;
-
-    CallCombiner* call_combiner_;
-  };
-
-  struct Listener {
-    explicit Listener(OrphanablePtr<ListenerInterface> l)
-        : listener(std::move(l)) {}
-    OrphanablePtr<ListenerInterface> listener;
-    grpc_closure destroy_done;
-  };
-
-  struct ShutdownTag {
-    ShutdownTag(void* tag_arg, grpc_completion_queue* cq_arg)
-        : tag(tag_arg), cq(cq_arg) {}
-    void* const tag;
-    grpc_completion_queue* const cq;
-    grpc_cq_completion completion;
-  };
-
-  static void ListenerDestroyDone(void* arg, grpc_error* error);
-
-  static void DoneShutdownEvent(void* server,
-                                grpc_cq_completion* /*completion*/) {
-    static_cast<Server*>(server)->Unref();
-  }
-
-  static void DoneRequestEvent(void* req, grpc_cq_completion* completion);
-
-  void FailCall(size_t cq_idx, RequestedCall* rc, grpc_error* error);
-  grpc_call_error QueueRequestedCall(size_t cq_idx, RequestedCall* rc);
-
-  void MaybeFinishShutdown();
-
-  void KillPendingWorkLocked(grpc_error* error);
-
-  static grpc_call_error ValidateServerRequest(
-      grpc_completion_queue* cq_for_notification, void* tag,
-      grpc_byte_buffer** optional_payload, RegisteredMethod* rm);
-  grpc_call_error ValidateServerRequestAndCq(
-      size_t* cq_idx, grpc_completion_queue* cq_for_notification, void* tag,
-      grpc_byte_buffer** optional_payload, RegisteredMethod* rm);
-
-  std::vector<grpc_channel*> GetChannelsLocked() const;
-
-  grpc_channel_args* const channel_args_;
-  grpc_resource_user* default_resource_user_ = nullptr;
-  RefCountedPtr<channelz::ServerNode> channelz_node_;
-
-  std::vector<grpc_completion_queue*> cqs_;
-  std::vector<grpc_pollset*> pollsets_;
-  bool started_ = false;
-
-  // The two following mutexes control access to server-state.
-  // mu_global_ controls access to non-call-related state (e.g., channel state).
-  // mu_call_ controls access to call-related state (e.g., the call lists).
-  //
-  // If they are ever required to be nested, you must lock mu_global_
-  // before mu_call_. This is currently used in shutdown processing
-  // (ShutdownAndNotify() and MaybeFinishShutdown()).
-  Mutex mu_global_;  // mutex for server and channel state
-  Mutex mu_call_;    // mutex for call-specific state
-
-  // startup synchronization: flag is protected by mu_global_, signals whether
-  // we are doing the listener start routine or not.
-  bool starting_ = false;
-  CondVar starting_cv_;
-
-  std::vector<std::unique_ptr<RegisteredMethod>> registered_methods_;
-
-  // Request matcher for unregistered methods.
-  std::unique_ptr<RequestMatcherInterface> unregistered_request_matcher_;
-
-  std::atomic_bool shutdown_flag_{false};
-  bool shutdown_published_ = false;
-  std::vector<ShutdownTag> shutdown_tags_;
-
-  std::list<ChannelData*> channels_;
-
-  std::list<Listener> listeners_;
-  size_t listeners_destroyed_ = 0;
-
-  // The last time we printed a shutdown progress message.
-  gpr_timespec last_shutdown_message_time_;
-};
-
-}  // namespace grpc_core
-
-struct grpc_server {
-  grpc_core::OrphanablePtr<grpc_core::Server> core_server;
-};
-
+namespace grpc_core { 
+
+extern TraceFlag grpc_server_channel_trace; 
+
+class Server : public InternallyRefCounted<Server> { 
+ public: 
+  // Filter vtable. 
+  static const grpc_channel_filter kServerTopFilter; 
+
+  // Opaque type used for registered methods. 
+  struct RegisteredMethod; 
+
+  // An object to represent the most relevant characteristics of a 
+  // newly-allocated call object when using an AllocatingRequestMatcherBatch. 
+  struct BatchCallAllocation { 
+    grpc_experimental_completion_queue_functor* tag; 
+    grpc_call** call; 
+    grpc_metadata_array* initial_metadata; 
+    grpc_call_details* details; 
+  }; 
+
+  // An object to represent the most relevant characteristics of a 
+  // newly-allocated call object when using an 
+  // AllocatingRequestMatcherRegistered. 
+  struct RegisteredCallAllocation { 
+    grpc_experimental_completion_queue_functor* tag; 
+    grpc_call** call; 
+    grpc_metadata_array* initial_metadata; 
+    gpr_timespec* deadline; 
+    grpc_byte_buffer** optional_payload; 
+  }; 
+
+  /// Interface for listeners. 
+  /// Implementations must override the Orphan() method, which should stop 
+  /// listening and initiate destruction of the listener. 
+  class ListenerInterface : public Orphanable { 
+   public: 
+    virtual ~ListenerInterface() = default; 
+
+    /// Starts listening. This listener may refer to the pollset object beyond 
+    /// this call, so it is a pointer rather than a reference. 
+    virtual void Start(Server* server, 
+                       const std::vector<grpc_pollset*>* pollsets) = 0; 
+
+    /// Returns the channelz node for the listen socket, or null if not 
+    /// supported. 
+    virtual channelz::ListenSocketNode* channelz_listen_socket_node() const = 0; 
+
+    /// Sets a closure to be invoked by the listener when its destruction 
+    /// is complete. 
+    virtual void SetOnDestroyDone(grpc_closure* on_destroy_done) = 0; 
+  }; 
+ 
+  explicit Server(const grpc_channel_args* args); 
+  ~Server(); 
+ 
+  void Orphan() override; 
+ 
+  const grpc_channel_args* channel_args() const { return channel_args_; } 
+  grpc_resource_user* default_resource_user() const { 
+    return default_resource_user_; 
+  } 
+  channelz::ServerNode* channelz_node() const { return channelz_node_.get(); } 
+ 
+  // Do not call this before Start(). Returns the pollsets. The 
+  // vector itself is immutable, but the pollsets inside are mutable. The 
+  // result is valid for the lifetime of the server. 
+  const std::vector<grpc_pollset*>& pollsets() const { return pollsets_; } 
+ 
+  bool HasOpenConnections(); 
+ 
+  // Adds a listener to the server.  When the server starts, it will call 
+  // the listener's Start() method, and when it shuts down, it will orphan 
+  // the listener. 
+  void AddListener(OrphanablePtr<ListenerInterface> listener); 
+ 
+  // Starts listening for connections. 
+  void Start(); 
+ 
+  // Sets up a transport.  Creates a channel stack and binds the transport to 
+  // the server.  Called from the listener when a new connection is accepted. 
+  void SetupTransport(grpc_transport* transport, 
+                      grpc_pollset* accepting_pollset, 
+                      const grpc_channel_args* args, 
+                      const RefCountedPtr<channelz::SocketNode>& socket_node, 
+                      grpc_resource_user* resource_user = nullptr); 
+ 
+  void RegisterCompletionQueue(grpc_completion_queue* cq); 
+ 
+  // Functions to specify that a specific registered method or the unregistered 
+  // collection should use a specific allocator for request matching. 
+  void SetRegisteredMethodAllocator( 
+      grpc_completion_queue* cq, void* method_tag, 
+      std::function<RegisteredCallAllocation()> allocator); 
+  void SetBatchMethodAllocator(grpc_completion_queue* cq, 
+                               std::function<BatchCallAllocation()> allocator); 
+ 
+  RegisteredMethod* RegisterMethod( 
+      const char* method, const char* host, 
+      grpc_server_register_method_payload_handling payload_handling, 
+      uint32_t flags); 
+ 
+  grpc_call_error RequestCall(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); 
+ 
+  grpc_call_error RequestRegisteredCall( 
+      RegisteredMethod* rm, 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); 
+ 
+  void ShutdownAndNotify(grpc_completion_queue* cq, void* tag); 
+ 
+  void CancelAllCalls(); 
+ 
+ private: 
+  struct RequestedCall; 
+ 
+  struct ChannelRegisteredMethod { 
+    RegisteredMethod* server_registered_method = nullptr; 
+    uint32_t flags; 
+    bool has_host; 
+    ExternallyManagedSlice method; 
+    ExternallyManagedSlice host; 
+  }; 
+ 
+  class RequestMatcherInterface; 
+  class RealRequestMatcher; 
+  class AllocatingRequestMatcherBase; 
+  class AllocatingRequestMatcherBatch; 
+  class AllocatingRequestMatcherRegistered; 
+ 
+  class ChannelData { 
+   public: 
+    ChannelData() = default; 
+    ~ChannelData(); 
+ 
+    void InitTransport(RefCountedPtr<Server> server, grpc_channel* channel, 
+                       size_t cq_idx, grpc_transport* transport, 
+                       intptr_t channelz_socket_uuid); 
+ 
+    RefCountedPtr<Server> server() const { return server_; } 
+    grpc_channel* channel() const { return channel_; } 
+    size_t cq_idx() const { return cq_idx_; } 
+ 
+    ChannelRegisteredMethod* GetRegisteredMethod(const grpc_slice& host, 
+                                                 const grpc_slice& path, 
+                                                 bool is_idempotent); 
+ 
+    // Filter vtable functions. 
+    static grpc_error* InitChannelElement(grpc_channel_element* elem, 
+                                          grpc_channel_element_args* args); 
+    static void DestroyChannelElement(grpc_channel_element* elem); 
+ 
+   private: 
+    class ConnectivityWatcher; 
+ 
+    static void AcceptStream(void* arg, grpc_transport* /*transport*/, 
+                             const void* transport_server_data); 
+ 
+    void Destroy(); 
+ 
+    static void FinishDestroy(void* arg, grpc_error* error); 
+ 
+    RefCountedPtr<Server> server_; 
+    grpc_channel* channel_; 
+    // The index into Server::cqs_ of the CQ used as a starting point for 
+    // where to publish new incoming calls. 
+    size_t cq_idx_; 
+    y_absl::optional<std::list<ChannelData*>::iterator> list_position_; 
+    // A hash-table of the methods and hosts of the registered methods. 
+    // TODO(vjpai): Convert this to an STL map type as opposed to a direct 
+    // bucket implementation. (Consider performance impact, hash function to 
+    // use, etc.) 
+    std::unique_ptr<std::vector<ChannelRegisteredMethod>> registered_methods_; 
+    uint32_t registered_method_max_probes_; 
+    grpc_closure finish_destroy_channel_closure_; 
+    intptr_t channelz_socket_uuid_; 
+  }; 
+ 
+  class CallData { 
+   public: 
+    enum class CallState { 
+      NOT_STARTED,  // Waiting for metadata. 
+      PENDING,      // Initial metadata read, not flow controlled in yet. 
+      ACTIVATED,    // Flow controlled in, on completion queue. 
+      ZOMBIED,      // Cancelled before being queued. 
+    }; 
+ 
+    CallData(grpc_call_element* elem, const grpc_call_element_args& args, 
+             RefCountedPtr<Server> server); 
+    ~CallData(); 
+ 
+    // Starts the recv_initial_metadata batch on the call. 
+    // Invoked from ChannelData::AcceptStream(). 
+    void Start(grpc_call_element* elem); 
+ 
+    void SetState(CallState state); 
+ 
+    // Attempts to move from PENDING to ACTIVATED state.  Returns true 
+    // on success. 
+    bool MaybeActivate(); 
+ 
+    // Publishes an incoming call to the application after it has been 
+    // matched. 
+    void Publish(size_t cq_idx, RequestedCall* rc); 
+ 
+    void KillZombie(); 
+ 
+    void FailCallCreation(); 
+ 
+    // Filter vtable functions. 
+    static grpc_error* InitCallElement(grpc_call_element* elem, 
+                                       const grpc_call_element_args* args); 
+    static void DestroyCallElement(grpc_call_element* elem, 
+                                   const grpc_call_final_info* /*final_info*/, 
+                                   grpc_closure* /*ignored*/); 
+    static void StartTransportStreamOpBatch( 
+        grpc_call_element* elem, grpc_transport_stream_op_batch* batch); 
+ 
+   private: 
+    // Helper functions for handling calls at the top of the call stack. 
+    static void RecvInitialMetadataBatchComplete(void* arg, grpc_error* error); 
+    void StartNewRpc(grpc_call_element* elem); 
+    static void PublishNewRpc(void* arg, grpc_error* error); 
+ 
+    // Functions used inside the call stack. 
+    void StartTransportStreamOpBatchImpl(grpc_call_element* elem, 
+                                         grpc_transport_stream_op_batch* batch); 
+    static void RecvInitialMetadataReady(void* arg, grpc_error* error); 
+    static void RecvTrailingMetadataReady(void* arg, grpc_error* error); 
+ 
+    RefCountedPtr<Server> server_; 
+ 
+    grpc_call* call_; 
+ 
+    Atomic<CallState> state_{CallState::NOT_STARTED}; 
+ 
+    y_absl::optional<grpc_slice> path_; 
+    y_absl::optional<grpc_slice> host_; 
+    grpc_millis deadline_ = GRPC_MILLIS_INF_FUTURE; 
+ 
+    grpc_completion_queue* cq_new_ = nullptr; 
+ 
+    RequestMatcherInterface* matcher_ = nullptr; 
+    grpc_byte_buffer* payload_ = nullptr; 
+ 
+    grpc_closure kill_zombie_closure_; 
+ 
+    grpc_metadata_array initial_metadata_ = 
+        grpc_metadata_array();  // Zero-initialize the C struct. 
+    grpc_closure recv_initial_metadata_batch_complete_; 
+ 
+    grpc_metadata_batch* recv_initial_metadata_ = nullptr; 
+    uint32_t recv_initial_metadata_flags_ = 0; 
+    grpc_closure recv_initial_metadata_ready_; 
+    grpc_closure* original_recv_initial_metadata_ready_; 
+    grpc_error* recv_initial_metadata_error_ = GRPC_ERROR_NONE; 
+ 
+    bool seen_recv_trailing_metadata_ready_ = false; 
+    grpc_closure recv_trailing_metadata_ready_; 
+    grpc_closure* original_recv_trailing_metadata_ready_; 
+    grpc_error* recv_trailing_metadata_error_ = GRPC_ERROR_NONE; 
+ 
+    grpc_closure publish_; 
+ 
+    CallCombiner* call_combiner_; 
+  }; 
+ 
+  struct Listener { 
+    explicit Listener(OrphanablePtr<ListenerInterface> l) 
+        : listener(std::move(l)) {} 
+    OrphanablePtr<ListenerInterface> listener; 
+    grpc_closure destroy_done; 
+  }; 
+ 
+  struct ShutdownTag { 
+    ShutdownTag(void* tag_arg, grpc_completion_queue* cq_arg) 
+        : tag(tag_arg), cq(cq_arg) {} 
+    void* const tag; 
+    grpc_completion_queue* const cq; 
+    grpc_cq_completion completion; 
+  }; 
+ 
+  static void ListenerDestroyDone(void* arg, grpc_error* error); 
+ 
+  static void DoneShutdownEvent(void* server, 
+                                grpc_cq_completion* /*completion*/) { 
+    static_cast<Server*>(server)->Unref(); 
+  } 
+ 
+  static void DoneRequestEvent(void* req, grpc_cq_completion* completion); 
+ 
+  void FailCall(size_t cq_idx, RequestedCall* rc, grpc_error* error); 
+  grpc_call_error QueueRequestedCall(size_t cq_idx, RequestedCall* rc); 
+ 
+  void MaybeFinishShutdown(); 
+ 
+  void KillPendingWorkLocked(grpc_error* error); 
+ 
+  static grpc_call_error ValidateServerRequest( 
+      grpc_completion_queue* cq_for_notification, void* tag, 
+      grpc_byte_buffer** optional_payload, RegisteredMethod* rm); 
+  grpc_call_error ValidateServerRequestAndCq( 
+      size_t* cq_idx, grpc_completion_queue* cq_for_notification, void* tag, 
+      grpc_byte_buffer** optional_payload, RegisteredMethod* rm); 
+ 
+  std::vector<grpc_channel*> GetChannelsLocked() const; 
+ 
+  grpc_channel_args* const channel_args_; 
+  grpc_resource_user* default_resource_user_ = nullptr; 
+  RefCountedPtr<channelz::ServerNode> channelz_node_; 
+ 
+  std::vector<grpc_completion_queue*> cqs_; 
+  std::vector<grpc_pollset*> pollsets_; 
+  bool started_ = false; 
+ 
+  // The two following mutexes control access to server-state. 
+  // mu_global_ controls access to non-call-related state (e.g., channel state). 
+  // mu_call_ controls access to call-related state (e.g., the call lists). 
+  // 
+  // If they are ever required to be nested, you must lock mu_global_ 
+  // before mu_call_. This is currently used in shutdown processing 
+  // (ShutdownAndNotify() and MaybeFinishShutdown()). 
+  Mutex mu_global_;  // mutex for server and channel state 
+  Mutex mu_call_;    // mutex for call-specific state 
+ 
+  // startup synchronization: flag is protected by mu_global_, signals whether 
+  // we are doing the listener start routine or not. 
+  bool starting_ = false; 
+  CondVar starting_cv_; 
+ 
+  std::vector<std::unique_ptr<RegisteredMethod>> registered_methods_; 
+ 
+  // Request matcher for unregistered methods. 
+  std::unique_ptr<RequestMatcherInterface> unregistered_request_matcher_; 
+ 
+  std::atomic_bool shutdown_flag_{false}; 
+  bool shutdown_published_ = false; 
+  std::vector<ShutdownTag> shutdown_tags_; 
+ 
+  std::list<ChannelData*> channels_; 
+ 
+  std::list<Listener> listeners_; 
+  size_t listeners_destroyed_ = 0; 
+ 
+  // The last time we printed a shutdown progress message. 
+  gpr_timespec last_shutdown_message_time_; 
+}; 
+ 
+}  // namespace grpc_core 
+ 
+struct grpc_server { 
+  grpc_core::OrphanablePtr<grpc_core::Server> core_server; 
+}; 
+ 
 #endif /* GRPC_CORE_LIB_SURFACE_SERVER_H */
diff --git a/contrib/libs/grpc/src/core/lib/surface/version.cc b/contrib/libs/grpc/src/core/lib/surface/version.cc
index bed4f427e9..1cf5eafd0b 100644
--- a/contrib/libs/grpc/src/core/lib/surface/version.cc
+++ b/contrib/libs/grpc/src/core/lib/surface/version.cc
@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "13.0.0"; }
+const char* grpc_version_string(void) { return "13.0.0"; } 
 
-const char* grpc_g_stands_for(void) { return "geeky"; }
+const char* grpc_g_stands_for(void) { return "geeky"; } 
diff --git a/contrib/libs/grpc/src/core/lib/transport/authority_override.cc b/contrib/libs/grpc/src/core/lib/transport/authority_override.cc
index 8c13320b73..5abb13386e 100644
--- a/contrib/libs/grpc/src/core/lib/transport/authority_override.cc
+++ b/contrib/libs/grpc/src/core/lib/transport/authority_override.cc
@@ -1,38 +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.
-//
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/channel/channel_args.h"
-
-// Channel arg key for the authority override.
-#define GRPC_ARG_AUTHORITY_OVERRIDE "grpc.authority_override"
-
-namespace grpc_core {
-
-/// Returns a channel argument containing \a authority.
-grpc_arg CreateAuthorityOverrideChannelArg(const char* authority) {
-  return grpc_channel_arg_string_create(
-      const_cast<char*>(GRPC_ARG_AUTHORITY_OVERRIDE),
-      const_cast<char*>(authority));
-}
-
-/// Returns the authority override from \a args or nullptr.
-const char* FindAuthorityOverrideInArgs(const grpc_channel_args* args) {
-  return grpc_channel_args_find_string(args, GRPC_ARG_AUTHORITY_OVERRIDE);
-}
-
-}  // namespace grpc_core
+// 
+// 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. 
+// 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+#include "src/core/lib/channel/channel_args.h" 
+ 
+// Channel arg key for the authority override. 
+#define GRPC_ARG_AUTHORITY_OVERRIDE "grpc.authority_override" 
+ 
+namespace grpc_core { 
+ 
+/// Returns a channel argument containing \a authority. 
+grpc_arg CreateAuthorityOverrideChannelArg(const char* authority) { 
+  return grpc_channel_arg_string_create( 
+      const_cast<char*>(GRPC_ARG_AUTHORITY_OVERRIDE), 
+      const_cast<char*>(authority)); 
+} 
+ 
+/// Returns the authority override from \a args or nullptr. 
+const char* FindAuthorityOverrideInArgs(const grpc_channel_args* args) { 
+  return grpc_channel_args_find_string(args, GRPC_ARG_AUTHORITY_OVERRIDE); 
+} 
+ 
+}  // namespace grpc_core 
diff --git a/contrib/libs/grpc/src/core/lib/transport/authority_override.h b/contrib/libs/grpc/src/core/lib/transport/authority_override.h
index 9e584b56cb..667b33aaf4 100644
--- a/contrib/libs/grpc/src/core/lib/transport/authority_override.h
+++ b/contrib/libs/grpc/src/core/lib/transport/authority_override.h
@@ -1,32 +1,32 @@
-//
-// 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_CORE_LIB_TRANSPORT_AUTHORITY_OVERRIDE_H
-#define GRPC_CORE_LIB_TRANSPORT_AUTHORITY_OVERRIDE_H
-
-#include <grpc/support/port_platform.h>
-
-namespace grpc_core {
-
-/// Returns a channel argument containing \a authority.
-grpc_arg CreateAuthorityOverrideChannelArg(const char* authority);
-
-/// Returns the authority override from \a args or nullptr.
-const char* FindAuthorityOverrideInArgs(const grpc_channel_args* args);
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_LIB_TRANSPORT_AUTHORITY_OVERRIDE_H */
+// 
+// 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_CORE_LIB_TRANSPORT_AUTHORITY_OVERRIDE_H 
+#define GRPC_CORE_LIB_TRANSPORT_AUTHORITY_OVERRIDE_H 
+ 
+#include <grpc/support/port_platform.h> 
+ 
+namespace grpc_core { 
+ 
+/// Returns a channel argument containing \a authority. 
+grpc_arg CreateAuthorityOverrideChannelArg(const char* authority); 
+ 
+/// Returns the authority override from \a args or nullptr. 
+const char* FindAuthorityOverrideInArgs(const grpc_channel_args* args); 
+ 
+}  // namespace grpc_core 
+ 
+#endif /* GRPC_CORE_LIB_TRANSPORT_AUTHORITY_OVERRIDE_H */ 
diff --git a/contrib/libs/grpc/src/core/lib/transport/bdp_estimator.h b/contrib/libs/grpc/src/core/lib/transport/bdp_estimator.h
index 7eb336d8bb..babbdab93f 100644
--- a/contrib/libs/grpc/src/core/lib/transport/bdp_estimator.h
+++ b/contrib/libs/grpc/src/core/lib/transport/bdp_estimator.h
@@ -74,8 +74,8 @@ class BdpEstimator {
   // Completes a previously started ping, returns when to schedule the next one
   grpc_millis CompletePing();
 
-  int64_t accumulator() { return accumulator_; }
-
+  int64_t accumulator() { return accumulator_; } 
+ 
  private:
   enum class PingState { UNSCHEDULED, SCHEDULED, STARTED };
 
diff --git a/contrib/libs/grpc/src/core/lib/transport/byte_stream.h b/contrib/libs/grpc/src/core/lib/transport/byte_stream.h
index ecb605ad9b..f56eeeb5ae 100644
--- a/contrib/libs/grpc/src/core/lib/transport/byte_stream.h
+++ b/contrib/libs/grpc/src/core/lib/transport/byte_stream.h
@@ -26,15 +26,15 @@
 #include "src/core/lib/iomgr/closure.h"
 
 /** Internal bit flag for grpc_begin_message's \a flags signaling the use of
- * compression for the message. (Does not apply for stream compression.) */
+ * compression for the message. (Does not apply for stream compression.) */ 
 #define GRPC_WRITE_INTERNAL_COMPRESS (0x80000000u)
-/** Internal bit flag for determining whether the message was compressed and had
- * to be decompressed by the message_decompress filter. (Does not apply for
- * stream compression.) */
-#define GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED (0x40000000u)
+/** Internal bit flag for determining whether the message was compressed and had 
+ * to be decompressed by the message_decompress filter. (Does not apply for 
+ * stream compression.) */ 
+#define GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED (0x40000000u) 
 /** Mask of all valid internal flags. */
-#define GRPC_WRITE_INTERNAL_USED_MASK \
-  (GRPC_WRITE_INTERNAL_COMPRESS | GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED)
+#define GRPC_WRITE_INTERNAL_USED_MASK \ 
+  (GRPC_WRITE_INTERNAL_COMPRESS | GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED) 
 
 namespace grpc_core {
 
diff --git a/contrib/libs/grpc/src/core/lib/transport/connectivity_state.cc b/contrib/libs/grpc/src/core/lib/transport/connectivity_state.cc
index 7b13049017..016faa39c1 100644
--- a/contrib/libs/grpc/src/core/lib/transport/connectivity_state.cc
+++ b/contrib/libs/grpc/src/core/lib/transport/connectivity_state.cc
@@ -58,13 +58,13 @@ const char* ConnectivityStateName(grpc_connectivity_state state) {
 class AsyncConnectivityStateWatcherInterface::Notifier {
  public:
   Notifier(RefCountedPtr<AsyncConnectivityStateWatcherInterface> watcher,
-           grpc_connectivity_state state, const y_absl::Status& status,
-           const std::shared_ptr<WorkSerializer>& work_serializer)
-      : watcher_(std::move(watcher)), state_(state), status_(status) {
-    if (work_serializer != nullptr) {
-      work_serializer->Run(
-          [this]() { SendNotification(this, GRPC_ERROR_NONE); },
-          DEBUG_LOCATION);
+           grpc_connectivity_state state, const y_absl::Status& status, 
+           const std::shared_ptr<WorkSerializer>& work_serializer) 
+      : watcher_(std::move(watcher)), state_(state), status_(status) { 
+    if (work_serializer != nullptr) { 
+      work_serializer->Run( 
+          [this]() { SendNotification(this, GRPC_ERROR_NONE); }, 
+          DEBUG_LOCATION); 
     } else {
       GRPC_CLOSURE_INIT(&closure_, SendNotification, this,
                         grpc_schedule_on_exec_ctx);
@@ -76,24 +76,24 @@ class AsyncConnectivityStateWatcherInterface::Notifier {
   static void SendNotification(void* arg, grpc_error* /*ignored*/) {
     Notifier* self = static_cast<Notifier*>(arg);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
-      gpr_log(GPR_INFO, "watcher %p: delivering async notification for %s (%s)",
-              self->watcher_.get(), ConnectivityStateName(self->state_),
-              self->status_.ToString().c_str());
+      gpr_log(GPR_INFO, "watcher %p: delivering async notification for %s (%s)", 
+              self->watcher_.get(), ConnectivityStateName(self->state_), 
+              self->status_.ToString().c_str()); 
     }
-    self->watcher_->OnConnectivityStateChange(self->state_, self->status_);
+    self->watcher_->OnConnectivityStateChange(self->state_, self->status_); 
     delete self;
   }
 
   RefCountedPtr<AsyncConnectivityStateWatcherInterface> watcher_;
   const grpc_connectivity_state state_;
-  const y_absl::Status status_;
+  const y_absl::Status status_; 
   grpc_closure closure_;
 };
 
 void AsyncConnectivityStateWatcherInterface::Notify(
-    grpc_connectivity_state state, const y_absl::Status& status) {
-  new Notifier(Ref(), state, status,
-               work_serializer_);  // Deletes itself when done.
+    grpc_connectivity_state state, const y_absl::Status& status) { 
+  new Notifier(Ref(), state, status, 
+               work_serializer_);  // Deletes itself when done. 
 }
 
 //
@@ -110,7 +110,7 @@ ConnectivityStateTracker::~ConnectivityStateTracker() {
               name_, this, p.first, ConnectivityStateName(current_state),
               ConnectivityStateName(GRPC_CHANNEL_SHUTDOWN));
     }
-    p.second->Notify(GRPC_CHANNEL_SHUTDOWN, y_absl::Status());
+    p.second->Notify(GRPC_CHANNEL_SHUTDOWN, y_absl::Status()); 
   }
 }
 
@@ -129,7 +129,7 @@ void ConnectivityStateTracker::AddWatcher(
               name_, this, watcher.get(), ConnectivityStateName(initial_state),
               ConnectivityStateName(current_state));
     }
-    watcher->Notify(current_state, status_);
+    watcher->Notify(current_state, status_); 
   }
   // If we're in state SHUTDOWN, don't add the watcher, so that it will
   // be orphaned immediately.
@@ -148,17 +148,17 @@ void ConnectivityStateTracker::RemoveWatcher(
 }
 
 void ConnectivityStateTracker::SetState(grpc_connectivity_state state,
-                                        const y_absl::Status& status,
+                                        const y_absl::Status& status, 
                                         const char* reason) {
   grpc_connectivity_state current_state = state_.Load(MemoryOrder::RELAXED);
   if (state == current_state) return;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
-    gpr_log(GPR_INFO, "ConnectivityStateTracker %s[%p]: %s -> %s (%s, %s)",
-            name_, this, ConnectivityStateName(current_state),
-            ConnectivityStateName(state), reason, status.ToString().c_str());
+    gpr_log(GPR_INFO, "ConnectivityStateTracker %s[%p]: %s -> %s (%s, %s)", 
+            name_, this, ConnectivityStateName(current_state), 
+            ConnectivityStateName(state), reason, status.ToString().c_str()); 
   }
   state_.Store(state, MemoryOrder::RELAXED);
-  status_ = status;
+  status_ = status; 
   for (const auto& p : watchers_) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_connectivity_state_trace)) {
       gpr_log(GPR_INFO,
@@ -166,7 +166,7 @@ void ConnectivityStateTracker::SetState(grpc_connectivity_state state,
               name_, this, p.first, ConnectivityStateName(current_state),
               ConnectivityStateName(state));
     }
-    p.second->Notify(state, status);
+    p.second->Notify(state, status); 
   }
   // If the new state is SHUTDOWN, orphan all of the watchers.  This
   // avoids the need for the callers to explicitly cancel them.
diff --git a/contrib/libs/grpc/src/core/lib/transport/connectivity_state.h b/contrib/libs/grpc/src/core/lib/transport/connectivity_state.h
index 9e34c646c7..21408bab6b 100644
--- a/contrib/libs/grpc/src/core/lib/transport/connectivity_state.h
+++ b/contrib/libs/grpc/src/core/lib/transport/connectivity_state.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "y_absl/status/status.h"
-
+#include "y_absl/status/status.h" 
+ 
 #include <grpc/grpc.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -31,7 +31,7 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/iomgr/work_serializer.h" 
 
 namespace grpc_core {
 
@@ -51,8 +51,8 @@ class ConnectivityStateWatcherInterface
   virtual ~ConnectivityStateWatcherInterface() = default;
 
   // Notifies the watcher that the state has changed to new_state.
-  virtual void Notify(grpc_connectivity_state new_state,
-                      const y_absl::Status& status) = 0;
+  virtual void Notify(grpc_connectivity_state new_state, 
+                      const y_absl::Status& status) = 0; 
 
   void Orphan() override { Unref(); }
 };
@@ -67,24 +67,24 @@ class AsyncConnectivityStateWatcherInterface
 
   // Schedules a closure on the ExecCtx to invoke
   // OnConnectivityStateChange() asynchronously.
-  void Notify(grpc_connectivity_state new_state,
-              const y_absl::Status& status) override final;
+  void Notify(grpc_connectivity_state new_state, 
+              const y_absl::Status& status) override final; 
 
  protected:
   class Notifier;
 
-  // If \a work_serializer is nullptr, then the notification will be scheduled
-  // on the ExecCtx.
-  explicit AsyncConnectivityStateWatcherInterface(
-      std::shared_ptr<WorkSerializer> work_serializer = nullptr)
-      : work_serializer_(std::move(work_serializer)) {}
+  // If \a work_serializer is nullptr, then the notification will be scheduled 
+  // on the ExecCtx. 
+  explicit AsyncConnectivityStateWatcherInterface( 
+      std::shared_ptr<WorkSerializer> work_serializer = nullptr) 
+      : work_serializer_(std::move(work_serializer)) {} 
 
   // Invoked asynchronously when Notify() is called.
-  virtual void OnConnectivityStateChange(grpc_connectivity_state new_state,
-                                         const y_absl::Status& status) = 0;
+  virtual void OnConnectivityStateChange(grpc_connectivity_state new_state, 
+                                         const y_absl::Status& status) = 0; 
 
  private:
-  std::shared_ptr<WorkSerializer> work_serializer_;
+  std::shared_ptr<WorkSerializer> work_serializer_; 
 };
 
 // Tracks connectivity state.  Maintains a list of watchers that are
@@ -96,9 +96,9 @@ class AsyncConnectivityStateWatcherInterface
 class ConnectivityStateTracker {
  public:
   ConnectivityStateTracker(const char* name,
-                           grpc_connectivity_state state = GRPC_CHANNEL_IDLE,
-                           const y_absl::Status& status = y_absl::Status())
-      : name_(name), state_(state), status_(status) {}
+                           grpc_connectivity_state state = GRPC_CHANNEL_IDLE, 
+                           const y_absl::Status& status = y_absl::Status()) 
+      : name_(name), state_(state), status_(status) {} 
 
   ~ConnectivityStateTracker();
 
@@ -116,21 +116,21 @@ class ConnectivityStateTracker {
 
   // Sets connectivity state.
   // Not thread safe; access must be serialized with an external lock.
-  void SetState(grpc_connectivity_state state, const y_absl::Status& status,
-                const char* reason);
+  void SetState(grpc_connectivity_state state, const y_absl::Status& status, 
+                const char* reason); 
 
   // Gets the current state.
   // Thread safe; no need to use an external lock.
   grpc_connectivity_state state() const;
 
-  // Get the current status.
-  // Not thread safe; access must be serialized with an external lock.
-  y_absl::Status status() const { return status_; }
-
+  // Get the current status. 
+  // Not thread safe; access must be serialized with an external lock. 
+  y_absl::Status status() const { return status_; } 
+ 
  private:
   const char* name_;
   Atomic<grpc_connectivity_state> state_;
-  y_absl::Status status_;
+  y_absl::Status status_; 
   // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
   // be a set instead of a map.
   std::map<ConnectivityStateWatcherInterface*,
diff --git a/contrib/libs/grpc/src/core/lib/transport/error_utils.cc b/contrib/libs/grpc/src/core/lib/transport/error_utils.cc
index 9634f09ad1..a17e630f94 100644
--- a/contrib/libs/grpc/src/core/lib/transport/error_utils.cc
+++ b/contrib/libs/grpc/src/core/lib/transport/error_utils.cc
@@ -123,19 +123,19 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
   }
 }
 
-y_absl::Status grpc_error_to_absl_status(grpc_error* error) {
-  grpc_status_code status;
-  // TODO(yashykt): This should be updated once we decide on how to use the
-  // y_absl::Status payload to capture all the contents of grpc_error.
-  grpc_slice message;
-  grpc_error_get_status(error, GRPC_MILLIS_INF_FUTURE, &status, &message,
-                        nullptr /* http_error */, nullptr /* error_string */);
-  return y_absl::Status(static_cast<y_absl::StatusCode>(status),
-                      y_absl::string_view(reinterpret_cast<const char*>(
-                                            GRPC_SLICE_START_PTR(message)),
-                                        GRPC_SLICE_LENGTH(message)));
-}
-
+y_absl::Status grpc_error_to_absl_status(grpc_error* error) { 
+  grpc_status_code status; 
+  // TODO(yashykt): This should be updated once we decide on how to use the 
+  // y_absl::Status payload to capture all the contents of grpc_error. 
+  grpc_slice message; 
+  grpc_error_get_status(error, GRPC_MILLIS_INF_FUTURE, &status, &message, 
+                        nullptr /* http_error */, nullptr /* error_string */); 
+  return y_absl::Status(static_cast<y_absl::StatusCode>(status), 
+                      y_absl::string_view(reinterpret_cast<const char*>( 
+                                            GRPC_SLICE_START_PTR(message)), 
+                                        GRPC_SLICE_LENGTH(message))); 
+} 
+ 
 bool grpc_error_has_clear_grpc_status(grpc_error* error) {
   intptr_t unused;
   if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &unused)) {
diff --git a/contrib/libs/grpc/src/core/lib/transport/error_utils.h b/contrib/libs/grpc/src/core/lib/transport/error_utils.h
index fb967202f3..8d34d99341 100644
--- a/contrib/libs/grpc/src/core/lib/transport/error_utils.h
+++ b/contrib/libs/grpc/src/core/lib/transport/error_utils.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "y_absl/status/status.h"
-
+#include "y_absl/status/status.h" 
+ 
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/transport/http2_errors.h"
@@ -39,10 +39,10 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
                            grpc_http2_error_code* http_status,
                            const char** error_string);
 
-/// Utility Function to convert a grpc_error * \a error to an y_absl::Status.
-/// Does NOT consume a ref to grpc_error.
-y_absl::Status grpc_error_to_absl_status(grpc_error* error);
-
+/// Utility Function to convert a grpc_error * \a error to an y_absl::Status. 
+/// Does NOT consume a ref to grpc_error. 
+y_absl::Status grpc_error_to_absl_status(grpc_error* error); 
+ 
 /// A utility function to check whether there is a clear status code that
 /// doesn't need to be guessed in \a error. This means that \a error or some
 /// child has GRPC_ERROR_INT_GRPC_STATUS set, or that it is GRPC_ERROR_NONE or
diff --git a/contrib/libs/grpc/src/core/lib/transport/metadata.cc b/contrib/libs/grpc/src/core/lib/transport/metadata.cc
index 33d4d5ac70..51a86f7596 100644
--- a/contrib/libs/grpc/src/core/lib/transport/metadata.cc
+++ b/contrib/libs/grpc/src/core/lib/transport/metadata.cc
@@ -250,25 +250,25 @@ void grpc_mdctx_global_shutdown() {
     gpr_mu_destroy(&shard->mu);
     gc_mdtab(shard);
     if (shard->count != 0) {
-      gpr_log(GPR_ERROR, "WARNING: %" PRIuPTR " metadata elements were leaked",
+      gpr_log(GPR_ERROR, "WARNING: %" PRIuPTR " metadata elements were leaked", 
               shard->count);
-      for (int i = 0; i < shard->capacity; i++) {
-        for (InternedMetadata* md = shard->elems[i].next; md;
-             md = md->bucket_next()) {
-          char* key_str = grpc_slice_to_c_string(md->key());
-          char* value_str = grpc_slice_to_c_string(md->value());
-          gpr_log(GPR_ERROR, "mdelem '%s' = '%s'", key_str, value_str);
-          gpr_free(key_str);
-          gpr_free(value_str);
-        }
-      }
+      for (int i = 0; i < shard->capacity; i++) { 
+        for (InternedMetadata* md = shard->elems[i].next; md; 
+             md = md->bucket_next()) { 
+          char* key_str = grpc_slice_to_c_string(md->key()); 
+          char* value_str = grpc_slice_to_c_string(md->value()); 
+          gpr_log(GPR_ERROR, "mdelem '%s' = '%s'", key_str, value_str); 
+          gpr_free(key_str); 
+          gpr_free(value_str); 
+        } 
+      } 
       if (grpc_iomgr_abort_on_leaks()) {
         abort();
       }
     }
-    // For ASAN builds, we don't want to crash here, because that will
-    // prevent ASAN from providing leak detection information, which is
-    // far more useful than this simple assertion.
+    // For ASAN builds, we don't want to crash here, because that will 
+    // prevent ASAN from providing leak detection information, which is 
+    // far more useful than this simple assertion. 
 #ifndef GRPC_ASAN_ENABLED
     GPR_DEBUG_ASSERT(shard->count == 0);
 #endif
diff --git a/contrib/libs/grpc/src/core/lib/transport/static_metadata.cc b/contrib/libs/grpc/src/core/lib/transport/static_metadata.cc
index e027c00d39..6ee9665700 100644
--- a/contrib/libs/grpc/src/core/lib/transport/static_metadata.cc
+++ b/contrib/libs/grpc/src/core/lib/transport/static_metadata.cc
@@ -68,68 +68,68 @@ static constexpr uint8_t g_bytes[] = {
     114, 118, 105, 99,  101, 46,  108, 111, 97,  100, 95,  115, 116, 97,  116,
     115, 46,  118, 50,  46,  76,  111, 97,  100, 82,  101, 112, 111, 114, 116,
     105, 110, 103, 83,  101, 114, 118, 105, 99,  101, 47,  83,  116, 114, 101,
-    97,  109, 76,  111, 97,  100, 83,  116, 97,  116, 115, 47,  101, 110, 118,
-    111, 121, 46,  115, 101, 114, 118, 105, 99,  101, 46,  108, 111, 97,  100,
-    95,  115, 116, 97,  116, 115, 46,  118, 51,  46,  76,  111, 97,  100, 82,
-    101, 112, 111, 114, 116, 105, 110, 103, 83,  101, 114, 118, 105, 99,  101,
-    47,  83,  116, 114, 101, 97,  109, 76,  111, 97,  100, 83,  116, 97,  116,
-    115, 47,  103, 114, 112, 99,  46,  104, 101, 97,  108, 116, 104, 46,  118,
-    49,  46,  72,  101, 97,  108, 116, 104, 47,  87,  97,  116, 99,  104, 47,
-    101, 110, 118, 111, 121, 46,  115, 101, 114, 118, 105, 99,  101, 46,  100,
-    105, 115, 99,  111, 118, 101, 114, 121, 46,  118, 50,  46,  65,  103, 103,
-    114, 101, 103, 97,  116, 101, 100, 68,  105, 115, 99,  111, 118, 101, 114,
-    121, 83,  101, 114, 118, 105, 99,  101, 47,  83,  116, 114, 101, 97,  109,
-    65,  103, 103, 114, 101, 103, 97,  116, 101, 100, 82,  101, 115, 111, 117,
-    114, 99,  101, 115, 47,  101, 110, 118, 111, 121, 46,  115, 101, 114, 118,
-    105, 99,  101, 46,  100, 105, 115, 99,  111, 118, 101, 114, 121, 46,  118,
-    51,  46,  65,  103, 103, 114, 101, 103, 97,  116, 101, 100, 68,  105, 115,
-    99,  111, 118, 101, 114, 121, 83,  101, 114, 118, 105, 99,  101, 47,  83,
-    116, 114, 101, 97,  109, 65,  103, 103, 114, 101, 103, 97,  116, 101, 100,
-    82,  101, 115, 111, 117, 114, 99,  101, 115, 100, 101, 102, 108, 97,  116,
-    101, 103, 122, 105, 112, 115, 116, 114, 101, 97,  109, 47,  103, 122, 105,
-    112, 71,  69,  84,  80,  79,  83,  84,  47,  47,  105, 110, 100, 101, 120,
-    46,  104, 116, 109, 108, 104, 116, 116, 112, 104, 116, 116, 112, 115, 50,
-    48,  48,  50,  48,  52,  50,  48,  54,  51,  48,  52,  52,  48,  48,  52,
-    48,  52,  53,  48,  48,  97,  99,  99,  101, 112, 116, 45,  99,  104, 97,
-    114, 115, 101, 116, 103, 122, 105, 112, 44,  32,  100, 101, 102, 108, 97,
-    116, 101, 97,  99,  99,  101, 112, 116, 45,  108, 97,  110, 103, 117, 97,
-    103, 101, 97,  99,  99,  101, 112, 116, 45,  114, 97,  110, 103, 101, 115,
-    97,  99,  99,  101, 112, 116, 97,  99,  99,  101, 115, 115, 45,  99,  111,
-    110, 116, 114, 111, 108, 45,  97,  108, 108, 111, 119, 45,  111, 114, 105,
-    103, 105, 110, 97,  103, 101, 97,  108, 108, 111, 119, 97,  117, 116, 104,
-    111, 114, 105, 122, 97,  116, 105, 111, 110, 99,  97,  99,  104, 101, 45,
-    99,  111, 110, 116, 114, 111, 108, 99,  111, 110, 116, 101, 110, 116, 45,
-    100, 105, 115, 112, 111, 115, 105, 116, 105, 111, 110, 99,  111, 110, 116,
-    101, 110, 116, 45,  108, 97,  110, 103, 117, 97,  103, 101, 99,  111, 110,
-    116, 101, 110, 116, 45,  108, 101, 110, 103, 116, 104, 99,  111, 110, 116,
-    101, 110, 116, 45,  108, 111, 99,  97,  116, 105, 111, 110, 99,  111, 110,
-    116, 101, 110, 116, 45,  114, 97,  110, 103, 101, 99,  111, 111, 107, 105,
-    101, 100, 97,  116, 101, 101, 116, 97,  103, 101, 120, 112, 101, 99,  116,
-    101, 120, 112, 105, 114, 101, 115, 102, 114, 111, 109, 105, 102, 45,  109,
-    97,  116, 99,  104, 105, 102, 45,  109, 111, 100, 105, 102, 105, 101, 100,
-    45,  115, 105, 110, 99,  101, 105, 102, 45,  110, 111, 110, 101, 45,  109,
-    97,  116, 99,  104, 105, 102, 45,  114, 97,  110, 103, 101, 105, 102, 45,
-    117, 110, 109, 111, 100, 105, 102, 105, 101, 100, 45,  115, 105, 110, 99,
-    101, 108, 97,  115, 116, 45,  109, 111, 100, 105, 102, 105, 101, 100, 108,
-    105, 110, 107, 108, 111, 99,  97,  116, 105, 111, 110, 109, 97,  120, 45,
-    102, 111, 114, 119, 97,  114, 100, 115, 112, 114, 111, 120, 121, 45,  97,
-    117, 116, 104, 101, 110, 116, 105, 99,  97,  116, 101, 112, 114, 111, 120,
-    121, 45,  97,  117, 116, 104, 111, 114, 105, 122, 97,  116, 105, 111, 110,
-    114, 97,  110, 103, 101, 114, 101, 102, 101, 114, 101, 114, 114, 101, 102,
-    114, 101, 115, 104, 114, 101, 116, 114, 121, 45,  97,  102, 116, 101, 114,
-    115, 101, 114, 118, 101, 114, 115, 101, 116, 45,  99,  111, 111, 107, 105,
-    101, 115, 116, 114, 105, 99,  116, 45,  116, 114, 97,  110, 115, 112, 111,
-    114, 116, 45,  115, 101, 99,  117, 114, 105, 116, 121, 116, 114, 97,  110,
-    115, 102, 101, 114, 45,  101, 110, 99,  111, 100, 105, 110, 103, 118, 97,
-    114, 121, 118, 105, 97,  119, 119, 119, 45,  97,  117, 116, 104, 101, 110,
-    116, 105, 99,  97,  116, 101, 48,  105, 100, 101, 110, 116, 105, 116, 121,
-    116, 114, 97,  105, 108, 101, 114, 115, 97,  112, 112, 108, 105, 99,  97,
-    116, 105, 111, 110, 47,  103, 114, 112, 99,  103, 114, 112, 99,  80,  85,
-    84,  108, 98,  45,  99,  111, 115, 116, 45,  98,  105, 110, 105, 100, 101,
-    110, 116, 105, 116, 121, 44,  100, 101, 102, 108, 97,  116, 101, 105, 100,
-    101, 110, 116, 105, 116, 121, 44,  103, 122, 105, 112, 100, 101, 102, 108,
-    97,  116, 101, 44,  103, 122, 105, 112, 105, 100, 101, 110, 116, 105, 116,
-    121, 44,  100, 101, 102, 108, 97,  116, 101, 44,  103, 122, 105, 112};
+    97,  109, 76,  111, 97,  100, 83,  116, 97,  116, 115, 47,  101, 110, 118, 
+    111, 121, 46,  115, 101, 114, 118, 105, 99,  101, 46,  108, 111, 97,  100, 
+    95,  115, 116, 97,  116, 115, 46,  118, 51,  46,  76,  111, 97,  100, 82, 
+    101, 112, 111, 114, 116, 105, 110, 103, 83,  101, 114, 118, 105, 99,  101, 
+    47,  83,  116, 114, 101, 97,  109, 76,  111, 97,  100, 83,  116, 97,  116, 
+    115, 47,  103, 114, 112, 99,  46,  104, 101, 97,  108, 116, 104, 46,  118, 
+    49,  46,  72,  101, 97,  108, 116, 104, 47,  87,  97,  116, 99,  104, 47, 
+    101, 110, 118, 111, 121, 46,  115, 101, 114, 118, 105, 99,  101, 46,  100, 
+    105, 115, 99,  111, 118, 101, 114, 121, 46,  118, 50,  46,  65,  103, 103, 
+    114, 101, 103, 97,  116, 101, 100, 68,  105, 115, 99,  111, 118, 101, 114, 
+    121, 83,  101, 114, 118, 105, 99,  101, 47,  83,  116, 114, 101, 97,  109, 
+    65,  103, 103, 114, 101, 103, 97,  116, 101, 100, 82,  101, 115, 111, 117, 
+    114, 99,  101, 115, 47,  101, 110, 118, 111, 121, 46,  115, 101, 114, 118, 
+    105, 99,  101, 46,  100, 105, 115, 99,  111, 118, 101, 114, 121, 46,  118, 
+    51,  46,  65,  103, 103, 114, 101, 103, 97,  116, 101, 100, 68,  105, 115, 
+    99,  111, 118, 101, 114, 121, 83,  101, 114, 118, 105, 99,  101, 47,  83, 
+    116, 114, 101, 97,  109, 65,  103, 103, 114, 101, 103, 97,  116, 101, 100, 
+    82,  101, 115, 111, 117, 114, 99,  101, 115, 100, 101, 102, 108, 97,  116, 
+    101, 103, 122, 105, 112, 115, 116, 114, 101, 97,  109, 47,  103, 122, 105, 
+    112, 71,  69,  84,  80,  79,  83,  84,  47,  47,  105, 110, 100, 101, 120, 
+    46,  104, 116, 109, 108, 104, 116, 116, 112, 104, 116, 116, 112, 115, 50, 
+    48,  48,  50,  48,  52,  50,  48,  54,  51,  48,  52,  52,  48,  48,  52, 
+    48,  52,  53,  48,  48,  97,  99,  99,  101, 112, 116, 45,  99,  104, 97, 
+    114, 115, 101, 116, 103, 122, 105, 112, 44,  32,  100, 101, 102, 108, 97, 
+    116, 101, 97,  99,  99,  101, 112, 116, 45,  108, 97,  110, 103, 117, 97, 
+    103, 101, 97,  99,  99,  101, 112, 116, 45,  114, 97,  110, 103, 101, 115, 
+    97,  99,  99,  101, 112, 116, 97,  99,  99,  101, 115, 115, 45,  99,  111, 
+    110, 116, 114, 111, 108, 45,  97,  108, 108, 111, 119, 45,  111, 114, 105, 
+    103, 105, 110, 97,  103, 101, 97,  108, 108, 111, 119, 97,  117, 116, 104, 
+    111, 114, 105, 122, 97,  116, 105, 111, 110, 99,  97,  99,  104, 101, 45, 
+    99,  111, 110, 116, 114, 111, 108, 99,  111, 110, 116, 101, 110, 116, 45, 
+    100, 105, 115, 112, 111, 115, 105, 116, 105, 111, 110, 99,  111, 110, 116, 
+    101, 110, 116, 45,  108, 97,  110, 103, 117, 97,  103, 101, 99,  111, 110, 
+    116, 101, 110, 116, 45,  108, 101, 110, 103, 116, 104, 99,  111, 110, 116, 
+    101, 110, 116, 45,  108, 111, 99,  97,  116, 105, 111, 110, 99,  111, 110, 
+    116, 101, 110, 116, 45,  114, 97,  110, 103, 101, 99,  111, 111, 107, 105, 
+    101, 100, 97,  116, 101, 101, 116, 97,  103, 101, 120, 112, 101, 99,  116, 
+    101, 120, 112, 105, 114, 101, 115, 102, 114, 111, 109, 105, 102, 45,  109, 
+    97,  116, 99,  104, 105, 102, 45,  109, 111, 100, 105, 102, 105, 101, 100, 
+    45,  115, 105, 110, 99,  101, 105, 102, 45,  110, 111, 110, 101, 45,  109, 
+    97,  116, 99,  104, 105, 102, 45,  114, 97,  110, 103, 101, 105, 102, 45, 
+    117, 110, 109, 111, 100, 105, 102, 105, 101, 100, 45,  115, 105, 110, 99, 
+    101, 108, 97,  115, 116, 45,  109, 111, 100, 105, 102, 105, 101, 100, 108, 
+    105, 110, 107, 108, 111, 99,  97,  116, 105, 111, 110, 109, 97,  120, 45, 
+    102, 111, 114, 119, 97,  114, 100, 115, 112, 114, 111, 120, 121, 45,  97, 
+    117, 116, 104, 101, 110, 116, 105, 99,  97,  116, 101, 112, 114, 111, 120, 
+    121, 45,  97,  117, 116, 104, 111, 114, 105, 122, 97,  116, 105, 111, 110, 
+    114, 97,  110, 103, 101, 114, 101, 102, 101, 114, 101, 114, 114, 101, 102, 
+    114, 101, 115, 104, 114, 101, 116, 114, 121, 45,  97,  102, 116, 101, 114, 
+    115, 101, 114, 118, 101, 114, 115, 101, 116, 45,  99,  111, 111, 107, 105, 
+    101, 115, 116, 114, 105, 99,  116, 45,  116, 114, 97,  110, 115, 112, 111, 
+    114, 116, 45,  115, 101, 99,  117, 114, 105, 116, 121, 116, 114, 97,  110, 
+    115, 102, 101, 114, 45,  101, 110, 99,  111, 100, 105, 110, 103, 118, 97, 
+    114, 121, 118, 105, 97,  119, 119, 119, 45,  97,  117, 116, 104, 101, 110, 
+    116, 105, 99,  97,  116, 101, 48,  105, 100, 101, 110, 116, 105, 116, 121, 
+    116, 114, 97,  105, 108, 101, 114, 115, 97,  112, 112, 108, 105, 99,  97, 
+    116, 105, 111, 110, 47,  103, 114, 112, 99,  103, 114, 112, 99,  80,  85, 
+    84,  108, 98,  45,  99,  111, 115, 116, 45,  98,  105, 110, 105, 100, 101, 
+    110, 116, 105, 116, 121, 44,  100, 101, 102, 108, 97,  116, 101, 105, 100, 
+    101, 110, 116, 105, 116, 121, 44,  103, 122, 105, 112, 100, 101, 102, 108, 
+    97,  116, 101, 44,  103, 122, 105, 112, 105, 100, 101, 110, 116, 105, 116, 
+    121, 44,  100, 101, 102, 108, 97,  116, 101, 44,  103, 122, 105, 112}; 
 
 grpc_slice_refcount grpc_core::StaticSliceRefcount::kStaticSubRefcount;
 
@@ -194,7 +194,7 @@ struct StaticMetadataCtx {
       StaticSliceRefcount(102), StaticSliceRefcount(103),
       StaticSliceRefcount(104), StaticSliceRefcount(105),
       StaticSliceRefcount(106), StaticSliceRefcount(107),
-      StaticSliceRefcount(108), StaticSliceRefcount(109),
+      StaticSliceRefcount(108), StaticSliceRefcount(109), 
   };
 
   const StaticMetadataSlice slices[GRPC_STATIC_MDSTR_COUNT] = {
@@ -235,80 +235,80 @@ struct StaticMetadataCtx {
       grpc_core::StaticMetadataSlice(&refcounts[33].base, 31, g_bytes + 434),
       grpc_core::StaticMetadataSlice(&refcounts[34].base, 36, g_bytes + 465),
       grpc_core::StaticMetadataSlice(&refcounts[35].base, 65, g_bytes + 501),
-      grpc_core::StaticMetadataSlice(&refcounts[36].base, 65, g_bytes + 566),
-      grpc_core::StaticMetadataSlice(&refcounts[37].base, 28, g_bytes + 631),
-      grpc_core::StaticMetadataSlice(&refcounts[38].base, 80, g_bytes + 659),
-      grpc_core::StaticMetadataSlice(&refcounts[39].base, 80, g_bytes + 739),
-      grpc_core::StaticMetadataSlice(&refcounts[40].base, 7, g_bytes + 819),
-      grpc_core::StaticMetadataSlice(&refcounts[41].base, 4, g_bytes + 826),
-      grpc_core::StaticMetadataSlice(&refcounts[42].base, 11, g_bytes + 830),
-      grpc_core::StaticMetadataSlice(&refcounts[43].base, 3, g_bytes + 841),
-      grpc_core::StaticMetadataSlice(&refcounts[44].base, 4, g_bytes + 844),
-      grpc_core::StaticMetadataSlice(&refcounts[45].base, 1, g_bytes + 848),
-      grpc_core::StaticMetadataSlice(&refcounts[46].base, 11, g_bytes + 849),
-      grpc_core::StaticMetadataSlice(&refcounts[47].base, 4, g_bytes + 860),
-      grpc_core::StaticMetadataSlice(&refcounts[48].base, 5, g_bytes + 864),
-      grpc_core::StaticMetadataSlice(&refcounts[49].base, 3, g_bytes + 869),
-      grpc_core::StaticMetadataSlice(&refcounts[50].base, 3, g_bytes + 872),
-      grpc_core::StaticMetadataSlice(&refcounts[51].base, 3, g_bytes + 875),
-      grpc_core::StaticMetadataSlice(&refcounts[52].base, 3, g_bytes + 878),
-      grpc_core::StaticMetadataSlice(&refcounts[53].base, 3, g_bytes + 881),
-      grpc_core::StaticMetadataSlice(&refcounts[54].base, 3, g_bytes + 884),
-      grpc_core::StaticMetadataSlice(&refcounts[55].base, 3, g_bytes + 887),
-      grpc_core::StaticMetadataSlice(&refcounts[56].base, 14, g_bytes + 890),
-      grpc_core::StaticMetadataSlice(&refcounts[57].base, 13, g_bytes + 904),
-      grpc_core::StaticMetadataSlice(&refcounts[58].base, 15, g_bytes + 917),
-      grpc_core::StaticMetadataSlice(&refcounts[59].base, 13, g_bytes + 932),
-      grpc_core::StaticMetadataSlice(&refcounts[60].base, 6, g_bytes + 945),
-      grpc_core::StaticMetadataSlice(&refcounts[61].base, 27, g_bytes + 951),
-      grpc_core::StaticMetadataSlice(&refcounts[62].base, 3, g_bytes + 978),
-      grpc_core::StaticMetadataSlice(&refcounts[63].base, 5, g_bytes + 981),
-      grpc_core::StaticMetadataSlice(&refcounts[64].base, 13, g_bytes + 986),
-      grpc_core::StaticMetadataSlice(&refcounts[65].base, 13, g_bytes + 999),
-      grpc_core::StaticMetadataSlice(&refcounts[66].base, 19, g_bytes + 1012),
-      grpc_core::StaticMetadataSlice(&refcounts[67].base, 16, g_bytes + 1031),
-      grpc_core::StaticMetadataSlice(&refcounts[68].base, 14, g_bytes + 1047),
-      grpc_core::StaticMetadataSlice(&refcounts[69].base, 16, g_bytes + 1061),
-      grpc_core::StaticMetadataSlice(&refcounts[70].base, 13, g_bytes + 1077),
-      grpc_core::StaticMetadataSlice(&refcounts[71].base, 6, g_bytes + 1090),
-      grpc_core::StaticMetadataSlice(&refcounts[72].base, 4, g_bytes + 1096),
-      grpc_core::StaticMetadataSlice(&refcounts[73].base, 4, g_bytes + 1100),
-      grpc_core::StaticMetadataSlice(&refcounts[74].base, 6, g_bytes + 1104),
-      grpc_core::StaticMetadataSlice(&refcounts[75].base, 7, g_bytes + 1110),
-      grpc_core::StaticMetadataSlice(&refcounts[76].base, 4, g_bytes + 1117),
-      grpc_core::StaticMetadataSlice(&refcounts[77].base, 8, g_bytes + 1121),
-      grpc_core::StaticMetadataSlice(&refcounts[78].base, 17, g_bytes + 1129),
-      grpc_core::StaticMetadataSlice(&refcounts[79].base, 13, g_bytes + 1146),
-      grpc_core::StaticMetadataSlice(&refcounts[80].base, 8, g_bytes + 1159),
-      grpc_core::StaticMetadataSlice(&refcounts[81].base, 19, g_bytes + 1167),
-      grpc_core::StaticMetadataSlice(&refcounts[82].base, 13, g_bytes + 1186),
-      grpc_core::StaticMetadataSlice(&refcounts[83].base, 4, g_bytes + 1199),
-      grpc_core::StaticMetadataSlice(&refcounts[84].base, 8, g_bytes + 1203),
-      grpc_core::StaticMetadataSlice(&refcounts[85].base, 12, g_bytes + 1211),
-      grpc_core::StaticMetadataSlice(&refcounts[86].base, 18, g_bytes + 1223),
-      grpc_core::StaticMetadataSlice(&refcounts[87].base, 19, g_bytes + 1241),
-      grpc_core::StaticMetadataSlice(&refcounts[88].base, 5, g_bytes + 1260),
-      grpc_core::StaticMetadataSlice(&refcounts[89].base, 7, g_bytes + 1265),
-      grpc_core::StaticMetadataSlice(&refcounts[90].base, 7, g_bytes + 1272),
-      grpc_core::StaticMetadataSlice(&refcounts[91].base, 11, g_bytes + 1279),
-      grpc_core::StaticMetadataSlice(&refcounts[92].base, 6, g_bytes + 1290),
-      grpc_core::StaticMetadataSlice(&refcounts[93].base, 10, g_bytes + 1296),
-      grpc_core::StaticMetadataSlice(&refcounts[94].base, 25, g_bytes + 1306),
-      grpc_core::StaticMetadataSlice(&refcounts[95].base, 17, g_bytes + 1331),
-      grpc_core::StaticMetadataSlice(&refcounts[96].base, 4, g_bytes + 1348),
-      grpc_core::StaticMetadataSlice(&refcounts[97].base, 3, g_bytes + 1352),
-      grpc_core::StaticMetadataSlice(&refcounts[98].base, 16, g_bytes + 1355),
-      grpc_core::StaticMetadataSlice(&refcounts[99].base, 1, g_bytes + 1371),
-      grpc_core::StaticMetadataSlice(&refcounts[100].base, 8, g_bytes + 1372),
-      grpc_core::StaticMetadataSlice(&refcounts[101].base, 8, g_bytes + 1380),
-      grpc_core::StaticMetadataSlice(&refcounts[102].base, 16, g_bytes + 1388),
-      grpc_core::StaticMetadataSlice(&refcounts[103].base, 4, g_bytes + 1404),
-      grpc_core::StaticMetadataSlice(&refcounts[104].base, 3, g_bytes + 1408),
-      grpc_core::StaticMetadataSlice(&refcounts[105].base, 11, g_bytes + 1411),
-      grpc_core::StaticMetadataSlice(&refcounts[106].base, 16, g_bytes + 1422),
-      grpc_core::StaticMetadataSlice(&refcounts[107].base, 13, g_bytes + 1438),
-      grpc_core::StaticMetadataSlice(&refcounts[108].base, 12, g_bytes + 1451),
-      grpc_core::StaticMetadataSlice(&refcounts[109].base, 21, g_bytes + 1463),
+      grpc_core::StaticMetadataSlice(&refcounts[36].base, 65, g_bytes + 566), 
+      grpc_core::StaticMetadataSlice(&refcounts[37].base, 28, g_bytes + 631), 
+      grpc_core::StaticMetadataSlice(&refcounts[38].base, 80, g_bytes + 659), 
+      grpc_core::StaticMetadataSlice(&refcounts[39].base, 80, g_bytes + 739), 
+      grpc_core::StaticMetadataSlice(&refcounts[40].base, 7, g_bytes + 819), 
+      grpc_core::StaticMetadataSlice(&refcounts[41].base, 4, g_bytes + 826), 
+      grpc_core::StaticMetadataSlice(&refcounts[42].base, 11, g_bytes + 830), 
+      grpc_core::StaticMetadataSlice(&refcounts[43].base, 3, g_bytes + 841), 
+      grpc_core::StaticMetadataSlice(&refcounts[44].base, 4, g_bytes + 844), 
+      grpc_core::StaticMetadataSlice(&refcounts[45].base, 1, g_bytes + 848), 
+      grpc_core::StaticMetadataSlice(&refcounts[46].base, 11, g_bytes + 849), 
+      grpc_core::StaticMetadataSlice(&refcounts[47].base, 4, g_bytes + 860), 
+      grpc_core::StaticMetadataSlice(&refcounts[48].base, 5, g_bytes + 864), 
+      grpc_core::StaticMetadataSlice(&refcounts[49].base, 3, g_bytes + 869), 
+      grpc_core::StaticMetadataSlice(&refcounts[50].base, 3, g_bytes + 872), 
+      grpc_core::StaticMetadataSlice(&refcounts[51].base, 3, g_bytes + 875), 
+      grpc_core::StaticMetadataSlice(&refcounts[52].base, 3, g_bytes + 878), 
+      grpc_core::StaticMetadataSlice(&refcounts[53].base, 3, g_bytes + 881), 
+      grpc_core::StaticMetadataSlice(&refcounts[54].base, 3, g_bytes + 884), 
+      grpc_core::StaticMetadataSlice(&refcounts[55].base, 3, g_bytes + 887), 
+      grpc_core::StaticMetadataSlice(&refcounts[56].base, 14, g_bytes + 890), 
+      grpc_core::StaticMetadataSlice(&refcounts[57].base, 13, g_bytes + 904), 
+      grpc_core::StaticMetadataSlice(&refcounts[58].base, 15, g_bytes + 917), 
+      grpc_core::StaticMetadataSlice(&refcounts[59].base, 13, g_bytes + 932), 
+      grpc_core::StaticMetadataSlice(&refcounts[60].base, 6, g_bytes + 945), 
+      grpc_core::StaticMetadataSlice(&refcounts[61].base, 27, g_bytes + 951), 
+      grpc_core::StaticMetadataSlice(&refcounts[62].base, 3, g_bytes + 978), 
+      grpc_core::StaticMetadataSlice(&refcounts[63].base, 5, g_bytes + 981), 
+      grpc_core::StaticMetadataSlice(&refcounts[64].base, 13, g_bytes + 986), 
+      grpc_core::StaticMetadataSlice(&refcounts[65].base, 13, g_bytes + 999), 
+      grpc_core::StaticMetadataSlice(&refcounts[66].base, 19, g_bytes + 1012), 
+      grpc_core::StaticMetadataSlice(&refcounts[67].base, 16, g_bytes + 1031), 
+      grpc_core::StaticMetadataSlice(&refcounts[68].base, 14, g_bytes + 1047), 
+      grpc_core::StaticMetadataSlice(&refcounts[69].base, 16, g_bytes + 1061), 
+      grpc_core::StaticMetadataSlice(&refcounts[70].base, 13, g_bytes + 1077), 
+      grpc_core::StaticMetadataSlice(&refcounts[71].base, 6, g_bytes + 1090), 
+      grpc_core::StaticMetadataSlice(&refcounts[72].base, 4, g_bytes + 1096), 
+      grpc_core::StaticMetadataSlice(&refcounts[73].base, 4, g_bytes + 1100), 
+      grpc_core::StaticMetadataSlice(&refcounts[74].base, 6, g_bytes + 1104), 
+      grpc_core::StaticMetadataSlice(&refcounts[75].base, 7, g_bytes + 1110), 
+      grpc_core::StaticMetadataSlice(&refcounts[76].base, 4, g_bytes + 1117), 
+      grpc_core::StaticMetadataSlice(&refcounts[77].base, 8, g_bytes + 1121), 
+      grpc_core::StaticMetadataSlice(&refcounts[78].base, 17, g_bytes + 1129), 
+      grpc_core::StaticMetadataSlice(&refcounts[79].base, 13, g_bytes + 1146), 
+      grpc_core::StaticMetadataSlice(&refcounts[80].base, 8, g_bytes + 1159), 
+      grpc_core::StaticMetadataSlice(&refcounts[81].base, 19, g_bytes + 1167), 
+      grpc_core::StaticMetadataSlice(&refcounts[82].base, 13, g_bytes + 1186), 
+      grpc_core::StaticMetadataSlice(&refcounts[83].base, 4, g_bytes + 1199), 
+      grpc_core::StaticMetadataSlice(&refcounts[84].base, 8, g_bytes + 1203), 
+      grpc_core::StaticMetadataSlice(&refcounts[85].base, 12, g_bytes + 1211), 
+      grpc_core::StaticMetadataSlice(&refcounts[86].base, 18, g_bytes + 1223), 
+      grpc_core::StaticMetadataSlice(&refcounts[87].base, 19, g_bytes + 1241), 
+      grpc_core::StaticMetadataSlice(&refcounts[88].base, 5, g_bytes + 1260), 
+      grpc_core::StaticMetadataSlice(&refcounts[89].base, 7, g_bytes + 1265), 
+      grpc_core::StaticMetadataSlice(&refcounts[90].base, 7, g_bytes + 1272), 
+      grpc_core::StaticMetadataSlice(&refcounts[91].base, 11, g_bytes + 1279), 
+      grpc_core::StaticMetadataSlice(&refcounts[92].base, 6, g_bytes + 1290), 
+      grpc_core::StaticMetadataSlice(&refcounts[93].base, 10, g_bytes + 1296), 
+      grpc_core::StaticMetadataSlice(&refcounts[94].base, 25, g_bytes + 1306), 
+      grpc_core::StaticMetadataSlice(&refcounts[95].base, 17, g_bytes + 1331), 
+      grpc_core::StaticMetadataSlice(&refcounts[96].base, 4, g_bytes + 1348), 
+      grpc_core::StaticMetadataSlice(&refcounts[97].base, 3, g_bytes + 1352), 
+      grpc_core::StaticMetadataSlice(&refcounts[98].base, 16, g_bytes + 1355), 
+      grpc_core::StaticMetadataSlice(&refcounts[99].base, 1, g_bytes + 1371), 
+      grpc_core::StaticMetadataSlice(&refcounts[100].base, 8, g_bytes + 1372), 
+      grpc_core::StaticMetadataSlice(&refcounts[101].base, 8, g_bytes + 1380), 
+      grpc_core::StaticMetadataSlice(&refcounts[102].base, 16, g_bytes + 1388), 
+      grpc_core::StaticMetadataSlice(&refcounts[103].base, 4, g_bytes + 1404), 
+      grpc_core::StaticMetadataSlice(&refcounts[104].base, 3, g_bytes + 1408), 
+      grpc_core::StaticMetadataSlice(&refcounts[105].base, 11, g_bytes + 1411), 
+      grpc_core::StaticMetadataSlice(&refcounts[106].base, 16, g_bytes + 1422), 
+      grpc_core::StaticMetadataSlice(&refcounts[107].base, 13, g_bytes + 1438), 
+      grpc_core::StaticMetadataSlice(&refcounts[108].base, 12, g_bytes + 1451), 
+      grpc_core::StaticMetadataSlice(&refcounts[109].base, 21, g_bytes + 1463), 
   };
   StaticMetadata static_mdelem_table[GRPC_STATIC_MDELEM_COUNT] = {
       StaticMetadata(
@@ -317,107 +317,107 @@ struct StaticMetadataCtx {
           0),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[1].base, 7, g_bytes + 5),
-          grpc_core::StaticMetadataSlice(&refcounts[43].base, 3, g_bytes + 841),
+          grpc_core::StaticMetadataSlice(&refcounts[43].base, 3, g_bytes + 841), 
           1),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[1].base, 7, g_bytes + 5),
-          grpc_core::StaticMetadataSlice(&refcounts[44].base, 4, g_bytes + 844),
+          grpc_core::StaticMetadataSlice(&refcounts[44].base, 4, g_bytes + 844), 
           2),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[0].base, 5, g_bytes + 0),
-          grpc_core::StaticMetadataSlice(&refcounts[45].base, 1, g_bytes + 848),
+          grpc_core::StaticMetadataSlice(&refcounts[45].base, 1, g_bytes + 848), 
           3),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[0].base, 5, g_bytes + 0),
-          grpc_core::StaticMetadataSlice(&refcounts[46].base, 11,
-                                         g_bytes + 849),
+          grpc_core::StaticMetadataSlice(&refcounts[46].base, 11, 
+                                         g_bytes + 849), 
           4),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[4].base, 7, g_bytes + 29),
-          grpc_core::StaticMetadataSlice(&refcounts[47].base, 4, g_bytes + 860),
+          grpc_core::StaticMetadataSlice(&refcounts[47].base, 4, g_bytes + 860), 
           5),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[4].base, 7, g_bytes + 29),
-          grpc_core::StaticMetadataSlice(&refcounts[48].base, 5, g_bytes + 864),
+          grpc_core::StaticMetadataSlice(&refcounts[48].base, 5, g_bytes + 864), 
           6),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[2].base, 7, g_bytes + 12),
-          grpc_core::StaticMetadataSlice(&refcounts[49].base, 3, g_bytes + 869),
+          grpc_core::StaticMetadataSlice(&refcounts[49].base, 3, g_bytes + 869), 
           7),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[2].base, 7, g_bytes + 12),
-          grpc_core::StaticMetadataSlice(&refcounts[50].base, 3, g_bytes + 872),
+          grpc_core::StaticMetadataSlice(&refcounts[50].base, 3, g_bytes + 872), 
           8),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[2].base, 7, g_bytes + 12),
-          grpc_core::StaticMetadataSlice(&refcounts[51].base, 3, g_bytes + 875),
+          grpc_core::StaticMetadataSlice(&refcounts[51].base, 3, g_bytes + 875), 
           9),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[2].base, 7, g_bytes + 12),
-          grpc_core::StaticMetadataSlice(&refcounts[52].base, 3, g_bytes + 878),
+          grpc_core::StaticMetadataSlice(&refcounts[52].base, 3, g_bytes + 878), 
           10),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[2].base, 7, g_bytes + 12),
-          grpc_core::StaticMetadataSlice(&refcounts[53].base, 3, g_bytes + 881),
+          grpc_core::StaticMetadataSlice(&refcounts[53].base, 3, g_bytes + 881), 
           11),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[2].base, 7, g_bytes + 12),
-          grpc_core::StaticMetadataSlice(&refcounts[54].base, 3, g_bytes + 884),
+          grpc_core::StaticMetadataSlice(&refcounts[54].base, 3, g_bytes + 884), 
           12),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[2].base, 7, g_bytes + 12),
-          grpc_core::StaticMetadataSlice(&refcounts[55].base, 3, g_bytes + 887),
+          grpc_core::StaticMetadataSlice(&refcounts[55].base, 3, g_bytes + 887), 
           13),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[56].base, 14,
-                                         g_bytes + 890),
+          grpc_core::StaticMetadataSlice(&refcounts[56].base, 14, 
+                                         g_bytes + 890), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           14),
       StaticMetadata(grpc_core::StaticMetadataSlice(&refcounts[16].base, 15,
                                                     g_bytes + 186),
-                     grpc_core::StaticMetadataSlice(&refcounts[57].base, 13,
-                                                    g_bytes + 904),
+                     grpc_core::StaticMetadataSlice(&refcounts[57].base, 13, 
+                                                    g_bytes + 904), 
                      15),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[58].base, 15,
-                                         g_bytes + 917),
+          grpc_core::StaticMetadataSlice(&refcounts[58].base, 15, 
+                                         g_bytes + 917), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           16),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[59].base, 13,
-                                         g_bytes + 932),
+          grpc_core::StaticMetadataSlice(&refcounts[59].base, 13, 
+                                         g_bytes + 932), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           17),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[60].base, 6, g_bytes + 945),
+          grpc_core::StaticMetadataSlice(&refcounts[60].base, 6, g_bytes + 945), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           18),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[61].base, 27,
-                                         g_bytes + 951),
+          grpc_core::StaticMetadataSlice(&refcounts[61].base, 27, 
+                                         g_bytes + 951), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           19),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[62].base, 3, g_bytes + 978),
+          grpc_core::StaticMetadataSlice(&refcounts[62].base, 3, g_bytes + 978), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           20),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[63].base, 5, g_bytes + 981),
+          grpc_core::StaticMetadataSlice(&refcounts[63].base, 5, g_bytes + 981), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           21),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[64].base, 13,
-                                         g_bytes + 986),
+          grpc_core::StaticMetadataSlice(&refcounts[64].base, 13, 
+                                         g_bytes + 986), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           22),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[65].base, 13,
-                                         g_bytes + 999),
+          grpc_core::StaticMetadataSlice(&refcounts[65].base, 13, 
+                                         g_bytes + 999), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           23),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[66].base, 19,
-                                         g_bytes + 1012),
+          grpc_core::StaticMetadataSlice(&refcounts[66].base, 19, 
+                                         g_bytes + 1012), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           24),
       StaticMetadata(
@@ -426,23 +426,23 @@ struct StaticMetadataCtx {
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           25),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[67].base, 16,
-                                         g_bytes + 1031),
+          grpc_core::StaticMetadataSlice(&refcounts[67].base, 16, 
+                                         g_bytes + 1031), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           26),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[68].base, 14,
-                                         g_bytes + 1047),
+          grpc_core::StaticMetadataSlice(&refcounts[68].base, 14, 
+                                         g_bytes + 1047), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           27),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[69].base, 16,
-                                         g_bytes + 1061),
+          grpc_core::StaticMetadataSlice(&refcounts[69].base, 16, 
+                                         g_bytes + 1061), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           28),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[70].base, 13,
-                                         g_bytes + 1077),
+          grpc_core::StaticMetadataSlice(&refcounts[70].base, 13, 
+                                         g_bytes + 1077), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           29),
       StaticMetadata(
@@ -451,33 +451,33 @@ struct StaticMetadataCtx {
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           30),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[71].base, 6,
-                                         g_bytes + 1090),
+          grpc_core::StaticMetadataSlice(&refcounts[71].base, 6, 
+                                         g_bytes + 1090), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           31),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[72].base, 4,
-                                         g_bytes + 1096),
+          grpc_core::StaticMetadataSlice(&refcounts[72].base, 4, 
+                                         g_bytes + 1096), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           32),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[73].base, 4,
-                                         g_bytes + 1100),
+          grpc_core::StaticMetadataSlice(&refcounts[73].base, 4, 
+                                         g_bytes + 1100), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           33),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[74].base, 6,
-                                         g_bytes + 1104),
+          grpc_core::StaticMetadataSlice(&refcounts[74].base, 6, 
+                                         g_bytes + 1104), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           34),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[75].base, 7,
-                                         g_bytes + 1110),
+          grpc_core::StaticMetadataSlice(&refcounts[75].base, 7, 
+                                         g_bytes + 1110), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           35),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[76].base, 4,
-                                         g_bytes + 1117),
+          grpc_core::StaticMetadataSlice(&refcounts[76].base, 4, 
+                                         g_bytes + 1117), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           36),
       StaticMetadata(
@@ -485,98 +485,98 @@ struct StaticMetadataCtx {
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           37),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[77].base, 8,
-                                         g_bytes + 1121),
+          grpc_core::StaticMetadataSlice(&refcounts[77].base, 8, 
+                                         g_bytes + 1121), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           38),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[78].base, 17,
-                                         g_bytes + 1129),
+          grpc_core::StaticMetadataSlice(&refcounts[78].base, 17, 
+                                         g_bytes + 1129), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           39),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[79].base, 13,
-                                         g_bytes + 1146),
+          grpc_core::StaticMetadataSlice(&refcounts[79].base, 13, 
+                                         g_bytes + 1146), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           40),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[80].base, 8,
-                                         g_bytes + 1159),
+          grpc_core::StaticMetadataSlice(&refcounts[80].base, 8, 
+                                         g_bytes + 1159), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           41),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[81].base, 19,
-                                         g_bytes + 1167),
+          grpc_core::StaticMetadataSlice(&refcounts[81].base, 19, 
+                                         g_bytes + 1167), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           42),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[82].base, 13,
-                                         g_bytes + 1186),
+          grpc_core::StaticMetadataSlice(&refcounts[82].base, 13, 
+                                         g_bytes + 1186), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           43),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[83].base, 4,
-                                         g_bytes + 1199),
+          grpc_core::StaticMetadataSlice(&refcounts[83].base, 4, 
+                                         g_bytes + 1199), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           44),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[84].base, 8,
-                                         g_bytes + 1203),
+          grpc_core::StaticMetadataSlice(&refcounts[84].base, 8, 
+                                         g_bytes + 1203), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           45),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[85].base, 12,
-                                         g_bytes + 1211),
+          grpc_core::StaticMetadataSlice(&refcounts[85].base, 12, 
+                                         g_bytes + 1211), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           46),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[86].base, 18,
-                                         g_bytes + 1223),
+          grpc_core::StaticMetadataSlice(&refcounts[86].base, 18, 
+                                         g_bytes + 1223), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           47),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[87].base, 19,
-                                         g_bytes + 1241),
+          grpc_core::StaticMetadataSlice(&refcounts[87].base, 19, 
+                                         g_bytes + 1241), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           48),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[88].base, 5,
-                                         g_bytes + 1260),
+          grpc_core::StaticMetadataSlice(&refcounts[88].base, 5, 
+                                         g_bytes + 1260), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           49),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[89].base, 7,
-                                         g_bytes + 1265),
+          grpc_core::StaticMetadataSlice(&refcounts[89].base, 7, 
+                                         g_bytes + 1265), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           50),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[90].base, 7,
-                                         g_bytes + 1272),
+          grpc_core::StaticMetadataSlice(&refcounts[90].base, 7, 
+                                         g_bytes + 1272), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           51),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[91].base, 11,
-                                         g_bytes + 1279),
+          grpc_core::StaticMetadataSlice(&refcounts[91].base, 11, 
+                                         g_bytes + 1279), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           52),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[92].base, 6,
-                                         g_bytes + 1290),
+          grpc_core::StaticMetadataSlice(&refcounts[92].base, 6, 
+                                         g_bytes + 1290), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           53),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[93].base, 10,
-                                         g_bytes + 1296),
+          grpc_core::StaticMetadataSlice(&refcounts[93].base, 10, 
+                                         g_bytes + 1296), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           54),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[94].base, 25,
-                                         g_bytes + 1306),
+          grpc_core::StaticMetadataSlice(&refcounts[94].base, 25, 
+                                         g_bytes + 1306), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           55),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[95].base, 17,
-                                         g_bytes + 1331),
+          grpc_core::StaticMetadataSlice(&refcounts[95].base, 17, 
+                                         g_bytes + 1331), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           56),
       StaticMetadata(
@@ -585,24 +585,24 @@ struct StaticMetadataCtx {
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           57),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[96].base, 4,
-                                         g_bytes + 1348),
+          grpc_core::StaticMetadataSlice(&refcounts[96].base, 4, 
+                                         g_bytes + 1348), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           58),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[97].base, 3,
-                                         g_bytes + 1352),
+          grpc_core::StaticMetadataSlice(&refcounts[97].base, 3, 
+                                         g_bytes + 1352), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           59),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[98].base, 16,
-                                         g_bytes + 1355),
+          grpc_core::StaticMetadataSlice(&refcounts[98].base, 16, 
+                                         g_bytes + 1355), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           60),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[7].base, 11, g_bytes + 50),
-          grpc_core::StaticMetadataSlice(&refcounts[99].base, 1,
-                                         g_bytes + 1371),
+          grpc_core::StaticMetadataSlice(&refcounts[99].base, 1, 
+                                         g_bytes + 1371), 
           61),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[7].base, 11, g_bytes + 50),
@@ -614,36 +614,36 @@ struct StaticMetadataCtx {
           63),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[9].base, 13, g_bytes + 77),
-          grpc_core::StaticMetadataSlice(&refcounts[100].base, 8,
-                                         g_bytes + 1372),
+          grpc_core::StaticMetadataSlice(&refcounts[100].base, 8, 
+                                         g_bytes + 1372), 
           64),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[9].base, 13, g_bytes + 77),
-          grpc_core::StaticMetadataSlice(&refcounts[41].base, 4, g_bytes + 826),
+          grpc_core::StaticMetadataSlice(&refcounts[41].base, 4, g_bytes + 826), 
           65),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[9].base, 13, g_bytes + 77),
-          grpc_core::StaticMetadataSlice(&refcounts[40].base, 7, g_bytes + 819),
+          grpc_core::StaticMetadataSlice(&refcounts[40].base, 7, g_bytes + 819), 
           66),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[5].base, 2, g_bytes + 36),
-          grpc_core::StaticMetadataSlice(&refcounts[101].base, 8,
-                                         g_bytes + 1380),
+          grpc_core::StaticMetadataSlice(&refcounts[101].base, 8, 
+                                         g_bytes + 1380), 
           67),
       StaticMetadata(grpc_core::StaticMetadataSlice(&refcounts[14].base, 12,
                                                     g_bytes + 158),
-                     grpc_core::StaticMetadataSlice(&refcounts[102].base, 16,
-                                                    g_bytes + 1388),
+                     grpc_core::StaticMetadataSlice(&refcounts[102].base, 16, 
+                                                    g_bytes + 1388), 
                      68),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[4].base, 7, g_bytes + 29),
-          grpc_core::StaticMetadataSlice(&refcounts[103].base, 4,
-                                         g_bytes + 1404),
+          grpc_core::StaticMetadataSlice(&refcounts[103].base, 4, 
+                                         g_bytes + 1404), 
           69),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[1].base, 7, g_bytes + 5),
-          grpc_core::StaticMetadataSlice(&refcounts[104].base, 3,
-                                         g_bytes + 1408),
+          grpc_core::StaticMetadataSlice(&refcounts[104].base, 3, 
+                                         g_bytes + 1408), 
           70),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[16].base, 15,
@@ -652,66 +652,66 @@ struct StaticMetadataCtx {
           71),
       StaticMetadata(grpc_core::StaticMetadataSlice(&refcounts[15].base, 16,
                                                     g_bytes + 170),
-                     grpc_core::StaticMetadataSlice(&refcounts[100].base, 8,
-                                                    g_bytes + 1372),
+                     grpc_core::StaticMetadataSlice(&refcounts[100].base, 8, 
+                                                    g_bytes + 1372), 
                      72),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[15].base, 16,
                                          g_bytes + 170),
-          grpc_core::StaticMetadataSlice(&refcounts[41].base, 4, g_bytes + 826),
+          grpc_core::StaticMetadataSlice(&refcounts[41].base, 4, g_bytes + 826), 
           73),
       StaticMetadata(
-          grpc_core::StaticMetadataSlice(&refcounts[105].base, 11,
-                                         g_bytes + 1411),
+          grpc_core::StaticMetadataSlice(&refcounts[105].base, 11, 
+                                         g_bytes + 1411), 
           grpc_core::StaticMetadataSlice(&refcounts[29].base, 0, g_bytes + 373),
           74),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[10].base, 20, g_bytes + 90),
-          grpc_core::StaticMetadataSlice(&refcounts[100].base, 8,
-                                         g_bytes + 1372),
+          grpc_core::StaticMetadataSlice(&refcounts[100].base, 8, 
+                                         g_bytes + 1372), 
           75),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[10].base, 20, g_bytes + 90),
-          grpc_core::StaticMetadataSlice(&refcounts[40].base, 7, g_bytes + 819),
+          grpc_core::StaticMetadataSlice(&refcounts[40].base, 7, g_bytes + 819), 
           76),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[10].base, 20, g_bytes + 90),
-          grpc_core::StaticMetadataSlice(&refcounts[106].base, 16,
-                                         g_bytes + 1422),
+          grpc_core::StaticMetadataSlice(&refcounts[106].base, 16, 
+                                         g_bytes + 1422), 
           77),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[10].base, 20, g_bytes + 90),
-          grpc_core::StaticMetadataSlice(&refcounts[41].base, 4, g_bytes + 826),
+          grpc_core::StaticMetadataSlice(&refcounts[41].base, 4, g_bytes + 826), 
           78),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[10].base, 20, g_bytes + 90),
-          grpc_core::StaticMetadataSlice(&refcounts[107].base, 13,
-                                         g_bytes + 1438),
+          grpc_core::StaticMetadataSlice(&refcounts[107].base, 13, 
+                                         g_bytes + 1438), 
           79),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[10].base, 20, g_bytes + 90),
-          grpc_core::StaticMetadataSlice(&refcounts[108].base, 12,
-                                         g_bytes + 1451),
+          grpc_core::StaticMetadataSlice(&refcounts[108].base, 12, 
+                                         g_bytes + 1451), 
           80),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[10].base, 20, g_bytes + 90),
-          grpc_core::StaticMetadataSlice(&refcounts[109].base, 21,
-                                         g_bytes + 1463),
+          grpc_core::StaticMetadataSlice(&refcounts[109].base, 21, 
+                                         g_bytes + 1463), 
           81),
       StaticMetadata(grpc_core::StaticMetadataSlice(&refcounts[16].base, 15,
                                                     g_bytes + 186),
-                     grpc_core::StaticMetadataSlice(&refcounts[100].base, 8,
-                                                    g_bytes + 1372),
+                     grpc_core::StaticMetadataSlice(&refcounts[100].base, 8, 
+                                                    g_bytes + 1372), 
                      82),
       StaticMetadata(
           grpc_core::StaticMetadataSlice(&refcounts[16].base, 15,
                                          g_bytes + 186),
-          grpc_core::StaticMetadataSlice(&refcounts[41].base, 4, g_bytes + 826),
+          grpc_core::StaticMetadataSlice(&refcounts[41].base, 4, g_bytes + 826), 
           83),
       StaticMetadata(grpc_core::StaticMetadataSlice(&refcounts[16].base, 15,
                                                     g_bytes + 186),
-                     grpc_core::StaticMetadataSlice(&refcounts[107].base, 13,
-                                                    g_bytes + 1438),
+                     grpc_core::StaticMetadataSlice(&refcounts[107].base, 13, 
+                                                    g_bytes + 1438), 
                      84),
   };
 
@@ -1195,16 +1195,16 @@ uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT] = {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 6, 6, 8, 8, 2, 4, 4};
 
 static const int8_t elems_r[] = {
-    15, 10, -8,  0,  2,   -43, -83, -44, 0,  4,  -8, 0,  0,  0,  10, 0,  -7, 0,
-    0,  3,  3,   0,  0,   0,   0,   0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,   0,  0,   0,   0,   0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  -68, 0,  -53, -56, -53, -77, 0,  30, 29, 28, 27, 26, 25, 24, 35, 22,
-    21, 20, 19,  18, 17,  16,  15,  16,  16, 16, 15, 14, 13, 12, 11, 10, 9,  8,
-    7,  6,  5,   4,  3,   2,   3,   2,   2,  6,  0,  0,  0,  0,  0,  0,  -7, 0};
+    15, 10, -8,  0,  2,   -43, -83, -44, 0,  4,  -8, 0,  0,  0,  10, 0,  -7, 0, 
+    0,  3,  3,   0,  0,   0,   0,   0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
+    0,  0,  0,   0,  0,   0,   0,   0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
+    0,  0,  -68, 0,  -53, -56, -53, -77, 0,  30, 29, 28, 27, 26, 25, 24, 35, 22, 
+    21, 20, 19,  18, 17,  16,  15,  16,  16, 16, 15, 14, 13, 12, 11, 10, 9,  8, 
+    7,  6,  5,   4,  3,   2,   3,   2,   2,  6,  0,  0,  0,  0,  0,  0,  -7, 0}; 
 static uint32_t elems_phash(uint32_t i) {
-  i -= 45;
-  uint32_t x = i % 108;
-  uint32_t y = i / 108;
+  i -= 45; 
+  uint32_t x = i % 108; 
+  uint32_t y = i / 108; 
   uint32_t h = x;
   if (y < GPR_ARRAY_SIZE(elems_r)) {
     uint32_t delta = (uint32_t)elems_r[y];
@@ -1214,26 +1214,26 @@ static uint32_t elems_phash(uint32_t i) {
 }
 
 static const uint16_t elem_keys[] = {
-    269,   270,   271,   272,   273,   274,  275,   1140, 1141,  1789,  153,
-    154,   487,   488,   1679,  45,    46,   1030,  1031, 795,   796,   1801,
-    1569,  651,   869,   2119,  1691,  2229, 6189,  6739, 6849,  6959,  7069,
-    7179,  7289,  7399,  7509,  1817,  7729, 7839,  7949, 8059,  8169,  8279,
-    8389,  8499,  6519,  6409,  8609,  7619, 8719,  6629, 8829,  8939,  9049,
-    9159,  9269,  9379,  9489,  9599,  9709, 9819,  9929, 10039, 10149, 10259,
-    10369, 1200,  543,   10479, 10589, 214,  10699, 1206, 1207,  1208,  1209,
-    1090,  10809, 11579, 1860,  0,     0,    0,     0,    1750,  0,     1867,
-    0,     0,     359,   0,     0,     0,    0,     1642};
+    269,   270,   271,   272,   273,   274,  275,   1140, 1141,  1789,  153, 
+    154,   487,   488,   1679,  45,    46,   1030,  1031, 795,   796,   1801, 
+    1569,  651,   869,   2119,  1691,  2229, 6189,  6739, 6849,  6959,  7069, 
+    7179,  7289,  7399,  7509,  1817,  7729, 7839,  7949, 8059,  8169,  8279, 
+    8389,  8499,  6519,  6409,  8609,  7619, 8719,  6629, 8829,  8939,  9049, 
+    9159,  9269,  9379,  9489,  9599,  9709, 9819,  9929, 10039, 10149, 10259, 
+    10369, 1200,  543,   10479, 10589, 214,  10699, 1206, 1207,  1208,  1209, 
+    1090,  10809, 11579, 1860,  0,     0,    0,     0,    1750,  0,     1867, 
+    0,     0,     359,   0,     0,     0,    0,     1642}; 
 static const uint8_t elem_idxs[] = {
-    7,  8,   9,   10,  11,  12, 13,  76, 78,  71,  1,  2,   5,   6,   25,  3,
-    4,  66,  65,  62,  63,  83, 30,  67, 61,  57,  73, 37,  14,  19,  20,  21,
-    22, 23,  24,  26,  27,  15, 29,  31, 32,  33,  34, 35,  36,  38,  17,  16,
-    39, 28,  40,  18,  41,  42, 43,  44, 45,  46,  47, 48,  49,  50,  51,  52,
-    53, 54,  55,  75,  69,  56, 58,  70, 59,  77,  79, 80,  81,  64,  60,  74,
-    82, 255, 255, 255, 255, 72, 255, 84, 255, 255, 0,  255, 255, 255, 255, 68};
+    7,  8,   9,   10,  11,  12, 13,  76, 78,  71,  1,  2,   5,   6,   25,  3, 
+    4,  66,  65,  62,  63,  83, 30,  67, 61,  57,  73, 37,  14,  19,  20,  21, 
+    22, 23,  24,  26,  27,  15, 29,  31, 32,  33,  34, 35,  36,  38,  17,  16, 
+    39, 28,  40,  18,  41,  42, 43,  44, 45,  46,  47, 48,  49,  50,  51,  52, 
+    53, 54,  55,  75,  69,  56, 58,  70, 59,  77,  79, 80,  81,  64,  60,  74, 
+    82, 255, 255, 255, 255, 72, 255, 84, 255, 255, 0,  255, 255, 255, 255, 68}; 
 
 grpc_mdelem grpc_static_mdelem_for_static_strings(intptr_t a, intptr_t b) {
   if (a == -1 || b == -1) return GRPC_MDNULL;
-  uint32_t k = static_cast<uint32_t>(a * 110 + b);
+  uint32_t k = static_cast<uint32_t>(a * 110 + b); 
   uint32_t h = elems_phash(k);
   return h < GPR_ARRAY_SIZE(elem_keys) && elem_keys[h] == k &&
                  elem_idxs[h] != 255
diff --git a/contrib/libs/grpc/src/core/lib/transport/static_metadata.h b/contrib/libs/grpc/src/core/lib/transport/static_metadata.h
index 5d844af558..5c5624617a 100644
--- a/contrib/libs/grpc/src/core/lib/transport/static_metadata.h
+++ b/contrib/libs/grpc/src/core/lib/transport/static_metadata.h
@@ -36,7 +36,7 @@
 static_assert(
     std::is_trivially_destructible<grpc_core::StaticMetadataSlice>::value,
     "grpc_core::StaticMetadataSlice must be trivially destructible.");
-#define GRPC_STATIC_MDSTR_COUNT 110
+#define GRPC_STATIC_MDSTR_COUNT 110 
 
 void grpc_init_static_metadata_ctx(void);
 void grpc_destroy_static_metadata_ctx(void);
@@ -46,7 +46,7 @@ constexpr uint64_t kGrpcStaticMetadataInitCanary = 0xCAFEF00DC0FFEE11L;
 uint64_t StaticMetadataInitCanary();
 #endif
 extern const StaticMetadataSlice* g_static_metadata_slice_table;
-}  // namespace grpc_core
+}  // namespace grpc_core 
 inline const grpc_core::StaticMetadataSlice* grpc_static_slice_table() {
   GPR_DEBUG_ASSERT(grpc_core::StaticMetadataInitCanary() ==
                    grpc_core::kGrpcStaticMetadataInitCanary);
@@ -132,161 +132,161 @@ inline const grpc_core::StaticMetadataSlice* grpc_static_slice_table() {
 /* "/envoy.service.load_stats.v2.LoadReportingService/StreamLoadStats" */
 #define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_LOAD_STATS_DOT_V2_DOT_LOADREPORTINGSERVICE_SLASH_STREAMLOADSTATS \
   (grpc_static_slice_table()[35])
-/* "/envoy.service.load_stats.v3.LoadReportingService/StreamLoadStats" */
-#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_LOAD_STATS_DOT_V3_DOT_LOADREPORTINGSERVICE_SLASH_STREAMLOADSTATS \
-  (grpc_static_slice_table()[36])
+/* "/envoy.service.load_stats.v3.LoadReportingService/StreamLoadStats" */ 
+#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_LOAD_STATS_DOT_V3_DOT_LOADREPORTINGSERVICE_SLASH_STREAMLOADSTATS \ 
+  (grpc_static_slice_table()[36]) 
 /* "/grpc.health.v1.Health/Watch" */
 #define GRPC_MDSTR_SLASH_GRPC_DOT_HEALTH_DOT_V1_DOT_HEALTH_SLASH_WATCH \
-  (grpc_static_slice_table()[37])
+  (grpc_static_slice_table()[37]) 
 /* "/envoy.service.discovery.v2.AggregatedDiscoveryService/StreamAggregatedResources"
  */
 #define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_DISCOVERY_DOT_V2_DOT_AGGREGATEDDISCOVERYSERVICE_SLASH_STREAMAGGREGATEDRESOURCES \
-  (grpc_static_slice_table()[38])
-/* "/envoy.service.discovery.v3.AggregatedDiscoveryService/StreamAggregatedResources"
- */
-#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_DISCOVERY_DOT_V3_DOT_AGGREGATEDDISCOVERYSERVICE_SLASH_STREAMAGGREGATEDRESOURCES \
-  (grpc_static_slice_table()[39])
+  (grpc_static_slice_table()[38]) 
+/* "/envoy.service.discovery.v3.AggregatedDiscoveryService/StreamAggregatedResources" 
+ */ 
+#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_DISCOVERY_DOT_V3_DOT_AGGREGATEDDISCOVERYSERVICE_SLASH_STREAMAGGREGATEDRESOURCES \ 
+  (grpc_static_slice_table()[39]) 
 /* "deflate" */
-#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table()[40])
+#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table()[40]) 
 /* "gzip" */
-#define GRPC_MDSTR_GZIP (grpc_static_slice_table()[41])
+#define GRPC_MDSTR_GZIP (grpc_static_slice_table()[41]) 
 /* "stream/gzip" */
-#define GRPC_MDSTR_STREAM_SLASH_GZIP (grpc_static_slice_table()[42])
+#define GRPC_MDSTR_STREAM_SLASH_GZIP (grpc_static_slice_table()[42]) 
 /* "GET" */
-#define GRPC_MDSTR_GET (grpc_static_slice_table()[43])
+#define GRPC_MDSTR_GET (grpc_static_slice_table()[43]) 
 /* "POST" */
-#define GRPC_MDSTR_POST (grpc_static_slice_table()[44])
+#define GRPC_MDSTR_POST (grpc_static_slice_table()[44]) 
 /* "/" */
-#define GRPC_MDSTR_SLASH (grpc_static_slice_table()[45])
+#define GRPC_MDSTR_SLASH (grpc_static_slice_table()[45]) 
 /* "/index.html" */
-#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table()[46])
+#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table()[46]) 
 /* "http" */
-#define GRPC_MDSTR_HTTP (grpc_static_slice_table()[47])
+#define GRPC_MDSTR_HTTP (grpc_static_slice_table()[47]) 
 /* "https" */
-#define GRPC_MDSTR_HTTPS (grpc_static_slice_table()[48])
+#define GRPC_MDSTR_HTTPS (grpc_static_slice_table()[48]) 
 /* "200" */
-#define GRPC_MDSTR_200 (grpc_static_slice_table()[49])
+#define GRPC_MDSTR_200 (grpc_static_slice_table()[49]) 
 /* "204" */
-#define GRPC_MDSTR_204 (grpc_static_slice_table()[50])
+#define GRPC_MDSTR_204 (grpc_static_slice_table()[50]) 
 /* "206" */
-#define GRPC_MDSTR_206 (grpc_static_slice_table()[51])
+#define GRPC_MDSTR_206 (grpc_static_slice_table()[51]) 
 /* "304" */
-#define GRPC_MDSTR_304 (grpc_static_slice_table()[52])
+#define GRPC_MDSTR_304 (grpc_static_slice_table()[52]) 
 /* "400" */
-#define GRPC_MDSTR_400 (grpc_static_slice_table()[53])
+#define GRPC_MDSTR_400 (grpc_static_slice_table()[53]) 
 /* "404" */
-#define GRPC_MDSTR_404 (grpc_static_slice_table()[54])
+#define GRPC_MDSTR_404 (grpc_static_slice_table()[54]) 
 /* "500" */
-#define GRPC_MDSTR_500 (grpc_static_slice_table()[55])
+#define GRPC_MDSTR_500 (grpc_static_slice_table()[55]) 
 /* "accept-charset" */
-#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table()[56])
+#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table()[56]) 
 /* "gzip, deflate" */
-#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table()[57])
+#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table()[57]) 
 /* "accept-language" */
-#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table()[58])
+#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table()[58]) 
 /* "accept-ranges" */
-#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table()[59])
+#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table()[59]) 
 /* "accept" */
-#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table()[60])
+#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table()[60]) 
 /* "access-control-allow-origin" */
-#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table()[61])
+#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table()[61]) 
 /* "age" */
-#define GRPC_MDSTR_AGE (grpc_static_slice_table()[62])
+#define GRPC_MDSTR_AGE (grpc_static_slice_table()[62]) 
 /* "allow" */
-#define GRPC_MDSTR_ALLOW (grpc_static_slice_table()[63])
+#define GRPC_MDSTR_ALLOW (grpc_static_slice_table()[63]) 
 /* "authorization" */
-#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table()[64])
+#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table()[64]) 
 /* "cache-control" */
-#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table()[65])
+#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table()[65]) 
 /* "content-disposition" */
-#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table()[66])
+#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table()[66]) 
 /* "content-language" */
-#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table()[67])
+#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table()[67]) 
 /* "content-length" */
-#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table()[68])
+#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table()[68]) 
 /* "content-location" */
-#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table()[69])
+#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table()[69]) 
 /* "content-range" */
-#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table()[70])
+#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table()[70]) 
 /* "cookie" */
-#define GRPC_MDSTR_COOKIE (grpc_static_slice_table()[71])
+#define GRPC_MDSTR_COOKIE (grpc_static_slice_table()[71]) 
 /* "date" */
-#define GRPC_MDSTR_DATE (grpc_static_slice_table()[72])
+#define GRPC_MDSTR_DATE (grpc_static_slice_table()[72]) 
 /* "etag" */
-#define GRPC_MDSTR_ETAG (grpc_static_slice_table()[73])
+#define GRPC_MDSTR_ETAG (grpc_static_slice_table()[73]) 
 /* "expect" */
-#define GRPC_MDSTR_EXPECT (grpc_static_slice_table()[74])
+#define GRPC_MDSTR_EXPECT (grpc_static_slice_table()[74]) 
 /* "expires" */
-#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table()[75])
+#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table()[75]) 
 /* "from" */
-#define GRPC_MDSTR_FROM (grpc_static_slice_table()[76])
+#define GRPC_MDSTR_FROM (grpc_static_slice_table()[76]) 
 /* "if-match" */
-#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table()[77])
+#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table()[77]) 
 /* "if-modified-since" */
-#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table()[78])
+#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table()[78]) 
 /* "if-none-match" */
-#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table()[79])
+#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table()[79]) 
 /* "if-range" */
-#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table()[80])
+#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table()[80]) 
 /* "if-unmodified-since" */
-#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table()[81])
+#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table()[81]) 
 /* "last-modified" */
-#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table()[82])
+#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table()[82]) 
 /* "link" */
-#define GRPC_MDSTR_LINK (grpc_static_slice_table()[83])
+#define GRPC_MDSTR_LINK (grpc_static_slice_table()[83]) 
 /* "location" */
-#define GRPC_MDSTR_LOCATION (grpc_static_slice_table()[84])
+#define GRPC_MDSTR_LOCATION (grpc_static_slice_table()[84]) 
 /* "max-forwards" */
-#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table()[85])
+#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table()[85]) 
 /* "proxy-authenticate" */
-#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table()[86])
+#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table()[86]) 
 /* "proxy-authorization" */
-#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table()[87])
+#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table()[87]) 
 /* "range" */
-#define GRPC_MDSTR_RANGE (grpc_static_slice_table()[88])
+#define GRPC_MDSTR_RANGE (grpc_static_slice_table()[88]) 
 /* "referer" */
-#define GRPC_MDSTR_REFERER (grpc_static_slice_table()[89])
+#define GRPC_MDSTR_REFERER (grpc_static_slice_table()[89]) 
 /* "refresh" */
-#define GRPC_MDSTR_REFRESH (grpc_static_slice_table()[90])
+#define GRPC_MDSTR_REFRESH (grpc_static_slice_table()[90]) 
 /* "retry-after" */
-#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table()[91])
+#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table()[91]) 
 /* "server" */
-#define GRPC_MDSTR_SERVER (grpc_static_slice_table()[92])
+#define GRPC_MDSTR_SERVER (grpc_static_slice_table()[92]) 
 /* "set-cookie" */
-#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table()[93])
+#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table()[93]) 
 /* "strict-transport-security" */
-#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table()[94])
+#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table()[94]) 
 /* "transfer-encoding" */
-#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table()[95])
+#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table()[95]) 
 /* "vary" */
-#define GRPC_MDSTR_VARY (grpc_static_slice_table()[96])
+#define GRPC_MDSTR_VARY (grpc_static_slice_table()[96]) 
 /* "via" */
-#define GRPC_MDSTR_VIA (grpc_static_slice_table()[97])
+#define GRPC_MDSTR_VIA (grpc_static_slice_table()[97]) 
 /* "www-authenticate" */
-#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table()[98])
+#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table()[98]) 
 /* "0" */
-#define GRPC_MDSTR_0 (grpc_static_slice_table()[99])
+#define GRPC_MDSTR_0 (grpc_static_slice_table()[99]) 
 /* "identity" */
-#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table()[100])
+#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table()[100]) 
 /* "trailers" */
-#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table()[101])
+#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table()[101]) 
 /* "application/grpc" */
-#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table()[102])
+#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table()[102]) 
 /* "grpc" */
-#define GRPC_MDSTR_GRPC (grpc_static_slice_table()[103])
+#define GRPC_MDSTR_GRPC (grpc_static_slice_table()[103]) 
 /* "PUT" */
-#define GRPC_MDSTR_PUT (grpc_static_slice_table()[104])
+#define GRPC_MDSTR_PUT (grpc_static_slice_table()[104]) 
 /* "lb-cost-bin" */
-#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table()[105])
+#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table()[105]) 
 /* "identity,deflate" */
-#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table()[106])
+#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table()[106]) 
 /* "identity,gzip" */
-#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table()[107])
+#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table()[107]) 
 /* "deflate,gzip" */
-#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table()[108])
+#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table()[108]) 
 /* "identity,deflate,gzip" */
 #define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE_COMMA_GZIP \
-  (grpc_static_slice_table()[109])
+  (grpc_static_slice_table()[109]) 
 
 namespace grpc_core {
 struct StaticSliceRefcount;
diff --git a/contrib/libs/grpc/src/core/lib/transport/transport.h b/contrib/libs/grpc/src/core/lib/transport/transport.h
index 2404455f9f..817faf357f 100644
--- a/contrib/libs/grpc/src/core/lib/transport/transport.h
+++ b/contrib/libs/grpc/src/core/lib/transport/transport.h
@@ -242,12 +242,12 @@ struct grpc_transport_stream_op_batch_payload {
 
   struct {
     grpc_metadata_batch* send_trailing_metadata = nullptr;
-    // Set by the transport to true if the stream successfully wrote the
-    // trailing metadata. If this is not set but there was a send trailing
-    // metadata op present, this can indicate that a server call can be marked
-    // as  a cancellation (since the stream was write-closed before status could
-    // be delivered).
-    bool* sent = nullptr;
+    // Set by the transport to true if the stream successfully wrote the 
+    // trailing metadata. If this is not set but there was a send trailing 
+    // metadata op present, this can indicate that a server call can be marked 
+    // as  a cancellation (since the stream was write-closed before status could 
+    // be delivered). 
+    bool* sent = nullptr; 
   } send_trailing_metadata;
 
   struct {
@@ -414,9 +414,9 @@ void grpc_transport_stream_op_batch_finish_with_failure(
     grpc_transport_stream_op_batch* op, grpc_error* error,
     grpc_core::CallCombiner* call_combiner);
 
-TString grpc_transport_stream_op_batch_string(
-    grpc_transport_stream_op_batch* op);
-TString grpc_transport_op_string(grpc_transport_op* op);
+TString grpc_transport_stream_op_batch_string( 
+    grpc_transport_stream_op_batch* op); 
+TString grpc_transport_op_string(grpc_transport_op* op); 
 
 /* Send a batch of operations on a transport
 
@@ -459,11 +459,11 @@ grpc_transport_op* grpc_make_transport_op(grpc_closure* on_consumed);
 grpc_transport_stream_op_batch* grpc_make_transport_stream_op(
     grpc_closure* on_consumed);
 
-namespace grpc_core {
-// This is the key to be used for loading/storing keepalive_throttling in the
-// y_absl::Status object.
-constexpr const char* kKeepaliveThrottlingKey =
-    "grpc.internal.keepalive_throttling";
-}  // namespace grpc_core
-
+namespace grpc_core { 
+// This is the key to be used for loading/storing keepalive_throttling in the 
+// y_absl::Status object. 
+constexpr const char* kKeepaliveThrottlingKey = 
+    "grpc.internal.keepalive_throttling"; 
+}  // namespace grpc_core 
+ 
 #endif /* GRPC_CORE_LIB_TRANSPORT_TRANSPORT_H */
diff --git a/contrib/libs/grpc/src/core/lib/transport/transport_op_string.cc b/contrib/libs/grpc/src/core/lib/transport/transport_op_string.cc
index b26ee0a4fd..e4d79fae42 100644
--- a/contrib/libs/grpc/src/core/lib/transport/transport_op_string.cc
+++ b/contrib/libs/grpc/src/core/lib/transport/transport_op_string.cc
@@ -25,12 +25,12 @@
 #include <stdio.h>
 #include <string.h>
 
-#include <vector>
-
-#include "y_absl/strings/str_cat.h"
-#include "y_absl/strings/str_format.h"
-#include "y_absl/strings/str_join.h"
-
+#include <vector> 
+ 
+#include "y_absl/strings/str_cat.h" 
+#include "y_absl/strings/str_format.h" 
+#include "y_absl/strings/str_join.h" 
+ 
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 #include "src/core/lib/gpr/string.h"
@@ -40,130 +40,130 @@
 /* These routines are here to facilitate debugging - they produce string
    representations of various transport data structures */
 
-static void put_metadata(grpc_mdelem md, std::vector<TString>* out) {
-  out->push_back("key=");
-  char* dump = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
-  out->push_back(dump);
-  gpr_free(dump);
-  out->push_back(" value=");
-  dump = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII);
-  out->push_back(dump);
-  gpr_free(dump);
+static void put_metadata(grpc_mdelem md, std::vector<TString>* out) { 
+  out->push_back("key="); 
+  char* dump = grpc_dump_slice(GRPC_MDKEY(md), GPR_DUMP_HEX | GPR_DUMP_ASCII); 
+  out->push_back(dump); 
+  gpr_free(dump); 
+  out->push_back(" value="); 
+  dump = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX | GPR_DUMP_ASCII); 
+  out->push_back(dump); 
+  gpr_free(dump); 
 }
 
-static void put_metadata_list(grpc_metadata_batch md,
-                              std::vector<TString>* out) {
+static void put_metadata_list(grpc_metadata_batch md, 
+                              std::vector<TString>* out) { 
   grpc_linked_mdelem* m;
   for (m = md.list.head; m != nullptr; m = m->next) {
-    if (m != md.list.head) out->push_back(", ");
-    put_metadata(m->md, out);
+    if (m != md.list.head) out->push_back(", "); 
+    put_metadata(m->md, out); 
   }
   if (md.deadline != GRPC_MILLIS_INF_FUTURE) {
-    out->push_back(y_absl::StrFormat(" deadline=%" PRId64, md.deadline));
+    out->push_back(y_absl::StrFormat(" deadline=%" PRId64, md.deadline)); 
   }
 }
 
-TString grpc_transport_stream_op_batch_string(
+TString grpc_transport_stream_op_batch_string( 
     grpc_transport_stream_op_batch* op) {
-  std::vector<TString> out;
+  std::vector<TString> out; 
 
   if (op->send_initial_metadata) {
-    out.push_back(" SEND_INITIAL_METADATA{");
-    put_metadata_list(*op->payload->send_initial_metadata.send_initial_metadata,
-                      &out);
-    out.push_back("}");
+    out.push_back(" SEND_INITIAL_METADATA{"); 
+    put_metadata_list(*op->payload->send_initial_metadata.send_initial_metadata, 
+                      &out); 
+    out.push_back("}"); 
   }
 
   if (op->send_message) {
     if (op->payload->send_message.send_message != nullptr) {
-      out.push_back(
-          y_absl::StrFormat(" SEND_MESSAGE:flags=0x%08x:len=%d",
-                          op->payload->send_message.send_message->flags(),
-                          op->payload->send_message.send_message->length()));
+      out.push_back( 
+          y_absl::StrFormat(" SEND_MESSAGE:flags=0x%08x:len=%d", 
+                          op->payload->send_message.send_message->flags(), 
+                          op->payload->send_message.send_message->length())); 
     } else {
       // This can happen when we check a batch after the transport has
       // processed and cleared the send_message op.
-      out.push_back(" SEND_MESSAGE(flag and length unknown, already orphaned)");
+      out.push_back(" SEND_MESSAGE(flag and length unknown, already orphaned)"); 
     }
   }
 
   if (op->send_trailing_metadata) {
-    out.push_back(" SEND_TRAILING_METADATA{");
+    out.push_back(" SEND_TRAILING_METADATA{"); 
     put_metadata_list(
-        *op->payload->send_trailing_metadata.send_trailing_metadata, &out);
-    out.push_back("}");
+        *op->payload->send_trailing_metadata.send_trailing_metadata, &out); 
+    out.push_back("}"); 
   }
 
   if (op->recv_initial_metadata) {
-    out.push_back(" RECV_INITIAL_METADATA");
+    out.push_back(" RECV_INITIAL_METADATA"); 
   }
 
   if (op->recv_message) {
-    out.push_back(" RECV_MESSAGE");
+    out.push_back(" RECV_MESSAGE"); 
   }
 
   if (op->recv_trailing_metadata) {
-    out.push_back(" RECV_TRAILING_METADATA");
+    out.push_back(" RECV_TRAILING_METADATA"); 
   }
 
   if (op->cancel_stream) {
-    out.push_back(y_absl::StrCat(
-        " CANCEL:",
-        grpc_error_string(op->payload->cancel_stream.cancel_error)));
+    out.push_back(y_absl::StrCat( 
+        " CANCEL:", 
+        grpc_error_string(op->payload->cancel_stream.cancel_error))); 
   }
 
-  return y_absl::StrJoin(out, "");
+  return y_absl::StrJoin(out, ""); 
 }
 
-TString grpc_transport_op_string(grpc_transport_op* op) {
-  std::vector<TString> out;
+TString grpc_transport_op_string(grpc_transport_op* op) { 
+  std::vector<TString> out; 
 
   if (op->start_connectivity_watch != nullptr) {
-    out.push_back(y_absl::StrFormat(
-        " START_CONNECTIVITY_WATCH:watcher=%p:from=%s",
+    out.push_back(y_absl::StrFormat( 
+        " START_CONNECTIVITY_WATCH:watcher=%p:from=%s", 
         op->start_connectivity_watch.get(),
-        grpc_core::ConnectivityStateName(op->start_connectivity_watch_state)));
+        grpc_core::ConnectivityStateName(op->start_connectivity_watch_state))); 
   }
 
   if (op->stop_connectivity_watch != nullptr) {
-    out.push_back(y_absl::StrFormat(" STOP_CONNECTIVITY_WATCH:watcher=%p",
-                                  op->stop_connectivity_watch));
+    out.push_back(y_absl::StrFormat(" STOP_CONNECTIVITY_WATCH:watcher=%p", 
+                                  op->stop_connectivity_watch)); 
   }
 
   if (op->disconnect_with_error != GRPC_ERROR_NONE) {
-    out.push_back(y_absl::StrCat(" DISCONNECT:",
-                               grpc_error_string(op->disconnect_with_error)));
+    out.push_back(y_absl::StrCat(" DISCONNECT:", 
+                               grpc_error_string(op->disconnect_with_error))); 
   }
 
   if (op->goaway_error) {
-    out.push_back(
-        y_absl::StrCat(" SEND_GOAWAY:%s", grpc_error_string(op->goaway_error)));
+    out.push_back( 
+        y_absl::StrCat(" SEND_GOAWAY:%s", grpc_error_string(op->goaway_error))); 
   }
 
   if (op->set_accept_stream) {
-    out.push_back(y_absl::StrFormat(" SET_ACCEPT_STREAM:%p(%p,...)",
-                                  op->set_accept_stream_fn,
-                                  op->set_accept_stream_user_data));
+    out.push_back(y_absl::StrFormat(" SET_ACCEPT_STREAM:%p(%p,...)", 
+                                  op->set_accept_stream_fn, 
+                                  op->set_accept_stream_user_data)); 
   }
 
   if (op->bind_pollset != nullptr) {
-    out.push_back(" BIND_POLLSET");
+    out.push_back(" BIND_POLLSET"); 
   }
 
   if (op->bind_pollset_set != nullptr) {
-    out.push_back(" BIND_POLLSET_SET");
+    out.push_back(" BIND_POLLSET_SET"); 
   }
 
   if (op->send_ping.on_initiate != nullptr || op->send_ping.on_ack != nullptr) {
-    out.push_back(" SEND_PING");
+    out.push_back(" SEND_PING"); 
   }
 
-  return y_absl::StrJoin(out, "");
+  return y_absl::StrJoin(out, ""); 
 }
 
 void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
                       grpc_call_element* elem,
                       grpc_transport_stream_op_batch* op) {
-  gpr_log(file, line, severity, "OP[%s:%p]: %s", elem->filter->name, elem,
-          grpc_transport_stream_op_batch_string(op).c_str());
+  gpr_log(file, line, severity, "OP[%s:%p]: %s", elem->filter->name, elem, 
+          grpc_transport_stream_op_batch_string(op).c_str()); 
 }
diff --git a/contrib/libs/grpc/src/core/lib/uri/uri_parser.cc b/contrib/libs/grpc/src/core/lib/uri/uri_parser.cc
index 1215e0d206..88143d09b8 100644
--- a/contrib/libs/grpc/src/core/lib/uri/uri_parser.cc
+++ b/contrib/libs/grpc/src/core/lib/uri/uri_parser.cc
@@ -22,10 +22,10 @@
 
 #include <string.h>
 
-#include <util/generic/string.h>
-
-#include "y_absl/strings/str_format.h"
-
+#include <util/generic/string.h> 
+ 
+#include "y_absl/strings/str_format.h" 
+ 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -38,25 +38,25 @@
 /** a size_t default value... maps to all 1's */
 #define NOT_SET (~(size_t)0)
 
-static grpc_uri* bad_uri(y_absl::string_view uri_text, size_t pos,
-                         const char* section, bool suppress_errors) {
+static grpc_uri* bad_uri(y_absl::string_view uri_text, size_t pos, 
+                         const char* section, bool suppress_errors) { 
   if (!suppress_errors) {
-    TString line_prefix = y_absl::StrFormat("bad uri.%s: '", section);
-    gpr_log(GPR_ERROR, "%s%s'", line_prefix.c_str(),
-            TString(uri_text).c_str());
-    size_t pfx_len = line_prefix.size() + pos;
-    gpr_log(GPR_ERROR, "%s^ here", TString(pfx_len, ' ').c_str());
+    TString line_prefix = y_absl::StrFormat("bad uri.%s: '", section); 
+    gpr_log(GPR_ERROR, "%s%s'", line_prefix.c_str(), 
+            TString(uri_text).c_str()); 
+    size_t pfx_len = line_prefix.size() + pos; 
+    gpr_log(GPR_ERROR, "%s^ here", TString(pfx_len, ' ').c_str()); 
   }
   return nullptr;
 }
 
 /** Returns a copy of percent decoded \a src[begin, end) */
-static char* decode_and_copy_component(y_absl::string_view src, size_t begin,
+static char* decode_and_copy_component(y_absl::string_view src, size_t begin, 
                                        size_t end) {
   grpc_slice component =
       (begin == NOT_SET || end == NOT_SET)
           ? grpc_empty_slice()
-          : grpc_slice_from_copied_buffer(src.data() + begin, end - begin);
+          : grpc_slice_from_copied_buffer(src.data() + begin, end - begin); 
   grpc_slice decoded_component =
       grpc_permissive_percent_decode_slice(component);
   char* out = grpc_dump_slice(decoded_component, GPR_DUMP_ASCII);
@@ -73,7 +73,7 @@ static bool valid_hex(char c) {
 /** Returns how many chars to advance if \a uri_text[i] begins a valid \a pchar
  * production. If \a uri_text[i] introduces an invalid \a pchar (such as percent
  * sign not followed by two hex digits), NOT_SET is returned. */
-static size_t parse_pchar(y_absl::string_view uri_text, size_t i) {
+static size_t parse_pchar(y_absl::string_view uri_text, size_t i) { 
   /* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
    * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
    * pct-encoded = "%" HEXDIG HEXDIG
@@ -106,8 +106,8 @@ static size_t parse_pchar(y_absl::string_view uri_text, size_t i) {
     case '=':
       return 1;
     case '%': /* pct-encoded */
-      if (uri_text.size() > i + 2 && valid_hex(uri_text[i + 1]) &&
-          valid_hex(uri_text[i + 2])) {
+      if (uri_text.size() > i + 2 && valid_hex(uri_text[i + 1]) && 
+          valid_hex(uri_text[i + 2])) { 
         return 2;
       }
       return NOT_SET;
@@ -116,8 +116,8 @@ static size_t parse_pchar(y_absl::string_view uri_text, size_t i) {
 }
 
 /* *( pchar / "?" / "/" ) */
-static int parse_fragment_or_query(y_absl::string_view uri_text, size_t* i) {
-  while (uri_text.size() > *i) {
+static int parse_fragment_or_query(y_absl::string_view uri_text, size_t* i) { 
+  while (uri_text.size() > *i) { 
     const size_t advance = parse_pchar(uri_text, *i); /* pchar */
     switch (advance) {
       case 0: /* uri_text[i] isn't in pchar */
@@ -179,7 +179,7 @@ static void parse_query_parts(grpc_uri* uri) {
   }
 }
 
-grpc_uri* grpc_uri_parse(y_absl::string_view uri_text, bool suppress_errors) {
+grpc_uri* grpc_uri_parse(y_absl::string_view uri_text, bool suppress_errors) { 
   grpc_uri* uri;
   size_t scheme_begin = 0;
   size_t scheme_end = NOT_SET;
@@ -193,7 +193,7 @@ grpc_uri* grpc_uri_parse(y_absl::string_view uri_text, bool suppress_errors) {
   size_t fragment_end = NOT_SET;
   size_t i;
 
-  for (i = scheme_begin; i < uri_text.size(); ++i) {
+  for (i = scheme_begin; i < uri_text.size(); ++i) { 
     if (uri_text[i] == ':') {
       scheme_end = i;
       break;
@@ -212,16 +212,16 @@ grpc_uri* grpc_uri_parse(y_absl::string_view uri_text, bool suppress_errors) {
     return bad_uri(uri_text, i, "scheme", suppress_errors);
   }
 
-  if (uri_text.size() > scheme_end + 2 && uri_text[scheme_end + 1] == '/' &&
-      uri_text[scheme_end + 2] == '/') {
+  if (uri_text.size() > scheme_end + 2 && uri_text[scheme_end + 1] == '/' && 
+      uri_text[scheme_end + 2] == '/') { 
     authority_begin = scheme_end + 3;
-    for (i = authority_begin; uri_text.size() > i && authority_end == NOT_SET;
+    for (i = authority_begin; uri_text.size() > i && authority_end == NOT_SET; 
          i++) {
       if (uri_text[i] == '/' || uri_text[i] == '?' || uri_text[i] == '#') {
         authority_end = i;
       }
     }
-    if (authority_end == NOT_SET && uri_text.size() == i) {
+    if (authority_end == NOT_SET && uri_text.size() == i) { 
       authority_end = i;
     }
     if (authority_end == NOT_SET) {
@@ -233,34 +233,34 @@ grpc_uri* grpc_uri_parse(y_absl::string_view uri_text, bool suppress_errors) {
     path_begin = scheme_end + 1;
   }
 
-  for (i = path_begin; i < uri_text.size(); ++i) {
+  for (i = path_begin; i < uri_text.size(); ++i) { 
     if (uri_text[i] == '?' || uri_text[i] == '#') {
       path_end = i;
       break;
     }
   }
-  if (path_end == NOT_SET && uri_text.size() == i) {
+  if (path_end == NOT_SET && uri_text.size() == i) { 
     path_end = i;
   }
   if (path_end == NOT_SET) {
     return bad_uri(uri_text, i, "path", suppress_errors);
   }
 
-  if (uri_text.size() > i && uri_text[i] == '?') {
+  if (uri_text.size() > i && uri_text[i] == '?') { 
     query_begin = ++i;
     if (!parse_fragment_or_query(uri_text, &i)) {
       return bad_uri(uri_text, i, "query", suppress_errors);
-    } else if (uri_text.size() > i && uri_text[i] != '#') {
+    } else if (uri_text.size() > i && uri_text[i] != '#') { 
       /* We must be at the end or at the beginning of a fragment */
       return bad_uri(uri_text, i, "query", suppress_errors);
     }
     query_end = i;
   }
-  if (uri_text.size() > i && uri_text[i] == '#') {
+  if (uri_text.size() > i && uri_text[i] == '#') { 
     fragment_begin = ++i;
     if (!parse_fragment_or_query(uri_text, &i)) {
       return bad_uri(uri_text, i - fragment_end, "fragment", suppress_errors);
-    } else if (uri_text.size() > i) {
+    } else if (uri_text.size() > i) { 
       /* We must be at the end */
       return bad_uri(uri_text, i, "fragment", suppress_errors);
     }
diff --git a/contrib/libs/grpc/src/core/lib/uri/uri_parser.h b/contrib/libs/grpc/src/core/lib/uri/uri_parser.h
index ccb9a4f29e..9f0e6f4a1b 100644
--- a/contrib/libs/grpc/src/core/lib/uri/uri_parser.h
+++ b/contrib/libs/grpc/src/core/lib/uri/uri_parser.h
@@ -21,8 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "y_absl/strings/string_view.h"
-
+#include "y_absl/strings/string_view.h" 
+ 
 #include <stddef.h>
 
 struct grpc_uri {
@@ -39,7 +39,7 @@ struct grpc_uri {
   char* fragment;
 };
 /** parse a uri, return NULL on failure */
-grpc_uri* grpc_uri_parse(y_absl::string_view uri_text, bool suppress_errors);
+grpc_uri* grpc_uri_parse(y_absl::string_view uri_text, bool suppress_errors); 
 
 /** return the part of a query string after the '=' in "?key=xxx&...", or NULL
  * if key is not present */
diff --git a/contrib/libs/grpc/src/core/lib/ya.make b/contrib/libs/grpc/src/core/lib/ya.make
index 93f59abe37..0baf847eec 100644
--- a/contrib/libs/grpc/src/core/lib/ya.make
+++ b/contrib/libs/grpc/src/core/lib/ya.make
@@ -6,30 +6,30 @@ OWNER(g:cpp-contrib)
 
 LICENSE(Apache-2.0)
 
-LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+LICENSE_TEXTS(.yandex_meta/licenses.list.txt) 
+ 
 PEERDIR(
-    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait
-    contrib/restricted/abseil-cpp-tstring/y_absl/container
-    contrib/restricted/abseil-cpp-tstring/y_absl/memory
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings
-    contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format
-    contrib/restricted/abseil-cpp-tstring/y_absl/synchronization
-    contrib/restricted/abseil-cpp-tstring/y_absl/time
+    contrib/restricted/abseil-cpp-tstring/y_absl/base/internal/spinlock_wait 
+    contrib/restricted/abseil-cpp-tstring/y_absl/container 
+    contrib/restricted/abseil-cpp-tstring/y_absl/memory 
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings 
+    contrib/restricted/abseil-cpp-tstring/y_absl/strings/internal/str_format 
+    contrib/restricted/abseil-cpp-tstring/y_absl/synchronization 
+    contrib/restricted/abseil-cpp-tstring/y_absl/time 
 )
 
 ADDINCL(
     GLOBAL contrib/libs/grpc/include
-    ${ARCADIA_BUILD_ROOT}/contrib/libs/grpc
+    ${ARCADIA_BUILD_ROOT}/contrib/libs/grpc 
     contrib/libs/grpc
 )
 
 NO_COMPILER_WARNINGS()
 
 IF (OS_LINUX OR OS_DARWIN)
-    CFLAGS(
-        -DGRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK=1
-    )
+    CFLAGS( 
+        -DGRPC_POSIX_FORK_ALLOW_PTHREAD_ATFORK=1 
+    ) 
 ENDIF()
 
 SRCS(
@@ -53,7 +53,7 @@ SRCS(
     gpr/string_util_windows.cc
     gpr/string_windows.cc
     gpr/sync.cc
-    gpr/sync_abseil.cc
+    gpr/sync_abseil.cc 
     gpr/sync_posix.cc
     gpr/sync_windows.cc
     gpr/time.cc