replace hand-crafted patch with computer program

134 files changed, 2184 insertions, 2667 deletions

diff --git a/contrib/libs/protobuf/src/google/protobuf/arena.cc b/contrib/libs/protobuf/src/google/protobuf/arena.cc
index c12bf2b3fe..bdf756609d 100644
--- a/contrib/libs/protobuf/src/google/protobuf/arena.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/arena.cc
@@ -168,8 +168,8 @@ void SerialArena::AllocateNewBlock(size_t n, const AllocationPolicy* policy) {
 #endif  // ADDRESS_SANITIZER
 }
 
-uint64_t SerialArena::SpaceUsed() const {
-  uint64_t space_used = ptr_ - head_->Pointer(kBlockHeaderSize);
+ui64 SerialArena::SpaceUsed() const {
+  ui64 space_used = ptr_ - head_->Pointer(kBlockHeaderSize);
   space_used += space_used_;
   // Remove the overhead of the SerialArena itself.
   space_used -= ThreadSafeArena::kSerialArenaSize;
@@ -263,11 +263,11 @@ void ThreadSafeArena::Init(bool record_allocs) {
   auto id = tc.next_lifecycle_id;
   // We increment lifecycle_id's by multiples of two so we can use bit 0 as
   // a tag.
-  constexpr uint64_t kDelta = 2;
-  constexpr uint64_t kInc = ThreadCache::kPerThreadIds * kDelta;
+  constexpr ui64 kDelta = 2;
+  constexpr ui64 kInc = ThreadCache::kPerThreadIds * kDelta;
   if (PROTOBUF_PREDICT_FALSE((id & (kInc - 1)) == 0)) {
     constexpr auto relaxed = std::memory_order_relaxed;
-    // On platforms that don't support uint64_t atomics we can certainly not
+    // On platforms that don't support ui64 atomics we can certainly not
     // afford to increment by large intervals and expect uniqueness due to
     // wrapping, hence we only add by 1.
     id = lifecycle_id_generator_.id.fetch_add(1, relaxed) * kInc;
@@ -316,7 +316,7 @@ SerialArena::Memory ThreadSafeArena::Free(size_t* space_allocated) {
   return mem;
 }
 
-uint64_t ThreadSafeArena::Reset() {
+ui64 ThreadSafeArena::Reset() {
   // Have to do this in a first pass, because some of the destructors might
   // refer to memory in other blocks.
   CleanupList();
@@ -406,18 +406,18 @@ void ThreadSafeArena::AddCleanupFallback(void* elem, void (*cleanup)(void*)) {
       ->AddCleanup(elem, cleanup, AllocPolicy());
 }
 
-uint64_t ThreadSafeArena::SpaceAllocated() const {
+ui64 ThreadSafeArena::SpaceAllocated() const {
   SerialArena* serial = threads_.load(std::memory_order_acquire);
-  uint64_t res = 0;
+  ui64 res = 0;
   for (; serial; serial = serial->next()) {
     res += serial->SpaceAllocated();
   }
   return res;
 }
 
-uint64_t ThreadSafeArena::SpaceUsed() const {
+ui64 ThreadSafeArena::SpaceUsed() const {
   SerialArena* serial = threads_.load(std::memory_order_acquire);
-  uint64_t space_used = 0;
+  ui64 space_used = 0;
   for (; serial; serial = serial->next()) {
     space_used += serial->SpaceUsed();
   }
diff --git a/contrib/libs/protobuf/src/google/protobuf/arena.h b/contrib/libs/protobuf/src/google/protobuf/arena.h
index dd78ded473..c0e833547a 100644
--- a/contrib/libs/protobuf/src/google/protobuf/arena.h
+++ b/contrib/libs/protobuf/src/google/protobuf/arena.h
@@ -351,19 +351,19 @@ class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena {
   // policies. Do not use these in unit tests.
   // Returns the total space allocated by the arena, which is the sum of the
   // sizes of the underlying blocks.
-  uint64_t SpaceAllocated() const { return impl_.SpaceAllocated(); }
+  ui64 SpaceAllocated() const { return impl_.SpaceAllocated(); }
   // Returns the total space used by the arena. Similar to SpaceAllocated but
   // does not include free space and block overhead. The total space returned
   // may not include space used by other threads executing concurrently with
   // the call to this method.
-  uint64_t SpaceUsed() const { return impl_.SpaceUsed(); }
+  ui64 SpaceUsed() const { return impl_.SpaceUsed(); }
 
   // Frees all storage allocated by this arena after calling destructors
   // registered with OwnDestructor() and freeing objects registered with Own().
   // Any objects allocated on this arena are unusable after this call. It also
   // returns the total space used by the arena which is the sums of the sizes
   // of the allocated blocks. This method is not thread-safe.
-  uint64_t Reset() { return impl_.Reset(); }
+  ui64 Reset() { return impl_.Reset(); }
 
   // Adds |object| to a list of heap-allocated objects to be freed with |delete|
   // when the arena is destroyed or reset.
diff --git a/contrib/libs/protobuf/src/google/protobuf/arena_impl.h b/contrib/libs/protobuf/src/google/protobuf/arena_impl.h
index b47bad78c7..eb3d4fbeff 100644
--- a/contrib/libs/protobuf/src/google/protobuf/arena_impl.h
+++ b/contrib/libs/protobuf/src/google/protobuf/arena_impl.h
@@ -56,7 +56,7 @@ inline constexpr size_t AlignUpTo8(size_t n) {
   return (n + 7) & static_cast<size_t>(-8);
 }
 
-using LifecycleIdAtomic = uint64_t;
+using LifecycleIdAtomic = ui64;
 
 // MetricsCollector collects stats for a particular arena.
 class PROTOBUF_EXPORT ArenaMetricsCollector {
@@ -66,11 +66,11 @@ class PROTOBUF_EXPORT ArenaMetricsCollector {
   // Invoked when the arena is about to be destroyed. This method will
   // typically finalize any metric collection and delete the collector.
   // space_allocated is the space used by the arena.
-  virtual void OnDestroy(uint64_t space_allocated) = 0;
+  virtual void OnDestroy(ui64 space_allocated) = 0;
 
   // OnReset() is called when the associated arena is reset.
   // space_allocated is the space used by the arena just before the reset.
-  virtual void OnReset(uint64_t space_allocated) = 0;
+  virtual void OnReset(ui64 space_allocated) = 0;
 
   // OnAlloc is called when an allocation happens.
   // type_info is promised to be static - its lifetime extends to
@@ -79,7 +79,7 @@ class PROTOBUF_EXPORT ArenaMetricsCollector {
   // intentionally want to avoid monitoring an allocation. (i.e. internal
   // allocations for managing the arena)
   virtual void OnAlloc(const std::type_info* allocated_type,
-                       uint64_t alloc_size) = 0;
+                       ui64 alloc_size) = 0;
 
   // Does OnAlloc() need to be called?  If false, metric collection overhead
   // will be reduced since we will not do extra work per allocation.
@@ -141,10 +141,10 @@ class PROTOBUF_EXPORT SerialArena {
   Memory Free(Deallocator deallocator);
 
   void CleanupList();
-  uint64_t SpaceAllocated() const {
+  ui64 SpaceAllocated() const {
     return space_allocated_.load(std::memory_order_relaxed);
   }
-  uint64_t SpaceUsed() const;
+  ui64 SpaceUsed() const;
 
   bool HasSpace(size_t n) { return n <= static_cast<size_t>(limit_ - ptr_); }
 
@@ -287,10 +287,10 @@ class PROTOBUF_EXPORT ThreadSafeArena {
   // if it was passed in.
   ~ThreadSafeArena();
 
-  uint64_t Reset();
+  ui64 Reset();
 
-  uint64_t SpaceAllocated() const;
-  uint64_t SpaceUsed() const;
+  ui64 SpaceAllocated() const;
+  ui64 SpaceUsed() const;
 
   void* AllocateAligned(size_t n, const std::type_info* type) {
     SerialArena* arena;
@@ -322,7 +322,7 @@ class PROTOBUF_EXPORT ThreadSafeArena {
 
  private:
   // Unique for each arena. Changes on Reset().
-  uint64_t tag_and_id_;
+  ui64 tag_and_id_;
   // The LSB of tag_and_id_ indicates if allocs in this arena are recorded.
   enum { kRecordAllocs = 1 };
 
@@ -353,7 +353,7 @@ class PROTOBUF_EXPORT ThreadSafeArena {
 
   inline bool ShouldRecordAlloc() const { return tag_and_id_ & kRecordAllocs; }
 
-  inline uint64_t LifeCycleId() const {
+  inline ui64 LifeCycleId() const {
     return tag_and_id_ & (-kRecordAllocs - 1);
   }
 
@@ -372,7 +372,7 @@ class PROTOBUF_EXPORT ThreadSafeArena {
     hint_.store(serial, std::memory_order_release);
   }
 
-  PROTOBUF_NDEBUG_INLINE bool GetSerialArenaFast(uint64_t lifecycle_id,
+  PROTOBUF_NDEBUG_INLINE bool GetSerialArenaFast(ui64 lifecycle_id,
                                                  SerialArena** arena) {
     if (GetSerialArenaFromThreadCache(lifecycle_id, arena)) return true;
     if (lifecycle_id & kRecordAllocs) return false;
@@ -389,7 +389,7 @@ class PROTOBUF_EXPORT ThreadSafeArena {
   }
 
   PROTOBUF_NDEBUG_INLINE bool GetSerialArenaFromThreadCache(
-      uint64_t lifecycle_id, SerialArena** arena) {
+      ui64 lifecycle_id, SerialArena** arena) {
     // If this thread already owns a block in this arena then try to use that.
     // This fast path optimizes the case where multiple threads allocate from
     // the same arena.
@@ -437,10 +437,10 @@ class PROTOBUF_EXPORT ThreadSafeArena {
     static constexpr size_t kPerThreadIds = 256;
     // Next lifecycle ID available to this thread. We need to reserve a new
     // batch, if `next_lifecycle_id & (kPerThreadIds - 1) == 0`.
-    uint64_t next_lifecycle_id;
+    ui64 next_lifecycle_id;
     // The ThreadCache is considered valid as long as this matches the
     // lifecycle_id of the arena being used.
-    uint64_t last_lifecycle_id_seen;
+    ui64 last_lifecycle_id_seen;
     SerialArena* last_serial_arena;
   };
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/descriptor.cc b/contrib/libs/protobuf/src/google/protobuf/descriptor.cc
index dffc45d72e..4a4ca1f6c8 100644
--- a/contrib/libs/protobuf/src/google/protobuf/descriptor.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/descriptor.cc
@@ -664,8 +664,8 @@ bool AllowedExtendeeInProto3(const TProtoStringType& name) {
 class TableArena {
  public:
   // Allocate a block on `n` bytes, with no destructor information saved.
-  void* AllocateMemory(uint32_t n) {
-    uint32_t tag = SizeToRawTag(n) + kFirstRawTag;
+  void* AllocateMemory(ui32 n) {
+    ui32 tag = SizeToRawTag(n) + kFirstRawTag;
     if (tag > 255) {
       // We can't fit the size, use an OutOfLineAlloc.
       return Create<OutOfLineAlloc>(OutOfLineAlloc{::operator new(n), n})->ptr;
@@ -709,7 +709,7 @@ class TableArena {
   // inspect the usage of the arena.
   void PrintUsageInfo() const {
     const auto print_histogram = [](Block* b, int size) {
-      std::map<uint32_t, uint32_t> unused_space_count;
+      std::map<ui32, ui32> unused_space_count;
       int count = 0;
       for (; b != nullptr; b = b->next) {
         ++unused_space_count[b->space_left()];
@@ -787,7 +787,7 @@ class TableArena {
 
   using Tag = unsigned char;
 
-  void* AllocRawInternal(uint32_t size, Tag tag) {
+  void* AllocRawInternal(ui32 size, Tag tag) {
     GOOGLE_DCHECK_GT(size, 0);
     size = RoundUp(size);
 
@@ -840,7 +840,7 @@ class TableArena {
 
   struct OutOfLineAlloc {
     void* ptr;
-    uint32_t size;
+    ui32 size;
   };
 
   template <typename... T>
@@ -910,11 +910,11 @@ class TableArena {
     void operator()(OutOfLineAlloc* p) { OperatorDelete(p->ptr, p->size); }
   };
 
-  static uint32_t SizeToRawTag(size_t n) { return (RoundUp(n) / 8) - 1; }
+  static ui32 SizeToRawTag(size_t n) { return (RoundUp(n) / 8) - 1; }
 
-  static uint32_t TagToSize(Tag tag) {
+  static ui32 TagToSize(Tag tag) {
     GOOGLE_DCHECK_GE(tag, kFirstRawTag);
-    return static_cast<uint32_t>(tag - kFirstRawTag + 1) * 8;
+    return static_cast<ui32>(tag - kFirstRawTag + 1) * 8;
   }
 
   struct Block {
@@ -926,7 +926,7 @@ class TableArena {
     // `allocated_size` is the total size of the memory block allocated.
     // The `Block` structure is constructed at the start and the rest of the
     // memory is used as the payload of the `Block`.
-    explicit Block(uint32_t allocated_size) {
+    explicit Block(ui32 allocated_size) {
       start_offset = 0;
       end_offset = capacity =
           reinterpret_cast<char*>(this) + allocated_size - data();
@@ -937,12 +937,12 @@ class TableArena {
       return reinterpret_cast<char*>(this) + RoundUp(sizeof(Block));
     }
 
-    uint32_t memory_used() {
+    ui32 memory_used() {
       return data() + capacity - reinterpret_cast<char*>(this);
     }
-    uint32_t space_left() const { return end_offset - start_offset; }
+    ui32 space_left() const { return end_offset - start_offset; }
 
-    void* Allocate(uint32_t n, Tag tag) {
+    void* Allocate(ui32 n, Tag tag) {
       GOOGLE_DCHECK_LE(n + 1, space_left());
       void* p = data() + start_offset;
       start_offset += n;
@@ -2471,16 +2471,16 @@ TProtoStringType FieldDescriptor::DefaultValueAsString(
   GOOGLE_CHECK(has_default_value()) << "No default value";
   switch (cpp_type()) {
     case CPPTYPE_INT32:
-      return StrCat(default_value_int32_t());
+      return StrCat(default_value_i32());
       break;
     case CPPTYPE_INT64:
-      return StrCat(default_value_int64_t());
+      return StrCat(default_value_i64());
       break;
     case CPPTYPE_UINT32:
-      return StrCat(default_value_uint32_t());
+      return StrCat(default_value_ui32());
       break;
     case CPPTYPE_UINT64:
-      return StrCat(default_value_uint64_t());
+      return StrCat(default_value_ui64());
       break;
     case CPPTYPE_FLOAT:
       return SimpleFtoa(default_value_float());
@@ -3458,7 +3458,7 @@ bool FileDescriptor::GetSourceLocation(const std::vector<int>& path,
   if (source_code_info_) {
     if (const SourceCodeInfo_Location* loc =
             tables_->GetSourceLocation(path, source_code_info_)) {
-      const RepeatedField<int32_t>& span = loc->span();
+      const RepeatedField<i32>& span = loc->span();
       if (span.size() == 3 || span.size() == 4) {
         out_location->start_line = span.Get(0);
         out_location->start_column = span.Get(1);
@@ -3924,13 +3924,13 @@ class DescriptorBuilder {
 
     // Convenience functions to set an int field the right way, depending on
     // its wire type (a single int CppType can represent multiple wire types).
-    void SetInt32(int number, int32_t value, FieldDescriptor::Type type,
+    void SetInt32(int number, i32 value, FieldDescriptor::Type type,
                   UnknownFieldSet* unknown_fields);
-    void SetInt64(int number, int64_t value, FieldDescriptor::Type type,
+    void SetInt64(int number, i64 value, FieldDescriptor::Type type,
                   UnknownFieldSet* unknown_fields);
-    void SetUInt32(int number, uint32_t value, FieldDescriptor::Type type,
+    void SetUInt32(int number, ui32 value, FieldDescriptor::Type type,
                    UnknownFieldSet* unknown_fields);
-    void SetUInt64(int number, uint64_t value, FieldDescriptor::Type type,
+    void SetUInt64(int number, ui64 value, FieldDescriptor::Type type,
                    UnknownFieldSet* unknown_fields);
 
     // A helper function that adds an error at the specified location of the
@@ -5298,19 +5298,19 @@ void DescriptorBuilder::BuildFieldOrExtension(const FieldDescriptorProto& proto,
       char* end_pos = nullptr;
       switch (result->cpp_type()) {
         case FieldDescriptor::CPPTYPE_INT32:
-          result->default_value_int32_t_ =
+          result->default_value_i32_ =
               strtol(proto.default_value().c_str(), &end_pos, 0);
           break;
         case FieldDescriptor::CPPTYPE_INT64:
-          result->default_value_int64_t_ =
+          result->default_value_i64_ =
               strto64(proto.default_value().c_str(), &end_pos, 0);
           break;
         case FieldDescriptor::CPPTYPE_UINT32:
-          result->default_value_uint32_t_ =
+          result->default_value_ui32_ =
               strtoul(proto.default_value().c_str(), &end_pos, 0);
           break;
         case FieldDescriptor::CPPTYPE_UINT64:
-          result->default_value_uint64_t_ =
+          result->default_value_ui64_ =
               strtou64(proto.default_value().c_str(), &end_pos, 0);
           break;
         case FieldDescriptor::CPPTYPE_FLOAT:
@@ -5391,16 +5391,16 @@ void DescriptorBuilder::BuildFieldOrExtension(const FieldDescriptorProto& proto,
       // No explicit default value
       switch (result->cpp_type()) {
         case FieldDescriptor::CPPTYPE_INT32:
-          result->default_value_int32_t_ = 0;
+          result->default_value_i32_ = 0;
           break;
         case FieldDescriptor::CPPTYPE_INT64:
-          result->default_value_int64_t_ = 0;
+          result->default_value_i64_ = 0;
           break;
         case FieldDescriptor::CPPTYPE_UINT32:
-          result->default_value_uint32_t_ = 0;
+          result->default_value_ui32_ = 0;
           break;
         case FieldDescriptor::CPPTYPE_UINT64:
-          result->default_value_uint64_t_ = 0;
+          result->default_value_ui64_ = 0;
           break;
         case FieldDescriptor::CPPTYPE_FLOAT:
           result->default_value_float_ = 0.0f;
@@ -6525,8 +6525,8 @@ void DescriptorBuilder::ValidateMessageOptions(Descriptor* message,
   VALIDATE_OPTIONS_FROM_ARRAY(message, enum_type, Enum);
   VALIDATE_OPTIONS_FROM_ARRAY(message, extension, Field);
 
-  const int64_t max_extension_range =
-      static_cast<int64_t>(message->options().message_set_wire_format()
+  const i64 max_extension_range =
+      static_cast<i64>(message->options().message_set_wire_format()
                                ? kint32max
                                : FieldDescriptor::kMaxNumber);
   for (int i = 0; i < message->extension_range_count(); ++i) {
@@ -7174,7 +7174,7 @@ void DescriptorBuilder::OptionInterpreter::UpdateSourceCodeInfo(
     if (matched) {
       // see if this location is in the range to remove
       bool loc_matches = true;
-      if (loc->path_size() < static_cast<int64_t>(pathv.size())) {
+      if (loc->path_size() < static_cast<i64>(pathv.size())) {
         loc_matches = false;
       } else {
         for (size_t j = 0; j < pathv.size(); j++) {
@@ -7317,7 +7317,7 @@ bool DescriptorBuilder::OptionInterpreter::SetOptionValue(
     case FieldDescriptor::CPPTYPE_INT32:
       if (uninterpreted_option_->has_positive_int_value()) {
         if (uninterpreted_option_->positive_int_value() >
-            static_cast<uint64_t>(kint32max)) {
+            static_cast<ui64>(kint32max)) {
           return AddValueError("Value out of range for int32 option \"" +
                                option_field->full_name() + "\".");
         } else {
@@ -7327,7 +7327,7 @@ bool DescriptorBuilder::OptionInterpreter::SetOptionValue(
         }
       } else if (uninterpreted_option_->has_negative_int_value()) {
         if (uninterpreted_option_->negative_int_value() <
-            static_cast<int64_t>(kint32min)) {
+            static_cast<i64>(kint32min)) {
           return AddValueError("Value out of range for int32 option \"" +
                                option_field->full_name() + "\".");
         } else {
@@ -7344,7 +7344,7 @@ bool DescriptorBuilder::OptionInterpreter::SetOptionValue(
     case FieldDescriptor::CPPTYPE_INT64:
       if (uninterpreted_option_->has_positive_int_value()) {
         if (uninterpreted_option_->positive_int_value() >
-            static_cast<uint64_t>(kint64max)) {
+            static_cast<ui64>(kint64max)) {
           return AddValueError("Value out of range for int64 option \"" +
                                option_field->full_name() + "\".");
         } else {
@@ -7428,7 +7428,7 @@ bool DescriptorBuilder::OptionInterpreter::SetOptionValue(
     }
 
     case FieldDescriptor::CPPTYPE_BOOL:
-      uint64_t value;
+      ui64 value;
       if (!uninterpreted_option_->has_identifier_value()) {
         return AddValueError(
             "Value must be identifier for boolean option "
@@ -7498,11 +7498,11 @@ bool DescriptorBuilder::OptionInterpreter::SetOptionValue(
                              "option \"" +
                              option_field->full_name() + "\".");
       } else {
-        // Sign-extension is not a problem, since we cast directly from int32_t
-        // to uint64_t, without first going through uint32_t.
+        // Sign-extension is not a problem, since we cast directly from i32
+        // to ui64, without first going through ui32.
         unknown_fields->AddVarint(
             option_field->number(),
-            static_cast<uint64_t>(static_cast<int64_t>(enum_value->number())));
+            static_cast<ui64>(static_cast<i64>(enum_value->number())));
       }
       break;
     }
@@ -7644,16 +7644,16 @@ bool DescriptorBuilder::OptionInterpreter::SetAggregateOption(
 }
 
 void DescriptorBuilder::OptionInterpreter::SetInt32(
-    int number, int32_t value, FieldDescriptor::Type type,
+    int number, i32 value, FieldDescriptor::Type type,
     UnknownFieldSet* unknown_fields) {
   switch (type) {
     case FieldDescriptor::TYPE_INT32:
       unknown_fields->AddVarint(
-          number, static_cast<uint64_t>(static_cast<int64_t>(value)));
+          number, static_cast<ui64>(static_cast<i64>(value)));
       break;
 
     case FieldDescriptor::TYPE_SFIXED32:
-      unknown_fields->AddFixed32(number, static_cast<uint32_t>(value));
+      unknown_fields->AddFixed32(number, static_cast<ui32>(value));
       break;
 
     case FieldDescriptor::TYPE_SINT32:
@@ -7668,15 +7668,15 @@ void DescriptorBuilder::OptionInterpreter::SetInt32(
 }
 
 void DescriptorBuilder::OptionInterpreter::SetInt64(
-    int number, int64_t value, FieldDescriptor::Type type,
+    int number, i64 value, FieldDescriptor::Type type,
     UnknownFieldSet* unknown_fields) {
   switch (type) {
     case FieldDescriptor::TYPE_INT64:
-      unknown_fields->AddVarint(number, static_cast<uint64_t>(value));
+      unknown_fields->AddVarint(number, static_cast<ui64>(value));
       break;
 
     case FieldDescriptor::TYPE_SFIXED64:
-      unknown_fields->AddFixed64(number, static_cast<uint64_t>(value));
+      unknown_fields->AddFixed64(number, static_cast<ui64>(value));
       break;
 
     case FieldDescriptor::TYPE_SINT64:
@@ -7691,15 +7691,15 @@ void DescriptorBuilder::OptionInterpreter::SetInt64(
 }
 
 void DescriptorBuilder::OptionInterpreter::SetUInt32(
-    int number, uint32_t value, FieldDescriptor::Type type,
+    int number, ui32 value, FieldDescriptor::Type type,
     UnknownFieldSet* unknown_fields) {
   switch (type) {
     case FieldDescriptor::TYPE_UINT32:
-      unknown_fields->AddVarint(number, static_cast<uint64_t>(value));
+      unknown_fields->AddVarint(number, static_cast<ui64>(value));
       break;
 
     case FieldDescriptor::TYPE_FIXED32:
-      unknown_fields->AddFixed32(number, static_cast<uint32_t>(value));
+      unknown_fields->AddFixed32(number, static_cast<ui32>(value));
       break;
 
     default:
@@ -7709,7 +7709,7 @@ void DescriptorBuilder::OptionInterpreter::SetUInt32(
 }
 
 void DescriptorBuilder::OptionInterpreter::SetUInt64(
-    int number, uint64_t value, FieldDescriptor::Type type,
+    int number, ui64 value, FieldDescriptor::Type type,
     UnknownFieldSet* unknown_fields) {
   switch (type) {
     case FieldDescriptor::TYPE_UINT64:
diff --git a/contrib/libs/protobuf/src/google/protobuf/descriptor.h b/contrib/libs/protobuf/src/google/protobuf/descriptor.h
index 6739e8075b..ec9edb32bc 100644
--- a/contrib/libs/protobuf/src/google/protobuf/descriptor.h
+++ b/contrib/libs/protobuf/src/google/protobuf/descriptor.h
@@ -763,20 +763,20 @@ class PROTOBUF_EXPORT FieldDescriptor : private internal::SymbolBase {
 
   // Get the field default value if cpp_type() == CPPTYPE_INT32.  If no
   // explicit default was defined, the default is 0.
-  int32_t default_value_int32_t() const;
-  int32_t default_value_int32() const { return default_value_int32_t(); }
+  i32 default_value_i32() const;
+  i32 default_value_int32() const { return default_value_i32(); }
   // Get the field default value if cpp_type() == CPPTYPE_INT64.  If no
   // explicit default was defined, the default is 0.
-  int64_t default_value_int64_t() const;
-  int64 default_value_int64() const { return default_value_int64_t(); }
+  i64 default_value_i64() const;
+  i64 default_value_int64() const { return default_value_i64(); }
   // Get the field default value if cpp_type() == CPPTYPE_UINT32.  If no
   // explicit default was defined, the default is 0.
-  uint32_t default_value_uint32_t() const;
-  uint32_t default_value_uint32() const { return default_value_uint32_t(); }
+  ui32 default_value_ui32() const;
+  ui32 default_value_uint32() const { return default_value_ui32(); }
   // Get the field default value if cpp_type() == CPPTYPE_UINT64.  If no
   // explicit default was defined, the default is 0.
-  uint64_t default_value_uint64_t() const;
-  uint64 default_value_uint64() const { return default_value_uint64_t(); }
+  ui64 default_value_ui64() const;
+  ui64 default_value_uint64() const { return default_value_ui64(); }
   // Get the field default value if cpp_type() == CPPTYPE_FLOAT.  If no
   // explicit default was defined, the default is 0.0.
   float default_value_float() const;
@@ -952,10 +952,10 @@ class PROTOBUF_EXPORT FieldDescriptor : private internal::SymbolBase {
   // descriptor.cc and update them to initialize the field.
 
   union {
-    int32_t default_value_int32_t_;
-    int64_t default_value_int64_t_;
-    uint32_t default_value_uint32_t_;
-    uint64_t default_value_uint64_t_;
+    i32 default_value_i32_;
+    i64 default_value_i64_;
+    ui32 default_value_ui32_;
+    ui64 default_value_ui64_;
     float default_value_float_;
     double default_value_double_;
     bool default_value_bool_;
@@ -2100,10 +2100,10 @@ PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, index_in_oneof, int)
 PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FieldDescriptor, FieldOptions)
 PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_default_value, bool)
 PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_json_name, bool)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int32_t, int32_t)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int64_t, int64_t)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint32_t, uint32_t)
-PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint64_t, uint64_t)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_i32, i32)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_i64, i64)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_ui32, ui32)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_ui64, ui64)
 PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_float, float)
 PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_double, double)
 PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_bool, bool)
diff --git a/contrib/libs/protobuf/src/google/protobuf/descriptor.pb.cc b/contrib/libs/protobuf/src/google/protobuf/descriptor.pb.cc
index ef67494573..768d78f1b3 100644
--- a/contrib/libs/protobuf/src/google/protobuf/descriptor.pb.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/descriptor.pb.cc
@@ -378,8 +378,8 @@ constexpr UninterpretedOption::UninterpretedOption(
   , identifier_value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
   , string_value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
   , aggregate_value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
-  , positive_int_value_(uint64_t{0u})
-  , negative_int_value_(int64_t{0})
+  , positive_int_value_(ui64{0u})
+  , negative_int_value_(i64{0})
   , double_value_(0){}
 struct UninterpretedOptionDefaultTypeInternal {
   constexpr UninterpretedOptionDefaultTypeInternal()
diff --git a/contrib/libs/protobuf/src/google/protobuf/descriptor.pb.h b/contrib/libs/protobuf/src/google/protobuf/descriptor.pb.h
index 197ea516aa..fe689b1fab 100644
--- a/contrib/libs/protobuf/src/google/protobuf/descriptor.pb.h
+++ b/contrib/libs/protobuf/src/google/protobuf/descriptor.pb.h
@@ -13488,7 +13488,7 @@ inline bool UninterpretedOption::has_positive_int_value() const {
   return _internal_has_positive_int_value();
 }
 inline void UninterpretedOption::clear_positive_int_value() {
-  positive_int_value_ = uint64_t{0u};
+  positive_int_value_ = ui64{0u};
   _has_bits_[0] &= ~0x00000008u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::uint64 UninterpretedOption::_internal_positive_int_value() const {
@@ -13516,7 +13516,7 @@ inline bool UninterpretedOption::has_negative_int_value() const {
   return _internal_has_negative_int_value();
 }
 inline void UninterpretedOption::clear_negative_int_value() {
-  negative_int_value_ = int64_t{0};
+  negative_int_value_ = i64{0};
   _has_bits_[0] &= ~0x00000010u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 UninterpretedOption::_internal_negative_int_value() const {
diff --git a/contrib/libs/protobuf/src/google/protobuf/descriptor_database.cc b/contrib/libs/protobuf/src/google/protobuf/descriptor_database.cc
index 33a7c9d01e..18c8558ceb 100644
--- a/contrib/libs/protobuf/src/google/protobuf/descriptor_database.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/descriptor_database.cc
@@ -590,7 +590,7 @@ bool EncodedDescriptorDatabase::FindNameOfFileContainingSymbol(
   io::CodedInputStream input(static_cast<const uint8_t*>(encoded_file.first),
                              encoded_file.second);
 
-  const uint32_t kNameTag = internal::WireFormatLite::MakeTag(
+  const ui32 kNameTag = internal::WireFormatLite::MakeTag(
       FileDescriptorProto::kNameFieldNumber,
       internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/duration.pb.cc b/contrib/libs/protobuf/src/google/protobuf/duration.pb.cc
index 2326c68ef2..8ac55c1cf9 100644
--- a/contrib/libs/protobuf/src/google/protobuf/duration.pb.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/duration.pb.cc
@@ -19,7 +19,7 @@ PROTOBUF_PRAGMA_INIT_SEG
 PROTOBUF_NAMESPACE_OPEN
 constexpr Duration::Duration(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
-  : seconds_(int64_t{0})
+  : seconds_(i64{0})
   , nanos_(0){}
 struct DurationDefaultTypeInternal {
   constexpr DurationDefaultTypeInternal()
diff --git a/contrib/libs/protobuf/src/google/protobuf/duration.pb.h b/contrib/libs/protobuf/src/google/protobuf/duration.pb.h
index aa3baf51e6..bec7eab139 100644
--- a/contrib/libs/protobuf/src/google/protobuf/duration.pb.h
+++ b/contrib/libs/protobuf/src/google/protobuf/duration.pb.h
@@ -230,7 +230,7 @@ class PROTOBUF_EXPORT Duration final :
 
 // int64 seconds = 1;
 inline void Duration::clear_seconds() {
-  seconds_ = int64_t{0};
+  seconds_ = i64{0};
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 Duration::_internal_seconds() const {
   return seconds_;
diff --git a/contrib/libs/protobuf/src/google/protobuf/dynamic_message.cc b/contrib/libs/protobuf/src/google/protobuf/dynamic_message.cc
index 9394521119..066efc1780 100644
--- a/contrib/libs/protobuf/src/google/protobuf/dynamic_message.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/dynamic_message.cc
@@ -140,13 +140,13 @@ int FieldSpaceUsed(const FieldDescriptor* field) {
   if (field->label() == FD::LABEL_REPEATED) {
     switch (field->cpp_type()) {
       case FD::CPPTYPE_INT32:
-        return sizeof(RepeatedField<int32_t>);
+        return sizeof(RepeatedField<i32>);
       case FD::CPPTYPE_INT64:
-        return sizeof(RepeatedField<int64_t>);
+        return sizeof(RepeatedField<i64>);
       case FD::CPPTYPE_UINT32:
-        return sizeof(RepeatedField<uint32_t>);
+        return sizeof(RepeatedField<ui32>);
       case FD::CPPTYPE_UINT64:
-        return sizeof(RepeatedField<uint64_t>);
+        return sizeof(RepeatedField<ui64>);
       case FD::CPPTYPE_DOUBLE:
         return sizeof(RepeatedField<double>);
       case FD::CPPTYPE_FLOAT:
@@ -173,13 +173,13 @@ int FieldSpaceUsed(const FieldDescriptor* field) {
   } else {
     switch (field->cpp_type()) {
       case FD::CPPTYPE_INT32:
-        return sizeof(int32_t);
+        return sizeof(i32);
       case FD::CPPTYPE_INT64:
-        return sizeof(int64_t);
+        return sizeof(i64);
       case FD::CPPTYPE_UINT32:
-        return sizeof(uint32_t);
+        return sizeof(ui32);
       case FD::CPPTYPE_UINT64:
-        return sizeof(uint64_t);
+        return sizeof(ui64);
       case FD::CPPTYPE_DOUBLE:
         return sizeof(double);
       case FD::CPPTYPE_FLOAT:
@@ -208,8 +208,8 @@ int FieldSpaceUsed(const FieldDescriptor* field) {
 
 inline int DivideRoundingUp(int i, int j) { return (i + (j - 1)) / j; }
 
-static const int kSafeAlignment = sizeof(uint64_t);
-static const int kMaxOneofUnionSize = sizeof(uint64_t);
+static const int kSafeAlignment = sizeof(ui64);
+static const int kMaxOneofUnionSize = sizeof(ui64);
 
 inline int AlignTo(int offset, int alignment) {
   return DivideRoundingUp(offset, alignment) * alignment;
@@ -316,8 +316,8 @@ struct DynamicMessageFactory::TypeInfo {
 
   // Warning:  The order in which the following pointers are defined is
   //   important (the prototype must be deleted *before* the offsets).
-  std::unique_ptr<uint32_t[]> offsets;
-  std::unique_ptr<uint32_t[]> has_bits_indices;
+  std::unique_ptr<ui32[]> offsets;
+  std::unique_ptr<ui32[]> has_bits_indices;
   std::unique_ptr<const Reflection> reflection;
   // Don't use a unique_ptr to hold the prototype: the destructor for
   // DynamicMessage needs to know whether it is the prototype, and does so by
@@ -346,7 +346,7 @@ DynamicMessage::DynamicMessage(DynamicMessageFactory::TypeInfo* type_info,
                                bool lock_factory)
     : type_info_(type_info), cached_byte_size_(0) {
   // The prototype in type_info has to be set before creating the prototype
-  // instance on memory. e.g., message Foo { map<int32_t, Foo> a = 1; }. When
+  // instance on memory. e.g., message Foo { map<i32, Foo> a = 1; }. When
   // creating prototype for Foo, prototype of the map entry will also be
   // created, which needs the address of the prototype of Foo (the value in
   // map). To break the cyclic dependency, we have to assign the address of
@@ -366,7 +366,7 @@ void* DynamicMessage::MutableWeakFieldMapRaw() {
   return OffsetToPointer(type_info_->weak_field_map_offset);
 }
 void* DynamicMessage::MutableOneofCaseRaw(int i) {
-  return OffsetToPointer(type_info_->oneof_case_offset + sizeof(uint32_t) * i);
+  return OffsetToPointer(type_info_->oneof_case_offset + sizeof(ui32) * i);
 }
 void* DynamicMessage::MutableOneofFieldRaw(const FieldDescriptor* f) {
   return OffsetToPointer(
@@ -390,7 +390,7 @@ void DynamicMessage::SharedCtor(bool lock_factory) {
   int oneof_count = 0;
   for (int i = 0; i < descriptor->oneof_decl_count(); ++i) {
     if (descriptor->oneof_decl(i)->is_synthetic()) continue;
-    new (MutableOneofCaseRaw(oneof_count++)) uint32_t{0};
+    new (MutableOneofCaseRaw(oneof_count++)) ui32{0};
   }
 
   if (type_info_->extensions_offset != -1) {
@@ -412,10 +412,10 @@ void DynamicMessage::SharedCtor(bool lock_factory) {
     }                                                               \
     break;
 
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64_t);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64_t);
+      HANDLE_TYPE(INT32, i32);
+      HANDLE_TYPE(INT64, i64);
+      HANDLE_TYPE(UINT32, ui32);
+      HANDLE_TYPE(UINT64, ui64);
       HANDLE_TYPE(DOUBLE, double);
       HANDLE_TYPE(FLOAT, float);
       HANDLE_TYPE(BOOL, bool);
@@ -534,7 +534,7 @@ DynamicMessage::~DynamicMessage() {
     const FieldDescriptor* field = descriptor->field(i);
     if (InRealOneof(field)) {
       void* field_ptr = MutableOneofCaseRaw(field->containing_oneof()->index());
-      if (*(reinterpret_cast<const int32_t*>(field_ptr)) == field->number()) {
+      if (*(reinterpret_cast<const i32*>(field_ptr)) == field->number()) {
         field_ptr = MutableOneofFieldRaw(field);
         if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
           switch (field->options().ctype()) {
@@ -566,10 +566,10 @@ DynamicMessage::~DynamicMessage() {
         ->~RepeatedField<LOWERCASE>();                     \
     break
 
-        HANDLE_TYPE(INT32, int32_t);
-        HANDLE_TYPE(INT64, int64_t);
-        HANDLE_TYPE(UINT32, uint32_t);
-        HANDLE_TYPE(UINT64, uint64_t);
+        HANDLE_TYPE(INT32, i32);
+        HANDLE_TYPE(INT64, i64);
+        HANDLE_TYPE(UINT32, ui32);
+        HANDLE_TYPE(UINT64, ui64);
         HANDLE_TYPE(DOUBLE, double);
         HANDLE_TYPE(FLOAT, float);
         HANDLE_TYPE(BOOL, bool);
@@ -728,7 +728,7 @@ const Message* DynamicMessageFactory::GetPrototypeNoLock(
   }
 
   // Compute size and offsets.
-  uint32_t* offsets = new uint32_t[type->field_count() + real_oneof_count];
+  ui32* offsets = new ui32[type->field_count() + real_oneof_count];
   type_info->offsets.reset(offsets);
 
   // Decide all field offsets by packing in order.
@@ -746,10 +746,10 @@ const Message* DynamicMessageFactory::GetPrototypeNoLock(
         // At least one field in the message requires a hasbit, so allocate
         // hasbits.
         type_info->has_bits_offset = size;
-        uint32_t* has_bits_indices = new uint32_t[type->field_count()];
+        ui32* has_bits_indices = new ui32[type->field_count()];
         for (int i = 0; i < type->field_count(); i++) {
           // Initialize to -1, fields that need a hasbit will overwrite.
-          has_bits_indices[i] = static_cast<uint32_t>(-1);
+          has_bits_indices[i] = static_cast<ui32>(-1);
         }
         type_info->has_bits_indices.reset(has_bits_indices);
       }
@@ -758,15 +758,15 @@ const Message* DynamicMessageFactory::GetPrototypeNoLock(
   }
 
   if (max_hasbit > 0) {
-    int has_bits_array_size = DivideRoundingUp(max_hasbit, bitsizeof(uint32_t));
-    size += has_bits_array_size * sizeof(uint32_t);
+    int has_bits_array_size = DivideRoundingUp(max_hasbit, bitsizeof(ui32));
+    size += has_bits_array_size * sizeof(ui32);
     size = AlignOffset(size);
   }
 
   // The oneof_case, if any. It is an array of uint32s.
   if (real_oneof_count > 0) {
     type_info->oneof_case_offset = size;
-    size += real_oneof_count * sizeof(uint32_t);
+    size += real_oneof_count * sizeof(ui32);
     size = AlignOffset(size);
   }
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/dynamic_message.h b/contrib/libs/protobuf/src/google/protobuf/dynamic_message.h
index 2b5130d2b6..9c92b1302e 100644
--- a/contrib/libs/protobuf/src/google/protobuf/dynamic_message.h
+++ b/contrib/libs/protobuf/src/google/protobuf/dynamic_message.h
@@ -182,23 +182,23 @@ class PROTOBUF_EXPORT DynamicMapSorter {
           return first < second;
         }
         case FieldDescriptor::CPPTYPE_INT32: {
-          int32_t first = reflection->GetInt32(*a, field_);
-          int32_t second = reflection->GetInt32(*b, field_);
+          i32 first = reflection->GetInt32(*a, field_);
+          i32 second = reflection->GetInt32(*b, field_);
           return first < second;
         }
         case FieldDescriptor::CPPTYPE_INT64: {
-          int64_t first = reflection->GetInt64(*a, field_);
-          int64_t second = reflection->GetInt64(*b, field_);
+          i64 first = reflection->GetInt64(*a, field_);
+          i64 second = reflection->GetInt64(*b, field_);
           return first < second;
         }
         case FieldDescriptor::CPPTYPE_UINT32: {
-          uint32_t first = reflection->GetUInt32(*a, field_);
-          uint32_t second = reflection->GetUInt32(*b, field_);
+          ui32 first = reflection->GetUInt32(*a, field_);
+          ui32 second = reflection->GetUInt32(*b, field_);
           return first < second;
         }
         case FieldDescriptor::CPPTYPE_UINT64: {
-          uint64_t first = reflection->GetUInt64(*a, field_);
-          uint64_t second = reflection->GetUInt64(*b, field_);
+          ui64 first = reflection->GetUInt64(*a, field_);
+          ui64 second = reflection->GetUInt64(*b, field_);
           return first < second;
         }
         case FieldDescriptor::CPPTYPE_STRING: {
diff --git a/contrib/libs/protobuf/src/google/protobuf/extension_set.cc b/contrib/libs/protobuf/src/google/protobuf/extension_set.cc
index c6de79a767..2ab830e53c 100644
--- a/contrib/libs/protobuf/src/google/protobuf/extension_set.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/extension_set.cc
@@ -379,10 +379,10 @@ enum { REPEATED_FIELD, OPTIONAL_FIELD };
     extension->repeated_##LOWERCASE##_value->Add(value);                      \
   }
 
-PRIMITIVE_ACCESSORS(INT32, int32_t, Int32)
-PRIMITIVE_ACCESSORS(INT64, int64, Int64)
-PRIMITIVE_ACCESSORS(UINT32, uint32_t, UInt32)
-PRIMITIVE_ACCESSORS(UINT64, uint64, UInt64)
+PRIMITIVE_ACCESSORS(INT32, i32, Int32)
+PRIMITIVE_ACCESSORS(INT64, i64, Int64)
+PRIMITIVE_ACCESSORS(UINT32, ui32, UInt32)
+PRIMITIVE_ACCESSORS(UINT64, ui64, UInt64)
 PRIMITIVE_ACCESSORS(FLOAT, float, Float)
 PRIMITIVE_ACCESSORS(DOUBLE, double, Double)
 PRIMITIVE_ACCESSORS(BOOL, bool, Bool)
@@ -397,7 +397,7 @@ const void* ExtensionSet::GetRawRepeatedField(int number,
   }
   // We assume that all the RepeatedField<>* pointers have the same
   // size and alignment within the anonymous union in Extension.
-  return extension->repeated_int32_t_value;
+  return extension->repeated_i32_value;
 }
 
 void* ExtensionSet::MutableRawRepeatedField(int number, FieldType field_type,
@@ -415,20 +415,20 @@ void* ExtensionSet::MutableRawRepeatedField(int number, FieldType field_type,
     switch (WireFormatLite::FieldTypeToCppType(
         static_cast<WireFormatLite::FieldType>(field_type))) {
       case WireFormatLite::CPPTYPE_INT32:
-        extension->repeated_int32_t_value =
-            Arena::CreateMessage<RepeatedField<int32_t>>(arena_);
+        extension->repeated_i32_value =
+            Arena::CreateMessage<RepeatedField<i32>>(arena_);
         break;
       case WireFormatLite::CPPTYPE_INT64:
-        extension->repeated_int64_value =
-            Arena::CreateMessage<RepeatedField<int64>>(arena_);
+        extension->repeated_i64_value =
+            Arena::CreateMessage<RepeatedField<i64>>(arena_);
         break;
       case WireFormatLite::CPPTYPE_UINT32:
-        extension->repeated_uint32_t_value =
-            Arena::CreateMessage<RepeatedField<uint32_t>>(arena_);
+        extension->repeated_ui32_value =
+            Arena::CreateMessage<RepeatedField<ui32>>(arena_);
         break;
       case WireFormatLite::CPPTYPE_UINT64:
-        extension->repeated_uint64_value =
-            Arena::CreateMessage<RepeatedField<uint64>>(arena_);
+        extension->repeated_ui64_value =
+            Arena::CreateMessage<RepeatedField<ui64>>(arena_);
         break;
       case WireFormatLite::CPPTYPE_DOUBLE:
         extension->repeated_double_value =
@@ -459,7 +459,7 @@ void* ExtensionSet::MutableRawRepeatedField(int number, FieldType field_type,
 
   // We assume that all the RepeatedField<>* pointers have the same
   // size and alignment within the anonymous union in Extension.
-  return extension->repeated_int32_t_value;
+  return extension->repeated_i32_value;
 }
 
 // Compatible version using old call signature. Does not create extensions when
@@ -469,7 +469,7 @@ void* ExtensionSet::MutableRawRepeatedField(int number) {
   GOOGLE_CHECK(extension != NULL) << "Extension not found.";
   // We assume that all the RepeatedField<>* pointers have the same
   // size and alignment within the anonymous union in Extension.
-  return extension->repeated_int32_t_value;
+  return extension->repeated_i32_value;
 }
 
 // -------------------------------------------------------------------
@@ -848,16 +848,16 @@ void ExtensionSet::RemoveLast(int number) {
 
   switch (cpp_type(extension->type)) {
     case WireFormatLite::CPPTYPE_INT32:
-      extension->repeated_int32_t_value->RemoveLast();
+      extension->repeated_i32_value->RemoveLast();
       break;
     case WireFormatLite::CPPTYPE_INT64:
-      extension->repeated_int64_value->RemoveLast();
+      extension->repeated_i64_value->RemoveLast();
       break;
     case WireFormatLite::CPPTYPE_UINT32:
-      extension->repeated_uint32_t_value->RemoveLast();
+      extension->repeated_ui32_value->RemoveLast();
       break;
     case WireFormatLite::CPPTYPE_UINT64:
-      extension->repeated_uint64_value->RemoveLast();
+      extension->repeated_ui64_value->RemoveLast();
       break;
     case WireFormatLite::CPPTYPE_FLOAT:
       extension->repeated_float_value->RemoveLast();
@@ -903,16 +903,16 @@ void ExtensionSet::SwapElements(int number, int index1, int index2) {
 
   switch (cpp_type(extension->type)) {
     case WireFormatLite::CPPTYPE_INT32:
-      extension->repeated_int32_t_value->SwapElements(index1, index2);
+      extension->repeated_i32_value->SwapElements(index1, index2);
       break;
     case WireFormatLite::CPPTYPE_INT64:
-      extension->repeated_int64_value->SwapElements(index1, index2);
+      extension->repeated_i64_value->SwapElements(index1, index2);
       break;
     case WireFormatLite::CPPTYPE_UINT32:
-      extension->repeated_uint32_t_value->SwapElements(index1, index2);
+      extension->repeated_ui32_value->SwapElements(index1, index2);
       break;
     case WireFormatLite::CPPTYPE_UINT64:
-      extension->repeated_uint64_value->SwapElements(index1, index2);
+      extension->repeated_ui64_value->SwapElements(index1, index2);
       break;
     case WireFormatLite::CPPTYPE_FLOAT:
       extension->repeated_float_value->SwapElements(index1, index2);
@@ -1007,10 +1007,10 @@ void ExtensionSet::InternalExtensionMergeFrom(
         *other_extension.repeated_##LOWERCASE##_value);  \
     break;
 
-      HANDLE_TYPE(INT32, int32_t, RepeatedField<int32_t>);
-      HANDLE_TYPE(INT64, int64, RepeatedField<int64>);
-      HANDLE_TYPE(UINT32, uint32_t, RepeatedField<uint32_t>);
-      HANDLE_TYPE(UINT64, uint64, RepeatedField<uint64>);
+      HANDLE_TYPE(INT32, i32, RepeatedField<i32>);
+      HANDLE_TYPE(INT64, i64, RepeatedField<i64>);
+      HANDLE_TYPE(UINT32, ui32, RepeatedField<ui32>);
+      HANDLE_TYPE(UINT64, ui64, RepeatedField<ui64>);
       HANDLE_TYPE(FLOAT, float, RepeatedField<float>);
       HANDLE_TYPE(DOUBLE, double, RepeatedField<double>);
       HANDLE_TYPE(BOOL, bool, RepeatedField<bool>);
@@ -1051,10 +1051,10 @@ void ExtensionSet::InternalExtensionMergeFrom(
                    other_extension.descriptor);       \
     break;
 
-        HANDLE_TYPE(INT32, int32_t, Int32);
-        HANDLE_TYPE(INT64, int64, Int64);
-        HANDLE_TYPE(UINT32, uint32_t, UInt32);
-        HANDLE_TYPE(UINT64, uint64, UInt64);
+        HANDLE_TYPE(INT32, i32, Int32);
+        HANDLE_TYPE(INT64, i64, Int64);
+        HANDLE_TYPE(UINT32, ui32, UInt32);
+        HANDLE_TYPE(UINT64, ui64, UInt64);
         HANDLE_TYPE(FLOAT, float, Float);
         HANDLE_TYPE(DOUBLE, double, Double);
         HANDLE_TYPE(BOOL, bool, Bool);
@@ -1218,7 +1218,7 @@ bool ExtensionSet::IsInitialized() const {
   return true;
 }
 
-bool ExtensionSet::FindExtensionInfoFromTag(uint32_t tag,
+bool ExtensionSet::FindExtensionInfoFromTag(ui32 tag,
                                             ExtensionFinder* extension_finder,
                                             int* field_number,
                                             ExtensionInfo* extension,
@@ -1252,7 +1252,7 @@ bool ExtensionSet::FindExtensionInfoFromFieldNumber(
   return expected_wire_type == wire_type;
 }
 
-bool ExtensionSet::ParseField(uint32_t tag, io::CodedInputStream* input,
+bool ExtensionSet::ParseField(ui32 tag, io::CodedInputStream* input,
                               ExtensionFinder* extension_finder,
                               FieldSkipper* field_skipper) {
   int number;
@@ -1267,7 +1267,7 @@ bool ExtensionSet::ParseField(uint32_t tag, io::CodedInputStream* input,
   }
 }
 
-const char* ExtensionSet::ParseField(uint64_t tag, const char* ptr,
+const char* ExtensionSet::ParseField(ui64 tag, const char* ptr,
                                      const MessageLite* extendee,
                                      internal::InternalMetadata* metadata,
                                      internal::ParseContext* ctx) {
@@ -1299,7 +1299,7 @@ bool ExtensionSet::ParseFieldWithExtensionInfo(int number,
   // Explicitly not read extension.is_packed, instead check whether the field
   // was encoded in packed form on the wire.
   if (was_packed_on_wire) {
-    uint32_t size;
+    ui32 size;
     if (!input->ReadVarint32(&size)) return false;
     io::CodedInputStream::Limit limit = input->PushLimit(size);
 
@@ -1317,16 +1317,16 @@ bool ExtensionSet::ParseFieldWithExtensionInfo(int number,
     }                                                                       \
     break
 
-      HANDLE_TYPE(INT32, Int32, int32_t);
-      HANDLE_TYPE(INT64, Int64, int64);
-      HANDLE_TYPE(UINT32, UInt32, uint32_t);
-      HANDLE_TYPE(UINT64, UInt64, uint64);
-      HANDLE_TYPE(SINT32, Int32, int32_t);
-      HANDLE_TYPE(SINT64, Int64, int64);
-      HANDLE_TYPE(FIXED32, UInt32, uint32_t);
-      HANDLE_TYPE(FIXED64, UInt64, uint64);
-      HANDLE_TYPE(SFIXED32, Int32, int32_t);
-      HANDLE_TYPE(SFIXED64, Int64, int64);
+      HANDLE_TYPE(INT32, Int32, i32);
+      HANDLE_TYPE(INT64, Int64, i64);
+      HANDLE_TYPE(UINT32, UInt32, ui32);
+      HANDLE_TYPE(UINT64, UInt64, ui64);
+      HANDLE_TYPE(SINT32, Int32, i32);
+      HANDLE_TYPE(SINT64, Int64, i64);
+      HANDLE_TYPE(FIXED32, UInt32, ui32);
+      HANDLE_TYPE(FIXED64, UInt64, ui64);
+      HANDLE_TYPE(SFIXED32, Int32, i32);
+      HANDLE_TYPE(SFIXED64, Int64, i64);
       HANDLE_TYPE(FLOAT, Float, float);
       HANDLE_TYPE(DOUBLE, Double, double);
       HANDLE_TYPE(BOOL, Bool, bool);
@@ -1376,16 +1376,16 @@ bool ExtensionSet::ParseFieldWithExtensionInfo(int number,
     }                                                                       \
   } break
 
-      HANDLE_TYPE(INT32, Int32, int32_t);
-      HANDLE_TYPE(INT64, Int64, int64);
-      HANDLE_TYPE(UINT32, UInt32, uint32_t);
-      HANDLE_TYPE(UINT64, UInt64, uint64);
-      HANDLE_TYPE(SINT32, Int32, int32_t);
-      HANDLE_TYPE(SINT64, Int64, int64);
-      HANDLE_TYPE(FIXED32, UInt32, uint32_t);
-      HANDLE_TYPE(FIXED64, UInt64, uint64);
-      HANDLE_TYPE(SFIXED32, Int32, int32_t);
-      HANDLE_TYPE(SFIXED64, Int64, int64);
+      HANDLE_TYPE(INT32, Int32, i32);
+      HANDLE_TYPE(INT64, Int64, i64);
+      HANDLE_TYPE(UINT32, UInt32, ui32);
+      HANDLE_TYPE(UINT64, UInt64, ui64);
+      HANDLE_TYPE(SINT32, Int32, i32);
+      HANDLE_TYPE(SINT64, Int64, i64);
+      HANDLE_TYPE(FIXED32, UInt32, ui32);
+      HANDLE_TYPE(FIXED64, UInt64, ui64);
+      HANDLE_TYPE(SFIXED32, Int32, i32);
+      HANDLE_TYPE(SFIXED64, Int64, i64);
       HANDLE_TYPE(FLOAT, Float, float);
       HANDLE_TYPE(DOUBLE, Double, double);
       HANDLE_TYPE(BOOL, Bool, bool);
@@ -1464,14 +1464,14 @@ bool ExtensionSet::ParseFieldWithExtensionInfo(int number,
   return true;
 }
 
-bool ExtensionSet::ParseField(uint32_t tag, io::CodedInputStream* input,
+bool ExtensionSet::ParseField(ui32 tag, io::CodedInputStream* input,
                               const MessageLite* extendee) {
   FieldSkipper skipper;
   GeneratedExtensionFinder finder(extendee);
   return ParseField(tag, input, &finder, &skipper);
 }
 
-bool ExtensionSet::ParseField(uint32_t tag, io::CodedInputStream* input,
+bool ExtensionSet::ParseField(ui32 tag, io::CodedInputStream* input,
                               const MessageLite* extendee,
                               io::CodedOutputStream* unknown_fields) {
   CodedOutputStreamFieldSkipper skipper(unknown_fields);
@@ -1483,7 +1483,7 @@ bool ExtensionSet::ParseMessageSetLite(io::CodedInputStream* input,
                                        ExtensionFinder* extension_finder,
                                        FieldSkipper* field_skipper) {
   while (true) {
-    const uint32_t tag = input->ReadTag();
+    const ui32 tag = input->ReadTag();
     switch (tag) {
       case 0:
         return true;
@@ -1511,7 +1511,7 @@ bool ExtensionSet::ParseMessageSetItemLite(io::CodedInputStream* input,
           extension_finder, field_skipper);
     }
 
-    bool SkipField(uint32_t tag, io::CodedInputStream* input) {
+    bool SkipField(ui32 tag, io::CodedInputStream* input) {
       return field_skipper->SkipField(input, tag);
     }
 
@@ -1599,10 +1599,10 @@ void ExtensionSet::Extension::Clear() {
     repeated_##LOWERCASE##_value->Clear();  \
     break
 
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64);
+      HANDLE_TYPE(INT32, i32);
+      HANDLE_TYPE(INT64, i64);
+      HANDLE_TYPE(UINT32, ui32);
+      HANDLE_TYPE(UINT64, ui64);
       HANDLE_TYPE(FLOAT, float);
       HANDLE_TYPE(DOUBLE, double);
       HANDLE_TYPE(BOOL, bool);
@@ -1650,12 +1650,12 @@ size_t ExtensionSet::Extension::ByteSize(int number) const {
     }                                                                \
     break
 
-        HANDLE_TYPE(INT32, Int32, int32_t);
-        HANDLE_TYPE(INT64, Int64, int64);
-        HANDLE_TYPE(UINT32, UInt32, uint32_t);
-        HANDLE_TYPE(UINT64, UInt64, uint64);
-        HANDLE_TYPE(SINT32, SInt32, int32_t);
-        HANDLE_TYPE(SINT64, SInt64, int64);
+        HANDLE_TYPE(INT32, Int32, i32);
+        HANDLE_TYPE(INT64, Int64, i64);
+        HANDLE_TYPE(UINT32, UInt32, ui32);
+        HANDLE_TYPE(UINT64, UInt64, ui64);
+        HANDLE_TYPE(SINT32, SInt32, i32);
+        HANDLE_TYPE(SINT64, SInt64, i64);
         HANDLE_TYPE(ENUM, Enum, enum);
 #undef HANDLE_TYPE
 
@@ -1665,10 +1665,10 @@ size_t ExtensionSet::Extension::ByteSize(int number) const {
     result += WireFormatLite::k##CAMELCASE##Size *               \
               FromIntSize(repeated_##LOWERCASE##_value->size()); \
     break
-        HANDLE_TYPE(FIXED32, Fixed32, uint32_t);
-        HANDLE_TYPE(FIXED64, Fixed64, uint64);
-        HANDLE_TYPE(SFIXED32, SFixed32, int32_t);
-        HANDLE_TYPE(SFIXED64, SFixed64, int64);
+        HANDLE_TYPE(FIXED32, Fixed32, ui32);
+        HANDLE_TYPE(FIXED64, Fixed64, ui64);
+        HANDLE_TYPE(SFIXED32, SFixed32, i32);
+        HANDLE_TYPE(SFIXED64, SFixed64, i64);
         HANDLE_TYPE(FLOAT, Float, float);
         HANDLE_TYPE(DOUBLE, Double, double);
         HANDLE_TYPE(BOOL, Bool, bool);
@@ -1701,12 +1701,12 @@ size_t ExtensionSet::Extension::ByteSize(int number) const {
     }                                                                       \
     break
 
-        HANDLE_TYPE(INT32, Int32, int32_t);
-        HANDLE_TYPE(INT64, Int64, int64);
-        HANDLE_TYPE(UINT32, UInt32, uint32_t);
-        HANDLE_TYPE(UINT64, UInt64, uint64);
-        HANDLE_TYPE(SINT32, SInt32, int32_t);
-        HANDLE_TYPE(SINT64, SInt64, int64);
+        HANDLE_TYPE(INT32, Int32, i32);
+        HANDLE_TYPE(INT64, Int64, i64);
+        HANDLE_TYPE(UINT32, UInt32, ui32);
+        HANDLE_TYPE(UINT64, UInt64, ui64);
+        HANDLE_TYPE(SINT32, SInt32, i32);
+        HANDLE_TYPE(SINT64, SInt64, i64);
         HANDLE_TYPE(STRING, String, string);
         HANDLE_TYPE(BYTES, Bytes, string);
         HANDLE_TYPE(ENUM, Enum, enum);
@@ -1720,10 +1720,10 @@ size_t ExtensionSet::Extension::ByteSize(int number) const {
     result += (tag_size + WireFormatLite::k##CAMELCASE##Size) *  \
               FromIntSize(repeated_##LOWERCASE##_value->size()); \
     break
-        HANDLE_TYPE(FIXED32, Fixed32, uint32_t);
-        HANDLE_TYPE(FIXED64, Fixed64, uint64);
-        HANDLE_TYPE(SFIXED32, SFixed32, int32_t);
-        HANDLE_TYPE(SFIXED64, SFixed64, int64);
+        HANDLE_TYPE(FIXED32, Fixed32, ui32);
+        HANDLE_TYPE(FIXED64, Fixed64, ui64);
+        HANDLE_TYPE(SFIXED32, SFixed32, i32);
+        HANDLE_TYPE(SFIXED64, SFixed64, i64);
         HANDLE_TYPE(FLOAT, Float, float);
         HANDLE_TYPE(DOUBLE, Double, double);
         HANDLE_TYPE(BOOL, Bool, bool);
@@ -1738,12 +1738,12 @@ size_t ExtensionSet::Extension::ByteSize(int number) const {
     result += WireFormatLite::CAMELCASE##Size(LOWERCASE); \
     break
 
-      HANDLE_TYPE(INT32, Int32, int32_t_value);
-      HANDLE_TYPE(INT64, Int64, int64_value);
-      HANDLE_TYPE(UINT32, UInt32, uint32_t_value);
-      HANDLE_TYPE(UINT64, UInt64, uint64_value);
-      HANDLE_TYPE(SINT32, SInt32, int32_t_value);
-      HANDLE_TYPE(SINT64, SInt64, int64_value);
+      HANDLE_TYPE(INT32, Int32, i32_value);
+      HANDLE_TYPE(INT64, Int64, i64_value);
+      HANDLE_TYPE(UINT32, UInt32, ui32_value);
+      HANDLE_TYPE(UINT64, UInt64, ui64_value);
+      HANDLE_TYPE(SINT32, SInt32, i32_value);
+      HANDLE_TYPE(SINT64, SInt64, i64_value);
       HANDLE_TYPE(STRING, String, *string_value);
       HANDLE_TYPE(BYTES, Bytes, *string_value);
       HANDLE_TYPE(ENUM, Enum, enum_value);
@@ -1785,10 +1785,10 @@ int ExtensionSet::Extension::GetSize() const {
   case WireFormatLite::CPPTYPE_##UPPERCASE: \
     return repeated_##LOWERCASE##_value->size()
 
-    HANDLE_TYPE(INT32, int32_t);
-    HANDLE_TYPE(INT64, int64);
-    HANDLE_TYPE(UINT32, uint32_t);
-    HANDLE_TYPE(UINT64, uint64);
+    HANDLE_TYPE(INT32, i32);
+    HANDLE_TYPE(INT64, i64);
+    HANDLE_TYPE(UINT32, ui32);
+    HANDLE_TYPE(UINT64, ui64);
     HANDLE_TYPE(FLOAT, float);
     HANDLE_TYPE(DOUBLE, double);
     HANDLE_TYPE(BOOL, bool);
@@ -1812,10 +1812,10 @@ void ExtensionSet::Extension::Free() {
     delete repeated_##LOWERCASE##_value;    \
     break
 
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64);
+      HANDLE_TYPE(INT32, i32);
+      HANDLE_TYPE(INT64, i64);
+      HANDLE_TYPE(UINT32, ui32);
+      HANDLE_TYPE(UINT64, ui64);
       HANDLE_TYPE(FLOAT, float);
       HANDLE_TYPE(DOUBLE, double);
       HANDLE_TYPE(BOOL, bool);
@@ -2013,16 +2013,16 @@ uint8_t* ExtensionSet::Extension::InternalSerializeFieldWithCachedSizesToArray(
     }                                                                \
     break
 
-        HANDLE_TYPE(INT32, Int32, int32_t);
-        HANDLE_TYPE(INT64, Int64, int64);
-        HANDLE_TYPE(UINT32, UInt32, uint32_t);
-        HANDLE_TYPE(UINT64, UInt64, uint64);
-        HANDLE_TYPE(SINT32, SInt32, int32_t);
-        HANDLE_TYPE(SINT64, SInt64, int64);
-        HANDLE_TYPE(FIXED32, Fixed32, uint32_t);
-        HANDLE_TYPE(FIXED64, Fixed64, uint64);
-        HANDLE_TYPE(SFIXED32, SFixed32, int32_t);
-        HANDLE_TYPE(SFIXED64, SFixed64, int64);
+        HANDLE_TYPE(INT32, Int32, i32);
+        HANDLE_TYPE(INT64, Int64, i64);
+        HANDLE_TYPE(UINT32, UInt32, ui32);
+        HANDLE_TYPE(UINT64, UInt64, ui64);
+        HANDLE_TYPE(SINT32, SInt32, i32);
+        HANDLE_TYPE(SINT64, SInt64, i64);
+        HANDLE_TYPE(FIXED32, Fixed32, ui32);
+        HANDLE_TYPE(FIXED64, Fixed64, ui64);
+        HANDLE_TYPE(SFIXED32, SFixed32, i32);
+        HANDLE_TYPE(SFIXED64, SFixed64, i64);
         HANDLE_TYPE(FLOAT, Float, float);
         HANDLE_TYPE(DOUBLE, Double, double);
         HANDLE_TYPE(BOOL, Bool, bool);
@@ -2047,16 +2047,16 @@ uint8_t* ExtensionSet::Extension::InternalSerializeFieldWithCachedSizesToArray(
     }                                                                \
     break
 
-        HANDLE_TYPE(INT32, Int32, int32_t);
-        HANDLE_TYPE(INT64, Int64, int64);
-        HANDLE_TYPE(UINT32, UInt32, uint32_t);
-        HANDLE_TYPE(UINT64, UInt64, uint64);
-        HANDLE_TYPE(SINT32, SInt32, int32_t);
-        HANDLE_TYPE(SINT64, SInt64, int64);
-        HANDLE_TYPE(FIXED32, Fixed32, uint32_t);
-        HANDLE_TYPE(FIXED64, Fixed64, uint64);
-        HANDLE_TYPE(SFIXED32, SFixed32, int32_t);
-        HANDLE_TYPE(SFIXED64, SFixed64, int64);
+        HANDLE_TYPE(INT32, Int32, i32);
+        HANDLE_TYPE(INT64, Int64, i64);
+        HANDLE_TYPE(UINT32, UInt32, ui32);
+        HANDLE_TYPE(UINT64, UInt64, ui64);
+        HANDLE_TYPE(SINT32, SInt32, i32);
+        HANDLE_TYPE(SINT64, SInt64, i64);
+        HANDLE_TYPE(FIXED32, Fixed32, ui32);
+        HANDLE_TYPE(FIXED64, Fixed64, ui64);
+        HANDLE_TYPE(SFIXED32, SFixed32, i32);
+        HANDLE_TYPE(SFIXED64, SFixed64, i64);
         HANDLE_TYPE(FLOAT, Float, float);
         HANDLE_TYPE(DOUBLE, Double, double);
         HANDLE_TYPE(BOOL, Bool, bool);
@@ -2095,16 +2095,16 @@ uint8_t* ExtensionSet::Extension::InternalSerializeFieldWithCachedSizesToArray(
     target = WireFormatLite::Write##CAMELCASE##ToArray(number, VALUE, target); \
     break
 
-      HANDLE_TYPE(INT32, Int32, int32_t_value);
-      HANDLE_TYPE(INT64, Int64, int64_value);
-      HANDLE_TYPE(UINT32, UInt32, uint32_t_value);
-      HANDLE_TYPE(UINT64, UInt64, uint64_value);
-      HANDLE_TYPE(SINT32, SInt32, int32_t_value);
-      HANDLE_TYPE(SINT64, SInt64, int64_value);
-      HANDLE_TYPE(FIXED32, Fixed32, uint32_t_value);
-      HANDLE_TYPE(FIXED64, Fixed64, uint64_value);
-      HANDLE_TYPE(SFIXED32, SFixed32, int32_t_value);
-      HANDLE_TYPE(SFIXED64, SFixed64, int64_value);
+      HANDLE_TYPE(INT32, Int32, i32_value);
+      HANDLE_TYPE(INT64, Int64, i64_value);
+      HANDLE_TYPE(UINT32, UInt32, ui32_value);
+      HANDLE_TYPE(UINT64, UInt64, ui64_value);
+      HANDLE_TYPE(SINT32, SInt32, i32_value);
+      HANDLE_TYPE(SINT64, SInt64, i64_value);
+      HANDLE_TYPE(FIXED32, Fixed32, ui32_value);
+      HANDLE_TYPE(FIXED64, Fixed64, ui64_value);
+      HANDLE_TYPE(SFIXED32, SFixed32, i32_value);
+      HANDLE_TYPE(SFIXED64, SFixed64, i64_value);
       HANDLE_TYPE(FLOAT, Float, float_value);
       HANDLE_TYPE(DOUBLE, Double, double_value);
       HANDLE_TYPE(BOOL, Bool, bool_value);
diff --git a/contrib/libs/protobuf/src/google/protobuf/extension_set.h b/contrib/libs/protobuf/src/google/protobuf/extension_set.h
index 2f2dde6014..45da392982 100644
--- a/contrib/libs/protobuf/src/google/protobuf/extension_set.h
+++ b/contrib/libs/protobuf/src/google/protobuf/extension_set.h
@@ -246,10 +246,10 @@ class PROTOBUF_EXPORT ExtensionSet {
 
   // singular fields -------------------------------------------------
 
-  int32_t GetInt32(int number, int32_t default_value) const;
-  int64 GetInt64(int number, int64 default_value) const;
-  uint32_t GetUInt32(int number, uint32_t default_value) const;
-  uint64 GetUInt64(int number, uint64 default_value) const;
+  i32 GetInt32(int number, i32 default_value) const;
+  i64 GetInt64(int number, i64 default_value) const;
+  ui32 GetUInt32(int number, ui32 default_value) const;
+  ui64 GetUInt64(int number, ui64 default_value) const;
   float GetFloat(int number, float default_value) const;
   double GetDouble(int number, double default_value) const;
   bool GetBool(int number, bool default_value) const;
@@ -265,10 +265,10 @@ class PROTOBUF_EXPORT ExtensionSet {
   // the extension lives in the same pool as the descriptor for the containing
   // type.
 #define desc const FieldDescriptor* descriptor  // avoid line wrapping
-  void SetInt32(int number, FieldType type, int32_t value, desc);
-  void SetInt64(int number, FieldType type, int64 value, desc);
-  void SetUInt32(int number, FieldType type, uint32_t value, desc);
-  void SetUInt64(int number, FieldType type, uint64 value, desc);
+  void SetInt32(int number, FieldType type, i32 value, desc);
+  void SetInt64(int number, FieldType type, i64 value, desc);
+  void SetUInt32(int number, FieldType type, ui32 value, desc);
+  void SetUInt64(int number, FieldType type, ui64 value, desc);
   void SetFloat(int number, FieldType type, float value, desc);
   void SetDouble(int number, FieldType type, double value, desc);
   void SetBool(int number, FieldType type, bool value, desc);
@@ -318,10 +318,10 @@ class PROTOBUF_EXPORT ExtensionSet {
   // (E.g.: borg/clients/internal/proto1/proto2_reflection.cc.)
   void* MutableRawRepeatedField(int number);
 
-  int32_t GetRepeatedInt32(int number, int index) const;
-  int64 GetRepeatedInt64(int number, int index) const;
-  uint32_t GetRepeatedUInt32(int number, int index) const;
-  uint64 GetRepeatedUInt64(int number, int index) const;
+  i32 GetRepeatedInt32(int number, int index) const;
+  i64 GetRepeatedInt64(int number, int index) const;
+  ui32 GetRepeatedUInt32(int number, int index) const;
+  ui64 GetRepeatedUInt64(int number, int index) const;
   float GetRepeatedFloat(int number, int index) const;
   double GetRepeatedDouble(int number, int index) const;
   bool GetRepeatedBool(int number, int index) const;
@@ -329,10 +329,10 @@ class PROTOBUF_EXPORT ExtensionSet {
   const TProtoStringType& GetRepeatedString(int number, int index) const;
   const MessageLite& GetRepeatedMessage(int number, int index) const;
 
-  void SetRepeatedInt32(int number, int index, int32_t value);
-  void SetRepeatedInt64(int number, int index, int64 value);
-  void SetRepeatedUInt32(int number, int index, uint32_t value);
-  void SetRepeatedUInt64(int number, int index, uint64 value);
+  void SetRepeatedInt32(int number, int index, i32 value);
+  void SetRepeatedInt64(int number, int index, i64 value);
+  void SetRepeatedUInt32(int number, int index, ui32 value);
+  void SetRepeatedUInt64(int number, int index, ui64 value);
   void SetRepeatedFloat(int number, int index, float value);
   void SetRepeatedDouble(int number, int index, double value);
   void SetRepeatedBool(int number, int index, bool value);
@@ -342,10 +342,10 @@ class PROTOBUF_EXPORT ExtensionSet {
   MessageLite* MutableRepeatedMessage(int number, int index);
 
 #define desc const FieldDescriptor* descriptor  // avoid line wrapping
-  void AddInt32(int number, FieldType type, bool packed, int32_t value, desc);
-  void AddInt64(int number, FieldType type, bool packed, int64 value, desc);
-  void AddUInt32(int number, FieldType type, bool packed, uint32_t value, desc);
-  void AddUInt64(int number, FieldType type, bool packed, uint64 value, desc);
+  void AddInt32(int number, FieldType type, bool packed, i32 value, desc);
+  void AddInt64(int number, FieldType type, bool packed, i64 value, desc);
+  void AddUInt32(int number, FieldType type, bool packed, ui32 value, desc);
+  void AddUInt64(int number, FieldType type, bool packed, ui64 value, desc);
   void AddFloat(int number, FieldType type, bool packed, float value, desc);
   void AddDouble(int number, FieldType type, bool packed, double value, desc);
   void AddBool(int number, FieldType type, bool packed, bool value, desc);
@@ -386,7 +386,7 @@ class PROTOBUF_EXPORT ExtensionSet {
 
   // Parses a single extension from the input. The input should start out
   // positioned immediately after the tag.
-  bool ParseField(uint32_t tag, io::CodedInputStream* input,
+  bool ParseField(ui32 tag, io::CodedInputStream* input,
                   ExtensionFinder* extension_finder,
                   FieldSkipper* field_skipper);
 
@@ -396,21 +396,21 @@ class PROTOBUF_EXPORT ExtensionSet {
   // extension by number.  See RegisterExtension(), above.  Unlike the other
   // methods of ExtensionSet, this only works for generated message types --
   // it looks up extensions registered using RegisterExtension().
-  bool ParseField(uint32_t tag, io::CodedInputStream* input,
+  bool ParseField(ui32 tag, io::CodedInputStream* input,
                   const MessageLite* extendee);
-  bool ParseField(uint32_t tag, io::CodedInputStream* input,
+  bool ParseField(ui32 tag, io::CodedInputStream* input,
                   const Message* extendee, UnknownFieldSet* unknown_fields);
-  bool ParseField(uint32_t tag, io::CodedInputStream* input,
+  bool ParseField(ui32 tag, io::CodedInputStream* input,
                   const MessageLite* extendee,
                   io::CodedOutputStream* unknown_fields);
 
   // Lite parser
-  const char* ParseField(uint64_t tag, const char* ptr,
+  const char* ParseField(ui64 tag, const char* ptr,
                          const MessageLite* extendee,
                          internal::InternalMetadata* metadata,
                          internal::ParseContext* ctx);
   // Full parser
-  const char* ParseField(uint64_t tag, const char* ptr, const Message* extendee,
+  const char* ParseField(ui64 tag, const char* ptr, const Message* extendee,
                          internal::InternalMetadata* metadata,
                          internal::ParseContext* ctx);
   template <typename Msg>
@@ -426,7 +426,7 @@ class PROTOBUF_EXPORT ExtensionSet {
       InternalMetadata* metadata;
     } item{this, extendee, metadata};
     while (!ctx->Done(&ptr)) {
-      uint32_t tag;
+      ui32 tag;
       ptr = ReadTag(ptr, &tag);
       GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
       if (tag == WireFormatLite::kMessageSetItemStartTag) {
@@ -544,18 +544,18 @@ class PROTOBUF_EXPORT ExtensionSet {
   template <typename Type, bool IsValid(int)>
   friend class RepeatedEnumTypeTraits;
 
-  const int32_t& GetRefInt32(int number, const int32_t& default_value) const;
-  const int64& GetRefInt64(int number, const int64& default_value) const;
-  const uint32_t& GetRefUInt32(int number, const uint32_t& default_value) const;
-  const uint64& GetRefUInt64(int number, const uint64& default_value) const;
+  const i32& GetRefInt32(int number, const i32& default_value) const;
+  const i64& GetRefInt64(int number, const i64& default_value) const;
+  const ui32& GetRefUInt32(int number, const ui32& default_value) const;
+  const ui64& GetRefUInt64(int number, const ui64& default_value) const;
   const float& GetRefFloat(int number, const float& default_value) const;
   const double& GetRefDouble(int number, const double& default_value) const;
   const bool& GetRefBool(int number, const bool& default_value) const;
   const int& GetRefEnum(int number, const int& default_value) const;
-  const int32_t& GetRefRepeatedInt32(int number, int index) const;
-  const int64& GetRefRepeatedInt64(int number, int index) const;
-  const uint32_t& GetRefRepeatedUInt32(int number, int index) const;
-  const uint64& GetRefRepeatedUInt64(int number, int index) const;
+  const i32& GetRefRepeatedInt32(int number, int index) const;
+  const i64& GetRefRepeatedInt64(int number, int index) const;
+  const ui32& GetRefRepeatedUInt32(int number, int index) const;
+  const ui64& GetRefRepeatedUInt64(int number, int index) const;
   const float& GetRefRepeatedFloat(int number, int index) const;
   const double& GetRefRepeatedDouble(int number, int index) const;
   const bool& GetRefRepeatedBool(int number, int index) const;
@@ -613,10 +613,10 @@ class PROTOBUF_EXPORT ExtensionSet {
     // The order of these fields packs Extension into 24 bytes when using 8
     // byte alignment. Consider this when adding or removing fields here.
     union {
-      int32_t int32_t_value;
-      int64 int64_value;
-      uint32_t uint32_t_value;
-      uint64 uint64_value;
+      i32 i32_value;
+      i64 i64_value;
+      ui32 ui32_value;
+      ui64 ui64_value;
       float float_value;
       double double_value;
       bool bool_value;
@@ -625,10 +625,10 @@ class PROTOBUF_EXPORT ExtensionSet {
       MessageLite* message_value;
       LazyMessageExtension* lazymessage_value;
 
-      RepeatedField<int32_t>* repeated_int32_t_value;
-      RepeatedField<int64>* repeated_int64_value;
-      RepeatedField<uint32_t>* repeated_uint32_t_value;
-      RepeatedField<uint64>* repeated_uint64_value;
+      RepeatedField<i32>* repeated_i32_value;
+      RepeatedField<i64>* repeated_i64_value;
+      RepeatedField<ui32>* repeated_ui32_value;
+      RepeatedField<ui64>* repeated_ui64_value;
       RepeatedField<float>* repeated_float_value;
       RepeatedField<double>* repeated_double_value;
       RepeatedField<bool>* repeated_bool_value;
@@ -772,7 +772,7 @@ class PROTOBUF_EXPORT ExtensionSet {
   // Note to support packed repeated field compatibility, it also fills whether
   // the tag on wire is packed, which can be different from
   // extension->is_packed (whether packed=true is specified).
-  bool FindExtensionInfoFromTag(uint32_t tag, ExtensionFinder* extension_finder,
+  bool FindExtensionInfoFromTag(ui32 tag, ExtensionFinder* extension_finder,
                                 int* field_number, ExtensionInfo* extension,
                                 bool* was_packed_on_wire);
 
@@ -826,26 +826,26 @@ class PROTOBUF_EXPORT ExtensionSet {
                            ExtensionFinder* extension_finder,
                            MessageSetFieldSkipper* field_skipper);
 
-  bool FindExtension(int wire_type, uint32_t field, const MessageLite* extendee,
+  bool FindExtension(int wire_type, ui32 field, const MessageLite* extendee,
                      const internal::ParseContext* /*ctx*/,
                      ExtensionInfo* extension, bool* was_packed_on_wire) {
     GeneratedExtensionFinder finder(extendee);
     return FindExtensionInfoFromFieldNumber(wire_type, field, &finder,
                                             extension, was_packed_on_wire);
   }
-  inline bool FindExtension(int wire_type, uint32_t field,
+  inline bool FindExtension(int wire_type, ui32 field,
                             const Message* extendee,
                             const internal::ParseContext* ctx,
                             ExtensionInfo* extension, bool* was_packed_on_wire);
   // Used for MessageSet only
-  const char* ParseFieldMaybeLazily(uint64_t tag, const char* ptr,
+  const char* ParseFieldMaybeLazily(ui64 tag, const char* ptr,
                                     const MessageLite* extendee,
                                     internal::InternalMetadata* metadata,
                                     internal::ParseContext* ctx) {
     // Lite MessageSet doesn't implement lazy.
     return ParseField(tag, ptr, extendee, metadata, ctx);
   }
-  const char* ParseFieldMaybeLazily(uint64_t tag, const char* ptr,
+  const char* ParseFieldMaybeLazily(ui64 tag, const char* ptr,
                                     const Message* extendee,
                                     internal::InternalMetadata* metadata,
                                     internal::ParseContext* ctx);
@@ -987,7 +987,7 @@ inline void ExtensionSet::AddString(int number, FieldType type,
 // For example, if "foo" is an extension of type "optional int32", then if you
 // try to write code like:
 //   my_message.MutableExtension(foo)
-// you will get a compile error because PrimitiveTypeTraits<int32_t> does not
+// you will get a compile error because PrimitiveTypeTraits<i32> does not
 // have a "Mutable()" method.
 
 // -------------------------------------------------------------------
@@ -1055,10 +1055,10 @@ class PROTOBUF_EXPORT RepeatedPrimitiveDefaults {
   template <typename Type>
   friend class RepeatedPrimitiveTypeTraits;
   static const RepeatedPrimitiveDefaults* default_instance();
-  RepeatedField<int32_t> default_repeated_field_int32_t_;
-  RepeatedField<int64> default_repeated_field_int64_;
-  RepeatedField<uint32_t> default_repeated_field_uint32_t_;
-  RepeatedField<uint64> default_repeated_field_uint64_;
+  RepeatedField<i32> default_repeated_field_i32_;
+  RepeatedField<i64> default_repeated_field_i64_;
+  RepeatedField<ui32> default_repeated_field_ui32_;
+  RepeatedField<ui64> default_repeated_field_ui64_;
   RepeatedField<double> default_repeated_field_double_;
   RepeatedField<float> default_repeated_field_float_;
   RepeatedField<bool> default_repeated_field_bool_;
@@ -1129,10 +1129,10 @@ class PROTOBUF_EXPORT RepeatedPrimitiveDefaults {
         set->MutableRawRepeatedField(number, field_type, is_packed, NULL));    \
   }
 
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(int32_t, Int32)
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(int64, Int64)
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint32_t, UInt32)
-PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint64, UInt64)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(i32, Int32)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(i64, Int64)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(ui32, UInt32)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(ui64, UInt64)
 PROTOBUF_DEFINE_PRIMITIVE_TYPE(float, Float)
 PROTOBUF_DEFINE_PRIMITIVE_TYPE(double, Double)
 PROTOBUF_DEFINE_PRIMITIVE_TYPE(bool, Bool)
@@ -1319,9 +1319,9 @@ class RepeatedEnumTypeTraits {
     // objects to return as default (empty) repeated fields on non-existent
     // extensions. We would not be able to know a-priori all of the enum types
     // (values of |Type|) to instantiate all of these, so we just re-use
-    // int32_t's default repeated field object.
+    // i32's default repeated field object.
     return reinterpret_cast<const RepeatedField<Type>*>(
-        RepeatedPrimitiveTypeTraits<int32_t>::GetDefaultRepeatedField());
+        RepeatedPrimitiveTypeTraits<i32>::GetDefaultRepeatedField());
   }
   template <typename ExtendeeT>
   static void Register(int number, FieldType type, bool is_packed) {
@@ -1460,7 +1460,7 @@ RepeatedMessageTypeTraits<Type>::GetDefaultRepeatedField() {
 //     optional int32 bar = 1234;
 //   }
 // then "bar" will be defined in C++ as:
-//   ExtensionIdentifier<Foo, PrimitiveTypeTraits<int32_t>, 5, false> bar(1234);
+//   ExtensionIdentifier<Foo, PrimitiveTypeTraits<i32>, 5, false> bar(1234);
 //
 // Note that we could, in theory, supply the field number as a template
 // parameter, and thus make an instance of ExtensionIdentifier have no
diff --git a/contrib/libs/protobuf/src/google/protobuf/extension_set_heavy.cc b/contrib/libs/protobuf/src/google/protobuf/extension_set_heavy.cc
index bb2f2f80f6..9a1fda4280 100644
--- a/contrib/libs/protobuf/src/google/protobuf/extension_set_heavy.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/extension_set_heavy.cc
@@ -69,7 +69,7 @@ class MessageSetFieldSkipper : public UnknownFieldSetFieldSkipper {
 };
 bool MessageSetFieldSkipper::SkipMessageSetField(io::CodedInputStream* input,
                                                  int field_number) {
-  uint32_t length;
+  ui32 length;
   if (!input->ReadVarint32(&length)) return false;
   if (unknown_fields_ == nullptr) {
     return input->Skip(length);
@@ -325,7 +325,7 @@ bool DescriptorPoolExtensionFinder::Find(int number, ExtensionInfo* output) {
 }
 
 
-bool ExtensionSet::FindExtension(int wire_type, uint32_t field,
+bool ExtensionSet::FindExtension(int wire_type, ui32 field,
                                  const Message* containing_type,
                                  const internal::ParseContext* ctx,
                                  ExtensionInfo* extension,
@@ -347,7 +347,7 @@ bool ExtensionSet::FindExtension(int wire_type, uint32_t field,
   return true;
 }
 
-const char* ExtensionSet::ParseField(uint64_t tag, const char* ptr,
+const char* ExtensionSet::ParseField(ui64 tag, const char* ptr,
                                      const Message* containing_type,
                                      internal::InternalMetadata* metadata,
                                      internal::ParseContext* ctx) {
@@ -364,7 +364,7 @@ const char* ExtensionSet::ParseField(uint64_t tag, const char* ptr,
 }
 
 const char* ExtensionSet::ParseFieldMaybeLazily(
-    uint64_t tag, const char* ptr, const Message* containing_type,
+    ui64 tag, const char* ptr, const Message* containing_type,
     internal::InternalMetadata* metadata, internal::ParseContext* ctx) {
   return ParseField(tag, ptr, containing_type, metadata, ctx);
 }
@@ -376,7 +376,7 @@ const char* ExtensionSet::ParseMessageSetItem(
                                                            metadata, ctx);
 }
 
-bool ExtensionSet::ParseField(uint32_t tag, io::CodedInputStream* input,
+bool ExtensionSet::ParseField(ui32 tag, io::CodedInputStream* input,
                               const Message* containing_type,
                               UnknownFieldSet* unknown_fields) {
   UnknownFieldSetFieldSkipper skipper(unknown_fields);
@@ -433,10 +433,10 @@ size_t ExtensionSet::Extension::SpaceUsedExcludingSelfLong() const {
                   repeated_##LOWERCASE##_value->SpaceUsedExcludingSelfLong(); \
     break
 
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64);
+      HANDLE_TYPE(INT32, i32);
+      HANDLE_TYPE(INT64, i64);
+      HANDLE_TYPE(UINT32, ui32);
+      HANDLE_TYPE(UINT64, ui64);
       HANDLE_TYPE(FLOAT, float);
       HANDLE_TYPE(DOUBLE, double);
       HANDLE_TYPE(BOOL, bool);
@@ -498,7 +498,7 @@ bool ExtensionSet::ParseMessageSet(io::CodedInputStream* input,
                                    ExtensionFinder* extension_finder,
                                    MessageSetFieldSkipper* field_skipper) {
   while (true) {
-    const uint32_t tag = input->ReadTag();
+    const ui32 tag = input->ReadTag();
     switch (tag) {
       case 0:
         return true;
@@ -526,7 +526,7 @@ bool ExtensionSet::ParseMessageSetItem(io::CodedInputStream* input,
           extension_finder, field_skipper);
     }
 
-    bool SkipField(uint32_t tag, io::CodedInputStream* input) {
+    bool SkipField(ui32 tag, io::CodedInputStream* input) {
       return field_skipper->SkipField(input, tag);
     }
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/extension_set_inl.h b/contrib/libs/protobuf/src/google/protobuf/extension_set_inl.h
index 513bd12010..97919dbac5 100644
--- a/contrib/libs/protobuf/src/google/protobuf/extension_set_inl.h
+++ b/contrib/libs/protobuf/src/google/protobuf/extension_set_inl.h
@@ -83,7 +83,7 @@ const char* ExtensionSet::ParseFieldWithExtensionInfo(
     switch (extension.type) {
 #define HANDLE_VARINT_TYPE(UPPERCASE, CPP_CAMELCASE)                        \
   case WireFormatLite::TYPE_##UPPERCASE: {                                  \
-    uint64_t value;                                                         \
+    ui64 value;                                                         \
     ptr = VarintParse(ptr, &value);                                         \
     GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);                                    \
     if (extension.is_repeated) {                                            \
@@ -103,7 +103,7 @@ const char* ExtensionSet::ParseFieldWithExtensionInfo(
 #undef HANDLE_VARINT_TYPE
 #define HANDLE_SVARINT_TYPE(UPPERCASE, CPP_CAMELCASE, SIZE)                 \
   case WireFormatLite::TYPE_##UPPERCASE: {                                  \
-    uint64_t val;                                                           \
+    ui64 val;                                                           \
     ptr = VarintParse(ptr, &val);                                           \
     GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);                                    \
     auto value = WireFormatLite::ZigZagDecode##SIZE(val);                   \
@@ -132,16 +132,16 @@ const char* ExtensionSet::ParseFieldWithExtensionInfo(
     }                                                                       \
   } break
 
-      HANDLE_FIXED_TYPE(FIXED32, UInt32, uint32_t);
-      HANDLE_FIXED_TYPE(FIXED64, UInt64, uint64_t);
-      HANDLE_FIXED_TYPE(SFIXED32, Int32, int32_t);
-      HANDLE_FIXED_TYPE(SFIXED64, Int64, int64_t);
+      HANDLE_FIXED_TYPE(FIXED32, UInt32, ui32);
+      HANDLE_FIXED_TYPE(FIXED64, UInt64, ui64);
+      HANDLE_FIXED_TYPE(SFIXED32, Int32, i32);
+      HANDLE_FIXED_TYPE(SFIXED64, Int64, i64);
       HANDLE_FIXED_TYPE(FLOAT, Float, float);
       HANDLE_FIXED_TYPE(DOUBLE, Double, double);
 #undef HANDLE_FIXED_TYPE
 
       case WireFormatLite::TYPE_ENUM: {
-        uint64_t val;
+        ui64 val;
         ptr = VarintParse(ptr, &val);
         GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
         int value = val;
@@ -181,7 +181,7 @@ const char* ExtensionSet::ParseFieldWithExtensionInfo(
                 : MutableMessage(number, WireFormatLite::TYPE_GROUP,
                                  *extension.message_info.prototype,
                                  extension.descriptor);
-        uint32_t tag = (number << 3) + WireFormatLite::WIRETYPE_START_GROUP;
+        ui32 tag = (number << 3) + WireFormatLite::WIRETYPE_START_GROUP;
         return ctx->ParseGroup(value, ptr, tag);
       }
 
@@ -206,14 +206,14 @@ const char* ExtensionSet::ParseMessageSetItemTmpl(
     const char* ptr, const Msg* extendee, internal::InternalMetadata* metadata,
     internal::ParseContext* ctx) {
   TProtoStringType payload;
-  uint32_t type_id;
+  ui32 type_id;
   enum class State { kNoTag, kHasType, kHasPayload, kDone };
   State state = State::kNoTag;
 
   while (!ctx->Done(&ptr)) {
-    uint32_t tag = static_cast<uint8_t>(*ptr++);
+    ui32 tag = static_cast<uint8_t>(*ptr++);
     if (tag == WireFormatLite::kMessageSetTypeIdTag) {
-      uint64_t tmp;
+      ui64 tmp;
       ptr = ParseBigVarint(ptr, &tmp);
       GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
       if (state == State::kNoTag) {
@@ -250,13 +250,13 @@ const char* ExtensionSet::ParseMessageSetItemTmpl(
       }
     } else if (tag == WireFormatLite::kMessageSetMessageTag) {
       if (state == State::kHasType) {
-        ptr = ParseFieldMaybeLazily(static_cast<uint64_t>(type_id) * 8 + 2, ptr,
+        ptr = ParseFieldMaybeLazily(static_cast<ui64>(type_id) * 8 + 2, ptr,
                                     extendee, metadata, ctx);
         GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
         state = State::kDone;
       } else {
         TProtoStringType tmp;
-        int32_t size = ReadSize(&ptr);
+        i32 size = ReadSize(&ptr);
         GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
         ptr = ctx->ReadString(ptr, size, &tmp);
         GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_bases.cc b/contrib/libs/protobuf/src/google/protobuf/generated_message_bases.cc
index 3acfa5f286..bc0b78fd67 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_bases.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_bases.cc
@@ -68,7 +68,7 @@ const char* ZeroFieldsBase::_InternalParse(const char* ptr,
   }
 
   while (!ctx->Done(&ptr)) {
-    uint32_t tag;
+    ui32 tag;
     ptr = internal::ReadTag(ptr, &tag);
     if ((tag == 0) || ((tag & 7) == 4)) {
       CHK_(ptr);
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_reflection.cc b/contrib/libs/protobuf/src/google/protobuf/generated_message_reflection.cc
index 4984ccdc9d..cbcf613951 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_reflection.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_reflection.cc
@@ -283,10 +283,10 @@ size_t Reflection::SpaceUsedLong(const Message& message) const {
                       .SpaceUsedExcludingSelfLong();                \
     break
 
-        HANDLE_TYPE(INT32, int32_t);
-        HANDLE_TYPE(INT64, int64);
-        HANDLE_TYPE(UINT32, uint32_t);
-        HANDLE_TYPE(UINT64, uint64);
+        HANDLE_TYPE(INT32, i32);
+        HANDLE_TYPE(INT64, i64);
+        HANDLE_TYPE(UINT32, ui32);
+        HANDLE_TYPE(UINT64, ui64);
         HANDLE_TYPE(DOUBLE, double);
         HANDLE_TYPE(FLOAT, float);
         HANDLE_TYPE(BOOL, bool);
@@ -676,10 +676,10 @@ void Reflection::SwapField(Message* message1, Message* message2,
         ->Swap(MutableRaw<RepeatedField<TYPE> >(message2, field)); \
     break;
 
-      SWAP_ARRAYS(INT32, int32_t);
-      SWAP_ARRAYS(INT64, int64);
-      SWAP_ARRAYS(UINT32, uint32_t);
-      SWAP_ARRAYS(UINT64, uint64);
+      SWAP_ARRAYS(INT32, i32);
+      SWAP_ARRAYS(INT64, i64);
+      SWAP_ARRAYS(UINT32, ui32);
+      SWAP_ARRAYS(UINT64, ui64);
       SWAP_ARRAYS(FLOAT, float);
       SWAP_ARRAYS(DOUBLE, double);
       SWAP_ARRAYS(BOOL, bool);
@@ -706,10 +706,10 @@ void Reflection::SwapField(Message* message1, Message* message2,
               *MutableRaw<TYPE>(message2, field)); \
     break;
 
-      SWAP_VALUES(INT32, int32_t);
-      SWAP_VALUES(INT64, int64);
-      SWAP_VALUES(UINT32, uint32_t);
-      SWAP_VALUES(UINT64, uint64);
+      SWAP_VALUES(INT32, i32);
+      SWAP_VALUES(INT64, i64);
+      SWAP_VALUES(UINT32, ui32);
+      SWAP_VALUES(UINT64, ui64);
       SWAP_VALUES(FLOAT, float);
       SWAP_VALUES(DOUBLE, double);
       SWAP_VALUES(BOOL, bool);
@@ -753,10 +753,10 @@ void Reflection::UnsafeShallowSwapField(Message* message1, Message* message2,
         ->InternalSwap(MutableRaw<RepeatedField<TYPE>>(message2, field)); \
     break;
 
-    SHALLOW_SWAP_ARRAYS(INT32, int32_t);
-    SHALLOW_SWAP_ARRAYS(INT64, int64);
-    SHALLOW_SWAP_ARRAYS(UINT32, uint32_t);
-    SHALLOW_SWAP_ARRAYS(UINT64, uint64);
+    SHALLOW_SWAP_ARRAYS(INT32, i32);
+    SHALLOW_SWAP_ARRAYS(INT64, i64);
+    SHALLOW_SWAP_ARRAYS(UINT32, ui32);
+    SHALLOW_SWAP_ARRAYS(UINT64, ui64);
     SHALLOW_SWAP_ARRAYS(FLOAT, float);
     SHALLOW_SWAP_ARRAYS(DOUBLE, double);
     SHALLOW_SWAP_ARRAYS(BOOL, bool);
@@ -790,10 +790,10 @@ void Reflection::SwapOneofField(Message* lhs, Message* rhs,
   type Get##name() const { return oneof_val.type_##var; } \
   void Set##name(type v) { oneof_val.type_##var = v; }
 
-    LOCAL_VAR_ACCESSOR(int32_t, int32, Int32);
-    LOCAL_VAR_ACCESSOR(int64, int64, Int64);
-    LOCAL_VAR_ACCESSOR(uint32_t, uint32, Uint32);
-    LOCAL_VAR_ACCESSOR(uint64, uint64, Uint64);
+    LOCAL_VAR_ACCESSOR(i32, int32, Int32);
+    LOCAL_VAR_ACCESSOR(i64, int64, Int64);
+    LOCAL_VAR_ACCESSOR(ui32, uint32, Uint32);
+    LOCAL_VAR_ACCESSOR(ui64, uint64, Uint64);
     LOCAL_VAR_ACCESSOR(float, float, Float);
     LOCAL_VAR_ACCESSOR(double, double, Double);
     LOCAL_VAR_ACCESSOR(bool, bool, Bool);
@@ -807,10 +807,10 @@ void Reflection::SwapOneofField(Message* lhs, Message* rhs,
     void ClearOneofCase() {}
 
     union {
-      int32_t type_int32;
-      int64 type_int64;
-      uint32_t type_uint32;
-      uint64 type_uint64;
+      i32 type_int32;
+      i64 type_int64;
+      ui32 type_uint32;
+      ui64 type_uint64;
       float type_float;
       double type_double;
       bool type_bool;
@@ -831,10 +831,10 @@ void Reflection::SwapOneofField(Message* lhs, Message* rhs,
   }                                                     \
   void Set##name(type v) { reflection->SetField<type>(message, field, v); }
 
-    MESSAGE_FIELD_ACCESSOR(int32_t, int32, Int32);
-    MESSAGE_FIELD_ACCESSOR(int64, int64, Int64);
-    MESSAGE_FIELD_ACCESSOR(uint32_t, uint32, Uint32);
-    MESSAGE_FIELD_ACCESSOR(uint64, uint64, Uint64);
+    MESSAGE_FIELD_ACCESSOR(i32, int32, Int32);
+    MESSAGE_FIELD_ACCESSOR(i64, int64, Int64);
+    MESSAGE_FIELD_ACCESSOR(ui32, uint32, Uint32);
+    MESSAGE_FIELD_ACCESSOR(ui64, uint64, Uint64);
     MESSAGE_FIELD_ACCESSOR(float, float, Float);
     MESSAGE_FIELD_ACCESSOR(double, double, Double);
     MESSAGE_FIELD_ACCESSOR(bool, bool, Bool);
@@ -1123,10 +1123,10 @@ int Reflection::FieldSize(const Message& message,
   case FieldDescriptor::CPPTYPE_##UPPERCASE: \
     return GetRaw<RepeatedField<LOWERCASE> >(message, field).size()
 
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64);
+      HANDLE_TYPE(INT32, i32);
+      HANDLE_TYPE(INT64, i64);
+      HANDLE_TYPE(UINT32, ui32);
+      HANDLE_TYPE(UINT64, ui64);
       HANDLE_TYPE(DOUBLE, double);
       HANDLE_TYPE(FLOAT, float);
       HANDLE_TYPE(BOOL, bool);
@@ -1177,10 +1177,10 @@ void Reflection::ClearField(Message* message,
     *MutableRaw<TYPE>(message, field) = field->default_value_##TYPE(); \
     break;
 
-        CLEAR_TYPE(INT32, int32_t);
-        CLEAR_TYPE(INT64, int64);
-        CLEAR_TYPE(UINT32, uint32_t);
-        CLEAR_TYPE(UINT64, uint64);
+        CLEAR_TYPE(INT32, i32);
+        CLEAR_TYPE(INT64, i64);
+        CLEAR_TYPE(UINT32, ui32);
+        CLEAR_TYPE(UINT64, ui64);
         CLEAR_TYPE(FLOAT, float);
         CLEAR_TYPE(DOUBLE, double);
         CLEAR_TYPE(BOOL, bool);
@@ -1213,7 +1213,7 @@ void Reflection::ClearField(Message* message,
         }
 
         case FieldDescriptor::CPPTYPE_MESSAGE:
-          if (schema_.HasBitIndex(field) == static_cast<uint32_t>(-1)) {
+          if (schema_.HasBitIndex(field) == static_cast<ui32>(-1)) {
             // Proto3 does not have has-bits and we need to set a message field
             // to nullptr in order to indicate its un-presence.
             if (message->GetArenaForAllocation() == nullptr) {
@@ -1233,10 +1233,10 @@ void Reflection::ClearField(Message* message,
     MutableRaw<RepeatedField<LOWERCASE> >(message, field)->Clear(); \
     break
 
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64);
+      HANDLE_TYPE(INT32, i32);
+      HANDLE_TYPE(INT64, i64);
+      HANDLE_TYPE(UINT32, ui32);
+      HANDLE_TYPE(UINT64, ui64);
       HANDLE_TYPE(DOUBLE, double);
       HANDLE_TYPE(FLOAT, float);
       HANDLE_TYPE(BOOL, bool);
@@ -1283,10 +1283,10 @@ void Reflection::RemoveLast(Message* message,
     MutableRaw<RepeatedField<LOWERCASE> >(message, field)->RemoveLast(); \
     break
 
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64);
+      HANDLE_TYPE(INT32, i32);
+      HANDLE_TYPE(INT64, i64);
+      HANDLE_TYPE(UINT32, ui32);
+      HANDLE_TYPE(UINT64, ui64);
       HANDLE_TYPE(DOUBLE, double);
       HANDLE_TYPE(FLOAT, float);
       HANDLE_TYPE(BOOL, bool);
@@ -1379,10 +1379,10 @@ void Reflection::SwapElements(Message* message, const FieldDescriptor* field,
         ->SwapElements(index1, index2);                   \
     break
 
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64);
+      HANDLE_TYPE(INT32, i32);
+      HANDLE_TYPE(INT64, i64);
+      HANDLE_TYPE(UINT32, ui32);
+      HANDLE_TYPE(UINT64, ui64);
       HANDLE_TYPE(DOUBLE, double);
       HANDLE_TYPE(FLOAT, float);
       HANDLE_TYPE(BOOL, bool);
@@ -1413,10 +1413,10 @@ struct FieldNumberSorter {
   }
 };
 
-bool IsIndexInHasBitSet(const uint32_t* has_bit_set, uint32_t has_bit_index) {
+bool IsIndexInHasBitSet(const ui32* has_bit_set, ui32 has_bit_index) {
   GOOGLE_DCHECK_NE(has_bit_index, ~0u);
   return ((has_bit_set[has_bit_index / 32] >> (has_bit_index % 32)) &
-          static_cast<uint32_t>(1)) != 0;
+          static_cast<ui32>(1)) != 0;
 }
 
 bool CreateUnknownEnumValues(const FileDescriptor* file) {
@@ -1445,9 +1445,9 @@ void Reflection::ListFieldsMayFailOnStripped(
   // encapsulation because this function takes a noticeable about of CPU
   // fleetwide and properly allowing this optimization through public interfaces
   // seems more trouble than it is worth.
-  const uint32_t* const has_bits =
+  const ui32* const has_bits =
       schema_.HasHasbits() ? GetHasBits(message) : nullptr;
-  const uint32_t* const has_bits_indices = schema_.has_bit_indices_;
+  const ui32* const has_bits_indices = schema_.has_bit_indices_;
   output->reserve(descriptor_->field_count());
   const int last_non_weak_field_index = last_non_weak_field_index_;
   for (int i = 0; i <= last_non_weak_field_index; i++) {
@@ -1462,15 +1462,15 @@ void Reflection::ListFieldsMayFailOnStripped(
     } else {
       const OneofDescriptor* containing_oneof = field->containing_oneof();
       if (schema_.InRealOneof(field)) {
-        const uint32_t* const oneof_case_array =
-            GetConstPointerAtOffset<uint32_t>(&message,
+        const ui32* const oneof_case_array =
+            GetConstPointerAtOffset<ui32>(&message,
                                               schema_.oneof_case_offset_);
         // Equivalent to: HasOneofField(message, field)
-        if (static_cast<int64>(oneof_case_array[containing_oneof->index()]) ==
+        if (static_cast<i64>(oneof_case_array[containing_oneof->index()]) ==
             field->number()) {
           output->push_back(field);
         }
-      } else if (has_bits && has_bits_indices[i] != static_cast<uint32_t>(-1)) {
+      } else if (has_bits && has_bits_indices[i] != static_cast<ui32>(-1)) {
         CheckInvalidAccess(schema_, field);
         // Equivalent to: HasBit(message, field)
         if (IsIndexInHasBitSet(has_bits, has_bits_indices[i])) {
@@ -1563,10 +1563,10 @@ void Reflection::ListFieldsOmitStripped(
     }                                                                          \
   }
 
-DEFINE_PRIMITIVE_ACCESSORS(Int32, int32_t, int32_t, INT32)
-DEFINE_PRIMITIVE_ACCESSORS(Int64, int64, int64, INT64)
-DEFINE_PRIMITIVE_ACCESSORS(UInt32, uint32_t, uint32_t, UINT32)
-DEFINE_PRIMITIVE_ACCESSORS(UInt64, uint64, uint64, UINT64)
+DEFINE_PRIMITIVE_ACCESSORS(Int32, i32, i32, INT32)
+DEFINE_PRIMITIVE_ACCESSORS(Int64, i64, i64, INT64)
+DEFINE_PRIMITIVE_ACCESSORS(UInt32, ui32, ui32, UINT32)
+DEFINE_PRIMITIVE_ACCESSORS(UInt64, ui64, ui64, UINT64)
 DEFINE_PRIMITIVE_ACCESSORS(Float, float, float, FLOAT)
 DEFINE_PRIMITIVE_ACCESSORS(Double, double, double, DOUBLE)
 DEFINE_PRIMITIVE_ACCESSORS(Bool, bool, bool, BOOL)
@@ -1641,10 +1641,10 @@ void Reflection::SetString(Message* message, const FieldDescriptor* field,
       default:  // TODO(kenton):  Support other string reps.
       case FieldOptions::STRING: {
         if (IsInlined(field)) {
-          const uint32_t index = schema_.InlinedStringIndex(field);
-          uint32_t* states =
+          const ui32 index = schema_.InlinedStringIndex(field);
+          ui32* states =
               &MutableInlinedStringDonatedArray(message)[index / 32];
-          uint32_t mask = ~(static_cast<uint32_t>(1) << (index % 32));
+          ui32 mask = ~(static_cast<ui32>(1) << (index % 32));
           MutableField<InlinedStringField>(message, field)
               ->Set(nullptr, value, message->GetArenaForAllocation(),
                     IsInlinedStringDonated(*message, field), states, mask);
@@ -1754,7 +1754,7 @@ int Reflection::GetEnumValue(const Message& message,
                              const FieldDescriptor* field) const {
   USAGE_CHECK_ALL(GetEnumValue, SINGULAR, ENUM);
 
-  int32_t value;
+  i32 value;
   if (field->is_extension()) {
     value = GetExtensionSet(message).GetEnum(
         field->number(), field->default_value_enum()->number());
@@ -2290,7 +2290,7 @@ const FieldDescriptor* Reflection::GetOneofFieldDescriptor(
     const FieldDescriptor* field = oneof_descriptor->field(0);
     return HasField(message, field) ? field : nullptr;
   }
-  uint32_t field_number = GetOneofCase(message, oneof_descriptor);
+  ui32 field_number = GetOneofCase(message, oneof_descriptor);
   if (field_number == 0) {
     return nullptr;
   }
@@ -2398,20 +2398,20 @@ Type* Reflection::MutableRaw(Message* message,
   return GetPointerAtOffset<Type>(message, schema_.GetFieldOffset(field));
 }
 
-const uint32_t* Reflection::GetHasBits(const Message& message) const {
+const ui32* Reflection::GetHasBits(const Message& message) const {
   GOOGLE_DCHECK(schema_.HasHasbits());
-  return &GetConstRefAtOffset<uint32_t>(message, schema_.HasBitsOffset());
+  return &GetConstRefAtOffset<ui32>(message, schema_.HasBitsOffset());
 }
 
-uint32_t* Reflection::MutableHasBits(Message* message) const {
+ui32* Reflection::MutableHasBits(Message* message) const {
   GOOGLE_DCHECK(schema_.HasHasbits());
-  return GetPointerAtOffset<uint32_t>(message, schema_.HasBitsOffset());
+  return GetPointerAtOffset<ui32>(message, schema_.HasBitsOffset());
 }
 
-uint32_t* Reflection::MutableOneofCase(
+ui32* Reflection::MutableOneofCase(
     Message* message, const OneofDescriptor* oneof_descriptor) const {
   GOOGLE_DCHECK(!oneof_descriptor->is_synthetic());
-  return GetPointerAtOffset<uint32_t>(
+  return GetPointerAtOffset<ui32>(
       message, schema_.GetOneofCaseOffset(oneof_descriptor));
 }
 
@@ -2436,16 +2436,16 @@ InternalMetadata* Reflection::MutableInternalMetadata(Message* message) const {
                                               schema_.GetMetadataOffset());
 }
 
-const uint32_t* Reflection::GetInlinedStringDonatedArray(
+const ui32* Reflection::GetInlinedStringDonatedArray(
     const Message& message) const {
   GOOGLE_DCHECK(schema_.HasInlinedString());
-  return &GetConstRefAtOffset<uint32_t>(message,
+  return &GetConstRefAtOffset<ui32>(message,
                                         schema_.InlinedStringDonatedOffset());
 }
 
-uint32_t* Reflection::MutableInlinedStringDonatedArray(Message* message) const {
+ui32* Reflection::MutableInlinedStringDonatedArray(Message* message) const {
   GOOGLE_DCHECK(schema_.HasHasbits());
-  return GetPointerAtOffset<uint32_t>(message,
+  return GetPointerAtOffset<ui32>(message,
                                       schema_.InlinedStringDonatedOffset());
 }
 
@@ -2460,7 +2460,7 @@ bool Reflection::IsInlinedStringDonated(const Message& message,
 bool Reflection::HasBit(const Message& message,
                         const FieldDescriptor* field) const {
   GOOGLE_DCHECK(!field->options().weak());
-  if (schema_.HasBitIndex(field) != static_cast<uint32_t>(-1)) {
+  if (schema_.HasBitIndex(field) != static_cast<ui32>(-1)) {
     return IsIndexInHasBitSet(GetHasBits(message), schema_.HasBitIndex(field));
   }
 
@@ -2500,13 +2500,13 @@ bool Reflection::HasBit(const Message& message,
       case FieldDescriptor::CPPTYPE_BOOL:
         return GetRaw<bool>(message, field) != false;
       case FieldDescriptor::CPPTYPE_INT32:
-        return GetRaw<int32_t>(message, field) != 0;
+        return GetRaw<i32>(message, field) != 0;
       case FieldDescriptor::CPPTYPE_INT64:
-        return GetRaw<int64>(message, field) != 0;
+        return GetRaw<i64>(message, field) != 0;
       case FieldDescriptor::CPPTYPE_UINT32:
-        return GetRaw<uint32_t>(message, field) != 0;
+        return GetRaw<ui32>(message, field) != 0;
       case FieldDescriptor::CPPTYPE_UINT64:
-        return GetRaw<uint64>(message, field) != 0;
+        return GetRaw<ui64>(message, field) != 0;
       case FieldDescriptor::CPPTYPE_FLOAT:
         return GetRaw<float>(message, field) != 0.0;
       case FieldDescriptor::CPPTYPE_DOUBLE:
@@ -2524,19 +2524,19 @@ bool Reflection::HasBit(const Message& message,
 
 void Reflection::SetBit(Message* message, const FieldDescriptor* field) const {
   GOOGLE_DCHECK(!field->options().weak());
-  const uint32_t index = schema_.HasBitIndex(field);
-  if (index == static_cast<uint32_t>(-1)) return;
+  const ui32 index = schema_.HasBitIndex(field);
+  if (index == static_cast<ui32>(-1)) return;
   MutableHasBits(message)[index / 32] |=
-      (static_cast<uint32_t>(1) << (index % 32));
+      (static_cast<ui32>(1) << (index % 32));
 }
 
 void Reflection::ClearBit(Message* message,
                           const FieldDescriptor* field) const {
   GOOGLE_DCHECK(!field->options().weak());
-  const uint32_t index = schema_.HasBitIndex(field);
-  if (index == static_cast<uint32_t>(-1)) return;
+  const ui32 index = schema_.HasBitIndex(field);
+  if (index == static_cast<ui32>(-1)) return;
   MutableHasBits(message)[index / 32] &=
-      ~(static_cast<uint32_t>(1) << (index % 32));
+      ~(static_cast<ui32>(1) << (index % 32));
 }
 
 void Reflection::SwapBit(Message* message1, Message* message2,
@@ -2587,7 +2587,7 @@ void Reflection::ClearOneof(Message* message,
   // TODO(jieluo): Consider to cache the unused object instead of deleting
   // it. It will be much faster if an application switches a lot from
   // a few oneof fields.  Time/space tradeoff
-  uint32_t oneof_case = GetOneofCase(*message, oneof_descriptor);
+  ui32 oneof_case = GetOneofCase(*message, oneof_descriptor);
   if (oneof_case > 0) {
     const FieldDescriptor* field = descriptor_->FindFieldByNumber(oneof_case);
     if (message->GetArenaForAllocation() == nullptr) {
@@ -2635,10 +2635,10 @@ void Reflection::ClearOneof(Message* message,
         MutableRawRepeatedField(message, field, CPPTYPE, CTYPE, NULL));  \
   }
 
-HANDLE_TYPE(int32_t, FieldDescriptor::CPPTYPE_INT32, -1);
-HANDLE_TYPE(int64, FieldDescriptor::CPPTYPE_INT64, -1);
-HANDLE_TYPE(uint32_t, FieldDescriptor::CPPTYPE_UINT32, -1);
-HANDLE_TYPE(uint64, FieldDescriptor::CPPTYPE_UINT64, -1);
+HANDLE_TYPE(i32, FieldDescriptor::CPPTYPE_INT32, -1);
+HANDLE_TYPE(i64, FieldDescriptor::CPPTYPE_INT64, -1);
+HANDLE_TYPE(ui32, FieldDescriptor::CPPTYPE_UINT32, -1);
+HANDLE_TYPE(ui64, FieldDescriptor::CPPTYPE_UINT64, -1);
 HANDLE_TYPE(float, FieldDescriptor::CPPTYPE_FLOAT, -1);
 HANDLE_TYPE(double, FieldDescriptor::CPPTYPE_DOUBLE, -1);
 HANDLE_TYPE(bool, FieldDescriptor::CPPTYPE_BOOL, -1);
@@ -2770,7 +2770,7 @@ namespace {
 
 // Helper function to transform migration schema into reflection schema.
 ReflectionSchema MigrationToReflectionSchema(
-    const Message* const* default_instance, const uint32_t* offsets,
+    const Message* const* default_instance, const ui32* offsets,
     MigrationSchema migration_schema) {
   ReflectionSchema result;
   result.default_instance_ = *default_instance;
@@ -2800,7 +2800,7 @@ class AssignDescriptorsHelper {
                           const EnumDescriptor** file_level_enum_descriptors,
                           const MigrationSchema* schemas,
                           const Message* const* default_instance_data,
-                          const uint32_t* offsets)
+                          const ui32* offsets)
       : factory_(factory),
         file_level_metadata_(file_level_metadata),
         file_level_enum_descriptors_(file_level_enum_descriptors),
@@ -2841,7 +2841,7 @@ class AssignDescriptorsHelper {
   const EnumDescriptor** file_level_enum_descriptors_;
   const MigrationSchema* schemas_;
   const Message* const* default_instance_data_;
-  const uint32_t* offsets_;
+  const ui32* offsets_;
 };
 
 namespace {
@@ -3002,8 +3002,8 @@ void RegisterFileLevelMetadata(const DescriptorTable* table) {
   RegisterAllTypesInternal(table->file_level_metadata, table->num_messages);
 }
 
-void UnknownFieldSetSerializer(const uint8_t* base, uint32_t offset,
-                               uint32_t tag, uint32_t has_offset,
+void UnknownFieldSetSerializer(const uint8_t* base, ui32 offset,
+                               ui32 tag, ui32 has_offset,
                                io::CodedOutputStream* output) {
   const void* ptr = base + offset;
   const InternalMetadata* metadata = static_cast<const InternalMetadata*>(ptr);
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_reflection.h b/contrib/libs/protobuf/src/google/protobuf/generated_message_reflection.h
index 6a570ff607..6a20ecae54 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_reflection.h
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_reflection.h
@@ -107,7 +107,7 @@ class WeakFieldMap;  // weak_field_map.h
 //                  message, or -1 if the message type has no extension
 //                  ranges.
 //   oneof_case_offset:  Offset in the message of an array of uint32s of
-//                  size descriptor->oneof_decl_count().  Each uint32_t
+//                  size descriptor->oneof_decl_count().  Each ui32
 //                  indicates what field is set for each oneof.
 //   object_size:   The size of a message object of this type, as measured
 //                  by sizeof().
@@ -119,7 +119,7 @@ class WeakFieldMap;  // weak_field_map.h
 struct ReflectionSchema {
  public:
   // Size of a google::protobuf::Message object of this type.
-  uint32_t GetObjectSize() const { return static_cast<uint32_t>(object_size_); }
+  ui32 GetObjectSize() const { return static_cast<ui32>(object_size_); }
 
   bool InRealOneof(const FieldDescriptor* field) const {
     return field->containing_oneof() &&
@@ -128,13 +128,13 @@ struct ReflectionSchema {
 
   // Offset of a non-oneof field.  Getting a field offset is slightly more
   // efficient when we know statically that it is not a oneof field.
-  uint32_t GetFieldOffsetNonOneof(const FieldDescriptor* field) const {
+  ui32 GetFieldOffsetNonOneof(const FieldDescriptor* field) const {
     GOOGLE_DCHECK(!InRealOneof(field));
     return OffsetValue(offsets_[field->index()], field->type());
   }
 
   // Offset of any field.
-  uint32_t GetFieldOffset(const FieldDescriptor* field) const {
+  ui32 GetFieldOffset(const FieldDescriptor* field) const {
     if (InRealOneof(field)) {
       size_t offset =
           static_cast<size_t>(field->containing_type()->field_count() +
@@ -149,58 +149,58 @@ struct ReflectionSchema {
     return Inlined(offsets_[field->index()], field->type());
   }
 
-  uint32_t GetOneofCaseOffset(const OneofDescriptor* oneof_descriptor) const {
-    return static_cast<uint32_t>(oneof_case_offset_) +
-           static_cast<uint32_t>(
+  ui32 GetOneofCaseOffset(const OneofDescriptor* oneof_descriptor) const {
+    return static_cast<ui32>(oneof_case_offset_) +
+           static_cast<ui32>(
                static_cast<size_t>(oneof_descriptor->index()) *
-               sizeof(uint32_t));
+               sizeof(ui32));
   }
 
   bool HasHasbits() const { return has_bits_offset_ != -1; }
 
   // Bit index within the bit array of hasbits.  Bit order is low-to-high.
-  uint32_t HasBitIndex(const FieldDescriptor* field) const {
-    if (has_bits_offset_ == -1) return static_cast<uint32_t>(-1);
+  ui32 HasBitIndex(const FieldDescriptor* field) const {
+    if (has_bits_offset_ == -1) return static_cast<ui32>(-1);
     GOOGLE_DCHECK(HasHasbits());
     return has_bit_indices_[field->index()];
   }
 
   // Byte offset of the hasbits array.
-  uint32_t HasBitsOffset() const {
+  ui32 HasBitsOffset() const {
     GOOGLE_DCHECK(HasHasbits());
-    return static_cast<uint32_t>(has_bits_offset_);
+    return static_cast<ui32>(has_bits_offset_);
   }
 
   bool HasInlinedString() const { return inlined_string_donated_offset_ != -1; }
 
   // Bit index within the bit array of _inlined_string_donated_.  Bit order is
   // low-to-high.
-  uint32_t InlinedStringIndex(const FieldDescriptor* field) const {
+  ui32 InlinedStringIndex(const FieldDescriptor* field) const {
     GOOGLE_DCHECK(HasInlinedString());
     return inlined_string_indices_[field->index()];
   }
 
   // Byte offset of the _inlined_string_donated_ array.
-  uint32_t InlinedStringDonatedOffset() const {
+  ui32 InlinedStringDonatedOffset() const {
     GOOGLE_DCHECK(HasInlinedString());
-    return static_cast<uint32_t>(inlined_string_donated_offset_);
+    return static_cast<ui32>(inlined_string_donated_offset_);
   }
 
   // The offset of the InternalMetadataWithArena member.
   // For Lite this will actually be an InternalMetadataWithArenaLite.
   // The schema doesn't contain enough information to distinguish between
   // these two cases.
-  uint32_t GetMetadataOffset() const {
-    return static_cast<uint32_t>(metadata_offset_);
+  ui32 GetMetadataOffset() const {
+    return static_cast<ui32>(metadata_offset_);
   }
 
   // Whether this message has an ExtensionSet.
   bool HasExtensionSet() const { return extensions_offset_ != -1; }
 
   // The offset of the ExtensionSet in this message.
-  uint32_t GetExtensionSetOffset() const {
+  ui32 GetExtensionSetOffset() const {
     GOOGLE_DCHECK(HasExtensionSet());
-    return static_cast<uint32_t>(extensions_offset_);
+    return static_cast<ui32>(extensions_offset_);
   }
 
   // The off set of WeakFieldMap when the message contains weak fields.
@@ -252,20 +252,20 @@ struct ReflectionSchema {
   //   ReflectionSchema schema = {a, b, c, d, e, ...};
   // private:
   const Message* default_instance_;
-  const uint32_t* offsets_;
-  const uint32_t* has_bit_indices_;
+  const ui32* offsets_;
+  const ui32* has_bit_indices_;
   int has_bits_offset_;
   int metadata_offset_;
   int extensions_offset_;
   int oneof_case_offset_;
   int object_size_;
   int weak_field_map_offset_;
-  const uint32_t* inlined_string_indices_;
+  const ui32* inlined_string_indices_;
   int inlined_string_donated_offset_;
 
   // We tag offset values to provide additional data about fields (such as
   // "unused" or "lazy" or "inlined").
-  static uint32_t OffsetValue(uint32_t v, FieldDescriptor::Type type) {
+  static ui32 OffsetValue(ui32 v, FieldDescriptor::Type type) {
     if (type == FieldDescriptor::TYPE_MESSAGE ||
         type == FieldDescriptor::TYPE_STRING ||
         type == FieldDescriptor::TYPE_BYTES) {
@@ -274,7 +274,7 @@ struct ReflectionSchema {
     return v & 0x7FFFFFFFu;
   }
 
-  static bool Inlined(uint32_t v, FieldDescriptor::Type type) {
+  static bool Inlined(ui32 v, FieldDescriptor::Type type) {
     if (type == FieldDescriptor::TYPE_STRING ||
         type == FieldDescriptor::TYPE_BYTES) {
       return (v & 1u) != 0u;
@@ -292,9 +292,9 @@ struct ReflectionSchema {
 // EXPERIMENTAL: these are changing rapidly, and may completely disappear
 // or merge with ReflectionSchema.
 struct MigrationSchema {
-  int32_t offsets_index;
-  int32_t has_bit_indices_index;
-  int32_t inlined_string_indices_index;
+  i32 offsets_index;
+  i32 has_bit_indices_index;
+  i32 inlined_string_indices_index;
   int object_size;
 };
 
@@ -313,7 +313,7 @@ struct PROTOBUF_EXPORT DescriptorTable {
   int num_messages;
   const MigrationSchema* schemas;
   const Message* const* default_instances;
-  const uint32_t* offsets;
+  const ui32* offsets;
   // update the following descriptor arrays.
   Metadata* file_level_metadata;
   const EnumDescriptor** file_level_enum_descriptors;
@@ -345,8 +345,8 @@ Metadata PROTOBUF_EXPORT AssignDescriptors(const DescriptorTable* (*table)(),
 
 // These cannot be in lite so we put them in the reflection.
 PROTOBUF_EXPORT void UnknownFieldSetSerializer(const uint8_t* base,
-                                               uint32_t offset, uint32_t tag,
-                                               uint32_t has_offset,
+                                               ui32 offset, ui32 tag,
+                                               ui32 has_offset,
                                                io::CodedOutputStream* output);
 
 struct PROTOBUF_EXPORT AddDescriptorsRunner {
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven.cc b/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven.cc
index 71ee647565..14ad6f3d95 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven.cc
@@ -45,7 +45,7 @@ namespace internal {
 
 namespace {
 
-UnknownFieldSet* MutableUnknownFields(MessageLite* msg, int64_t arena_offset) {
+UnknownFieldSet* MutableUnknownFields(MessageLite* msg, i64 arena_offset) {
   return Raw<InternalMetadata>(msg, arena_offset)
       ->mutable_unknown_fields<UnknownFieldSet>();
 }
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven.h b/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven.h
index 178a0c1c6a..933030abc1 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven.h
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven.h
@@ -81,13 +81,13 @@ enum ProcessingTypes {
 static_assert(TYPE_MAP < kRepeatedMask, "Invalid enum");
 
 struct PROTOBUF_EXPORT FieldMetadata {
-  uint32_t offset;  // offset of this field in the struct
-  uint32_t tag;     // field * 8 + wire_type
+  ui32 offset;  // offset of this field in the struct
+  ui32 tag;     // field * 8 + wire_type
   // byte offset * 8 + bit_offset;
   // if the high bit is set then this is the byte offset of the oneof_case
   // for this field.
-  uint32_t has_offset;
-  uint32_t type;    // the type of this field.
+  ui32 has_offset;
+  ui32 type;    // the type of this field.
   const void* ptr;  // auxiliary data
 
   // From the serializer point of view each fundamental type can occur in
@@ -122,10 +122,10 @@ struct PROTOBUF_EXPORT FieldMetadata {
 // Additional data, needed for some types, is stored in
 // AuxiliaryParseTableField.
 struct ParseTableField {
-  uint32_t offset;
+  ui32 offset;
   // The presence_index ordinarily represents a has_bit index, but for fields
   // inside a oneof it represents the index in _oneof_case_.
-  uint32_t presence_index;
+  ui32 presence_index;
   unsigned char normal_wiretype;
   unsigned char packed_wiretype;
 
@@ -187,10 +187,10 @@ struct ParseTable {
   // TODO(ckennelly): Do something with this padding.
 
   // TODO(ckennelly): Vet these for sign extension.
-  int64_t has_bits_offset;
-  int64_t oneof_case_offset;
-  int64_t extension_offset;
-  int64_t arena_offset;
+  i64 has_bits_offset;
+  i64 oneof_case_offset;
+  i64 extension_offset;
+  i64 arena_offset;
 
   // ExplicitlyInitialized<T> -> T requires a reinterpret_cast, which prevents
   // the tables from being constructed as a constexpr.  We use void to avoid
@@ -248,7 +248,7 @@ struct SerializationTable {
 
 PROTOBUF_EXPORT void SerializeInternal(const uint8_t* base,
                                        const FieldMetadata* table,
-                                       int32_t num_fields,
+                                       i32 num_fields,
                                        io::CodedOutputStream* output);
 
 inline void TableSerialize(const MessageLite& msg,
@@ -260,7 +260,7 @@ inline void TableSerialize(const MessageLite& msg,
   // TODO(gerbens) This skips the first test if we could use the fast
   // array serialization path, we should make this
   // int cached_size =
-  //    *reinterpret_cast<const int32_t*>(base + field_table->offset);
+  //    *reinterpret_cast<const i32*>(base + field_table->offset);
   // SerializeWithCachedSize(msg, field_table + 1, num_fields, cached_size, ...)
   // But we keep conformance with the old way for now.
   SerializeInternal(base, field_table + 1, num_fields, output);
@@ -268,7 +268,7 @@ inline void TableSerialize(const MessageLite& msg,
 
 PROTOBUF_EXPORT uint8_t* SerializeInternalToArray(const uint8_t* base,
                                   const FieldMetadata* table,
-                                  int32_t num_fields, bool is_deterministic,
+                                  i32 num_fields, bool is_deterministic,
                                   uint8_t* buffer);
 
 inline uint8_t* TableSerializeToArray(const MessageLite& msg,
@@ -306,8 +306,8 @@ struct CompareMapKey {
 };
 
 template <typename MapFieldType, const SerializationTable* table>
-void MapFieldSerializer(const uint8_t* base, uint32_t offset, uint32_t tag,
-                        uint32_t has_offset, io::CodedOutputStream* output) {
+void MapFieldSerializer(const uint8_t* base, ui32 offset, ui32 tag,
+                        ui32 has_offset, io::CodedOutputStream* output) {
   typedef MapEntryHelper<typename MapFieldType::EntryTypeTrait> Entry;
   typedef typename MapFieldType::MapType::const_iterator Iter;
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven_lite.cc b/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven_lite.cc
index 9bcdde5cee..fca8a57079 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven_lite.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven_lite.cc
@@ -43,7 +43,7 @@ namespace internal {
 
 namespace {
 
-TProtoStringType* MutableUnknownFields(MessageLite* msg, int64_t arena_offset) {
+TProtoStringType* MutableUnknownFields(MessageLite* msg, i64 arena_offset) {
   return Raw<InternalMetadata>(msg, arena_offset)
       ->mutable_unknown_fields<TProtoStringType>();
 }
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven_lite.h b/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven_lite.h
index 78c9bb6dd4..0c3bc16600 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven_lite.h
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_table_driven_lite.h
@@ -70,18 +70,18 @@ enum Cardinality {
 };
 
 template <typename Type>
-inline Type* Raw(MessageLite* msg, int64_t offset) {
+inline Type* Raw(MessageLite* msg, i64 offset) {
   return reinterpret_cast<Type*>(reinterpret_cast<uint8_t*>(msg) + offset);
 }
 
 template <typename Type>
-inline const Type* Raw(const MessageLite* msg, int64_t offset) {
+inline const Type* Raw(const MessageLite* msg, i64 offset) {
   return reinterpret_cast<const Type*>(reinterpret_cast<const uint8_t*>(msg) +
                                        offset);
 }
 
 inline ExtensionSet* GetExtensionSet(MessageLite* msg,
-                                     int64_t extension_offset) {
+                                     i64 extension_offset) {
   if (extension_offset == -1) {
     return NULL;
   }
@@ -90,7 +90,7 @@ inline ExtensionSet* GetExtensionSet(MessageLite* msg,
 }
 
 template <typename Type>
-inline Type* AddField(MessageLite* msg, int64_t offset) {
+inline Type* AddField(MessageLite* msg, i64 offset) {
   static_assert(std::is_trivial<Type>::value ||
                     std::is_same<Type, InlinedStringField>::value,
                 "Do not assign");
@@ -100,7 +100,7 @@ inline Type* AddField(MessageLite* msg, int64_t offset) {
 }
 
 template <>
-inline TProtoStringType* AddField<TProtoStringType>(MessageLite* msg, int64_t offset) {
+inline TProtoStringType* AddField<TProtoStringType>(MessageLite* msg, i64 offset) {
   RepeatedPtrField<TProtoStringType>* repeated =
       Raw<RepeatedPtrField<TProtoStringType>>(msg, offset);
   return repeated->Add();
@@ -108,35 +108,35 @@ inline TProtoStringType* AddField<TProtoStringType>(MessageLite* msg, int64_t of
 
 
 template <typename Type>
-inline void AddField(MessageLite* msg, int64_t offset, Type value) {
+inline void AddField(MessageLite* msg, i64 offset, Type value) {
   static_assert(std::is_trivial<Type>::value, "Do not assign");
   *AddField<Type>(msg, offset) = value;
 }
 
-inline void SetBit(uint32_t* has_bits, uint32_t has_bit_index) {
+inline void SetBit(ui32* has_bits, ui32 has_bit_index) {
   GOOGLE_DCHECK(has_bits != nullptr);
 
-  uint32_t mask = static_cast<uint32_t>(1u) << (has_bit_index % 32);
+  ui32 mask = static_cast<ui32>(1u) << (has_bit_index % 32);
   has_bits[has_bit_index / 32u] |= mask;
 }
 
 template <typename Type>
-inline Type* MutableField(MessageLite* msg, uint32_t* has_bits,
-                          uint32_t has_bit_index, int64_t offset) {
+inline Type* MutableField(MessageLite* msg, ui32* has_bits,
+                          ui32 has_bit_index, i64 offset) {
   SetBit(has_bits, has_bit_index);
   return Raw<Type>(msg, offset);
 }
 
 template <typename Type>
-inline void SetField(MessageLite* msg, uint32_t* has_bits,
-                     uint32_t has_bit_index, int64_t offset, Type value) {
+inline void SetField(MessageLite* msg, ui32* has_bits,
+                     ui32 has_bit_index, i64 offset, Type value) {
   static_assert(std::is_trivial<Type>::value, "Do not assign");
   *MutableField<Type>(msg, has_bits, has_bit_index, offset) = value;
 }
 
 template <typename Type>
-inline void SetOneofField(MessageLite* msg, uint32_t* oneof_case,
-                          uint32_t oneof_case_index, int64_t offset,
+inline void SetOneofField(MessageLite* msg, ui32* oneof_case,
+                          ui32 oneof_case_index, i64 offset,
                           int field_number, Type value) {
   oneof_case[oneof_case_index] = field_number;
   *Raw<Type>(msg, offset) = value;
@@ -179,9 +179,9 @@ inline void ClearOneofField(const ParseTableField& field, Arena* arena,
 template <ProcessingType field_type>
 inline void ResetOneofField(const ParseTable& table, int field_number,
                             Arena* arena, MessageLite* msg,
-                            uint32_t* oneof_case, int64_t offset,
+                            ui32* oneof_case, i64 offset,
                             const void* default_ptr) {
-  if (static_cast<int64_t>(*oneof_case) == field_number) {
+  if (static_cast<i64>(*oneof_case) == field_number) {
     // The oneof is already set to the right type, so there is no need to clear
     // it.
     return;
@@ -213,8 +213,8 @@ inline void ResetOneofField(const ParseTable& table, int field_number,
 template <typename UnknownFieldHandler, Cardinality cardinality,
           bool is_string_type, StringType ctype>
 static inline bool HandleString(io::CodedInputStream* input, MessageLite* msg,
-                                Arena* arena, uint32_t* has_bits,
-                                uint32_t has_bit_index, int64_t offset,
+                                Arena* arena, ui32* has_bits,
+                                ui32 has_bit_index, i64 offset,
                                 const void* default_ptr,
                                 const char* field_name) {
   StringPiece utf8_string_data;
@@ -300,8 +300,8 @@ static inline bool HandleString(io::CodedInputStream* input, MessageLite* msg,
 
 template <typename UnknownFieldHandler, Cardinality cardinality>
 inline bool HandleEnum(const ParseTable& table, io::CodedInputStream* input,
-                       MessageLite* msg, uint32_t* presence,
-                       uint32_t presence_index, int64_t offset, uint32_t tag,
+                       MessageLite* msg, ui32* presence,
+                       ui32 presence_index, i64 offset, ui32 tag,
                        int field_number) {
   int value;
   if (PROTOBUF_PREDICT_FALSE(
@@ -366,7 +366,7 @@ class MergePartialFromCodedStreamHelper {
   }
 };
 
-template <typename UnknownFieldHandler, uint32_t kMaxTag>
+template <typename UnknownFieldHandler, ui32 kMaxTag>
 bool MergePartialFromCodedStreamInlined(MessageLite* msg,
                                         const ParseTable& table,
                                         io::CodedInputStream* input) {
@@ -375,11 +375,11 @@ bool MergePartialFromCodedStreamInlined(MessageLite* msg,
   //
   // TODO(ckennelly):  Make this a compile-time parameter with templates.
   GOOGLE_DCHECK_GE(table.has_bits_offset, 0);
-  uint32_t* has_bits = Raw<uint32_t>(msg, table.has_bits_offset);
+  ui32* has_bits = Raw<ui32>(msg, table.has_bits_offset);
   GOOGLE_DCHECK(has_bits != NULL);
 
   while (true) {
-    uint32_t tag = input->ReadTagWithCutoffNoLastTag(kMaxTag).first;
+    ui32 tag = input->ReadTagWithCutoffNoLastTag(kMaxTag).first;
     const WireFormatLite::WireType wire_type =
         WireFormatLite::GetTagWireType(tag);
     const int field_number = WireFormatLite::GetTagFieldNumber(tag);
@@ -407,8 +407,8 @@ bool MergePartialFromCodedStreamInlined(MessageLite* msg,
     const ParseTableField* data = table.fields + field_number;
 
     // TODO(ckennelly): Avoid sign extension
-    const int64_t presence_index = data->presence_index;
-    const int64_t offset = data->offset;
+    const i64 presence_index = data->presence_index;
+    const i64 offset = data->offset;
     const unsigned char processing_type = data->processing_type;
 
     if (data->normal_wiretype == static_cast<unsigned char>(wire_type)) {
@@ -434,7 +434,7 @@ bool MergePartialFromCodedStreamInlined(MessageLite* msg,
     break;                                                                     \
   }                                                                            \
   case (WireFormatLite::TYPE_##TYPE) | kOneofMask: {                           \
-    uint32_t* oneof_case = Raw<uint32_t>(msg, table.oneof_case_offset);        \
+    ui32* oneof_case = Raw<ui32>(msg, table.oneof_case_offset);        \
     CPPTYPE value;                                                             \
     if (PROTOBUF_PREDICT_FALSE(                                                \
             (!WireFormatLite::ReadPrimitive<                                   \
@@ -448,17 +448,17 @@ bool MergePartialFromCodedStreamInlined(MessageLite* msg,
     break;                                                                     \
   }
 
-        HANDLE_TYPE(INT32, int32_t)
-        HANDLE_TYPE(INT64, int64_t)
-        HANDLE_TYPE(SINT32, int32_t)
-        HANDLE_TYPE(SINT64, int64_t)
-        HANDLE_TYPE(UINT32, uint32_t)
-        HANDLE_TYPE(UINT64, uint64_t)
+        HANDLE_TYPE(INT32, i32)
+        HANDLE_TYPE(INT64, i64)
+        HANDLE_TYPE(SINT32, i32)
+        HANDLE_TYPE(SINT64, i64)
+        HANDLE_TYPE(UINT32, ui32)
+        HANDLE_TYPE(UINT64, ui64)
 
-        HANDLE_TYPE(FIXED32, uint32_t)
-        HANDLE_TYPE(FIXED64, uint64_t)
-        HANDLE_TYPE(SFIXED32, int32_t)
-        HANDLE_TYPE(SFIXED64, int64_t)
+        HANDLE_TYPE(FIXED32, ui32)
+        HANDLE_TYPE(FIXED64, ui64)
+        HANDLE_TYPE(SFIXED32, i32)
+        HANDLE_TYPE(SFIXED64, i64)
 
         HANDLE_TYPE(FLOAT, float)
         HANDLE_TYPE(DOUBLE, double)
@@ -505,7 +505,7 @@ bool MergePartialFromCodedStreamInlined(MessageLite* msg,
 #endif  // !GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
         {
           Arena* const arena = msg->GetArena();
-          uint32_t* oneof_case = Raw<uint32_t>(msg, table.oneof_case_offset);
+          ui32* oneof_case = Raw<ui32>(msg, table.oneof_case_offset);
           const void* default_ptr = table.aux[field_number].strings.default_ptr;
 
           ResetOneofField<ProcessingType_STRING>(
@@ -572,7 +572,7 @@ bool MergePartialFromCodedStreamInlined(MessageLite* msg,
         }
         case (WireFormatLite::TYPE_STRING) | kOneofMask: {
           Arena* const arena = msg->GetArena();
-          uint32_t* oneof_case = Raw<uint32_t>(msg, table.oneof_case_offset);
+          ui32* oneof_case = Raw<ui32>(msg, table.oneof_case_offset);
           const void* default_ptr = table.aux[field_number].strings.default_ptr;
           const char* field_name = table.aux[field_number].strings.field_name;
 
@@ -609,7 +609,7 @@ bool MergePartialFromCodedStreamInlined(MessageLite* msg,
           break;
         }
         case WireFormatLite::TYPE_ENUM | kOneofMask: {
-          uint32_t* oneof_case = Raw<uint32_t>(msg, table.oneof_case_offset);
+          ui32* oneof_case = Raw<ui32>(msg, table.oneof_case_offset);
           if (PROTOBUF_PREDICT_FALSE(
                   (!HandleEnum<UnknownFieldHandler, Cardinality_ONEOF>(
                       table, input, msg, oneof_case, presence_index, offset,
@@ -699,7 +699,7 @@ bool MergePartialFromCodedStreamInlined(MessageLite* msg,
         }
         case WireFormatLite::TYPE_MESSAGE | kOneofMask: {
           Arena* const arena = msg->GetArena();
-          uint32_t* oneof_case = Raw<uint32_t>(msg, table.oneof_case_offset);
+          ui32* oneof_case = Raw<ui32>(msg, table.oneof_case_offset);
           MessageLite** submsg_holder = Raw<MessageLite*>(msg, offset);
           ResetOneofField<ProcessingType_MESSAGE>(
               table, field_number, arena, msg, oneof_case + presence_index,
@@ -768,17 +768,17 @@ bool MergePartialFromCodedStreamInlined(MessageLite* msg,
     break;                                                                     \
   }
 
-        HANDLE_PACKED_TYPE(INT32, int32_t, Int32)
-        HANDLE_PACKED_TYPE(INT64, int64_t, Int64)
-        HANDLE_PACKED_TYPE(SINT32, int32_t, Int32)
-        HANDLE_PACKED_TYPE(SINT64, int64_t, Int64)
-        HANDLE_PACKED_TYPE(UINT32, uint32_t, UInt32)
-        HANDLE_PACKED_TYPE(UINT64, uint64_t, UInt64)
+        HANDLE_PACKED_TYPE(INT32, i32, Int32)
+        HANDLE_PACKED_TYPE(INT64, i64, Int64)
+        HANDLE_PACKED_TYPE(SINT32, i32, Int32)
+        HANDLE_PACKED_TYPE(SINT64, i64, Int64)
+        HANDLE_PACKED_TYPE(UINT32, ui32, UInt32)
+        HANDLE_PACKED_TYPE(UINT64, ui64, UInt64)
 
-        HANDLE_PACKED_TYPE(FIXED32, uint32_t, UInt32)
-        HANDLE_PACKED_TYPE(FIXED64, uint64_t, UInt64)
-        HANDLE_PACKED_TYPE(SFIXED32, int32_t, Int32)
-        HANDLE_PACKED_TYPE(SFIXED64, int64_t, Int64)
+        HANDLE_PACKED_TYPE(FIXED32, ui32, UInt32)
+        HANDLE_PACKED_TYPE(FIXED64, ui64, UInt64)
+        HANDLE_PACKED_TYPE(SFIXED32, i32, Int32)
+        HANDLE_PACKED_TYPE(SFIXED64, i64, Int64)
 
         HANDLE_PACKED_TYPE(FLOAT, float, Float)
         HANDLE_PACKED_TYPE(DOUBLE, double, Double)
@@ -790,7 +790,7 @@ bool MergePartialFromCodedStreamInlined(MessageLite* msg,
           // InternalMetadata) when all inputs in the repeated series
           // are valid, we implement our own parser rather than call
           // WireFormat::ReadPackedEnumPreserveUnknowns.
-          uint32_t length;
+          ui32 length;
           if (PROTOBUF_PREDICT_FALSE(!input->ReadVarint32(&length))) {
             return false;
           }
@@ -863,7 +863,7 @@ bool MergePartialFromCodedStreamImpl(MessageLite* msg, const ParseTable& table,
         msg, table, input);
   } else {
     return MergePartialFromCodedStreamInlined<
-        UnknownFieldHandler, std::numeric_limits<uint32_t>::max()>(msg, table,
+        UnknownFieldHandler, std::numeric_limits<ui32>::max()>(msg, table,
                                                                    input);
   }
 }
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_decl.h b/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_decl.h
index d294caa5df..389472ca69 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_decl.h
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_decl.h
@@ -52,8 +52,8 @@ namespace internal {
 struct TcFieldData {
   constexpr TcFieldData() : data(0) {}
   constexpr TcFieldData(uint16_t coded_tag, uint8_t hasbit_idx, uint16_t offset)
-      : data(static_cast<uint64_t>(offset) << 48 |
-             static_cast<uint64_t>(hasbit_idx) << 16 | coded_tag) {}
+      : data(static_cast<ui64>(offset) << 48 |
+             static_cast<ui64>(hasbit_idx) << 16 | coded_tag) {}
 
   template <typename TagType = uint16_t>
   TagType coded_tag() const {
@@ -62,7 +62,7 @@ struct TcFieldData {
   uint8_t hasbit_idx() const { return static_cast<uint8_t>(data >> 16); }
   uint16_t offset() const { return static_cast<uint16_t>(data >> 48); }
 
-  uint64_t data;
+  ui64 data;
 };
 
 struct TailCallParseTableBase;
@@ -77,12 +77,12 @@ typedef const char* (*TailCallParseFunc)(PROTOBUF_TC_PARAM_DECL);
 #endif
 
 // Base class for message-level table with info for the tail-call parser.
-struct alignas(uint64_t) TailCallParseTableBase {
+struct alignas(ui64) TailCallParseTableBase {
   // Common attributes for message layout:
   uint16_t has_bits_offset;
   uint16_t extension_offset;
-  uint32_t extension_range_low;
-  uint32_t extension_range_high;
+  ui32 extension_range_low;
+  ui32 extension_range_high;
   const MessageLite* default_instance;
 
   // Handler for fields which are not handled by table dispatch.
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_impl.h b/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_impl.h
index 6ea72d9bf3..159637cc3e 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_impl.h
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_impl.h
@@ -118,7 +118,7 @@ class TcParserBase {
       return table->fallback(PROTOBUF_TC_PARAM_PASS);
     }
     ptr += sizeof(TagType);
-    hasbits |= (uint64_t{1} << data.hasbit_idx());
+    hasbits |= (ui64{1} << data.hasbit_idx());
     auto& field = RefAt<FieldType*>(msg, data.offset());
     if (field == nullptr) {
       auto arena = ctx->data().arena;
@@ -175,12 +175,12 @@ class TcParserBase {
   }
 
   static inline PROTOBUF_ALWAYS_INLINE void SyncHasbits(
-      MessageLite* msg, uint64_t hasbits, const TailCallParseTableBase* table) {
-    const uint32_t has_bits_offset = table->has_bits_offset;
+      MessageLite* msg, ui64 hasbits, const TailCallParseTableBase* table) {
+    const ui32 has_bits_offset = table->has_bits_offset;
     if (has_bits_offset) {
       // Only the first 32 has-bits are updated. Nothing above those is stored,
       // but e.g. messages without has-bits update the upper bits.
-      RefAt<uint32_t>(msg, has_bits_offset) = static_cast<uint32_t>(hasbits);
+      RefAt<ui32>(msg, has_bits_offset) = static_cast<ui32>(hasbits);
     }
   }
 
@@ -217,14 +217,14 @@ class TcParserBase {
   if (PROTOBUF_PREDICT_FALSE(!(x))) return nullptr /* NOLINT */
 
     SyncHasbits(msg, hasbits, table);
-    uint32 tag;
+    ui32 tag;
     ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
     CHK_(ptr);
     if ((tag & 7) == WireFormatLite::WIRETYPE_END_GROUP || tag == 0) {
       ctx->SetLastTag(tag);
       return ptr;
     }
-    uint32_t num = tag >> 3;
+    ui32 num = tag >> 3;
     if (table->extension_range_low <= num &&
         num <= table->extension_range_high) {
       return RefAt<ExtensionSet>(msg, table->extension_offset)
@@ -244,7 +244,7 @@ class TcParserBase {
 // This is templated on lg2(table size), since dispatching depends upon the size
 // of the table. The template parameter avoids runtime overhead for computing
 // the table entry index.
-template <uint32_t kPowerOf2>
+template <ui32 kPowerOf2>
 struct TcParser final : TcParserBase {
   // Dispatch to the designated parse function
   inline PROTOBUF_ALWAYS_INLINE static const char* TagDispatch(
@@ -274,10 +274,10 @@ struct TcParser final : TcParserBase {
                                ParseContext* ctx,
                                const TailCallParseTableBase* table) {
     ScopedArenaSwap saved(msg, ctx);
-    const uint32_t has_bits_offset = table->has_bits_offset;
+    const ui32 has_bits_offset = table->has_bits_offset;
     while (!ctx->Done(&ptr)) {
-      uint64_t hasbits = 0;
-      if (has_bits_offset) hasbits = RefAt<uint32_t>(msg, has_bits_offset);
+      ui64 hasbits = 0;
+      if (has_bits_offset) hasbits = RefAt<ui32>(msg, has_bits_offset);
       ptr = TagDispatch(msg, ptr, ctx, table, hasbits, {});
       if (ptr == nullptr) break;
       if (ctx->LastTag() != 1) break;  // Ended on terminating tag
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_impl.inc b/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_impl.inc
index 8d38a513e2..7af615973d 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_impl.inc
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_tctable_impl.inc
@@ -39,48 +39,48 @@ PROTOBUF_TCT_EXTERN template const char *TcParser<2>::ParseLoop(::PROTOBUF_NAMES
 PROTOBUF_TCT_EXTERN template const char *TcParser<3>::ParseLoop(::PROTOBUF_NAMESPACE_ID::MessageLite*, char const*, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext*, ::PROTOBUF_NAMESPACE_ID::internal::TailCallParseTableBase const*);
 PROTOBUF_TCT_EXTERN template const char *TcParser<4>::ParseLoop(::PROTOBUF_NAMESPACE_ID::MessageLite*, char const*, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext*, ::PROTOBUF_NAMESPACE_ID::internal::TailCallParseTableBase const*);
 PROTOBUF_TCT_EXTERN template const char *TcParser<5>::ParseLoop(::PROTOBUF_NAMESPACE_ID::MessageLite*, char const*, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext*, ::PROTOBUF_NAMESPACE_ID::internal::TailCallParseTableBase const*);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedFixed<uint64_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedFixed<uint32_t, uint8_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<uint64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<uint64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<uint64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<uint64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<uint64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<uint64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<uint64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<uint32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<uint32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<uint32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<uint32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<uint32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<uint32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<uint32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<int64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<int64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<int64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<int64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<int64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<int64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<int64_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<int32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<int32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<int32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<int32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<int32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<int32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<int32_t, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularFixed<ui64, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularFixed<ui64, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularFixed<ui64, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularFixed<ui64, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularFixed<ui64, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedFixed<ui64, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedFixed<ui64, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularFixed<ui32, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularFixed<ui32, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularFixed<ui32, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularFixed<ui32, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularFixed<ui32, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedFixed<ui32, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedFixed<ui32, uint8_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<ui64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<ui64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<ui64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<ui64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<ui64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<ui64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<ui64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<ui32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<ui32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<ui32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<ui32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<ui32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<ui32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<ui32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<i64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<i64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<i64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<i64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<i64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<i64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<i64, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<i32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<i32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<i32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<i32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<i32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<i32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<i32, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
 PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<bool, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
 PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<bool, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
 PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<bool, uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
@@ -94,48 +94,48 @@ PROTOBUF_TCT_EXTERN template const char* TcParserBase::SingularString<uint8_t, :
 PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedString<uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kUtf8>(PROTOBUF_TC_PARAM_DECL);
 PROTOBUF_TCT_EXTERN template const char* TcParserBase::SingularString<uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kUtf8ValidateOnly>(PROTOBUF_TC_PARAM_DECL);
 PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedString<uint8_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kUtf8ValidateOnly>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedFixed<uint64_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedFixed<uint32_t, uint16_t>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<uint64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<uint64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<uint64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<uint64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<uint64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<uint64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<uint64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<uint32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<uint32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<uint32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<uint32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<uint32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<uint32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<uint32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<int64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<int64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<int64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<int64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<int64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<int64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<int64_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<int32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<int32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<int32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<int32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<int32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<int32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
-PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<int32_t, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularFixed<ui64, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularFixed<ui64, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularFixed<ui64, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularFixed<ui64, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularFixed<ui64, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedFixed<ui64, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedFixed<ui64, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularFixed<ui32, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularFixed<ui32, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularFixed<ui32, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularFixed<ui32, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularFixed<ui32, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedFixed<ui32, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedFixed<ui32, uint16_t>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<ui64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<ui64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<ui64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<ui64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<ui64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<ui64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<ui64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<ui32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<ui32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<ui32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<ui32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<ui32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<ui32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<ui32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<i64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<i64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<i64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<i64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<i64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<i64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<i64, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<i32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<i32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<i32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<4>::SingularVarint<i32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParser<5>::SingularVarint<i32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::RepeatedVarint<i32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
+PROTOBUF_TCT_EXTERN template const char* TcParserBase::PackedVarint<i32, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kZigZag>(PROTOBUF_TC_PARAM_DECL);
 PROTOBUF_TCT_EXTERN template const char* TcParser<1>::SingularVarint<bool, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
 PROTOBUF_TCT_EXTERN template const char* TcParser<2>::SingularVarint<bool, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
 PROTOBUF_TCT_EXTERN template const char* TcParser<3>::SingularVarint<bool, uint16_t, ::PROTOBUF_NAMESPACE_ID::internal::TcParserBase::kNoConversion>(PROTOBUF_TC_PARAM_DECL);
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_util.cc b/contrib/libs/protobuf/src/google/protobuf/generated_message_util.cc
index 4da3bff9ba..c6458275ca 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_util.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_util.cc
@@ -126,9 +126,9 @@ struct PrimitiveTypeHelper<WireFormatLite::TYPE_BOOL> {
 
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_INT32> {
-  typedef int32_t Type;
+  typedef i32 Type;
   static void Serialize(const void* ptr, io::CodedOutputStream* output) {
-    WireFormatLite::WriteInt32NoTag(Get<int32_t>(ptr), output);
+    WireFormatLite::WriteInt32NoTag(Get<i32>(ptr), output);
   }
   static uint8_t* SerializeToArray(const void* ptr, uint8_t* buffer) {
     return WireFormatLite::WriteInt32NoTagToArray(Get<Type>(ptr), buffer);
@@ -137,9 +137,9 @@ struct PrimitiveTypeHelper<WireFormatLite::TYPE_INT32> {
 
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_SINT32> {
-  typedef int32_t Type;
+  typedef i32 Type;
   static void Serialize(const void* ptr, io::CodedOutputStream* output) {
-    WireFormatLite::WriteSInt32NoTag(Get<int32_t>(ptr), output);
+    WireFormatLite::WriteSInt32NoTag(Get<i32>(ptr), output);
   }
   static uint8_t* SerializeToArray(const void* ptr, uint8_t* buffer) {
     return WireFormatLite::WriteSInt32NoTagToArray(Get<Type>(ptr), buffer);
@@ -148,9 +148,9 @@ struct PrimitiveTypeHelper<WireFormatLite::TYPE_SINT32> {
 
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_UINT32> {
-  typedef uint32_t Type;
+  typedef ui32 Type;
   static void Serialize(const void* ptr, io::CodedOutputStream* output) {
-    WireFormatLite::WriteUInt32NoTag(Get<uint32_t>(ptr), output);
+    WireFormatLite::WriteUInt32NoTag(Get<ui32>(ptr), output);
   }
   static uint8_t* SerializeToArray(const void* ptr, uint8_t* buffer) {
     return WireFormatLite::WriteUInt32NoTagToArray(Get<Type>(ptr), buffer);
@@ -158,9 +158,9 @@ struct PrimitiveTypeHelper<WireFormatLite::TYPE_UINT32> {
 };
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_INT64> {
-  typedef int64_t Type;
+  typedef i64 Type;
   static void Serialize(const void* ptr, io::CodedOutputStream* output) {
-    WireFormatLite::WriteInt64NoTag(Get<int64_t>(ptr), output);
+    WireFormatLite::WriteInt64NoTag(Get<i64>(ptr), output);
   }
   static uint8_t* SerializeToArray(const void* ptr, uint8_t* buffer) {
     return WireFormatLite::WriteInt64NoTagToArray(Get<Type>(ptr), buffer);
@@ -169,9 +169,9 @@ struct PrimitiveTypeHelper<WireFormatLite::TYPE_INT64> {
 
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_SINT64> {
-  typedef int64_t Type;
+  typedef i64 Type;
   static void Serialize(const void* ptr, io::CodedOutputStream* output) {
-    WireFormatLite::WriteSInt64NoTag(Get<int64_t>(ptr), output);
+    WireFormatLite::WriteSInt64NoTag(Get<i64>(ptr), output);
   }
   static uint8_t* SerializeToArray(const void* ptr, uint8_t* buffer) {
     return WireFormatLite::WriteSInt64NoTagToArray(Get<Type>(ptr), buffer);
@@ -179,9 +179,9 @@ struct PrimitiveTypeHelper<WireFormatLite::TYPE_SINT64> {
 };
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_UINT64> {
-  typedef uint64_t Type;
+  typedef ui64 Type;
   static void Serialize(const void* ptr, io::CodedOutputStream* output) {
-    WireFormatLite::WriteUInt64NoTag(Get<uint64_t>(ptr), output);
+    WireFormatLite::WriteUInt64NoTag(Get<ui64>(ptr), output);
   }
   static uint8_t* SerializeToArray(const void* ptr, uint8_t* buffer) {
     return WireFormatLite::WriteUInt64NoTagToArray(Get<Type>(ptr), buffer);
@@ -190,9 +190,9 @@ struct PrimitiveTypeHelper<WireFormatLite::TYPE_UINT64> {
 
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_FIXED32> {
-  typedef uint32_t Type;
+  typedef ui32 Type;
   static void Serialize(const void* ptr, io::CodedOutputStream* output) {
-    WireFormatLite::WriteFixed32NoTag(Get<uint32_t>(ptr), output);
+    WireFormatLite::WriteFixed32NoTag(Get<ui32>(ptr), output);
   }
   static uint8_t* SerializeToArray(const void* ptr, uint8_t* buffer) {
     return WireFormatLite::WriteFixed32NoTagToArray(Get<Type>(ptr), buffer);
@@ -201,9 +201,9 @@ struct PrimitiveTypeHelper<WireFormatLite::TYPE_FIXED32> {
 
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_FIXED64> {
-  typedef uint64_t Type;
+  typedef ui64 Type;
   static void Serialize(const void* ptr, io::CodedOutputStream* output) {
-    WireFormatLite::WriteFixed64NoTag(Get<uint64_t>(ptr), output);
+    WireFormatLite::WriteFixed64NoTag(Get<ui64>(ptr), output);
   }
   static uint8_t* SerializeToArray(const void* ptr, uint8_t* buffer) {
     return WireFormatLite::WriteFixed64NoTagToArray(Get<Type>(ptr), buffer);
@@ -217,12 +217,12 @@ struct PrimitiveTypeHelper<WireFormatLite::TYPE_ENUM>
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_SFIXED32>
     : PrimitiveTypeHelper<WireFormatLite::TYPE_FIXED32> {
-  typedef int32_t Type;
+  typedef i32 Type;
 };
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_SFIXED64>
     : PrimitiveTypeHelper<WireFormatLite::TYPE_FIXED64> {
-  typedef int64_t Type;
+  typedef i64 Type;
 };
 template <>
 struct PrimitiveTypeHelper<WireFormatLite::TYPE_FLOAT>
@@ -270,12 +270,12 @@ void SerializeTo(const void* ptr, O* output) {
 }
 
 template <typename O>
-void WriteTagTo(uint32_t tag, O* output) {
+void WriteTagTo(ui32 tag, O* output) {
   SerializeTo<WireFormatLite::TYPE_UINT32>(&tag, output);
 }
 
 template <typename O>
-void WriteLengthTo(uint32_t length, O* output) {
+void WriteLengthTo(ui32 length, O* output) {
   SerializeTo<WireFormatLite::TYPE_UINT32>(&length, output);
 }
 
@@ -316,7 +316,7 @@ void SerializeMessageNoTable(const MessageLite* msg, ArrayOutput* output) {
 // Helper to branch to fast path if possible
 void SerializeMessageDispatch(const MessageLite& msg,
                               const FieldMetadata* field_table, int num_fields,
-                              int32_t cached_size,
+                              i32 cached_size,
                               io::CodedOutputStream* output) {
   const uint8_t* base = reinterpret_cast<const uint8_t*>(&msg);
   SerializeInternal(base, field_table, num_fields, output);
@@ -325,7 +325,7 @@ void SerializeMessageDispatch(const MessageLite& msg,
 // Helper to branch to fast path if possible
 void SerializeMessageDispatch(const MessageLite& msg,
                               const FieldMetadata* field_table, int num_fields,
-                              int32_t cached_size, ArrayOutput* output) {
+                              i32 cached_size, ArrayOutput* output) {
   const uint8_t* base = reinterpret_cast<const uint8_t*>(&msg);
   output->ptr = SerializeInternalToArray(base, field_table, num_fields,
                                          output->is_deterministic, output->ptr);
@@ -347,7 +347,7 @@ void SerializeMessageTo(const MessageLite* msg, const void* table_ptr,
   const FieldMetadata* field_table = table->field_table;
   const uint8_t* base = reinterpret_cast<const uint8_t*>(msg);
   int cached_size =
-      *reinterpret_cast<const int32_t*>(base + field_table->offset);
+      *reinterpret_cast<const i32*>(base + field_table->offset);
   WriteLengthTo(cached_size, output);
   int num_fields = table->num_fields - 1;
   SerializeMessageDispatch(*msg, field_table + 1, num_fields, cached_size,
@@ -368,7 +368,7 @@ void SerializeGroupTo(const MessageLite* msg, const void* table_ptr,
   const FieldMetadata* field_table = table->field_table;
   const uint8_t* base = reinterpret_cast<const uint8_t*>(msg);
   int cached_size =
-      *reinterpret_cast<const int32_t*>(base + field_table->offset);
+      *reinterpret_cast<const i32*>(base + field_table->offset);
   int num_fields = table->num_fields - 1;
   SerializeMessageDispatch(*msg, field_table + 1, num_fields, cached_size,
                            output);
@@ -628,7 +628,7 @@ bool IsNull<FieldMetadata::kInlinedType>(const void* ptr) {
 
 void SerializeInternal(const uint8_t* base,
                        const FieldMetadata* field_metadata_table,
-                       int32_t num_fields, io::CodedOutputStream* output) {
+                       i32 num_fields, io::CodedOutputStream* output) {
   SpecialSerializer func = nullptr;
   for (int i = 0; i < num_fields; i++) {
     const FieldMetadata& field_metadata = field_metadata_table[i];
@@ -670,7 +670,7 @@ void SerializeInternal(const uint8_t* base,
 
 uint8_t* SerializeInternalToArray(const uint8_t* base,
                                   const FieldMetadata* field_metadata_table,
-                                  int32_t num_fields, bool is_deterministic,
+                                  i32 num_fields, bool is_deterministic,
                                   uint8_t* buffer) {
   ArrayOutput array_output = {buffer, is_deterministic};
   ArrayOutput* output = &array_output;
@@ -719,14 +719,14 @@ uint8_t* SerializeInternalToArray(const uint8_t* base,
 #undef SERIALIZERS_FOR_TYPE
 
 void ExtensionSerializer(const MessageLite* extendee, const uint8_t* ptr,
-                         uint32_t offset, uint32_t tag, uint32_t has_offset,
+                         ui32 offset, ui32 tag, ui32 has_offset,
                          io::CodedOutputStream* output) {
   reinterpret_cast<const ExtensionSet*>(ptr + offset)
       ->SerializeWithCachedSizes(extendee, tag, has_offset, output);
 }
 
-void UnknownFieldSerializerLite(const uint8_t* ptr, uint32_t offset,
-                                uint32_t tag, uint32_t has_offset,
+void UnknownFieldSerializerLite(const uint8_t* ptr, ui32 offset,
+                                ui32 tag, ui32 has_offset,
                                 io::CodedOutputStream* output) {
   output->WriteString(
       reinterpret_cast<const InternalMetadata*>(ptr + offset)
diff --git a/contrib/libs/protobuf/src/google/protobuf/generated_message_util.h b/contrib/libs/protobuf/src/google/protobuf/generated_message_util.h
index 65139d032a..a1f6c2169c 100644
--- a/contrib/libs/protobuf/src/google/protobuf/generated_message_util.h
+++ b/contrib/libs/protobuf/src/google/protobuf/generated_message_util.h
@@ -132,28 +132,28 @@ bool AllAreInitializedWeak(const RepeatedPtrField<T>& t) {
   return true;
 }
 
-inline bool IsPresent(const void* base, uint32_t hasbit) {
-  const uint32_t* has_bits_array = static_cast<const uint32_t*>(base);
+inline bool IsPresent(const void* base, ui32 hasbit) {
+  const ui32* has_bits_array = static_cast<const ui32*>(base);
   return (has_bits_array[hasbit / 32] & (1u << (hasbit & 31))) != 0;
 }
 
-inline bool IsOneofPresent(const void* base, uint32_t offset, uint32_t tag) {
-  const uint32_t* oneof = reinterpret_cast<const uint32_t*>(
+inline bool IsOneofPresent(const void* base, ui32 offset, ui32 tag) {
+  const ui32* oneof = reinterpret_cast<const ui32*>(
       static_cast<const uint8_t*>(base) + offset);
   return *oneof == tag >> 3;
 }
 
-typedef void (*SpecialSerializer)(const uint8_t* base, uint32_t offset,
-                                  uint32_t tag, uint32_t has_offset,
+typedef void (*SpecialSerializer)(const uint8_t* base, ui32 offset,
+                                  ui32 tag, ui32 has_offset,
                                   io::CodedOutputStream* output);
 
 PROTOBUF_EXPORT void ExtensionSerializer(const MessageLite* extendee,
-                                         const uint8_t* ptr, uint32_t offset,
-                                         uint32_t tag, uint32_t has_offset,
+                                         const uint8_t* ptr, ui32 offset,
+                                         ui32 tag, ui32 has_offset,
                                          io::CodedOutputStream* output);
 PROTOBUF_EXPORT void UnknownFieldSerializerLite(const uint8_t* base,
-                                                uint32_t offset, uint32_t tag,
-                                                uint32_t has_offset,
+                                                ui32 offset, ui32 tag,
+                                                ui32 has_offset,
                                                 io::CodedOutputStream* output);
 
 PROTOBUF_EXPORT MessageLite* DuplicateIfNonNullInternal(MessageLite* message);
diff --git a/contrib/libs/protobuf/src/google/protobuf/has_bits.h b/contrib/libs/protobuf/src/google/protobuf/has_bits.h
index acbca689ed..1881a6f8ad 100644
--- a/contrib/libs/protobuf/src/google/protobuf/has_bits.h
+++ b/contrib/libs/protobuf/src/google/protobuf/has_bits.h
@@ -53,11 +53,11 @@ class HasBits {
     memset(has_bits_, 0, sizeof(has_bits_));
   }
 
-  PROTOBUF_NDEBUG_INLINE uint32_t& operator[](int index) {
+  PROTOBUF_NDEBUG_INLINE ui32& operator[](int index) {
     return has_bits_[index];
   }
 
-  PROTOBUF_NDEBUG_INLINE const uint32_t& operator[](int index) const {
+  PROTOBUF_NDEBUG_INLINE const ui32& operator[](int index) const {
     return has_bits_[index];
   }
 
@@ -76,7 +76,7 @@ class HasBits {
   bool empty() const;
 
  private:
-  uint32_t has_bits_[doublewords];
+  ui32 has_bits_[doublewords];
 };
 
 template <>
diff --git a/contrib/libs/protobuf/src/google/protobuf/inlined_string_field.cc b/contrib/libs/protobuf/src/google/protobuf/inlined_string_field.cc
index 62c623366c..d0db3f6cc8 100644
--- a/contrib/libs/protobuf/src/google/protobuf/inlined_string_field.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/inlined_string_field.cc
@@ -47,8 +47,8 @@ namespace internal {
 
 TProtoStringType* InlinedStringField::Mutable(const LazyString& /*default_value*/,
                                          Arena* arena, bool donated,
-                                         uint32_t* donating_states,
-                                         uint32_t mask) {
+                                         ui32* donating_states,
+                                         ui32 mask) {
   if (arena == nullptr || !donated) {
     return UnsafeMutablePointer();
   }
@@ -57,8 +57,8 @@ TProtoStringType* InlinedStringField::Mutable(const LazyString& /*default_value*
 
 TProtoStringType* InlinedStringField::Mutable(ArenaStringPtr::EmptyDefault,
                                          Arena* arena, bool donated,
-                                         uint32_t* donating_states,
-                                         uint32_t mask) {
+                                         ui32* donating_states,
+                                         ui32 mask) {
   if (arena == nullptr || !donated) {
     return UnsafeMutablePointer();
   }
@@ -67,21 +67,21 @@ TProtoStringType* InlinedStringField::Mutable(ArenaStringPtr::EmptyDefault,
 
 TProtoStringType* InlinedStringField::MutableSlow(::google::protobuf::Arena* arena,
                                              bool donated,
-                                             uint32_t* donating_states,
-                                             uint32_t mask) {
+                                             ui32* donating_states,
+                                             ui32 mask) {
   return UnsafeMutablePointer();
 }
 
 void InlinedStringField::SetAllocated(const TProtoStringType* default_value,
                                       TProtoStringType* value, Arena* arena,
-                                      bool donated, uint32_t* donating_states,
-                                      uint32_t mask) {
+                                      bool donated, ui32* donating_states,
+                                      ui32 mask) {
   SetAllocatedNoArena(default_value, value);
 }
 
 void InlinedStringField::Set(const TProtoStringType* default_value,
                              TProtoStringType&& value, Arena* arena, bool donated,
-                             uint32_t* donating_states, uint32_t mask) {
+                             ui32* donating_states, ui32 mask) {
   SetNoArena(default_value, std::move(value));
 }
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/inlined_string_field.h b/contrib/libs/protobuf/src/google/protobuf/inlined_string_field.h
index 6b8bdc73b9..8fc9d3e697 100644
--- a/contrib/libs/protobuf/src/google/protobuf/inlined_string_field.h
+++ b/contrib/libs/protobuf/src/google/protobuf/inlined_string_field.h
@@ -121,7 +121,7 @@ class PROTOBUF_EXPORT InlinedStringField {
   ~InlinedStringField() { Destruct(); }
 
   // Lvalue Set. To save space, we pack the donating states of multiple
-  // InlinedStringFields into an uint32_t `donating_states`. The `mask`
+  // InlinedStringFields into an ui32 `donating_states`. The `mask`
   // indicates the position of the bit for this InlinedStringField. `donated` is
   // whether this field is donated.
   //
@@ -131,8 +131,8 @@ class PROTOBUF_EXPORT InlinedStringField {
   //
   // This method never changes the `donating_states`.
   void Set(const TProtoStringType* default_value, ConstStringParam value,
-           Arena* arena, bool donated, uint32_t* /*donating_states*/,
-           uint32_t /*mask*/) {
+           Arena* arena, bool donated, ui32* /*donating_states*/,
+           ui32 /*mask*/) {
     (void)arena;
     (void)donated;
     SetNoArena(default_value, value);
@@ -141,17 +141,17 @@ class PROTOBUF_EXPORT InlinedStringField {
   // Rvalue Set. If this field is donated, this method will undonate this field
   // by mutating the `donating_states` according to `mask`.
   void Set(const TProtoStringType* default_value, TProtoStringType&& value, Arena* arena,
-           bool donated, uint32_t* donating_states, uint32_t mask);
+           bool donated, ui32* donating_states, ui32 mask);
 
   template <typename FirstParam>
   void Set(FirstParam p1, const char* str, ::google::protobuf::Arena* arena, bool donated,
-           uint32_t* donating_states, uint32_t mask) {
+           ui32* donating_states, ui32 mask) {
     Set(p1, ConstStringParam(str), arena, donated, donating_states, mask);
   }
 
   template <typename FirstParam>
   void Set(FirstParam p1, const char* str, size_t size, ::google::protobuf::Arena* arena,
-           bool donated, uint32_t* donating_states, uint32_t mask) {
+           bool donated, ui32* donating_states, ui32 mask) {
     ConstStringParam sp{str, size};  // for string_view and `const string &`
     Set(p1, sp, arena, donated, donating_states, mask);
   }
@@ -159,22 +159,22 @@ class PROTOBUF_EXPORT InlinedStringField {
   template <typename FirstParam, typename RefWrappedType>
   void Set(FirstParam p1,
            std::reference_wrapper<RefWrappedType> const_string_ref,
-           ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
-           uint32_t mask) {
+           ::google::protobuf::Arena* arena, bool donated, ui32* donating_states,
+           ui32 mask) {
     Set(p1, const_string_ref.get(), arena, donated, donating_states, mask);
   }
 
   template <typename FirstParam, typename SecondParam>
   void SetBytes(FirstParam p1, SecondParam&& p2, ::google::protobuf::Arena* arena,
-                bool donated, uint32_t* donating_states, uint32_t mask) {
+                bool donated, ui32* donating_states, ui32 mask) {
     Set(p1, static_cast<SecondParam&&>(p2), arena, donated, donating_states,
         mask);
   }
 
   template <typename FirstParam>
   void SetBytes(FirstParam p1, const void* str, size_t size,
-                ::google::protobuf::Arena* arena, bool donated, uint32_t* donating_states,
-                uint32_t mask) {
+                ::google::protobuf::Arena* arena, bool donated, ui32* donating_states,
+                ui32 mask) {
     // Must work whether ConstStringParam is string_view or `const string &`
     ConstStringParam sp{static_cast<const char*>(str), size};
     Set(p1, sp, arena, donated, donating_states, mask);
@@ -194,9 +194,9 @@ class PROTOBUF_EXPORT InlinedStringField {
   // `donating_states` according to `mask`, and copies the content of the
   // original string to the returning string.
   TProtoStringType* Mutable(const LazyString& default_value, Arena* arena,
-                       bool donated, uint32_t* donating_states, uint32_t mask);
+                       bool donated, ui32* donating_states, ui32 mask);
   TProtoStringType* Mutable(ArenaStringPtr::EmptyDefault, Arena* arena, bool donated,
-                       uint32_t* donating_states, uint32_t mask);
+                       ui32* donating_states, ui32 mask);
 
   // Release returns a TProtoStringType* instance that is heap-allocated and is not
   // Own()'d by any arena. If the field is not set, this returns NULL. The
@@ -215,8 +215,8 @@ class PROTOBUF_EXPORT InlinedStringField {
   // If this field is donated, this method undonates this field by mutating the
   // `donating_states` according to `mask`.
   void SetAllocated(const TProtoStringType* default_value, TProtoStringType* value,
-                    Arena* arena, bool donated, uint32_t* donating_states,
-                    uint32_t mask);
+                    Arena* arena, bool donated, ui32* donating_states,
+                    ui32 mask);
 
   void SetAllocatedNoArena(const TProtoStringType* default_value,
                            TProtoStringType* value);
@@ -227,9 +227,9 @@ class PROTOBUF_EXPORT InlinedStringField {
   PROTOBUF_NDEBUG_INLINE void Swap(InlinedStringField* from,
                                    const TProtoStringType* default_value,
                                    Arena* arena, bool donated,
-                                   bool from_donated, uint32_t* donating_states,
-                                   uint32_t* from_donating_states,
-                                   uint32_t mask);
+                                   bool from_donated, ui32* donating_states,
+                                   ui32* from_donating_states,
+                                   ui32 mask);
 
   // Frees storage (if not on an arena).
   PROTOBUF_NDEBUG_INLINE void Destroy(const TProtoStringType* default_value,
@@ -275,7 +275,7 @@ class PROTOBUF_EXPORT InlinedStringField {
   alignas(TProtoStringType) char value_[sizeof(TProtoStringType)];
 
   TProtoStringType* MutableSlow(::google::protobuf::Arena* arena, bool donated,
-                           uint32_t* donating_states, uint32_t mask);
+                           ui32* donating_states, ui32 mask);
 
 
   // When constructed in an Arena, we want our destructor to be skipped.
@@ -345,8 +345,8 @@ inline void InlinedStringField::SetNoArena(const TProtoStringType* /*default_val
 
 inline void InlinedStringField::Swap(
     InlinedStringField* from, const TProtoStringType* /*default_value*/,
-    Arena* arena, bool donated, bool from_donated, uint32_t* donating_states,
-    uint32_t* from_donating_states, uint32_t mask) {
+    Arena* arena, bool donated, bool from_donated, ui32* donating_states,
+    ui32* from_donating_states, ui32 mask) {
 #if GOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE
   // If one is donated and the other is not, undonate the donated one.
   if (donated && !from_donated) {
diff --git a/contrib/libs/protobuf/src/google/protobuf/io/coded_stream.cc b/contrib/libs/protobuf/src/google/protobuf/io/coded_stream.cc
index 8c61bcbff7..1688c98121 100644
--- a/contrib/libs/protobuf/src/google/protobuf/io/coded_stream.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/io/coded_stream.cc
@@ -151,7 +151,7 @@ CodedInputStream::IncrementRecursionDepthAndPushLimit(int byte_limit) {
 }
 
 CodedInputStream::Limit CodedInputStream::ReadLengthAndPushLimit() {
-  uint32_t length;
+  ui32 length;
   return PushLimit(ReadVarint32(&length) ? length : 0);
 }
 
@@ -308,11 +308,11 @@ bool CodedInputStream::ReadStringFallback(TProtoStringType* buffer, int size) {
 }
 
 
-bool CodedInputStream::ReadLittleEndian32Fallback(uint32_t* value) {
+bool CodedInputStream::ReadLittleEndian32Fallback(ui32* value) {
   uint8_t bytes[sizeof(*value)];
 
   const uint8_t* ptr;
-  if (BufferSize() >= static_cast<int64_t>(sizeof(*value))) {
+  if (BufferSize() >= static_cast<i64>(sizeof(*value))) {
     // Fast path:  Enough bytes in the buffer to read directly.
     ptr = buffer_;
     Advance(sizeof(*value));
@@ -325,11 +325,11 @@ bool CodedInputStream::ReadLittleEndian32Fallback(uint32_t* value) {
   return true;
 }
 
-bool CodedInputStream::ReadLittleEndian64Fallback(uint64* value) {
+bool CodedInputStream::ReadLittleEndian64Fallback(ui64* value) {
   uint8_t bytes[sizeof(*value)];
 
   const uint8_t* ptr;
-  if (BufferSize() >= static_cast<int64_t>(sizeof(*value))) {
+  if (BufferSize() >= static_cast<i64>(sizeof(*value))) {
     // Fast path:  Enough bytes in the buffer to read directly.
     ptr = buffer_;
     Advance(sizeof(*value));
@@ -341,24 +341,6 @@ bool CodedInputStream::ReadLittleEndian64Fallback(uint64* value) {
   ReadLittleEndian64FromArray(ptr, value);
   return true;
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-bool CodedInputStream::ReadLittleEndian64Fallback(uint64_t* value) {
-  uint8_t bytes[sizeof(*value)];
-
-  const uint8_t* ptr;
-  if (BufferSize() >= static_cast<int64_t>(sizeof(*value))) {
-    // Fast path:  Enough bytes in the buffer to read directly.
-    ptr = buffer_;
-    Advance(sizeof(*value));
-  } else {
-    // Slow path:  Had to read past the end of the buffer.
-    if (!ReadRaw(bytes, sizeof(*value))) return false;
-    ptr = bytes;
-  }
-  ReadLittleEndian64FromArray(ptr, value);
-  return true;
-}
-#endif
 
 namespace {
 
@@ -366,11 +348,11 @@ namespace {
 // compile time, compiler can generate optimal code. For example, instead of
 // subtracting 0x80 at each iteration, it subtracts properly shifted mask once.
 template <size_t N>
-const uint8_t* DecodeVarint64KnownSize(const uint8_t* buffer, uint64_t* value) {
+const uint8_t* DecodeVarint64KnownSize(const uint8_t* buffer, ui64* value) {
   GOOGLE_DCHECK_GT(N, 0);
-  uint64_t result = static_cast<uint64_t>(buffer[N - 1]) << (7 * (N - 1));
+  ui64 result = static_cast<ui64>(buffer[N - 1]) << (7 * (N - 1));
   for (size_t i = 0, offset = 0; i < N - 1; i++, offset += 7) {
-    result += static_cast<uint64_t>(buffer[i] - 0x80) << offset;
+    result += static_cast<ui64>(buffer[i] - 0x80) << offset;
   }
   *value = result;
   return buffer + N;
@@ -381,18 +363,18 @@ const uint8_t* DecodeVarint64KnownSize(const uint8_t* buffer, uint64_t* value) {
 // part is buffer + (number of bytes read).  This function is always inlined,
 // so returning a pair is costless.
 PROTOBUF_ALWAYS_INLINE
-::std::pair<bool, const uint8_t*> ReadVarint32FromArray(uint32_t first_byte,
+::std::pair<bool, const uint8_t*> ReadVarint32FromArray(ui32 first_byte,
                                                       const uint8_t* buffer,
-                                                      uint32_t* value);
+                                                      ui32* value);
 inline ::std::pair<bool, const uint8_t*> ReadVarint32FromArray(
-    uint32_t first_byte, const uint8_t* buffer, uint32_t* value) {
+    ui32 first_byte, const uint8_t* buffer, ui32* value) {
   // Fast path:  We have enough bytes left in the buffer to guarantee that
   // this read won't cross the end, so we can skip the checks.
   GOOGLE_DCHECK_EQ(*buffer, first_byte);
   GOOGLE_DCHECK_EQ(first_byte & 0x80, 0x80) << first_byte;
   const uint8_t* ptr = buffer;
-  uint32_t b;
-  uint32_t result = first_byte - 0x80;
+  ui32 b;
+  ui32 result = first_byte - 0x80;
   ++ptr;  // We just processed the first byte.  Move on to the second.
   b = *(ptr++);
   result += b << 7;
@@ -428,9 +410,9 @@ done:
 }
 
 PROTOBUF_ALWAYS_INLINE::std::pair<bool, const uint8_t*> ReadVarint64FromArray(
-    const uint8_t* buffer, uint64_t* value);
+    const uint8_t* buffer, ui64* value);
 inline ::std::pair<bool, const uint8_t*> ReadVarint64FromArray(
-    const uint8_t* buffer, uint64_t* value) {
+    const uint8_t* buffer, ui64* value) {
   // Assumes varint64 is at least 2 bytes.
   GOOGLE_DCHECK_GE(buffer[0], 128);
 
@@ -464,22 +446,22 @@ inline ::std::pair<bool, const uint8_t*> ReadVarint64FromArray(
 
 }  // namespace
 
-bool CodedInputStream::ReadVarint32Slow(uint32_t* value) {
+bool CodedInputStream::ReadVarint32Slow(ui32* value) {
   // Directly invoke ReadVarint64Fallback, since we already tried to optimize
   // for one-byte varints.
-  std::pair<uint64_t, bool> p = ReadVarint64Fallback();
-  *value = static_cast<uint32_t>(p.first);
+  std::pair<ui64, bool> p = ReadVarint64Fallback();
+  *value = static_cast<ui32>(p.first);
   return p.second;
 }
 
-int64_t CodedInputStream::ReadVarint32Fallback(uint32_t first_byte_or_zero) {
+i64 CodedInputStream::ReadVarint32Fallback(ui32 first_byte_or_zero) {
   if (BufferSize() >= kMaxVarintBytes ||
       // Optimization:  We're also safe if the buffer is non-empty and it ends
       // with a byte that would terminate a varint.
       (buffer_end_ > buffer_ && !(buffer_end_[-1] & 0x80))) {
     GOOGLE_DCHECK_NE(first_byte_or_zero, 0)
         << "Caller should provide us with *buffer_ when buffer is non-empty";
-    uint32_t temp;
+    ui32 temp;
     ::std::pair<bool, const uint8_t*> p =
         ReadVarint32FromArray(first_byte_or_zero, buffer_, &temp);
     if (!p.first) return -1;
@@ -489,16 +471,16 @@ int64_t CodedInputStream::ReadVarint32Fallback(uint32_t first_byte_or_zero) {
     // Really slow case: we will incur the cost of an extra function call here,
     // but moving this out of line reduces the size of this function, which
     // improves the common case. In micro benchmarks, this is worth about 10-15%
-    uint32_t temp;
-    return ReadVarint32Slow(&temp) ? static_cast<int64_t>(temp) : -1;
+    ui32 temp;
+    return ReadVarint32Slow(&temp) ? static_cast<i64>(temp) : -1;
   }
 }
 
 int CodedInputStream::ReadVarintSizeAsIntSlow() {
   // Directly invoke ReadVarint64Fallback, since we already tried to optimize
   // for one-byte varints.
-  std::pair<uint64_t, bool> p = ReadVarint64Fallback();
-  if (!p.second || p.first > static_cast<uint64_t>(INT_MAX)) return -1;
+  std::pair<ui64, bool> p = ReadVarint64Fallback();
+  if (!p.second || p.first > static_cast<ui64>(INT_MAX)) return -1;
   return p.first;
 }
 
@@ -507,9 +489,9 @@ int CodedInputStream::ReadVarintSizeAsIntFallback() {
       // Optimization:  We're also safe if the buffer is non-empty and it ends
       // with a byte that would terminate a varint.
       (buffer_end_ > buffer_ && !(buffer_end_[-1] & 0x80))) {
-    uint64_t temp;
+    ui64 temp;
     ::std::pair<bool, const uint8_t*> p = ReadVarint64FromArray(buffer_, &temp);
-    if (!p.first || temp > static_cast<uint64_t>(INT_MAX)) return -1;
+    if (!p.first || temp > static_cast<ui64>(INT_MAX)) return -1;
     buffer_ = p.second;
     return temp;
   } else {
@@ -520,7 +502,7 @@ int CodedInputStream::ReadVarintSizeAsIntFallback() {
   }
 }
 
-uint32_t CodedInputStream::ReadTagSlow() {
+ui32 CodedInputStream::ReadTagSlow() {
   if (buffer_ == buffer_end_) {
     // Call refresh.
     if (!Refresh()) {
@@ -541,12 +523,12 @@ uint32_t CodedInputStream::ReadTagSlow() {
 
   // For the slow path, just do a 64-bit read. Try to optimize for one-byte tags
   // again, since we have now refreshed the buffer.
-  uint64_t result = 0;
+  ui64 result = 0;
   if (!ReadVarint64(&result)) return 0;
-  return static_cast<uint32_t>(result);
+  return static_cast<ui32>(result);
 }
 
-uint32_t CodedInputStream::ReadTagFallback(uint32_t first_byte_or_zero) {
+ui32 CodedInputStream::ReadTagFallback(ui32 first_byte_or_zero) {
   const int buf_size = BufferSize();
   if (buf_size >= kMaxVarintBytes ||
       // Optimization:  We're also safe if the buffer is non-empty and it ends
@@ -557,7 +539,7 @@ uint32_t CodedInputStream::ReadTagFallback(uint32_t first_byte_or_zero) {
       ++buffer_;
       return 0;
     }
-    uint32_t tag;
+    ui32 tag;
     ::std::pair<bool, const uint8_t*> p =
         ReadVarint32FromArray(first_byte_or_zero, buffer_, &tag);
     if (!p.first) {
@@ -583,13 +565,13 @@ uint32_t CodedInputStream::ReadTagFallback(uint32_t first_byte_or_zero) {
   }
 }
 
-bool CodedInputStream::ReadVarint64Slow(uint64_t* value) {
+bool CodedInputStream::ReadVarint64Slow(ui64* value) {
   // Slow path:  This read might cross the end of the buffer, so we
   // need to check and refresh the buffer if and when it does.
 
-  uint64_t result = 0;
+  ui64 result = 0;
   int count = 0;
-  uint32_t b;
+  ui32 b;
 
   do {
     if (count == kMaxVarintBytes) {
@@ -603,7 +585,7 @@ bool CodedInputStream::ReadVarint64Slow(uint64_t* value) {
       }
     }
     b = *buffer_;
-    result |= static_cast<uint64_t>(b & 0x7F) << (7 * count);
+    result |= static_cast<ui64>(b & 0x7F) << (7 * count);
     Advance(1);
     ++count;
   } while (b & 0x80);
@@ -612,12 +594,12 @@ bool CodedInputStream::ReadVarint64Slow(uint64_t* value) {
   return true;
 }
 
-std::pair<uint64_t, bool> CodedInputStream::ReadVarint64Fallback() {
+std::pair<ui64, bool> CodedInputStream::ReadVarint64Fallback() {
   if (BufferSize() >= kMaxVarintBytes ||
       // Optimization:  We're also safe if the buffer is non-empty and it ends
       // with a byte that would terminate a varint.
       (buffer_end_ > buffer_ && !(buffer_end_[-1] & 0x80))) {
-    uint64_t temp;
+    ui64 temp;
     ::std::pair<bool, const uint8_t*> p = ReadVarint64FromArray(buffer_, &temp);
     if (!p.first) {
       return std::make_pair(0, false);
@@ -625,7 +607,7 @@ std::pair<uint64_t, bool> CodedInputStream::ReadVarint64Fallback() {
     buffer_ = p.second;
     return std::make_pair(temp, true);
   } else {
-    uint64_t temp;
+    ui64 temp;
     bool success = ReadVarint64Slow(&temp);
     return std::make_pair(temp, success);
   }
@@ -885,7 +867,7 @@ uint8_t* EpsCopyOutputStream::WriteRawLittleEndian32(const void* data, int size,
   auto end = p + size;
   while (end - p >= kSlopBytes) {
     ptr = EnsureSpace(ptr);
-    uint32_t buffer[4];
+    ui32 buffer[4];
     static_assert(sizeof(buffer) == kSlopBytes, "Buffer must be kSlopBytes");
     std::memcpy(buffer, p, kSlopBytes);
     p += kSlopBytes;
@@ -894,7 +876,7 @@ uint8_t* EpsCopyOutputStream::WriteRawLittleEndian32(const void* data, int size,
   }
   while (p < end) {
     ptr = EnsureSpace(ptr);
-    uint32_t buffer;
+    ui32 buffer;
     std::memcpy(&buffer, p, 4);
     p += 4;
     ptr = CodedOutputStream::WriteLittleEndian32ToArray(buffer, ptr);
@@ -908,7 +890,7 @@ uint8_t* EpsCopyOutputStream::WriteRawLittleEndian64(const void* data, int size,
   auto end = p + size;
   while (end - p >= kSlopBytes) {
     ptr = EnsureSpace(ptr);
-    uint64_t buffer[2];
+    ui64 buffer[2];
     static_assert(sizeof(buffer) == kSlopBytes, "Buffer must be kSlopBytes");
     std::memcpy(buffer, p, kSlopBytes);
     p += kSlopBytes;
@@ -917,7 +899,7 @@ uint8_t* EpsCopyOutputStream::WriteRawLittleEndian64(const void* data, int size,
   }
   while (p < end) {
     ptr = EnsureSpace(ptr);
-    uint64_t buffer;
+    ui64 buffer;
     std::memcpy(&buffer, p, 8);
     p += 8;
     ptr = CodedOutputStream::WriteLittleEndian64ToArray(buffer, ptr);
@@ -927,19 +909,19 @@ uint8_t* EpsCopyOutputStream::WriteRawLittleEndian64(const void* data, int size,
 #endif
 
 
-uint8_t* EpsCopyOutputStream::WriteStringMaybeAliasedOutline(uint32_t num,
+uint8_t* EpsCopyOutputStream::WriteStringMaybeAliasedOutline(ui32 num,
                                                            const TProtoStringType& s,
                                                            uint8_t* ptr) {
   ptr = EnsureSpace(ptr);
-  uint32_t size = s.size();
+  ui32 size = s.size();
   ptr = WriteLengthDelim(num, size, ptr);
   return WriteRawMaybeAliased(s.data(), size, ptr);
 }
 
-uint8_t* EpsCopyOutputStream::WriteStringOutline(uint32_t num, const TProtoStringType& s,
+uint8_t* EpsCopyOutputStream::WriteStringOutline(ui32 num, const TProtoStringType& s,
                                                uint8_t* ptr) {
   ptr = EnsureSpace(ptr);
-  uint32_t size = s.size();
+  ui32 size = s.size();
   ptr = WriteLengthDelim(num, size, ptr);
   return WriteRaw(s.data(), size, ptr);
 }
@@ -969,7 +951,7 @@ uint8_t* CodedOutputStream::WriteStringWithSizeToArray(const TProtoStringType& s
   return WriteStringToArray(str, target);
 }
 
-uint8_t* CodedOutputStream::WriteVarint32ToArrayOutOfLineHelper(uint32_t value,
+uint8_t* CodedOutputStream::WriteVarint32ToArrayOutOfLineHelper(ui32 value,
                                                               uint8_t* target) {
   GOOGLE_DCHECK_GE(value, 0x80);
   target[0] |= static_cast<uint8_t>(0x80);
diff --git a/contrib/libs/protobuf/src/google/protobuf/io/coded_stream.h b/contrib/libs/protobuf/src/google/protobuf/io/coded_stream.h
index 9a4d1161c7..70886e31fe 100644
--- a/contrib/libs/protobuf/src/google/protobuf/io/coded_stream.h
+++ b/contrib/libs/protobuf/src/google/protobuf/io/coded_stream.h
@@ -75,7 +75,7 @@
 //     return;
 //   }
 //
-//   uint32_t size;
+//   ui32 size;
 //   coded_input->ReadVarint32(&size);
 //
 //   char* text = new char[size + 1];
@@ -233,35 +233,25 @@ class PROTOBUF_EXPORT CodedInputStream {
 
 
   // Read a 32-bit little-endian integer.
-  bool ReadLittleEndian32(uint32_t* value);
+  bool ReadLittleEndian32(ui32* value);
   // Read a 64-bit little-endian integer.
-  bool ReadLittleEndian64(uint64* value);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  bool ReadLittleEndian64(uint64_t* value);
-#endif
+  bool ReadLittleEndian64(ui64* value);
 
   // These methods read from an externally provided buffer. The caller is
   // responsible for ensuring that the buffer has sufficient space.
   // Read a 32-bit little-endian integer.
   static const uint8_t* ReadLittleEndian32FromArray(const uint8_t* buffer,
-                                                  uint32_t* value);
+                                                  ui32* value);
   // Read a 64-bit little-endian integer.
   static const uint8_t* ReadLittleEndian64FromArray(const uint8_t* buffer,
-                                                  uint64* value);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  static const uint8_t* ReadLittleEndian64FromArray(const uint8_t* buffer,
-                                                  uint64_t* value);
-#endif
+                                                  ui64* value);
 
   // Read an unsigned integer with Varint encoding, truncating to 32 bits.
   // Reading a 32-bit value is equivalent to reading a 64-bit one and casting
-  // it to uint32_t, but may be more efficient.
-  bool ReadVarint32(uint32_t* value);
+  // it to ui32, but may be more efficient.
+  bool ReadVarint32(ui32* value);
   // Read an unsigned integer with Varint encoding.
-  bool ReadVarint64(uint64* value);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  bool ReadVarint64(uint64_t* value);
-#endif
+  bool ReadVarint64(ui64* value);
 
   // Reads a varint off the wire into an "int". This should be used for reading
   // sizes off the wire (sizes of strings, submessages, bytes fields, etc).
@@ -282,11 +272,11 @@ class PROTOBUF_EXPORT CodedInputStream {
   // Always inline because this is only called in one place per parse loop
   // but it is called for every iteration of said loop, so it should be fast.
   // GCC doesn't want to inline this by default.
-  PROTOBUF_ALWAYS_INLINE uint32_t ReadTag() {
+  PROTOBUF_ALWAYS_INLINE ui32 ReadTag() {
     return last_tag_ = ReadTagNoLastTag();
   }
 
-  PROTOBUF_ALWAYS_INLINE uint32_t ReadTagNoLastTag();
+  PROTOBUF_ALWAYS_INLINE ui32 ReadTagNoLastTag();
 
   // This usually a faster alternative to ReadTag() when cutoff is a manifest
   // constant.  It does particularly well for cutoff >= 127.  The first part
@@ -297,14 +287,14 @@ class PROTOBUF_EXPORT CodedInputStream {
   // because that can arise in several ways, and for best performance we want
   // to avoid an extra "is tag == 0?" check here.)
   PROTOBUF_ALWAYS_INLINE
-  std::pair<uint32_t, bool> ReadTagWithCutoff(uint32_t cutoff) {
-    std::pair<uint32_t, bool> result = ReadTagWithCutoffNoLastTag(cutoff);
+  std::pair<ui32, bool> ReadTagWithCutoff(ui32 cutoff) {
+    std::pair<ui32, bool> result = ReadTagWithCutoffNoLastTag(cutoff);
     last_tag_ = result.first;
     return result;
   }
 
   PROTOBUF_ALWAYS_INLINE
-  std::pair<uint32_t, bool> ReadTagWithCutoffNoLastTag(uint32_t cutoff);
+  std::pair<ui32, bool> ReadTagWithCutoffNoLastTag(ui32 cutoff);
 
   // Usually returns true if calling ReadVarint32() now would produce the given
   // value.  Will always return false if ReadVarint32() would not return the
@@ -313,7 +303,7 @@ class PROTOBUF_EXPORT CodedInputStream {
   // parameter.
   // Always inline because this collapses to a small number of instructions
   // when given a constant parameter, but GCC doesn't want to inline by default.
-  PROTOBUF_ALWAYS_INLINE bool ExpectTag(uint32_t expected);
+  PROTOBUF_ALWAYS_INLINE bool ExpectTag(ui32 expected);
 
   // Like above, except this reads from the specified buffer. The caller is
   // responsible for ensuring that the buffer is large enough to read a varint
@@ -324,7 +314,7 @@ class PROTOBUF_EXPORT CodedInputStream {
   // was not.
   PROTOBUF_ALWAYS_INLINE
   static const uint8_t* ExpectTagFromArray(const uint8_t* buffer,
-                                         uint32_t expected);
+                                         ui32 expected);
 
   // Usually returns true if no more bytes can be read.  Always returns false
   // if more bytes can be read.  If ExpectAtEnd() returns true, a subsequent
@@ -343,8 +333,8 @@ class PROTOBUF_EXPORT CodedInputStream {
   // of the enclosing message.  The enclosing message would like to check that
   // tag to make sure it had the right number, so it calls LastTagWas() on
   // return from the embedded parser to check.
-  bool LastTagWas(uint32_t expected);
-  void SetLastTag(uint32_t tag) { last_tag_ = tag; }
+  bool LastTagWas(ui32 expected);
+  void SetLastTag(ui32 tag) { last_tag_ = tag; }
 
   // When parsing message (but NOT a group), this method must be called
   // immediately after MergeFromCodedStream() returns (if it returns true)
@@ -558,7 +548,7 @@ class PROTOBUF_EXPORT CodedInputStream {
   int overflow_bytes_;
 
   // LastTagWas() stuff.
-  uint32_t last_tag_;  // result of last ReadTag() or ReadTagWithCutoff().
+  ui32 last_tag_;  // result of last ReadTag() or ReadTagWithCutoff().
 
   // This is set true by ReadTag{Fallback/Slow}() if it is called when exactly
   // at EOF, or by ExpectAtEnd() when it returns true.  This happens when we
@@ -626,25 +616,22 @@ class PROTOBUF_EXPORT CodedInputStream {
   // message crosses multiple buffers.  Note: ReadVarint32Fallback() and
   // ReadVarint64Fallback() are called frequently and generally not inlined, so
   // they have been optimized to avoid "out" parameters.  The former returns -1
-  // if it fails and the uint32_t it read otherwise.  The latter has a bool
+  // if it fails and the ui32 it read otherwise.  The latter has a bool
   // indicating success or failure as part of its return type.
-  int64_t ReadVarint32Fallback(uint32_t first_byte_or_zero);
+  i64 ReadVarint32Fallback(ui32 first_byte_or_zero);
   int ReadVarintSizeAsIntFallback();
-  std::pair<uint64_t, bool> ReadVarint64Fallback();
-  bool ReadVarint32Slow(uint32_t* value);
-  bool ReadVarint64Slow(uint64_t* value);
+  std::pair<ui64, bool> ReadVarint64Fallback();
+  bool ReadVarint32Slow(ui32* value);
+  bool ReadVarint64Slow(ui64* value);
   int ReadVarintSizeAsIntSlow();
-  bool ReadLittleEndian32Fallback(uint32_t* value);
-  bool ReadLittleEndian64Fallback(uint64* value);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  bool ReadLittleEndian64Fallback(uint64_t* value);
-#endif
+  bool ReadLittleEndian32Fallback(ui32* value);
+  bool ReadLittleEndian64Fallback(ui64* value);
 
   // Fallback/slow methods for reading tags. These do not update last_tag_,
   // but will set legitimate_message_end_ if we are at the end of the input
   // stream.
-  uint32_t ReadTagFallback(uint32_t first_byte_or_zero);
-  uint32_t ReadTagSlow();
+  ui32 ReadTagFallback(ui32 first_byte_or_zero);
+  ui32 ReadTagSlow();
   bool ReadStringFallback(TProtoStringType* buffer, int size);
 
   // Return the size of the buffer.
@@ -727,7 +714,7 @@ class PROTOBUF_EXPORT EpsCopyOutputStream {
   }
 
 
-  uint8_t* WriteStringMaybeAliased(uint32_t num, const TProtoStringType& s, uint8_t* ptr) {
+  uint8_t* WriteStringMaybeAliased(ui32 num, const TProtoStringType& s, uint8_t* ptr) {
     std::ptrdiff_t size = s.size();
     if (PROTOBUF_PREDICT_FALSE(
             size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
@@ -738,12 +725,12 @@ class PROTOBUF_EXPORT EpsCopyOutputStream {
     std::memcpy(ptr, s.data(), size);
     return ptr + size;
   }
-  uint8_t* WriteBytesMaybeAliased(uint32_t num, const TProtoStringType& s, uint8_t* ptr) {
+  uint8_t* WriteBytesMaybeAliased(ui32 num, const TProtoStringType& s, uint8_t* ptr) {
     return WriteStringMaybeAliased(num, s, ptr);
   }
 
   template <typename T>
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteString(uint32_t num, const T& s,
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteString(ui32 num, const T& s,
                                             uint8_t* ptr) {
     std::ptrdiff_t size = s.size();
     if (PROTOBUF_PREDICT_FALSE(
@@ -756,7 +743,7 @@ class PROTOBUF_EXPORT EpsCopyOutputStream {
     return ptr + size;
   }
   template <typename T>
-  uint8_t* WriteBytes(uint32_t num, const T& s, uint8_t* ptr) {
+  uint8_t* WriteBytes(ui32 num, const T& s, uint8_t* ptr) {
     return WriteString(num, s, ptr);
   }
 
@@ -861,7 +848,7 @@ class PROTOBUF_EXPORT EpsCopyOutputStream {
     return buffer_;
   }
 
-  static constexpr int TagSize(uint32_t tag) {
+  static constexpr int TagSize(ui32 tag) {
     return (tag < (1 << 7))    ? 1
            : (tag < (1 << 14)) ? 2
            : (tag < (1 << 21)) ? 3
@@ -869,12 +856,12 @@ class PROTOBUF_EXPORT EpsCopyOutputStream {
                                : 5;
   }
 
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteTag(uint32_t num, uint32_t wt, uint8_t* ptr) {
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteTag(ui32 num, ui32 wt, uint8_t* ptr) {
     GOOGLE_DCHECK(ptr < end_);  // NOLINT
     return UnsafeVarint((num << 3) | wt, ptr);
   }
 
-  PROTOBUF_ALWAYS_INLINE uint8_t* WriteLengthDelim(int num, uint32_t size,
+  PROTOBUF_ALWAYS_INLINE uint8_t* WriteLengthDelim(int num, ui32 size,
                                                  uint8_t* ptr) {
     ptr = WriteTag(num, 2, ptr);
     return UnsafeWriteSize(size, ptr);
@@ -884,9 +871,9 @@ class PROTOBUF_EXPORT EpsCopyOutputStream {
 
   uint8_t* WriteAliasedRaw(const void* data, int size, uint8_t* ptr);
 
-  uint8_t* WriteStringMaybeAliasedOutline(uint32_t num, const TProtoStringType& s,
+  uint8_t* WriteStringMaybeAliasedOutline(ui32 num, const TProtoStringType& s,
                                         uint8_t* ptr);
-  uint8_t* WriteStringOutline(uint32_t num, const TProtoStringType& s, uint8_t* ptr);
+  uint8_t* WriteStringOutline(ui32 num, const TProtoStringType& s, uint8_t* ptr);
 
   template <typename T, typename E>
   PROTOBUF_ALWAYS_INLINE uint8_t* WriteVarintPacked(int num, const T& r, int size,
@@ -902,13 +889,13 @@ class PROTOBUF_EXPORT EpsCopyOutputStream {
     return ptr;
   }
 
-  static uint32_t Encode32(uint32_t v) { return v; }
-  static uint64_t Encode64(uint64_t v) { return v; }
-  static uint32_t ZigZagEncode32(int32_t v) {
-    return (static_cast<uint32_t>(v) << 1) ^ static_cast<uint32_t>(v >> 31);
+  static ui32 Encode32(ui32 v) { return v; }
+  static ui64 Encode64(ui64 v) { return v; }
+  static ui32 ZigZagEncode32(i32 v) {
+    return (static_cast<ui32>(v) << 1) ^ static_cast<ui32>(v >> 31);
   }
-  static uint64_t ZigZagEncode64(int64_t v) {
-    return (static_cast<uint64_t>(v) << 1) ^ static_cast<uint64_t>(v >> 63);
+  static ui64 ZigZagEncode64(i64 v) {
+    return (static_cast<ui64>(v) << 1) ^ static_cast<ui64>(v >> 63);
   }
 
   template <typename T>
@@ -937,7 +924,7 @@ class PROTOBUF_EXPORT EpsCopyOutputStream {
     return ptr;
   }
 
-  PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeWriteSize(uint32_t value,
+  PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeWriteSize(ui32 value,
                                                        uint8_t* ptr) {
     while (PROTOBUF_PREDICT_FALSE(value >= 0x80)) {
       *ptr = static_cast<uint8_t>(value | 0x80);
@@ -1142,65 +1129,65 @@ class PROTOBUF_EXPORT CodedOutputStream {
 
 
   // Write a 32-bit little-endian integer.
-  void WriteLittleEndian32(uint32_t value) {
+  void WriteLittleEndian32(ui32 value) {
     cur_ = impl_.EnsureSpace(cur_);
     SetCur(WriteLittleEndian32ToArray(value, Cur()));
   }
   // Like WriteLittleEndian32()  but writing directly to the target array.
-  static uint8_t* WriteLittleEndian32ToArray(uint32_t value, uint8_t* target);
+  static uint8_t* WriteLittleEndian32ToArray(ui32 value, uint8_t* target);
   // Write a 64-bit little-endian integer.
-  void WriteLittleEndian64(uint64_t value) {
+  void WriteLittleEndian64(ui64 value) {
     cur_ = impl_.EnsureSpace(cur_);
     SetCur(WriteLittleEndian64ToArray(value, Cur()));
   }
   // Like WriteLittleEndian64()  but writing directly to the target array.
-  static uint8_t* WriteLittleEndian64ToArray(uint64_t value, uint8_t* target);
+  static uint8_t* WriteLittleEndian64ToArray(ui64 value, uint8_t* target);
 
   // Write an unsigned integer with Varint encoding.  Writing a 32-bit value
-  // is equivalent to casting it to uint64_t and writing it as a 64-bit value,
+  // is equivalent to casting it to ui64 and writing it as a 64-bit value,
   // but may be more efficient.
-  void WriteVarint32(uint32_t value);
+  void WriteVarint32(ui32 value);
   // Like WriteVarint32()  but writing directly to the target array.
-  static uint8_t* WriteVarint32ToArray(uint32_t value, uint8_t* target);
+  static uint8_t* WriteVarint32ToArray(ui32 value, uint8_t* target);
   // Like WriteVarint32()  but writing directly to the target array, and with the
   // less common-case paths being out of line rather than inlined.
-  static uint8_t* WriteVarint32ToArrayOutOfLine(uint32_t value, uint8_t* target);
+  static uint8_t* WriteVarint32ToArrayOutOfLine(ui32 value, uint8_t* target);
   // Write an unsigned integer with Varint encoding.
-  void WriteVarint64(uint64_t value);
+  void WriteVarint64(ui64 value);
   // Like WriteVarint64()  but writing directly to the target array.
-  static uint8_t* WriteVarint64ToArray(uint64_t value, uint8_t* target);
+  static uint8_t* WriteVarint64ToArray(ui64 value, uint8_t* target);
 
   // Equivalent to WriteVarint32() except when the value is negative,
   // in which case it must be sign-extended to a full 10 bytes.
-  void WriteVarint32SignExtended(int32_t value);
+  void WriteVarint32SignExtended(i32 value);
   // Like WriteVarint32SignExtended()  but writing directly to the target array.
-  static uint8_t* WriteVarint32SignExtendedToArray(int32_t value, uint8_t* target);
+  static uint8_t* WriteVarint32SignExtendedToArray(i32 value, uint8_t* target);
 
   // This is identical to WriteVarint32(), but optimized for writing tags.
   // In particular, if the input is a compile-time constant, this method
   // compiles down to a couple instructions.
   // Always inline because otherwise the aforementioned optimization can't work,
   // but GCC by default doesn't want to inline this.
-  void WriteTag(uint32_t value);
+  void WriteTag(ui32 value);
   // Like WriteTag()  but writing directly to the target array.
   PROTOBUF_ALWAYS_INLINE
-  static uint8_t* WriteTagToArray(uint32_t value, uint8_t* target);
+  static uint8_t* WriteTagToArray(ui32 value, uint8_t* target);
 
   // Returns the number of bytes needed to encode the given value as a varint.
-  static size_t VarintSize32(uint32_t value);
+  static size_t VarintSize32(ui32 value);
   // Returns the number of bytes needed to encode the given value as a varint.
-  static size_t VarintSize64(uint64_t value);
+  static size_t VarintSize64(ui64 value);
 
   // If negative, 10 bytes.  Otherwise, same as VarintSize32().
-  static size_t VarintSize32SignExtended(int32_t value);
+  static size_t VarintSize32SignExtended(i32 value);
 
   // Same as above, plus one.  The additional one comes at no compute cost.
-  static size_t VarintSize32PlusOne(uint32_t value);
-  static size_t VarintSize64PlusOne(uint64_t value);
-  static size_t VarintSize32SignExtendedPlusOne(int32_t value);
+  static size_t VarintSize32PlusOne(ui32 value);
+  static size_t VarintSize64PlusOne(ui64 value);
+  static size_t VarintSize32SignExtendedPlusOne(i32 value);
 
   // Compile-time equivalent of VarintSize32().
-  template <uint32_t Value>
+  template <ui32 Value>
   struct StaticVarintSize32 {
     static const size_t value = (Value < (1 << 7))    ? 1
                                 : (Value < (1 << 14)) ? 2
@@ -1270,7 +1257,7 @@ class PROTOBUF_EXPORT CodedOutputStream {
  private:
   EpsCopyOutputStream impl_;
   uint8_t* cur_;
-  int64_t start_count_;
+  i64 start_count_;
   static std::atomic<bool> default_serialization_deterministic_;
 
   // See above.  Other projects may use "friend" to allow them to call this.
@@ -1285,7 +1272,7 @@ class PROTOBUF_EXPORT CodedOutputStream {
     default_serialization_deterministic_.store(true, std::memory_order_relaxed);
   }
   // REQUIRES: value >= 0x80, and that (value & 7f) has been written to *target.
-  static uint8_t* WriteVarint32ToArrayOutOfLineHelper(uint32_t value, uint8_t* target);
+  static uint8_t* WriteVarint32ToArrayOutOfLineHelper(ui32 value, uint8_t* target);
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedOutputStream);
 };
 
@@ -1293,8 +1280,8 @@ class PROTOBUF_EXPORT CodedOutputStream {
 // The vast majority of varints are only one byte.  These inline
 // methods optimize for that case.
 
-inline bool CodedInputStream::ReadVarint32(uint32_t* value) {
-  uint32_t v = 0;
+inline bool CodedInputStream::ReadVarint32(ui32* value) {
+  ui32 v = 0;
   if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
     v = *buffer_;
     if (v < 0x80) {
@@ -1303,33 +1290,21 @@ inline bool CodedInputStream::ReadVarint32(uint32_t* value) {
       return true;
     }
   }
-  int64_t result = ReadVarint32Fallback(v);
-  *value = static_cast<uint32_t>(result);
+  i64 result = ReadVarint32Fallback(v);
+  *value = static_cast<ui32>(result);
   return result >= 0;
 }
 
-inline bool CodedInputStream::ReadVarint64(uint64* value) {
-  if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80) {
-    *value = *buffer_;
-    Advance(1);
-    return true;
-  }
-  std::pair<uint64, bool> p = ReadVarint64Fallback();
-  *value = p.first;
-  return p.second;
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline bool CodedInputStream::ReadVarint64(uint64_t* value) {
+inline bool CodedInputStream::ReadVarint64(ui64* value) {
   if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80) {
     *value = *buffer_;
     Advance(1);
     return true;
   }
-  std::pair<uint64_t, bool> p = ReadVarint64Fallback();
+  std::pair<ui64, bool> p = ReadVarint64Fallback();
   *value = p.first;
   return p.second;
 }
-#endif
 
 inline bool CodedInputStream::ReadVarintSizeAsInt(int* value) {
   if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
@@ -1346,60 +1321,39 @@ inline bool CodedInputStream::ReadVarintSizeAsInt(int* value) {
 
 // static
 inline const uint8_t* CodedInputStream::ReadLittleEndian32FromArray(
-    const uint8_t* buffer, uint32_t* value) {
+    const uint8_t* buffer, ui32* value) {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
   memcpy(value, buffer, sizeof(*value));
   return buffer + sizeof(*value);
 #else
-  *value = (static_cast<uint32_t>(buffer[0])) |
-           (static_cast<uint32_t>(buffer[1]) << 8) |
-           (static_cast<uint32_t>(buffer[2]) << 16) |
-           (static_cast<uint32_t>(buffer[3]) << 24);
+  *value = (static_cast<ui32>(buffer[0])) |
+           (static_cast<ui32>(buffer[1]) << 8) |
+           (static_cast<ui32>(buffer[2]) << 16) |
+           (static_cast<ui32>(buffer[3]) << 24);
   return buffer + sizeof(*value);
 #endif
 }
 // static
 inline const uint8_t* CodedInputStream::ReadLittleEndian64FromArray(
-    const uint8_t* buffer, uint64* value) {
-#if defined(PROTOBUF_LITTLE_ENDIAN)
-  memcpy(value, buffer, sizeof(*value));
-  return buffer + sizeof(*value);
-#else
-  uint32_t part0 = (static_cast<uint32_t>(buffer[0])) |
-                 (static_cast<uint32_t>(buffer[1]) << 8) |
-                 (static_cast<uint32_t>(buffer[2]) << 16) |
-                 (static_cast<uint32_t>(buffer[3]) << 24);
-  uint32_t part1 = (static_cast<uint32_t>(buffer[4])) |
-                 (static_cast<uint32_t>(buffer[5]) << 8) |
-                 (static_cast<uint32_t>(buffer[6]) << 16) |
-                 (static_cast<uint32_t>(buffer[7]) << 24);
-  *value = static_cast<uint64>(part0) | (static_cast<uint64>(part1) << 32);
-  return buffer + sizeof(*value);
-#endif
-}
-
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline const uint8_t* CodedInputStream::ReadLittleEndian64FromArray(
-    const uint8_t* buffer, uint64_t* value) {
+    const uint8_t* buffer, ui64* value) {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
   memcpy(value, buffer, sizeof(*value));
   return buffer + sizeof(*value);
 #else
-  uint32_t part0 = (static_cast<uint32_t>(buffer[0])) |
-                 (static_cast<uint32_t>(buffer[1]) << 8) |
-                 (static_cast<uint32_t>(buffer[2]) << 16) |
-                 (static_cast<uint32_t>(buffer[3]) << 24);
-  uint32_t part1 = (static_cast<uint32_t>(buffer[4])) |
-                 (static_cast<uint32_t>(buffer[5]) << 8) |
-                 (static_cast<uint32_t>(buffer[6]) << 16) |
-                 (static_cast<uint32_t>(buffer[7]) << 24);
-  *value = static_cast<uint64_t>(part0) | (static_cast<uint64_t>(part1) << 32);
+  ui32 part0 = (static_cast<ui32>(buffer[0])) |
+                 (static_cast<ui32>(buffer[1]) << 8) |
+                 (static_cast<ui32>(buffer[2]) << 16) |
+                 (static_cast<ui32>(buffer[3]) << 24);
+  ui32 part1 = (static_cast<ui32>(buffer[4])) |
+                 (static_cast<ui32>(buffer[5]) << 8) |
+                 (static_cast<ui32>(buffer[6]) << 16) |
+                 (static_cast<ui32>(buffer[7]) << 24);
+  *value = static_cast<ui64>(part0) | (static_cast<ui64>(part1) << 32);
   return buffer + sizeof(*value);
 #endif
 }
-#endif
 
-inline bool CodedInputStream::ReadLittleEndian32(uint32_t* value) {
+inline bool CodedInputStream::ReadLittleEndian32(ui32* value) {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
   if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
     buffer_ = ReadLittleEndian32FromArray(buffer_, value);
@@ -1412,20 +1366,7 @@ inline bool CodedInputStream::ReadLittleEndian32(uint32_t* value) {
 #endif
 }
 
-inline bool CodedInputStream::ReadLittleEndian64(uint64* value) {
-#if defined(PROTOBUF_LITTLE_ENDIAN)
-  if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
-    buffer_ = ReadLittleEndian64FromArray(buffer_, value);
-    return true;
-  } else {
-    return ReadLittleEndian64Fallback(value);
-  }
-#else
-  return ReadLittleEndian64Fallback(value);
-#endif
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline bool CodedInputStream::ReadLittleEndian64(uint64_t* value) {
+inline bool CodedInputStream::ReadLittleEndian64(ui64* value) {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
   if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
     buffer_ = ReadLittleEndian64FromArray(buffer_, value);
@@ -1437,10 +1378,9 @@ inline bool CodedInputStream::ReadLittleEndian64(uint64_t* value) {
   return ReadLittleEndian64Fallback(value);
 #endif
 }
-#endif
 
-inline uint32_t CodedInputStream::ReadTagNoLastTag() {
-  uint32_t v = 0;
+inline ui32 CodedInputStream::ReadTagNoLastTag() {
+  ui32 v = 0;
   if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
     v = *buffer_;
     if (v < 0x80) {
@@ -1452,20 +1392,20 @@ inline uint32_t CodedInputStream::ReadTagNoLastTag() {
   return v;
 }
 
-inline std::pair<uint32_t, bool> CodedInputStream::ReadTagWithCutoffNoLastTag(
-    uint32_t cutoff) {
+inline std::pair<ui32, bool> CodedInputStream::ReadTagWithCutoffNoLastTag(
+    ui32 cutoff) {
   // In performance-sensitive code we can expect cutoff to be a compile-time
   // constant, and things like "cutoff >= kMax1ByteVarint" to be evaluated at
   // compile time.
-  uint32_t first_byte_or_zero = 0;
+  ui32 first_byte_or_zero = 0;
   if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
     // Hot case: buffer_ non_empty, buffer_[0] in [1, 128).
     // TODO(gpike): Is it worth rearranging this? E.g., if the number of fields
     // is large enough then is it better to check for the two-byte case first?
     first_byte_or_zero = buffer_[0];
     if (static_cast<int8_t>(buffer_[0]) > 0) {
-      const uint32_t kMax1ByteVarint = 0x7f;
-      uint32_t tag = buffer_[0];
+      const ui32 kMax1ByteVarint = 0x7f;
+      ui32 tag = buffer_[0];
       Advance(1);
       return std::make_pair(tag, cutoff >= kMax1ByteVarint || tag <= cutoff);
     }
@@ -1474,8 +1414,8 @@ inline std::pair<uint32_t, bool> CodedInputStream::ReadTagWithCutoffNoLastTag(
     // first byte and the second byte.
     if (cutoff >= 0x80 && PROTOBUF_PREDICT_TRUE(buffer_ + 1 < buffer_end_) &&
         PROTOBUF_PREDICT_TRUE((buffer_[0] & ~buffer_[1]) >= 0x80)) {
-      const uint32_t kMax2ByteVarint = (0x7f << 7) + 0x7f;
-      uint32_t tag = (1u << 7) * buffer_[1] + (buffer_[0] - 0x80);
+      const ui32 kMax2ByteVarint = (0x7f << 7) + 0x7f;
+      ui32 tag = (1u << 7) * buffer_[1] + (buffer_[0] - 0x80);
       Advance(2);
       // It might make sense to test for tag == 0 now, but it is so rare that
       // that we don't bother.  A varint-encoded 0 should be one byte unless
@@ -1488,11 +1428,11 @@ inline std::pair<uint32_t, bool> CodedInputStream::ReadTagWithCutoffNoLastTag(
     }
   }
   // Slow path
-  const uint32_t tag = ReadTagFallback(first_byte_or_zero);
-  return std::make_pair(tag, static_cast<uint32_t>(tag - 1) < cutoff);
+  const ui32 tag = ReadTagFallback(first_byte_or_zero);
+  return std::make_pair(tag, static_cast<ui32>(tag - 1) < cutoff);
 }
 
-inline bool CodedInputStream::LastTagWas(uint32_t expected) {
+inline bool CodedInputStream::LastTagWas(ui32 expected) {
   return last_tag_ == expected;
 }
 
@@ -1500,7 +1440,7 @@ inline bool CodedInputStream::ConsumedEntireMessage() {
   return legitimate_message_end_;
 }
 
-inline bool CodedInputStream::ExpectTag(uint32_t expected) {
+inline bool CodedInputStream::ExpectTag(ui32 expected) {
   if (expected < (1 << 7)) {
     if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) &&
         buffer_[0] == expected) {
@@ -1525,7 +1465,7 @@ inline bool CodedInputStream::ExpectTag(uint32_t expected) {
 }
 
 inline const uint8_t* CodedInputStream::ExpectTagFromArray(const uint8_t* buffer,
-                                                         uint32_t expected) {
+                                                         ui32 expected) {
   if (expected < (1 << 7)) {
     if (buffer[0] == expected) {
       return buffer + 1;
@@ -1658,13 +1598,13 @@ inline bool CodedInputStream::Skip(int count) {
   return SkipFallback(count, original_buffer_size);
 }
 
-inline uint8_t* CodedOutputStream::WriteVarint32ToArray(uint32_t value,
+inline uint8_t* CodedOutputStream::WriteVarint32ToArray(ui32 value,
                                                       uint8_t* target) {
   return EpsCopyOutputStream::UnsafeVarint(value, target);
 }
 
 inline uint8_t* CodedOutputStream::WriteVarint32ToArrayOutOfLine(
-    uint32_t value, uint8_t* target) {
+    ui32 value, uint8_t* target) {
   target[0] = static_cast<uint8_t>(value);
   if (value < 0x80) {
     return target + 1;
@@ -1673,21 +1613,21 @@ inline uint8_t* CodedOutputStream::WriteVarint32ToArrayOutOfLine(
   }
 }
 
-inline uint8_t* CodedOutputStream::WriteVarint64ToArray(uint64_t value,
+inline uint8_t* CodedOutputStream::WriteVarint64ToArray(ui64 value,
                                                       uint8_t* target) {
   return EpsCopyOutputStream::UnsafeVarint(value, target);
 }
 
-inline void CodedOutputStream::WriteVarint32SignExtended(int32_t value) {
-  WriteVarint64(static_cast<uint64_t>(value));
+inline void CodedOutputStream::WriteVarint32SignExtended(i32 value) {
+  WriteVarint64(static_cast<ui64>(value));
 }
 
 inline uint8_t* CodedOutputStream::WriteVarint32SignExtendedToArray(
-    int32_t value, uint8_t* target) {
-  return WriteVarint64ToArray(static_cast<uint64_t>(value), target);
+    i32 value, uint8_t* target) {
+  return WriteVarint64ToArray(static_cast<ui64>(value), target);
 }
 
-inline uint8_t* CodedOutputStream::WriteLittleEndian32ToArray(uint32_t value,
+inline uint8_t* CodedOutputStream::WriteLittleEndian32ToArray(ui32 value,
                                                             uint8_t* target) {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
   memcpy(target, &value, sizeof(value));
@@ -1700,13 +1640,13 @@ inline uint8_t* CodedOutputStream::WriteLittleEndian32ToArray(uint32_t value,
   return target + sizeof(value);
 }
 
-inline uint8_t* CodedOutputStream::WriteLittleEndian64ToArray(uint64_t value,
+inline uint8_t* CodedOutputStream::WriteLittleEndian64ToArray(ui64 value,
                                                             uint8_t* target) {
 #if defined(PROTOBUF_LITTLE_ENDIAN)
   memcpy(target, &value, sizeof(value));
 #else
-  uint32_t part0 = static_cast<uint32_t>(value);
-  uint32_t part1 = static_cast<uint32_t>(value >> 32);
+  ui32 part0 = static_cast<ui32>(value);
+  ui32 part1 = static_cast<ui32>(value >> 32);
 
   target[0] = static_cast<uint8_t>(part0);
   target[1] = static_cast<uint8_t>(part0 >> 8);
@@ -1720,63 +1660,63 @@ inline uint8_t* CodedOutputStream::WriteLittleEndian64ToArray(uint64_t value,
   return target + sizeof(value);
 }
 
-inline void CodedOutputStream::WriteVarint32(uint32_t value) {
+inline void CodedOutputStream::WriteVarint32(ui32 value) {
   cur_ = impl_.EnsureSpace(cur_);
   SetCur(WriteVarint32ToArray(value, Cur()));
 }
 
-inline void CodedOutputStream::WriteVarint64(uint64_t value) {
+inline void CodedOutputStream::WriteVarint64(ui64 value) {
   cur_ = impl_.EnsureSpace(cur_);
   SetCur(WriteVarint64ToArray(value, Cur()));
 }
 
-inline void CodedOutputStream::WriteTag(uint32_t value) {
+inline void CodedOutputStream::WriteTag(ui32 value) {
   WriteVarint32(value);
 }
 
-inline uint8_t* CodedOutputStream::WriteTagToArray(uint32_t value,
+inline uint8_t* CodedOutputStream::WriteTagToArray(ui32 value,
                                                    uint8_t* target) {
   return WriteVarint32ToArray(value, target);
 }
 
-inline size_t CodedOutputStream::VarintSize32(uint32_t value) {
+inline size_t CodedOutputStream::VarintSize32(ui32 value) {
   // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
   // Use an explicit multiplication to implement the divide of
   // a number in the 1..31 range.
   // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
   // undefined.
-  uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
+  ui32 log2value = Bits::Log2FloorNonZero(value | 0x1);
   return static_cast<size_t>((log2value * 9 + 73) / 64);
 }
 
-inline size_t CodedOutputStream::VarintSize32PlusOne(uint32_t value) {
+inline size_t CodedOutputStream::VarintSize32PlusOne(ui32 value) {
   // Same as above, but one more.
-  uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
+  ui32 log2value = Bits::Log2FloorNonZero(value | 0x1);
   return static_cast<size_t>((log2value * 9 + 73 + 64) / 64);
 }
 
-inline size_t CodedOutputStream::VarintSize64(uint64_t value) {
+inline size_t CodedOutputStream::VarintSize64(ui64 value) {
   // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
   // Use an explicit multiplication to implement the divide of
   // a number in the 1..63 range.
   // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
   // undefined.
-  uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
+  ui32 log2value = Bits::Log2FloorNonZero64(value | 0x1);
   return static_cast<size_t>((log2value * 9 + 73) / 64);
 }
 
-inline size_t CodedOutputStream::VarintSize64PlusOne(uint64_t value) {
+inline size_t CodedOutputStream::VarintSize64PlusOne(ui64 value) {
   // Same as above, but one more.
-  uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
+  ui32 log2value = Bits::Log2FloorNonZero64(value | 0x1);
   return static_cast<size_t>((log2value * 9 + 73 + 64) / 64);
 }
 
-inline size_t CodedOutputStream::VarintSize32SignExtended(int32_t value) {
-  return VarintSize64(static_cast<uint64_t>(int64_t{value}));
+inline size_t CodedOutputStream::VarintSize32SignExtended(i32 value) {
+  return VarintSize64(static_cast<ui64>(i64{value}));
 }
 
-inline size_t CodedOutputStream::VarintSize32SignExtendedPlusOne(int32_t value) {
-  return VarintSize64PlusOne(static_cast<uint64_t>(int64_t{value}));
+inline size_t CodedOutputStream::VarintSize32SignExtendedPlusOne(i32 value) {
+  return VarintSize64PlusOne(static_cast<ui64>(i64{value}));
 }
 
 inline void CodedOutputStream::WriteString(const TProtoStringType& str) {
diff --git a/contrib/libs/protobuf/src/google/protobuf/io/gzip_stream.cc b/contrib/libs/protobuf/src/google/protobuf/io/gzip_stream.cc
index 2f1d26f410..84b7993cc0 100644
--- a/contrib/libs/protobuf/src/google/protobuf/io/gzip_stream.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/io/gzip_stream.cc
@@ -186,7 +186,7 @@ bool GzipInputStream::Skip(int count) {
   return ok;
 }
 int64_t GzipInputStream::ByteCount() const {
-  int64_t ret = byte_count_ + zcontext_.total_out;
+  i64 ret = byte_count_ + zcontext_.total_out;
   if (zcontext_.next_out != NULL && output_position_ != NULL) {
     ret += reinterpret_cast<uintptr_t>(zcontext_.next_out) -
            reinterpret_cast<uintptr_t>(output_position_);
diff --git a/contrib/libs/protobuf/src/google/protobuf/io/gzip_stream.h b/contrib/libs/protobuf/src/google/protobuf/io/gzip_stream.h
index f0283e86f4..90a9cccfa6 100644
--- a/contrib/libs/protobuf/src/google/protobuf/io/gzip_stream.h
+++ b/contrib/libs/protobuf/src/google/protobuf/io/gzip_stream.h
@@ -96,7 +96,7 @@ class PROTOBUF_EXPORT GzipInputStream : public ZeroCopyInputStream {
   void* output_buffer_;
   void* output_position_;
   size_t output_buffer_length_;
-  int64_t byte_count_;
+  i64 byte_count_;
 
   int Inflate(int flush);
   void DoNextOutput(const void** data, int* size);
diff --git a/contrib/libs/protobuf/src/google/protobuf/io/tokenizer.cc b/contrib/libs/protobuf/src/google/protobuf/io/tokenizer.cc
index ed5e012210..54c6f7bed9 100644
--- a/contrib/libs/protobuf/src/google/protobuf/io/tokenizer.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/io/tokenizer.cc
@@ -860,48 +860,9 @@ bool Tokenizer::NextWithComments(TProtoStringType* prev_trailing_comments,
 // tokenizing.  Also, these can assume that whatever text they
 // are given is text that the tokenizer actually parsed as a token
 // of the given type.
-bool Tokenizer::ParseInteger(const TProtoStringType& text, uint64_t max_value,
-                             uint64* output) {
-  // Sadly, we can't just use strtoul() since it is only 32-bit and strtoull()
-  // is non-standard.  I hate the C standard library.  :(
-
-  //  return strtoull(text.c_str(), NULL, 0);
-
-  const char* ptr = text.c_str();
-  int base = 10;
-  if (ptr[0] == '0') {
-    if (ptr[1] == 'x' || ptr[1] == 'X') {
-      // This is hex.
-      base = 16;
-      ptr += 2;
-    } else {
-      // This is octal.
-      base = 8;
-    }
-  }
 
-  uint64_t result = 0;
-  for (; *ptr != '\0'; ptr++) {
-    int digit = DigitValue(*ptr);
-    if (digit < 0 || digit >= base) {
-      // The token provided by Tokenizer is invalid. i.e., 099 is an invalid
-      // token, but Tokenizer still think it's integer.
-      return false;
-    }
-    if (static_cast<uint64>(digit) > max_value ||
-        result > (max_value - digit) / base) {
-      // Overflow.
-      return false;
-    }
-    result = result * base + digit;
-  }
-
-  *output = result;
-  return true;
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-bool Tokenizer::ParseInteger(const TProtoStringType& text, uint64_t max_value,
-                             uint64_t* output) {
+bool Tokenizer::ParseInteger(const TProtoStringType& text, ui64 max_value,
+                             ui64* output) {
   // Sadly, we can't just use strtoul() since it is only 32-bit and strtoull()
   // is non-standard.  I hate the C standard library.  :(
 
@@ -920,7 +881,7 @@ bool Tokenizer::ParseInteger(const TProtoStringType& text, uint64_t max_value,
     }
   }
 
-  uint64_t result = 0;
+  ui64 result = 0;
   for (; *ptr != '\0'; ptr++) {
     int digit = DigitValue(*ptr);
     if (digit < 0 || digit >= base) {
@@ -928,7 +889,7 @@ bool Tokenizer::ParseInteger(const TProtoStringType& text, uint64_t max_value,
       // token, but Tokenizer still think it's integer.
       return false;
     }
-    if (static_cast<uint64_t>(digit) > max_value ||
+    if (static_cast<ui64>(digit) > max_value ||
         result > (max_value - digit) / base) {
       // Overflow.
       return false;
@@ -939,7 +900,6 @@ bool Tokenizer::ParseInteger(const TProtoStringType& text, uint64_t max_value,
   *output = result;
   return true;
 }
-#endif
 
 double Tokenizer::ParseFloat(const TProtoStringType& text) {
   const char* start = text.c_str();
@@ -970,8 +930,8 @@ double Tokenizer::ParseFloat(const TProtoStringType& text) {
 
 // Helper to append a Unicode code point to a string as UTF8, without bringing
 // in any external dependencies.
-static void AppendUTF8(uint32_t code_point, TProtoStringType* output) {
-  uint32_t tmp = 0;
+static void AppendUTF8(ui32 code_point, TProtoStringType* output) {
+  ui32 tmp = 0;
   int len = 0;
   if (code_point <= 0x7f) {
     tmp = code_point;
@@ -1001,7 +961,7 @@ static void AppendUTF8(uint32_t code_point, TProtoStringType* output) {
 
 // Try to read <len> hex digits from ptr, and stuff the numeric result into
 // *result. Returns true if that many digits were successfully consumed.
-static bool ReadHexDigits(const char* ptr, int len, uint32_t* result) {
+static bool ReadHexDigits(const char* ptr, int len, ui32* result) {
   *result = 0;
   if (len == 0) return false;
   for (const char* end = ptr + len; ptr < end; ++ptr) {
@@ -1016,22 +976,22 @@ static bool ReadHexDigits(const char* ptr, int len, uint32_t* result) {
 // surrogate. These numbers are in a reserved range of Unicode code points, so
 // if we encounter such a pair we know how to parse it and convert it into a
 // single code point.
-static const uint32_t kMinHeadSurrogate = 0xd800;
-static const uint32_t kMaxHeadSurrogate = 0xdc00;
-static const uint32_t kMinTrailSurrogate = 0xdc00;
-static const uint32_t kMaxTrailSurrogate = 0xe000;
+static const ui32 kMinHeadSurrogate = 0xd800;
+static const ui32 kMaxHeadSurrogate = 0xdc00;
+static const ui32 kMinTrailSurrogate = 0xdc00;
+static const ui32 kMaxTrailSurrogate = 0xe000;
 
-static inline bool IsHeadSurrogate(uint32_t code_point) {
+static inline bool IsHeadSurrogate(ui32 code_point) {
   return (code_point >= kMinHeadSurrogate) && (code_point < kMaxHeadSurrogate);
 }
 
-static inline bool IsTrailSurrogate(uint32_t code_point) {
+static inline bool IsTrailSurrogate(ui32 code_point) {
   return (code_point >= kMinTrailSurrogate) &&
          (code_point < kMaxTrailSurrogate);
 }
 
 // Combine a head and trail surrogate into a single Unicode code point.
-static uint32_t AssembleUTF16(uint32_t head_surrogate, uint32_t trail_surrogate) {
+static ui32 AssembleUTF16(ui32 head_surrogate, ui32 trail_surrogate) {
   GOOGLE_DCHECK(IsHeadSurrogate(head_surrogate));
   GOOGLE_DCHECK(IsTrailSurrogate(trail_surrogate));
   return 0x10000 + (((head_surrogate - kMinHeadSurrogate) << 10) |
@@ -1049,7 +1009,7 @@ static inline int UnicodeLength(char key) {
 // to parse that sequence. On success, returns a pointer to the first char
 // beyond that sequence, and fills in *code_point. On failure, returns ptr
 // itself.
-static const char* FetchUnicodePoint(const char* ptr, uint32_t* code_point) {
+static const char* FetchUnicodePoint(const char* ptr, ui32* code_point) {
   const char* p = ptr;
   // Fetch the code point.
   const int len = UnicodeLength(*p++);
@@ -1061,7 +1021,7 @@ static const char* FetchUnicodePoint(const char* ptr, uint32_t* code_point) {
   // "trail surrogate," and together they form a UTF-16 pair which decodes into
   // a single Unicode point. Trail surrogates may only use \u, not \U.
   if (IsHeadSurrogate(*code_point) && *p == '\\' && *(p + 1) == 'u') {
-    uint32_t trail_surrogate;
+    ui32 trail_surrogate;
     if (ReadHexDigits(p + 2, 4, &trail_surrogate) &&
         IsTrailSurrogate(trail_surrogate)) {
       *code_point = AssembleUTF16(*code_point, trail_surrogate);
@@ -1133,7 +1093,7 @@ void Tokenizer::ParseStringAppend(const TProtoStringType& text,
         output->push_back(static_cast<char>(code));
 
       } else if (*ptr == 'u' || *ptr == 'U') {
-        uint32_t unicode;
+        ui32 unicode;
         const char* end = FetchUnicodePoint(ptr, &unicode);
         if (end == ptr) {
           // Failure: Just dump out what we saw, don't try to parse it.
diff --git a/contrib/libs/protobuf/src/google/protobuf/io/tokenizer.h b/contrib/libs/protobuf/src/google/protobuf/io/tokenizer.h
index 5021df4fc1..f2d71f4454 100644
--- a/contrib/libs/protobuf/src/google/protobuf/io/tokenizer.h
+++ b/contrib/libs/protobuf/src/google/protobuf/io/tokenizer.h
@@ -217,12 +217,8 @@ class PROTOBUF_EXPORT Tokenizer {
   // result.  If the text is not from a Token of type TYPE_INTEGER originally
   // parsed by a Tokenizer, the result is undefined (possibly an assert
   // failure).
-  static bool ParseInteger(const TProtoStringType& text, uint64_t max_value,
-                           uint64* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  static bool ParseInteger(const TProtoStringType& text, uint64_t max_value,
-                           uint64_t* output);
-#endif
+  static bool ParseInteger(const TProtoStringType& text, ui64 max_value,
+                           ui64* output);
 
   // Options ---------------------------------------------------------
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc b/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc
index 0986ea271f..7f577c4088 100644
--- a/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc
@@ -338,12 +338,12 @@ bool ConcatenatingInputStream::Skip(int count) {
   while (stream_count_ > 0) {
     // Assume that ByteCount() can be used to find out how much we actually
     // skipped when Skip() fails.
-    int64_t target_byte_count = streams_[0]->ByteCount() + count;
+    i64 target_byte_count = streams_[0]->ByteCount() + count;
     if (streams_[0]->Skip(count)) return true;
 
     // Hit the end of the stream.  Figure out how many more bytes we still have
     // to skip.
-    int64_t final_byte_count = streams_[0]->ByteCount();
+    i64 final_byte_count = streams_[0]->ByteCount();
     GOOGLE_DCHECK_LT(final_byte_count, target_byte_count);
     count = target_byte_count - final_byte_count;
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h b/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h
index e6ba902e8d..3cb84d7e08 100644
--- a/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h
+++ b/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl.h
@@ -311,7 +311,7 @@ class PROTOBUF_EXPORT ConcatenatingInputStream : public ZeroCopyInputStream {
   // decremented.
   ZeroCopyInputStream* const* streams_;
   int stream_count_;
-  int64_t bytes_retired_;  // Bytes read from previous streams.
+  i64 bytes_retired_;  // Bytes read from previous streams.
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ConcatenatingInputStream);
 };
diff --git a/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc b/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
index 8be9ab9c13..e45e1e0346 100644
--- a/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
@@ -406,7 +406,7 @@ void CopyingOutputStreamAdaptor::FreeBuffer() {
 // ===================================================================
 
 LimitingInputStream::LimitingInputStream(ZeroCopyInputStream* input,
-                                         int64_t limit)
+                                         i64 limit)
     : input_(input), limit_(limit) {
   prior_bytes_read_ = input_->ByteCount();
 }
diff --git a/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h b/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h
index 200af105b8..115aca68a2 100644
--- a/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h
+++ b/contrib/libs/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h
@@ -236,7 +236,7 @@ class PROTOBUF_EXPORT CopyingInputStreamAdaptor : public ZeroCopyInputStream {
 
   // The current position of copying_stream_, relative to the point where
   // we started reading.
-  int64_t position_;
+  i64 position_;
 
   // Data is read into this buffer.  It may be NULL if no buffer is currently
   // in use.  Otherwise, it points to an array of size buffer_size_.
@@ -327,7 +327,7 @@ class PROTOBUF_EXPORT CopyingOutputStreamAdaptor : public ZeroCopyOutputStream {
 
   // The current position of copying_stream_, relative to the point where
   // we started writing.
-  int64_t position_;
+  i64 position_;
 
   // Data is written from this buffer.  It may be NULL if no buffer is
   // currently in use.  Otherwise, it points to an array of size buffer_size_.
@@ -348,7 +348,7 @@ class PROTOBUF_EXPORT CopyingOutputStreamAdaptor : public ZeroCopyOutputStream {
 // a particular byte count.
 class PROTOBUF_EXPORT LimitingInputStream : public ZeroCopyInputStream {
  public:
-  LimitingInputStream(ZeroCopyInputStream* input, int64_t limit);
+  LimitingInputStream(ZeroCopyInputStream* input, i64 limit);
   ~LimitingInputStream() override;
 
   // implements ZeroCopyInputStream ----------------------------------
@@ -360,8 +360,8 @@ class PROTOBUF_EXPORT LimitingInputStream : public ZeroCopyInputStream {
 
  private:
   ZeroCopyInputStream* input_;
-  int64_t limit_;  // Decreases as we go, becomes negative if we overshoot.
-  int64_t prior_bytes_read_;  // Bytes read on underlying stream at construction
+  i64 limit_;  // Decreases as we go, becomes negative if we overshoot.
+  i64 prior_bytes_read_;  // Bytes read on underlying stream at construction
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(LimitingInputStream);
 };
diff --git a/contrib/libs/protobuf/src/google/protobuf/map.h b/contrib/libs/protobuf/src/google/protobuf/map.h
index a3f1b42fc9..a6dfc02979 100644
--- a/contrib/libs/protobuf/src/google/protobuf/map.h
+++ b/contrib/libs/protobuf/src/google/protobuf/map.h
@@ -1023,12 +1023,12 @@ class Map {
     size_type BucketNumber(const K& k) const {
       // We xor the hash value against the random seed so that we effectively
       // have a random hash function.
-      uint64_t h = hash_function()(k) ^ seed_;
+      ui64 h = hash_function()(k) ^ seed_;
 
       // We use the multiplication method to determine the bucket number from
       // the hash value. The constant kPhi (suggested by Knuth) is roughly
       // (sqrt(5) - 1) / 2 * 2^64.
-      constexpr uint64_t kPhi = uint64_t{0x9e3779b97f4a7c15};
+      constexpr ui64 kPhi = ui64{0x9e3779b97f4a7c15};
       return ((kPhi * h) >> 32) & (num_buckets_ - 1);
     }
 
@@ -1082,9 +1082,9 @@ class Map {
       size_type s = reinterpret_cast<uintptr_t>(this) >> 4;
 #if defined(__x86_64__) && defined(__GNUC__) && \
     !defined(GOOGLE_PROTOBUF_NO_RDTSC)
-      uint32_t hi, lo;
+      ui32 hi, lo;
       asm volatile("rdtsc" : "=a"(lo), "=d"(hi));
-      s += ((static_cast<uint64_t>(hi) << 32) | lo);
+      s += ((static_cast<ui64>(hi) << 32) | lo);
 #endif
       return s;
     }
diff --git a/contrib/libs/protobuf/src/google/protobuf/map_entry.h b/contrib/libs/protobuf/src/google/protobuf/map_entry.h
index 2aec2d4b08..c054520931 100644
--- a/contrib/libs/protobuf/src/google/protobuf/map_entry.h
+++ b/contrib/libs/protobuf/src/google/protobuf/map_entry.h
@@ -78,8 +78,8 @@ namespace internal {
 //                         field.
 //
 // cpp type | proto type  | in-memory type | MapEntry accessor type
-// int32_t    TYPE_INT32    int32_t          int32_t
-// int32_t    TYPE_FIXED32  int32_t          int32_t
+// i32    TYPE_INT32    i32          i32
+// i32    TYPE_FIXED32  i32          i32
 // string     TYPE_STRING   ArenaStringPtr   string
 // FooEnum    TYPE_ENUM     int              int
 // FooMessage TYPE_MESSAGE  FooMessage*      FooMessage
diff --git a/contrib/libs/protobuf/src/google/protobuf/map_entry_lite.h b/contrib/libs/protobuf/src/google/protobuf/map_entry_lite.h
index 442dc9f623..72ab073da4 100644
--- a/contrib/libs/protobuf/src/google/protobuf/map_entry_lite.h
+++ b/contrib/libs/protobuf/src/google/protobuf/map_entry_lite.h
@@ -125,7 +125,7 @@ struct MapEntryFuncs {
     size_t inner_length =
         2 + KeyTypeHandler::ByteSize(key) + ValueTypeHandler::ByteSize(value);
     return inner_length + io::CodedOutputStream::VarintSize32(
-                              static_cast<uint32_t>(inner_length));
+                              static_cast<ui32>(inner_length));
   }
 
   static int GetCachedSize(const Key& key, const Value& value) {
@@ -229,7 +229,7 @@ class MapEntryImpl : public Base {
 
   const char* _InternalParse(const char* ptr, ParseContext* ctx) final {
     while (!ctx->Done(&ptr)) {
-      uint32_t tag;
+      ui32 tag;
       ptr = ReadTag(ptr, &tag);
       GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
       if (tag == kKeyTag) {
@@ -423,7 +423,7 @@ class MapEntryImpl : public Base {
     template <typename UnknownType>
     const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx,
                                         bool (*is_valid)(int),
-                                        uint32_t field_num,
+                                        ui32 field_num,
                                         InternalMetadata* metadata) {
       auto entry = NewEntry();
       ptr = entry->_InternalParse(ptr, ctx);
@@ -501,7 +501,7 @@ class MapEntryImpl : public Base {
  public:  // Needed for constructing tables
   KeyOnMemory key_;
   ValueOnMemory value_;
-  uint32_t _has_bits_[1];
+  ui32 _has_bits_[1];
 
  private:
   friend class ::PROTOBUF_NAMESPACE_ID::Arena;
@@ -642,8 +642,8 @@ struct MapEntryHelper<
   // The proto compiler generates the offsets in this struct as if this was
   // a regular message. This way the table driven code barely notices it's
   // dealing with a map field.
-  uint32_t _has_bits_;     // NOLINT
-  uint32_t _cached_size_;  // NOLINT
+  ui32 _has_bits_;     // NOLINT
+  ui32 _cached_size_;  // NOLINT
   KeyOnMemory key_;      // NOLINT
   ValueOnMemory value_;  // NOLINT
 };
diff --git a/contrib/libs/protobuf/src/google/protobuf/map_field.cc b/contrib/libs/protobuf/src/google/protobuf/map_field.cc
index 8fc49b20f3..3aa8658ac4 100644
--- a/contrib/libs/protobuf/src/google/protobuf/map_field.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/map_field.cc
@@ -236,15 +236,15 @@ void DynamicMapField::AllocateMapValue(MapValueRef* map_val) {
     map_val->SetValue(value);                                \
     break;                                                   \
   }
-    HANDLE_TYPE(INT32, int32_t);
-    HANDLE_TYPE(INT64, int64_t);
-    HANDLE_TYPE(UINT32, uint32_t);
-    HANDLE_TYPE(UINT64, uint64_t);
+    HANDLE_TYPE(INT32, i32);
+    HANDLE_TYPE(INT64, i64);
+    HANDLE_TYPE(UINT32, ui32);
+    HANDLE_TYPE(UINT64, ui64);
     HANDLE_TYPE(DOUBLE, double);
     HANDLE_TYPE(FLOAT, float);
     HANDLE_TYPE(BOOL, bool);
     HANDLE_TYPE(STRING, TProtoStringType);
-    HANDLE_TYPE(ENUM, int32_t);
+    HANDLE_TYPE(ENUM, i32);
 #undef HANDLE_TYPE
     case FieldDescriptor::CPPTYPE_MESSAGE: {
       const Message& message =
@@ -543,15 +543,15 @@ void DynamicMapField::SyncMapWithRepeatedFieldNoLock() const {
     map_val.SetValue(value);                                 \
     break;                                                   \
   }
-      HANDLE_TYPE(INT32, int32_t, Int32);
-      HANDLE_TYPE(INT64, int64_t, Int64);
-      HANDLE_TYPE(UINT32, uint32_t, UInt32);
-      HANDLE_TYPE(UINT64, uint64_t, UInt64);
+      HANDLE_TYPE(INT32, i32, Int32);
+      HANDLE_TYPE(INT64, i64, Int64);
+      HANDLE_TYPE(UINT32, ui32, UInt32);
+      HANDLE_TYPE(UINT64, ui64, UInt64);
       HANDLE_TYPE(DOUBLE, double, Double);
       HANDLE_TYPE(FLOAT, float, Float);
       HANDLE_TYPE(BOOL, bool, Bool);
       HANDLE_TYPE(STRING, TProtoStringType, String);
-      HANDLE_TYPE(ENUM, int32_t, EnumValue);
+      HANDLE_TYPE(ENUM, i32, EnumValue);
 #undef HANDLE_TYPE
       case FieldDescriptor::CPPTYPE_MESSAGE: {
         const Message& message = reflection->GetMessage(*it, val_des);
@@ -586,15 +586,15 @@ size_t DynamicMapField::SpaceUsedExcludingSelfNoLock() const {
     size += sizeof(TYPE) * map_size;         \
     break;                                   \
   }
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64_t);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64_t);
+      HANDLE_TYPE(INT32, i32);
+      HANDLE_TYPE(INT64, i64);
+      HANDLE_TYPE(UINT32, ui32);
+      HANDLE_TYPE(UINT64, ui64);
       HANDLE_TYPE(DOUBLE, double);
       HANDLE_TYPE(FLOAT, float);
       HANDLE_TYPE(BOOL, bool);
       HANDLE_TYPE(STRING, TProtoStringType);
-      HANDLE_TYPE(ENUM, int32_t);
+      HANDLE_TYPE(ENUM, i32);
 #undef HANDLE_TYPE
       case FieldDescriptor::CPPTYPE_MESSAGE: {
         while (it != map_.end()) {
diff --git a/contrib/libs/protobuf/src/google/protobuf/map_field.h b/contrib/libs/protobuf/src/google/protobuf/map_field.h
index 57d691267d..05258a8eea 100644
--- a/contrib/libs/protobuf/src/google/protobuf/map_field.h
+++ b/contrib/libs/protobuf/src/google/protobuf/map_field.h
@@ -96,19 +96,19 @@ class PROTOBUF_EXPORT MapKey {
     return type_;
   }
 
-  void SetInt64Value(int64_t value) {
+  void SetInt64Value(i64 value) {
     SetType(FieldDescriptor::CPPTYPE_INT64);
     val_.int64_value_ = value;
   }
-  void SetUInt64Value(uint64_t value) {
+  void SetUInt64Value(ui64 value) {
     SetType(FieldDescriptor::CPPTYPE_UINT64);
     val_.uint64_value_ = value;
   }
-  void SetInt32Value(int32_t value) {
+  void SetInt32Value(i32 value) {
     SetType(FieldDescriptor::CPPTYPE_INT32);
     val_.int32_value_ = value;
   }
-  void SetUInt32Value(uint32_t value) {
+  void SetUInt32Value(ui32 value) {
     SetType(FieldDescriptor::CPPTYPE_UINT32);
     val_.uint32_value_ = value;
   }
@@ -121,19 +121,19 @@ class PROTOBUF_EXPORT MapKey {
     *val_.string_value_.get_mutable() = std::move(val);
   }
 
-  int64_t GetInt64Value() const {
+  i64 GetInt64Value() const {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapKey::GetInt64Value");
     return val_.int64_value_;
   }
-  uint64_t GetUInt64Value() const {
+  ui64 GetUInt64Value() const {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapKey::GetUInt64Value");
     return val_.uint64_value_;
   }
-  int32_t GetInt32Value() const {
+  i32 GetInt32Value() const {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapKey::GetInt32Value");
     return val_.int32_value_;
   }
-  uint32_t GetUInt32Value() const {
+  ui32 GetUInt32Value() const {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapKey::GetUInt32Value");
     return val_.uint32_value_;
   }
@@ -243,10 +243,10 @@ class PROTOBUF_EXPORT MapKey {
   union KeyValue {
     KeyValue() {}
     internal::ExplicitlyConstructed<TProtoStringType> string_value_;
-    int64_t int64_value_;
-    int32_t int32_value_;
-    uint64_t uint64_value_;
-    uint32_t uint32_value_;
+    i64 int64_value_;
+    i32 int32_value_;
+    ui64 uint64_value_;
+    ui32 uint32_value_;
     bool bool_value_;
   } val_;
 
@@ -592,7 +592,7 @@ class MapField : public TypeDefinedMapFieldBase<Key, T> {
   }
   template <typename UnknownType>
   const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx,
-                                      bool (*is_valid)(int), uint32_t field_num,
+                                      bool (*is_valid)(int), ui32 field_num,
                                       InternalMetadata* metadata) {
     return impl_.template ParseWithEnumValidation<UnknownType>(
         ptr, ctx, is_valid, field_num, metadata);
@@ -683,25 +683,25 @@ class PROTOBUF_EXPORT MapValueConstRef {
  public:
   MapValueConstRef() : data_(nullptr), type_() {}
 
-  int64_t GetInt64Value() const {
+  i64 GetInt64Value() const {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
                "MapValueConstRef::GetInt64Value");
-    return *reinterpret_cast<int64_t*>(data_);
+    return *reinterpret_cast<i64*>(data_);
   }
-  uint64_t GetUInt64Value() const {
+  ui64 GetUInt64Value() const {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
                "MapValueConstRef::GetUInt64Value");
-    return *reinterpret_cast<uint64_t*>(data_);
+    return *reinterpret_cast<ui64*>(data_);
   }
-  int32_t GetInt32Value() const {
+  i32 GetInt32Value() const {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
                "MapValueConstRef::GetInt32Value");
-    return *reinterpret_cast<int32_t*>(data_);
+    return *reinterpret_cast<i32*>(data_);
   }
-  uint32_t GetUInt32Value() const {
+  ui32 GetUInt32Value() const {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
                "MapValueConstRef::GetUInt32Value");
-    return *reinterpret_cast<uint32_t*>(data_);
+    return *reinterpret_cast<ui32*>(data_);
   }
   bool GetBoolValue() const {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapValueConstRef::GetBoolValue");
@@ -775,21 +775,21 @@ class PROTOBUF_EXPORT MapValueRef final : public MapValueConstRef {
  public:
   MapValueRef() {}
 
-  void SetInt64Value(int64_t value) {
+  void SetInt64Value(i64 value) {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64, "MapValueRef::SetInt64Value");
-    *reinterpret_cast<int64_t*>(data_) = value;
+    *reinterpret_cast<i64*>(data_) = value;
   }
-  void SetUInt64Value(uint64_t value) {
+  void SetUInt64Value(ui64 value) {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64, "MapValueRef::SetUInt64Value");
-    *reinterpret_cast<uint64_t*>(data_) = value;
+    *reinterpret_cast<ui64*>(data_) = value;
   }
-  void SetInt32Value(int32_t value) {
+  void SetInt32Value(i32 value) {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32, "MapValueRef::SetInt32Value");
-    *reinterpret_cast<int32_t*>(data_) = value;
+    *reinterpret_cast<i32*>(data_) = value;
   }
-  void SetUInt32Value(uint32_t value) {
+  void SetUInt32Value(ui32 value) {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32, "MapValueRef::SetUInt32Value");
-    *reinterpret_cast<uint32_t*>(data_) = value;
+    *reinterpret_cast<ui32*>(data_) = value;
   }
   void SetBoolValue(bool value) {
     TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL, "MapValueRef::SetBoolValue");
@@ -830,15 +830,15 @@ class PROTOBUF_EXPORT MapValueRef final : public MapValueConstRef {
     delete reinterpret_cast<TYPE*>(data_);   \
     break;                                   \
   }
-      HANDLE_TYPE(INT32, int32_t);
-      HANDLE_TYPE(INT64, int64_t);
-      HANDLE_TYPE(UINT32, uint32_t);
-      HANDLE_TYPE(UINT64, uint64_t);
+      HANDLE_TYPE(INT32, i32);
+      HANDLE_TYPE(INT64, i64);
+      HANDLE_TYPE(UINT32, ui32);
+      HANDLE_TYPE(UINT64, ui64);
       HANDLE_TYPE(DOUBLE, double);
       HANDLE_TYPE(FLOAT, float);
       HANDLE_TYPE(BOOL, bool);
       HANDLE_TYPE(STRING, TProtoStringType);
-      HANDLE_TYPE(ENUM, int32_t);
+      HANDLE_TYPE(ENUM, i32);
       HANDLE_TYPE(MESSAGE, Message);
 #undef HANDLE_TYPE
     }
diff --git a/contrib/libs/protobuf/src/google/protobuf/map_field_inl.h b/contrib/libs/protobuf/src/google/protobuf/map_field_inl.h
index 0ff81e3dcb..78d96b8f44 100644
--- a/contrib/libs/protobuf/src/google/protobuf/map_field_inl.h
+++ b/contrib/libs/protobuf/src/google/protobuf/map_field_inl.h
@@ -49,31 +49,21 @@ namespace internal {
 template <typename T>
 T UnwrapMapKey(const MapKey& map_key);
 template <>
-inline int32_t UnwrapMapKey<int32_t>(const MapKey& map_key) {
+inline i32 UnwrapMapKey<i32>(const MapKey& map_key) {
   return map_key.GetInt32Value();
 }
 template <>
-inline uint32_t UnwrapMapKey<uint32_t>(const MapKey& map_key) {
+inline ui32 UnwrapMapKey<ui32>(const MapKey& map_key) {
   return map_key.GetUInt32Value();
 }
 template <>
-inline int64 UnwrapMapKey<int64>(const MapKey& map_key) {
+inline i64 UnwrapMapKey<i64>(const MapKey& map_key) {
   return map_key.GetInt64Value();
 }
 template <>
-inline uint64 UnwrapMapKey<uint64>(const MapKey& map_key) {
+inline ui64 UnwrapMapKey<ui64>(const MapKey& map_key) {
   return map_key.GetUInt64Value();
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-template <>
-inline int64_t UnwrapMapKey<int64_t>(const MapKey& map_key) {
-  return map_key.GetInt64Value();
-}
-template <>
-inline uint64_t UnwrapMapKey<uint64_t>(const MapKey& map_key) {
-  return map_key.GetUInt64Value();
-}
-#endif
 template <>
 inline bool UnwrapMapKey<bool>(const MapKey& map_key) {
   return map_key.GetBoolValue();
@@ -87,33 +77,21 @@ inline TProtoStringType UnwrapMapKey<TProtoStringType>(const MapKey& map_key) {
 template <typename T>
 inline void SetMapKey(MapKey* map_key, const T& value);
 template <>
-inline void SetMapKey<int32_t>(MapKey* map_key, const int32_t& value) {
+inline void SetMapKey<i32>(MapKey* map_key, const i32& value) {
   map_key->SetInt32Value(value);
 }
 template <>
-inline void SetMapKey<uint32_t>(MapKey* map_key, const uint32_t& value) {
+inline void SetMapKey<ui32>(MapKey* map_key, const ui32& value) {
   map_key->SetUInt32Value(value);
 }
 template <>
-inline void SetMapKey<int64>(MapKey* map_key, const int64& value) {
+inline void SetMapKey<i64>(MapKey* map_key, const i64& value) {
   map_key->SetInt64Value(value);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
 template <>
-inline void SetMapKey<int64_t>(MapKey* map_key, const int64_t& value) {
-  map_key->SetInt64Value(value);
-}
-#endif
-template <>
-inline void SetMapKey<uint64>(MapKey* map_key, const uint64& value) {
+inline void SetMapKey<ui64>(MapKey* map_key, const ui64& value) {
   map_key->SetUInt64Value(value);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-template <>
-inline void SetMapKey<uint64_t>(MapKey* map_key, const uint64_t& value) {
-  map_key->SetUInt64Value(value);
-}
-#endif
 template <>
 inline void SetMapKey<bool>(MapKey* map_key, const bool& value) {
   map_key->SetBoolValue(value);
diff --git a/contrib/libs/protobuf/src/google/protobuf/map_field_lite.h b/contrib/libs/protobuf/src/google/protobuf/map_field_lite.h
index 2a321063e1..91edd5f82f 100644
--- a/contrib/libs/protobuf/src/google/protobuf/map_field_lite.h
+++ b/contrib/libs/protobuf/src/google/protobuf/map_field_lite.h
@@ -106,7 +106,7 @@ class MapFieldLite {
 
   template <typename UnknownType>
   const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx,
-                                      bool (*is_valid)(int), uint32_t field_num,
+                                      bool (*is_valid)(int), ui32 field_num,
                                       InternalMetadata* metadata) {
     typename Derived::template Parser<MapFieldLite, Map<Key, T>> parser(this);
     return parser.template ParseWithEnumValidation<UnknownType>(
@@ -129,7 +129,7 @@ struct EnumParseWrapper {
   }
   T* map_field;
   bool (*is_valid)(int);
-  uint32_t field_num;
+  ui32 field_num;
   InternalMetadata* metadata;
 };
 
@@ -138,7 +138,7 @@ struct EnumParseWrapper {
 // generated code
 template <typename UnknownType, typename T>
 EnumParseWrapper<UnknownType, T> InitEnumParseWrapper(
-    T* map_field, bool (*is_valid)(int), uint32_t field_num,
+    T* map_field, bool (*is_valid)(int), ui32 field_num,
     InternalMetadata* metadata) {
   return EnumParseWrapper<UnknownType, T>{map_field, is_valid, field_num,
                                           metadata};
diff --git a/contrib/libs/protobuf/src/google/protobuf/map_type_handler.h b/contrib/libs/protobuf/src/google/protobuf/map_type_handler.h
index 22a0f9325f..5ca4e62159 100644
--- a/contrib/libs/protobuf/src/google/protobuf/map_type_handler.h
+++ b/contrib/libs/protobuf/src/google/protobuf/map_type_handler.h
@@ -100,19 +100,19 @@ class MapWireFieldTypeTraits {};
 TYPE_TRAITS(MESSAGE, Type, LENGTH_DELIMITED, true, false)
 TYPE_TRAITS(STRING, ArenaStringPtr, LENGTH_DELIMITED, false, false)
 TYPE_TRAITS(BYTES, ArenaStringPtr, LENGTH_DELIMITED, false, false)
-TYPE_TRAITS(INT64, int64, VARINT, false, false)
-TYPE_TRAITS(UINT64, uint64, VARINT, false, false)
-TYPE_TRAITS(INT32, int32_t, VARINT, false, false)
-TYPE_TRAITS(UINT32, uint32_t, VARINT, false, false)
-TYPE_TRAITS(SINT64, int64, VARINT, false, false)
-TYPE_TRAITS(SINT32, int32_t, VARINT, false, false)
+TYPE_TRAITS(INT64, i64, VARINT, false, false)
+TYPE_TRAITS(UINT64, ui64, VARINT, false, false)
+TYPE_TRAITS(INT32, i32, VARINT, false, false)
+TYPE_TRAITS(UINT32, ui32, VARINT, false, false)
+TYPE_TRAITS(SINT64, i64, VARINT, false, false)
+TYPE_TRAITS(SINT32, i32, VARINT, false, false)
 TYPE_TRAITS(ENUM, int, VARINT, false, true)
 TYPE_TRAITS(DOUBLE, double, FIXED64, false, false)
 TYPE_TRAITS(FLOAT, float, FIXED32, false, false)
-TYPE_TRAITS(FIXED64, uint64, FIXED64, false, false)
-TYPE_TRAITS(FIXED32, uint32_t, FIXED32, false, false)
-TYPE_TRAITS(SFIXED64, int64, FIXED64, false, false)
-TYPE_TRAITS(SFIXED32, int32_t, FIXED32, false, false)
+TYPE_TRAITS(FIXED64, ui64, FIXED64, false, false)
+TYPE_TRAITS(FIXED32, ui32, FIXED32, false, false)
+TYPE_TRAITS(SFIXED64, i64, FIXED64, false, false)
+TYPE_TRAITS(SFIXED32, i32, FIXED32, false, false)
 TYPE_TRAITS(BOOL, bool, VARINT, false, false)
 
 #undef TYPE_TRAITS
@@ -406,23 +406,23 @@ const char* MapTypeHandler<WireFormatLite::TYPE_BYTES, Type>::Read(
   return ctx->ReadString(ptr, size, value);
 }
 
-inline const char* ReadINT64(const char* ptr, int64* value) {
-  return VarintParse(ptr, reinterpret_cast<uint64*>(value));
+inline const char* ReadINT64(const char* ptr, i64* value) {
+  return VarintParse(ptr, reinterpret_cast<ui64*>(value));
 }
-inline const char* ReadUINT64(const char* ptr, uint64* value) {
+inline const char* ReadUINT64(const char* ptr, ui64* value) {
   return VarintParse(ptr, value);
 }
-inline const char* ReadINT32(const char* ptr, int32_t* value) {
-  return VarintParse(ptr, reinterpret_cast<uint32_t*>(value));
+inline const char* ReadINT32(const char* ptr, i32* value) {
+  return VarintParse(ptr, reinterpret_cast<ui32*>(value));
 }
-inline const char* ReadUINT32(const char* ptr, uint32_t* value) {
+inline const char* ReadUINT32(const char* ptr, ui32* value) {
   return VarintParse(ptr, value);
 }
-inline const char* ReadSINT64(const char* ptr, int64* value) {
+inline const char* ReadSINT64(const char* ptr, i64* value) {
   *value = ReadVarintZigZag64(&ptr);
   return ptr;
 }
-inline const char* ReadSINT32(const char* ptr, int32_t* value) {
+inline const char* ReadSINT32(const char* ptr, i32* value) {
   *value = ReadVarintZigZag32(&ptr);
   return ptr;
 }
@@ -447,16 +447,16 @@ inline const char* ReadFLOAT(const char* ptr, float* value) {
 inline const char* ReadDOUBLE(const char* ptr, double* value) {
   return ReadUnaligned(ptr, value);
 }
-inline const char* ReadFIXED64(const char* ptr, uint64* value) {
+inline const char* ReadFIXED64(const char* ptr, ui64* value) {
   return ReadUnaligned(ptr, value);
 }
-inline const char* ReadFIXED32(const char* ptr, uint32_t* value) {
+inline const char* ReadFIXED32(const char* ptr, ui32* value) {
   return ReadUnaligned(ptr, value);
 }
-inline const char* ReadSFIXED64(const char* ptr, int64* value) {
+inline const char* ReadSFIXED64(const char* ptr, i64* value) {
   return ReadUnaligned(ptr, value);
 }
-inline const char* ReadSFIXED32(const char* ptr, int32_t* value) {
+inline const char* ReadSFIXED32(const char* ptr, i32* value) {
   return ReadUnaligned(ptr, value);
 }
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/message.cc b/contrib/libs/protobuf/src/google/protobuf/message.cc
index aa0e24bb0c..8d28f595f6 100644
--- a/contrib/libs/protobuf/src/google/protobuf/message.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/message.cc
@@ -251,7 +251,7 @@ size_t Message::SpaceUsedLong() const {
   return GetReflection()->SpaceUsedLong(*this);
 }
 
-uint64_t Message::GetInvariantPerBuild(uint64_t salt) {
+ui64 Message::GetInvariantPerBuild(ui64 salt) {
   return salt;
 }
 
@@ -389,14 +389,14 @@ const internal::RepeatedFieldAccessor* Reflection::RepeatedFieldAccessor(
 #define HANDLE_PRIMITIVE_TYPE(TYPE, type) \
   case FieldDescriptor::CPPTYPE_##TYPE:   \
     return GetSingleton<internal::RepeatedFieldPrimitiveAccessor<type> >();
-    HANDLE_PRIMITIVE_TYPE(INT32, int32_t)
-    HANDLE_PRIMITIVE_TYPE(UINT32, uint32_t)
-    HANDLE_PRIMITIVE_TYPE(INT64, int64_t)
-    HANDLE_PRIMITIVE_TYPE(UINT64, uint64_t)
+    HANDLE_PRIMITIVE_TYPE(INT32, i32)
+    HANDLE_PRIMITIVE_TYPE(UINT32, ui32)
+    HANDLE_PRIMITIVE_TYPE(INT64, i64)
+    HANDLE_PRIMITIVE_TYPE(UINT64, ui64)
     HANDLE_PRIMITIVE_TYPE(FLOAT, float)
     HANDLE_PRIMITIVE_TYPE(DOUBLE, double)
     HANDLE_PRIMITIVE_TYPE(BOOL, bool)
-    HANDLE_PRIMITIVE_TYPE(ENUM, int32_t)
+    HANDLE_PRIMITIVE_TYPE(ENUM, i32)
 #undef HANDLE_PRIMITIVE_TYPE
     case FieldDescriptor::CPPTYPE_STRING:
       switch (field->options().ctype()) {
diff --git a/contrib/libs/protobuf/src/google/protobuf/message.h b/contrib/libs/protobuf/src/google/protobuf/message.h
index d25d9f414b..451c78e87c 100644
--- a/contrib/libs/protobuf/src/google/protobuf/message.h
+++ b/contrib/libs/protobuf/src/google/protobuf/message.h
@@ -206,18 +206,18 @@ struct Metadata {
 
 namespace internal {
 template <class To>
-inline To* GetPointerAtOffset(Message* message, uint32_t offset) {
+inline To* GetPointerAtOffset(Message* message, ui32 offset) {
   return reinterpret_cast<To*>(reinterpret_cast<char*>(message) + offset);
 }
 
 template <class To>
-const To* GetConstPointerAtOffset(const Message* message, uint32_t offset) {
+const To* GetConstPointerAtOffset(const Message* message, ui32 offset) {
   return reinterpret_cast<const To*>(reinterpret_cast<const char*>(message) +
                                      offset);
 }
 
 template <class To>
-const To& GetConstRefAtOffset(const Message& message, uint32_t offset) {
+const To& GetConstRefAtOffset(const Message& message, ui32 offset) {
   return *GetConstPointerAtOffset<To>(&message, offset);
 }
 
@@ -421,7 +421,7 @@ class PROTOBUF_EXPORT Message : public MessageLite {
 
 
  protected:
-  static uint64_t GetInvariantPerBuild(uint64_t salt);
+  static ui64 GetInvariantPerBuild(ui64 salt);
 
  private:
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Message);
@@ -575,11 +575,11 @@ class PROTOBUF_EXPORT Reflection final {
   // These get the value of a non-repeated field.  They return the default
   // value for fields that aren't set.
 
-  int32_t GetInt32(const Message& message, const FieldDescriptor* field) const;
-  int64 GetInt64(const Message& message, const FieldDescriptor* field) const;
-  uint32_t GetUInt32(const Message& message,
+  i32 GetInt32(const Message& message, const FieldDescriptor* field) const;
+  i64 GetInt64(const Message& message, const FieldDescriptor* field) const;
+  ui32 GetUInt32(const Message& message,
                      const FieldDescriptor* field) const;
-  uint64 GetUInt64(const Message& message,
+  ui64 GetUInt64(const Message& message,
                      const FieldDescriptor* field) const;
   float GetFloat(const Message& message, const FieldDescriptor* field) const;
   double GetDouble(const Message& message, const FieldDescriptor* field) const;
@@ -625,13 +625,13 @@ class PROTOBUF_EXPORT Reflection final {
   // These mutate the value of a non-repeated field.
 
   void SetInt32(Message* message, const FieldDescriptor* field,
-                int32_t value) const;
+                i32 value) const;
   void SetInt64(Message* message, const FieldDescriptor* field,
-                int64 value) const;
+                i64 value) const;
   void SetUInt32(Message* message, const FieldDescriptor* field,
-                 uint32_t value) const;
+                 ui32 value) const;
   void SetUInt64(Message* message, const FieldDescriptor* field,
-                 uint64 value) const;
+                 ui64 value) const;
   void SetFloat(Message* message, const FieldDescriptor* field,
                 float value) const;
   void SetDouble(Message* message, const FieldDescriptor* field,
@@ -700,13 +700,13 @@ class PROTOBUF_EXPORT Reflection final {
   // Repeated field getters ------------------------------------------
   // These get the value of one element of a repeated field.
 
-  int32_t GetRepeatedInt32(const Message& message, const FieldDescriptor* field,
+  i32 GetRepeatedInt32(const Message& message, const FieldDescriptor* field,
                            int index) const;
-  int64 GetRepeatedInt64(const Message& message, const FieldDescriptor* field,
+  i64 GetRepeatedInt64(const Message& message, const FieldDescriptor* field,
                            int index) const;
-  uint32_t GetRepeatedUInt32(const Message& message,
+  ui32 GetRepeatedUInt32(const Message& message,
                              const FieldDescriptor* field, int index) const;
-  uint64 GetRepeatedUInt64(const Message& message,
+  ui64 GetRepeatedUInt64(const Message& message,
                              const FieldDescriptor* field, int index) const;
   float GetRepeatedFloat(const Message& message, const FieldDescriptor* field,
                          int index) const;
@@ -741,13 +741,13 @@ class PROTOBUF_EXPORT Reflection final {
   // These mutate the value of one element of a repeated field.
 
   void SetRepeatedInt32(Message* message, const FieldDescriptor* field,
-                        int index, int32_t value) const;
+                        int index, i32 value) const;
   void SetRepeatedInt64(Message* message, const FieldDescriptor* field,
-                        int index, int64 value) const;
+                        int index, i64 value) const;
   void SetRepeatedUInt32(Message* message, const FieldDescriptor* field,
-                         int index, uint32_t value) const;
+                         int index, ui32 value) const;
   void SetRepeatedUInt64(Message* message, const FieldDescriptor* field,
-                         int index, uint64 value) const;
+                         int index, ui64 value) const;
   void SetRepeatedFloat(Message* message, const FieldDescriptor* field,
                         int index, float value) const;
   void SetRepeatedDouble(Message* message, const FieldDescriptor* field,
@@ -778,13 +778,13 @@ class PROTOBUF_EXPORT Reflection final {
   // These add an element to a repeated field.
 
   void AddInt32(Message* message, const FieldDescriptor* field,
-                int32_t value) const;
+                i32 value) const;
   void AddInt64(Message* message, const FieldDescriptor* field,
-                int64 value) const;
+                i64 value) const;
   void AddUInt32(Message* message, const FieldDescriptor* field,
-                 uint32_t value) const;
+                 ui32 value) const;
   void AddUInt64(Message* message, const FieldDescriptor* field,
-                 uint64 value) const;
+                 ui64 value) const;
   void AddFloat(Message* message, const FieldDescriptor* field,
                 float value) const;
   void AddDouble(Message* message, const FieldDescriptor* field,
@@ -827,14 +827,14 @@ class PROTOBUF_EXPORT Reflection final {
   // to acceptable T.
   //
   //   field->cpp_type()      T
-  //   CPPTYPE_INT32        int32_t
-  //   CPPTYPE_UINT32       uint32_t
-  //   CPPTYPE_INT64        int64_t
-  //   CPPTYPE_UINT64       uint64_t
+  //   CPPTYPE_INT32        i32
+  //   CPPTYPE_UINT32       ui32
+  //   CPPTYPE_INT64        i64
+  //   CPPTYPE_UINT64       ui64
   //   CPPTYPE_DOUBLE       double
   //   CPPTYPE_FLOAT        float
   //   CPPTYPE_BOOL         bool
-  //   CPPTYPE_ENUM         generated enum type or int32_t
+  //   CPPTYPE_ENUM         generated enum type or i32
   //   CPPTYPE_STRING       TProtoStringType
   //   CPPTYPE_MESSAGE      generated message type or google::protobuf::Message
   //
@@ -1157,11 +1157,11 @@ class PROTOBUF_EXPORT Reflection final {
 
   const Message* GetDefaultMessageInstance(const FieldDescriptor* field) const;
 
-  inline const uint32_t* GetHasBits(const Message& message) const;
-  inline uint32_t* MutableHasBits(Message* message) const;
-  inline uint32_t GetOneofCase(const Message& message,
+  inline const ui32* GetHasBits(const Message& message) const;
+  inline ui32* MutableHasBits(Message* message) const;
+  inline ui32 GetOneofCase(const Message& message,
                                const OneofDescriptor* oneof_descriptor) const;
-  inline uint32_t* MutableOneofCase(
+  inline ui32* MutableOneofCase(
       Message* message, const OneofDescriptor* oneof_descriptor) const;
   inline bool HasExtensionSet(const Message& /* message */) const {
     return schema_.HasExtensionSet();
@@ -1183,9 +1183,9 @@ class PROTOBUF_EXPORT Reflection final {
   inline void SwapBit(Message* message1, Message* message2,
                       const FieldDescriptor* field) const;
 
-  inline const uint32_t* GetInlinedStringDonatedArray(
+  inline const ui32* GetInlinedStringDonatedArray(
       const Message& message) const;
-  inline uint32_t* MutableInlinedStringDonatedArray(Message* message) const;
+  inline ui32* MutableInlinedStringDonatedArray(Message* message) const;
   inline bool IsInlinedStringDonated(const Message& message,
                                      const FieldDescriptor* field) const;
 
@@ -1354,10 +1354,10 @@ class PROTOBUF_EXPORT MessageFactory {
   Reflection::MutableRepeatedFieldInternal<TYPE>(                  \
       Message * message, const FieldDescriptor* field) const;
 
-DECLARE_GET_REPEATED_FIELD(int32_t)
-DECLARE_GET_REPEATED_FIELD(int64)
-DECLARE_GET_REPEATED_FIELD(uint32_t)
-DECLARE_GET_REPEATED_FIELD(uint64)
+DECLARE_GET_REPEATED_FIELD(i32)
+DECLARE_GET_REPEATED_FIELD(i64)
+DECLARE_GET_REPEATED_FIELD(ui32)
+DECLARE_GET_REPEATED_FIELD(ui64)
 DECLARE_GET_REPEATED_FIELD(float)
 DECLARE_GET_REPEATED_FIELD(double)
 DECLARE_GET_REPEATED_FIELD(bool)
@@ -1483,17 +1483,17 @@ const Type& Reflection::DefaultRaw(const FieldDescriptor* field) const {
   return *reinterpret_cast<const Type*>(schema_.GetFieldDefault(field));
 }
 
-uint32_t Reflection::GetOneofCase(
+ui32 Reflection::GetOneofCase(
     const Message& message, const OneofDescriptor* oneof_descriptor) const {
   GOOGLE_DCHECK(!oneof_descriptor->is_synthetic());
-  return internal::GetConstRefAtOffset<uint32_t>(
+  return internal::GetConstRefAtOffset<ui32>(
       message, schema_.GetOneofCaseOffset(oneof_descriptor));
 }
 
 bool Reflection::HasOneofField(const Message& message,
                                const FieldDescriptor* field) const {
   return (GetOneofCase(message, field->containing_oneof()) ==
-          static_cast<uint32_t>(field->number()));
+          static_cast<ui32>(field->number()));
 }
 
 template <typename Type>
diff --git a/contrib/libs/protobuf/src/google/protobuf/message_lite.cc b/contrib/libs/protobuf/src/google/protobuf/message_lite.cc
index 1fa4ee5c21..fba73634b7 100644
--- a/contrib/libs/protobuf/src/google/protobuf/message_lite.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/message_lite.cc
@@ -393,7 +393,7 @@ bool MessageLite::SerializePartialToCodedStream(
   }
   int final_byte_count = output->ByteCount();
 
-  if (final_byte_count - original_byte_count != static_cast<int64_t>(size)) {
+  if (final_byte_count - original_byte_count != static_cast<i64>(size)) {
     ByteSizeConsistencyError(size, ByteSizeLong(),
                              final_byte_count - original_byte_count, *this);
   }
@@ -492,7 +492,7 @@ bool MessageLite::SerializePartialToArray(void* data, int size) const {
                << " exceeded maximum protobuf size of 2GB: " << byte_size;
     return false;
   }
-  if (size < static_cast<int64_t>(byte_size)) return false;
+  if (size < static_cast<i64>(byte_size)) return false;
   uint8_t* start = reinterpret_cast<uint8_t*>(data);
   SerializeToArrayImpl(*this, start, byte_size);
   return true;
diff --git a/contrib/libs/protobuf/src/google/protobuf/message_lite.h b/contrib/libs/protobuf/src/google/protobuf/message_lite.h
index d7a9f678b3..e754e6b62b 100644
--- a/contrib/libs/protobuf/src/google/protobuf/message_lite.h
+++ b/contrib/libs/protobuf/src/google/protobuf/message_lite.h
@@ -158,7 +158,7 @@ class ExplicitlyConstructed {
   // Prefer c++14 aligned_storage, but for compatibility this will do.
   union AlignedUnion {
     alignas(T) char space[sizeof(T)];
-    int64_t align_to_int64;
+    i64 align_to_int64;
     void* align_to_ptr;
   } union_;
 };
diff --git a/contrib/libs/protobuf/src/google/protobuf/parse_context.cc b/contrib/libs/protobuf/src/google/protobuf/parse_context.cc
index ca5afad600..71346327d4 100644
--- a/contrib/libs/protobuf/src/google/protobuf/parse_context.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/parse_context.cc
@@ -55,7 +55,7 @@ bool ParseEndsInSlopRegion(const char* begin, int overrun, int depth) {
   auto ptr = begin + overrun;
   auto end = begin + kSlopBytes;
   while (ptr < end) {
-    uint32_t tag;
+    ui32 tag;
     ptr = ReadTag(ptr, &tag);
     if (ptr == nullptr || ptr > end) return false;
     // ending on 0 tag is allowed and is the major reason for the necessity of
@@ -63,7 +63,7 @@ bool ParseEndsInSlopRegion(const char* begin, int overrun, int depth) {
     if (tag == 0) return true;
     switch (tag & 7) {
       case 0: {  // Varint
-        uint64_t val;
+        ui64 val;
         ptr = VarintParse(ptr, &val);
         if (ptr == nullptr) return false;
         break;
@@ -73,7 +73,7 @@ bool ParseEndsInSlopRegion(const char* begin, int overrun, int depth) {
         break;
       }
       case 2: {  // len delim
-        int32_t size = ReadSize(&ptr);
+        i32 size = ReadSize(&ptr);
         if (ptr == nullptr || size > end - ptr) return false;
         ptr += size;
         break;
@@ -240,11 +240,11 @@ template <>
 void byteswap<1>(void* p) {}
 template <>
 void byteswap<4>(void* p) {
-  *static_cast<uint32_t*>(p) = bswap_32(*static_cast<uint32_t*>(p));
+  *static_cast<ui32*>(p) = bswap_32(*static_cast<ui32*>(p));
 }
 template <>
 void byteswap<8>(void* p) {
-  *static_cast<uint64_t*>(p) = bswap_64(*static_cast<uint64_t*>(p));
+  *static_cast<ui64*>(p) = bswap_64(*static_cast<ui64*>(p));
 }
 
 const char* EpsCopyInputStream::InitFrom(io::ZeroCopyInputStream* zcis) {
@@ -297,7 +297,7 @@ const char* ParseContext::ParseMessage(MessageLite* msg, const char* ptr) {
   return ptr;
 }
 
-inline void WriteVarint(uint64_t val, TProtoStringType* s) {
+inline void WriteVarint(ui64 val, TProtoStringType* s) {
   while (val >= 128) {
     uint8_t c = val | 0x80;
     s->push_back(c);
@@ -306,29 +306,29 @@ inline void WriteVarint(uint64_t val, TProtoStringType* s) {
   s->push_back(val);
 }
 
-void WriteVarint(uint32_t num, uint64_t val, TProtoStringType* s) {
+void WriteVarint(ui32 num, ui64 val, TProtoStringType* s) {
   WriteVarint(num << 3, s);
   WriteVarint(val, s);
 }
 
-void WriteLengthDelimited(uint32_t num, StringPiece val, TProtoStringType* s) {
+void WriteLengthDelimited(ui32 num, StringPiece val, TProtoStringType* s) {
   WriteVarint((num << 3) + 2, s);
   WriteVarint(val.size(), s);
   s->append(val.data(), val.size());
 }
 
-std::pair<const char*, uint32_t> VarintParseSlow32(const char* p,
-                                                   uint32_t res) {
-  for (std::uint32_t i = 2; i < 5; i++) {
-    uint32_t byte = static_cast<uint8_t>(p[i]);
+std::pair<const char*, ui32> VarintParseSlow32(const char* p,
+                                                   ui32 res) {
+  for (ui32 i = 2; i < 5; i++) {
+    ui32 byte = static_cast<uint8_t>(p[i]);
     res += (byte - 1) << (7 * i);
     if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
       return {p + i + 1, res};
     }
   }
   // Accept >5 bytes
-  for (std::uint32_t i = 5; i < 10; i++) {
-    uint32_t byte = static_cast<uint8_t>(p[i]);
+  for (ui32 i = 5; i < 10; i++) {
+    ui32 byte = static_cast<uint8_t>(p[i]);
     if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
       return {p + i + 1, res};
     }
@@ -336,11 +336,11 @@ std::pair<const char*, uint32_t> VarintParseSlow32(const char* p,
   return {nullptr, 0};
 }
 
-std::pair<const char*, uint64_t> VarintParseSlow64(const char* p,
-                                                   uint32_t res32) {
-  uint64_t res = res32;
-  for (std::uint32_t i = 2; i < 10; i++) {
-    uint64_t byte = static_cast<uint8_t>(p[i]);
+std::pair<const char*, ui64> VarintParseSlow64(const char* p,
+                                                   ui32 res32) {
+  ui64 res = res32;
+  for (ui32 i = 2; i < 10; i++) {
+    ui64 byte = static_cast<uint8_t>(p[i]);
     res += (byte - 1) << (7 * i);
     if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
       return {p + i + 1, res};
@@ -349,9 +349,9 @@ std::pair<const char*, uint64_t> VarintParseSlow64(const char* p,
   return {nullptr, 0};
 }
 
-std::pair<const char*, uint32_t> ReadTagFallback(const char* p, uint32_t res) {
-  for (std::uint32_t i = 2; i < 5; i++) {
-    uint32_t byte = static_cast<uint8_t>(p[i]);
+std::pair<const char*, ui32> ReadTagFallback(const char* p, ui32 res) {
+  for (ui32 i = 2; i < 5; i++) {
+    ui32 byte = static_cast<uint8_t>(p[i]);
     res += (byte - 1) << (7 * i);
     if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
       return {p + i + 1, res};
@@ -360,15 +360,15 @@ std::pair<const char*, uint32_t> ReadTagFallback(const char* p, uint32_t res) {
   return {nullptr, 0};
 }
 
-std::pair<const char*, int32_t> ReadSizeFallback(const char* p, uint32_t res) {
-  for (std::uint32_t i = 1; i < 4; i++) {
-    uint32_t byte = static_cast<uint8_t>(p[i]);
+std::pair<const char*, i32> ReadSizeFallback(const char* p, ui32 res) {
+  for (ui32 i = 1; i < 4; i++) {
+    ui32 byte = static_cast<uint8_t>(p[i]);
     res += (byte - 1) << (7 * i);
     if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
       return {p + i + 1, res};
     }
   }
-  std::uint32_t byte = static_cast<uint8_t>(p[4]);
+  ui32 byte = static_cast<uint8_t>(p[4]);
   if (PROTOBUF_PREDICT_FALSE(byte >= 8)) return {nullptr, 0};  // size >= 2gb
   res += (byte - 1) << 28;
   // Protect against sign integer overflow in PushLimit. Limits are relative
@@ -409,7 +409,7 @@ const char* InlineGreedyStringParser(TProtoStringType* s, const char* ptr,
 
 template <typename T, bool sign>
 const char* VarintParser(void* object, const char* ptr, ParseContext* ctx) {
-  return ctx->ReadPackedVarint(ptr, [object](uint64_t varint) {
+  return ctx->ReadPackedVarint(ptr, [object](ui64 varint) {
     T val;
     if (sign) {
       if (sizeof(T) == 8) {
@@ -426,27 +426,27 @@ const char* VarintParser(void* object, const char* ptr, ParseContext* ctx) {
 
 const char* PackedInt32Parser(void* object, const char* ptr,
                               ParseContext* ctx) {
-  return VarintParser<int32_t, false>(object, ptr, ctx);
+  return VarintParser<i32, false>(object, ptr, ctx);
 }
 const char* PackedUInt32Parser(void* object, const char* ptr,
                                ParseContext* ctx) {
-  return VarintParser<uint32_t, false>(object, ptr, ctx);
+  return VarintParser<ui32, false>(object, ptr, ctx);
 }
 const char* PackedInt64Parser(void* object, const char* ptr,
                               ParseContext* ctx) {
-  return VarintParser<int64_t, false>(object, ptr, ctx);
+  return VarintParser<i64, false>(object, ptr, ctx);
 }
 const char* PackedUInt64Parser(void* object, const char* ptr,
                                ParseContext* ctx) {
-  return VarintParser<uint64_t, false>(object, ptr, ctx);
+  return VarintParser<ui64, false>(object, ptr, ctx);
 }
 const char* PackedSInt32Parser(void* object, const char* ptr,
                                ParseContext* ctx) {
-  return VarintParser<int32_t, true>(object, ptr, ctx);
+  return VarintParser<i32, true>(object, ptr, ctx);
 }
 const char* PackedSInt64Parser(void* object, const char* ptr,
                                ParseContext* ctx) {
-  return VarintParser<int64_t, true>(object, ptr, ctx);
+  return VarintParser<i64, true>(object, ptr, ctx);
 }
 
 const char* PackedEnumParser(void* object, const char* ptr, ParseContext* ctx) {
@@ -467,19 +467,19 @@ const char* FixedParser(void* object, const char* ptr, ParseContext* ctx) {
 
 const char* PackedFixed32Parser(void* object, const char* ptr,
                                 ParseContext* ctx) {
-  return FixedParser<uint32_t>(object, ptr, ctx);
+  return FixedParser<ui32>(object, ptr, ctx);
 }
 const char* PackedSFixed32Parser(void* object, const char* ptr,
                                  ParseContext* ctx) {
-  return FixedParser<int32_t>(object, ptr, ctx);
+  return FixedParser<i32>(object, ptr, ctx);
 }
 const char* PackedFixed64Parser(void* object, const char* ptr,
                                 ParseContext* ctx) {
-  return FixedParser<uint64_t>(object, ptr, ctx);
+  return FixedParser<ui64>(object, ptr, ctx);
 }
 const char* PackedSFixed64Parser(void* object, const char* ptr,
                                  ParseContext* ctx) {
-  return FixedParser<int64_t>(object, ptr, ctx);
+  return FixedParser<i64>(object, ptr, ctx);
 }
 const char* PackedFloatParser(void* object, const char* ptr,
                               ParseContext* ctx) {
@@ -495,12 +495,12 @@ class UnknownFieldLiteParserHelper {
   explicit UnknownFieldLiteParserHelper(TProtoStringType* unknown)
       : unknown_(unknown) {}
 
-  void AddVarint(uint32_t num, uint64_t value) {
+  void AddVarint(ui32 num, ui64 value) {
     if (unknown_ == nullptr) return;
     WriteVarint(num * 8, unknown_);
     WriteVarint(value, unknown_);
   }
-  void AddFixed64(uint32_t num, uint64_t value) {
+  void AddFixed64(ui32 num, ui64 value) {
     if (unknown_ == nullptr) return;
     WriteVarint(num * 8 + 1, unknown_);
     char buffer[8];
@@ -508,7 +508,7 @@ class UnknownFieldLiteParserHelper {
         value, reinterpret_cast<uint8_t*>(buffer));
     unknown_->append(buffer, 8);
   }
-  const char* ParseLengthDelimited(uint32_t num, const char* ptr,
+  const char* ParseLengthDelimited(ui32 num, const char* ptr,
                                    ParseContext* ctx) {
     int size = ReadSize(&ptr);
     GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
@@ -517,14 +517,14 @@ class UnknownFieldLiteParserHelper {
     WriteVarint(size, unknown_);
     return ctx->AppendString(ptr, size, unknown_);
   }
-  const char* ParseGroup(uint32_t num, const char* ptr, ParseContext* ctx) {
+  const char* ParseGroup(ui32 num, const char* ptr, ParseContext* ctx) {
     if (unknown_) WriteVarint(num * 8 + 3, unknown_);
     ptr = ctx->ParseGroup(this, ptr, num * 8 + 3);
     GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
     if (unknown_) WriteVarint(num * 8 + 4, unknown_);
     return ptr;
   }
-  void AddFixed32(uint32_t num, uint32_t value) {
+  void AddFixed32(ui32 num, ui32 value) {
     if (unknown_ == nullptr) return;
     WriteVarint(num * 8 + 5, unknown_);
     char buffer[4];
@@ -547,7 +547,7 @@ const char* UnknownGroupLiteParse(TProtoStringType* unknown, const char* ptr,
   return WireFormatParser(field_parser, ptr, ctx);
 }
 
-const char* UnknownFieldParse(uint32_t tag, TProtoStringType* unknown,
+const char* UnknownFieldParse(ui32 tag, TProtoStringType* unknown,
                               const char* ptr, ParseContext* ctx) {
   UnknownFieldLiteParserHelper field_parser(unknown);
   return FieldParser(tag, field_parser, ptr, ctx);
diff --git a/contrib/libs/protobuf/src/google/protobuf/parse_context.h b/contrib/libs/protobuf/src/google/protobuf/parse_context.h
index 242dc27e82..6c8f8606e2 100644
--- a/contrib/libs/protobuf/src/google/protobuf/parse_context.h
+++ b/contrib/libs/protobuf/src/google/protobuf/parse_context.h
@@ -60,12 +60,12 @@ class MessageFactory;
 namespace internal {
 
 // Template code below needs to know about the existence of these functions.
-PROTOBUF_EXPORT void WriteVarint(uint32_t num, uint64_t val, TProtoStringType* s);
-PROTOBUF_EXPORT void WriteLengthDelimited(uint32_t num, StringPiece val,
+PROTOBUF_EXPORT void WriteVarint(ui32 num, ui64 val, TProtoStringType* s);
+PROTOBUF_EXPORT void WriteLengthDelimited(ui32 num, StringPiece val,
                                           TProtoStringType* s);
 // Inline because it is just forwarding to s->WriteVarint
-inline void WriteVarint(uint32_t num, uint64_t val, UnknownFieldSet* s);
-inline void WriteLengthDelimited(uint32_t num, StringPiece val,
+inline void WriteVarint(ui32 num, ui64 val, UnknownFieldSet* s);
+inline void WriteLengthDelimited(ui32 num, StringPiece val,
                                  UnknownFieldSet* s);
 
 
@@ -185,15 +185,15 @@ class PROTOBUF_EXPORT EpsCopyInputStream {
   PROTOBUF_MUST_USE_RESULT const char* ReadPackedVarint(const char* ptr,
                                                         Add add);
 
-  uint32_t LastTag() const { return last_tag_minus_1_ + 1; }
-  bool ConsumeEndGroup(uint32_t start_tag) {
+  ui32 LastTag() const { return last_tag_minus_1_ + 1; }
+  bool ConsumeEndGroup(ui32 start_tag) {
     bool res = last_tag_minus_1_ == start_tag;
     last_tag_minus_1_ = 0;
     return res;
   }
   bool EndedAtLimit() const { return last_tag_minus_1_ == 0; }
   bool EndedAtEndOfStream() const { return last_tag_minus_1_ == 1; }
-  void SetLastTag(uint32_t tag) { last_tag_minus_1_ = tag - 1; }
+  void SetLastTag(ui32 tag) { last_tag_minus_1_ = tag - 1; }
   void SetEndOfStream() { last_tag_minus_1_ = 1; }
   bool IsExceedingLimit(const char* ptr) {
     return ptr > limit_end_ &&
@@ -282,7 +282,7 @@ class PROTOBUF_EXPORT EpsCopyInputStream {
   // This var doesn't really belong in EpsCopyInputStream and should be part of
   // the ParseContext, but case 2 is most easily and optimally implemented in
   // DoneFallback.
-  uint32_t last_tag_minus_1_ = 0;
+  ui32 last_tag_minus_1_ = 0;
   int overall_limit_ = INT_MAX;  // Overall limit independent of pushed limits.
   // Pretty random large number that seems like a safe allocation on most
   // systems. TODO(gerbens) do we need to set this as build flag?
@@ -411,7 +411,7 @@ class PROTOBUF_EXPORT ParseContext : public EpsCopyInputStream {
 
   template <typename T>
   PROTOBUF_MUST_USE_RESULT PROTOBUF_NDEBUG_INLINE const char* ParseGroup(
-      T* msg, const char* ptr, uint32_t tag) {
+      T* msg, const char* ptr, ui32 tag) {
     if (--depth_ < 0) return nullptr;
     group_depth_++;
     ptr = msg->_InternalParse(ptr, this);
@@ -445,7 +445,7 @@ class PROTOBUF_EXPORT ParseContext : public EpsCopyInputStream {
   Data data_;
 };
 
-template <uint32_t tag>
+template <ui32 tag>
 bool ExpectTag(const char* ptr) {
   if (tag < 128) {
     return *ptr == static_cast<char>(tag);
@@ -478,8 +478,8 @@ struct EndianHelper<2> {
 
 template <>
 struct EndianHelper<4> {
-  static uint32_t Load(const void* p) {
-    uint32_t tmp;
+  static ui32 Load(const void* p) {
+    ui32 tmp;
     std::memcpy(&tmp, p, 4);
 #ifndef PROTOBUF_LITTLE_ENDIAN
     tmp = bswap_32(tmp);
@@ -490,8 +490,8 @@ struct EndianHelper<4> {
 
 template <>
 struct EndianHelper<8> {
-  static uint64_t Load(const void* p) {
-    uint64_t tmp;
+  static ui64 Load(const void* p) {
+    ui64 tmp;
     std::memcpy(&tmp, p, 8);
 #ifndef PROTOBUF_LITTLE_ENDIAN
     tmp = bswap_64(tmp);
@@ -509,38 +509,31 @@ T UnalignedLoad(const char* p) {
 }
 
 PROTOBUF_EXPORT
-std::pair<const char*, uint32_t> VarintParseSlow32(const char* p, uint32_t res);
+std::pair<const char*, ui32> VarintParseSlow32(const char* p, ui32 res);
 PROTOBUF_EXPORT
-std::pair<const char*, uint64_t> VarintParseSlow64(const char* p, uint32_t res);
+std::pair<const char*, ui64> VarintParseSlow64(const char* p, ui32 res);
 
-inline const char* VarintParseSlow(const char* p, uint32_t res, uint32_t* out) {
+inline const char* VarintParseSlow(const char* p, ui32 res, ui32* out) {
   auto tmp = VarintParseSlow32(p, res);
   *out = tmp.second;
   return tmp.first;
 }
 
-inline const char* VarintParseSlow(const char* p, uint32_t res, uint64* out) {
+inline const char* VarintParseSlow(const char* p, ui32 res, ui64* out) {
   auto tmp = VarintParseSlow64(p, res);
   *out = tmp.second;
   return tmp.first;
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline const char* VarintParseSlow(const char* p, uint32_t res, uint64_t* out) {
-  auto tmp = VarintParseSlow64(p, res);
-  *out = tmp.second;
-  return tmp.first;
-}
-#endif
 
 template <typename T>
 PROTOBUF_MUST_USE_RESULT const char* VarintParse(const char* p, T* out) {
   auto ptr = reinterpret_cast<const uint8_t*>(p);
-  uint32_t res = ptr[0];
+  ui32 res = ptr[0];
   if (!(res & 0x80)) {
     *out = res;
     return p + 1;
   }
-  uint32_t byte = ptr[1];
+  ui32 byte = ptr[1];
   res += (byte - 1) << 7;
   if (!(byte & 0x80)) {
     *out = res;
@@ -553,17 +546,17 @@ PROTOBUF_MUST_USE_RESULT const char* VarintParse(const char* p, T* out) {
 // Caller must ensure its safe to call.
 
 PROTOBUF_EXPORT
-std::pair<const char*, uint32_t> ReadTagFallback(const char* p, uint32_t res);
+std::pair<const char*, ui32> ReadTagFallback(const char* p, ui32 res);
 
 // Same as ParseVarint but only accept 5 bytes at most.
-inline const char* ReadTag(const char* p, uint32_t* out,
-                           uint32_t /*max_tag*/ = 0) {
-  uint32_t res = static_cast<uint8_t>(p[0]);
+inline const char* ReadTag(const char* p, ui32* out,
+                           ui32 /*max_tag*/ = 0) {
+  ui32 res = static_cast<uint8_t>(p[0]);
   if (res < 128) {
     *out = res;
     return p + 1;
   }
-  uint32_t second = static_cast<uint8_t>(p[1]);
+  ui32 second = static_cast<uint8_t>(p[1]);
   res += (second - 1) << 7;
   if (second < 128) {
     *out = res;
@@ -584,10 +577,10 @@ inline const char* ReadTag(const char* p, uint32_t* out,
 // adc [rsi], 1
 // add eax, eax
 // and eax, edi
-inline uint32_t DecodeTwoBytes(const char** ptr) {
-  uint32_t value = UnalignedLoad<uint16_t>(*ptr);
+inline ui32 DecodeTwoBytes(const char** ptr) {
+  ui32 value = UnalignedLoad<uint16_t>(*ptr);
   // Sign extend the low byte continuation bit
-  uint32_t x = static_cast<int8_t>(value);
+  ui32 x = static_cast<int8_t>(value);
   // This add is an amazing operation, it cancels the low byte continuation bit
   // from y transferring it to the carry. Simultaneously it also shifts the 7
   // LSB left by one tightly against high byte varint bits. Hence value now
@@ -599,18 +592,18 @@ inline uint32_t DecodeTwoBytes(const char** ptr) {
 }
 
 // More efficient varint parsing for big varints
-inline const char* ParseBigVarint(const char* p, uint64_t* out) {
+inline const char* ParseBigVarint(const char* p, ui64* out) {
   auto pnew = p;
   auto tmp = DecodeTwoBytes(&pnew);
-  uint64_t res = tmp >> 1;
+  ui64 res = tmp >> 1;
   if (PROTOBUF_PREDICT_TRUE(static_cast<std::int16_t>(tmp) >= 0)) {
     *out = res;
     return pnew;
   }
-  for (std::uint32_t i = 1; i < 5; i++) {
+  for (ui32 i = 1; i < 5; i++) {
     pnew = p + 2 * i;
     tmp = DecodeTwoBytes(&pnew);
-    res += (static_cast<std::uint64_t>(tmp) - 2) << (14 * i - 1);
+    res += (static_cast<ui64>(tmp) - 2) << (14 * i - 1);
     if (PROTOBUF_PREDICT_TRUE(static_cast<std::int16_t>(tmp) >= 0)) {
       *out = res;
       return pnew;
@@ -620,13 +613,13 @@ inline const char* ParseBigVarint(const char* p, uint64_t* out) {
 }
 
 PROTOBUF_EXPORT
-std::pair<const char*, int32_t> ReadSizeFallback(const char* p, uint32_t first);
+std::pair<const char*, i32> ReadSizeFallback(const char* p, ui32 first);
 // Used for tags, could read up to 5 bytes which must be available. Additionally
-// it makes sure the unsigned value fits a int32_t, otherwise returns nullptr.
+// it makes sure the unsigned value fits a i32, otherwise returns nullptr.
 // Caller must ensure its safe to call.
-inline uint32_t ReadSize(const char** pp) {
+inline ui32 ReadSize(const char** pp) {
   auto p = *pp;
-  uint32_t res = static_cast<uint8_t>(p[0]);
+  ui32 res = static_cast<uint8_t>(p[0]);
   if (res < 128) {
     *pp = p + 1;
     return res;
@@ -641,28 +634,28 @@ inline uint32_t ReadSize(const char** pp) {
 // function composition. We rely on the compiler to inline this.
 // Also in debug compiles having local scoped variables tend to generated
 // stack frames that scale as O(num fields).
-inline uint64_t ReadVarint64(const char** p) {
-  uint64_t tmp;
+inline ui64 ReadVarint64(const char** p) {
+  ui64 tmp;
   *p = VarintParse(*p, &tmp);
   return tmp;
 }
 
-inline uint32_t ReadVarint32(const char** p) {
-  uint32_t tmp;
+inline ui32 ReadVarint32(const char** p) {
+  ui32 tmp;
   *p = VarintParse(*p, &tmp);
   return tmp;
 }
 
-inline int64_t ReadVarintZigZag64(const char** p) {
-  uint64_t tmp;
+inline i64 ReadVarintZigZag64(const char** p) {
+  ui64 tmp;
   *p = VarintParse(*p, &tmp);
   return WireFormatLite::ZigZagDecode64(tmp);
 }
 
-inline int32_t ReadVarintZigZag32(const char** p) {
-  uint64_t tmp;
+inline i32 ReadVarintZigZag32(const char** p) {
+  ui64 tmp;
   *p = VarintParse(*p, &tmp);
-  return WireFormatLite::ZigZagDecode32(static_cast<uint32_t>(tmp));
+  return WireFormatLite::ZigZagDecode32(static_cast<ui32>(tmp));
 }
 
 template <typename T, typename std::enable_if<
@@ -730,7 +723,7 @@ const char* EpsCopyInputStream::ReadPackedFixed(const char* ptr, int size,
 template <typename Add>
 const char* ReadPackedVarintArray(const char* ptr, const char* end, Add add) {
   while (ptr < end) {
-    uint64_t varint;
+    ui64 varint;
     ptr = VarintParse(ptr, &varint);
     if (ptr == nullptr) return nullptr;
     add(varint);
@@ -800,22 +793,22 @@ PROTOBUF_EXPORT PROTOBUF_MUST_USE_RESULT const char* InlineGreedyStringParser(
   GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
 
 template <typename T>
-PROTOBUF_MUST_USE_RESULT const char* FieldParser(uint64_t tag, T& field_parser,
+PROTOBUF_MUST_USE_RESULT const char* FieldParser(ui64 tag, T& field_parser,
                                                  const char* ptr,
                                                  ParseContext* ctx) {
-  uint32_t number = tag >> 3;
+  ui32 number = tag >> 3;
   GOOGLE_PROTOBUF_PARSER_ASSERT(number != 0);
   using WireType = internal::WireFormatLite::WireType;
   switch (tag & 7) {
     case WireType::WIRETYPE_VARINT: {
-      uint64_t value;
+      ui64 value;
       ptr = VarintParse(ptr, &value);
       GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
       field_parser.AddVarint(number, value);
       break;
     }
     case WireType::WIRETYPE_FIXED64: {
-      uint64_t value = UnalignedLoad<uint64_t>(ptr);
+      ui64 value = UnalignedLoad<ui64>(ptr);
       ptr += 8;
       field_parser.AddFixed64(number, value);
       break;
@@ -835,7 +828,7 @@ PROTOBUF_MUST_USE_RESULT const char* FieldParser(uint64_t tag, T& field_parser,
       break;
     }
     case WireType::WIRETYPE_FIXED32: {
-      uint32_t value = UnalignedLoad<uint32_t>(ptr);
+      ui32 value = UnalignedLoad<ui32>(ptr);
       ptr += 4;
       field_parser.AddFixed32(number, value);
       break;
@@ -851,7 +844,7 @@ PROTOBUF_MUST_USE_RESULT const char* WireFormatParser(T& field_parser,
                                                       const char* ptr,
                                                       ParseContext* ctx) {
   while (!ctx->Done(&ptr)) {
-    uint32_t tag;
+    ui32 tag;
     ptr = ReadTag(ptr, &tag);
     GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
     if (tag == 0 || (tag & 7) == 4) {
@@ -888,7 +881,7 @@ PROTOBUF_MUST_USE_RESULT const char* PackedEnumParser(
     void* object, const char* ptr, ParseContext* ctx, bool (*is_valid)(int),
     InternalMetadata* metadata, int field_num) {
   return ctx->ReadPackedVarint(
-      ptr, [object, is_valid, metadata, field_num](uint64_t val) {
+      ptr, [object, is_valid, metadata, field_num](ui64 val) {
         if (is_valid(val)) {
           static_cast<RepeatedField<int>*>(object)->Add(val);
         } else {
@@ -903,7 +896,7 @@ PROTOBUF_MUST_USE_RESULT const char* PackedEnumParserArg(
     bool (*is_valid)(const void*, int), const void* data,
     InternalMetadata* metadata, int field_num) {
   return ctx->ReadPackedVarint(
-      ptr, [object, is_valid, data, metadata, field_num](uint64_t val) {
+      ptr, [object, is_valid, data, metadata, field_num](ui64 val) {
         if (is_valid(data, val)) {
           static_cast<RepeatedField<int>*>(object)->Add(val);
         } else {
@@ -934,7 +927,7 @@ PROTOBUF_EXPORT PROTOBUF_MUST_USE_RESULT const char* UnknownGroupLiteParse(
 // useful in the generated code. It uses overload on TProtoStringType* vs
 // UnknownFieldSet* to make the generated code isomorphic between full and lite.
 PROTOBUF_EXPORT PROTOBUF_MUST_USE_RESULT const char* UnknownFieldParse(
-    uint32_t tag, TProtoStringType* unknown, const char* ptr, ParseContext* ctx);
+    ui32 tag, TProtoStringType* unknown, const char* ptr, ParseContext* ctx);
 
 }  // namespace internal
 }  // namespace protobuf
diff --git a/contrib/libs/protobuf/src/google/protobuf/port_def.inc b/contrib/libs/protobuf/src/google/protobuf/port_def.inc
index a0d33dbe5b..d3f1db964f 100644
--- a/contrib/libs/protobuf/src/google/protobuf/port_def.inc
+++ b/contrib/libs/protobuf/src/google/protobuf/port_def.inc
@@ -662,7 +662,7 @@
   ::google::protobuf::MessageLite *msg, const char *ptr,                 \
       ::google::protobuf::internal::ParseContext *ctx,                   \
       const ::google::protobuf::internal::TailCallParseTableBase *table, \
-      uint64_t hasbits, ::google::protobuf::internal::TcFieldData data
+      ui64 hasbits, ::google::protobuf::internal::TcFieldData data
 
 #ifdef PROTOBUF_UNUSED
 #error PROTOBUF_UNUSED was previously defined
diff --git a/contrib/libs/protobuf/src/google/protobuf/reflection.h b/contrib/libs/protobuf/src/google/protobuf/reflection.h
index 52749b6786..36328ee21c 100644
--- a/contrib/libs/protobuf/src/google/protobuf/reflection.h
+++ b/contrib/libs/protobuf/src/google/protobuf/reflection.h
@@ -282,19 +282,19 @@ namespace internal {
 // cpp_type to the type that should be used in this interface:
 //
 //   field->cpp_type()      T                Actual type of void*
-//   CPPTYPE_INT32        int32_t                 int32_t
-//   CPPTYPE_UINT32       uint32_t                uint32_t
-//   CPPTYPE_INT64        int64_t                 int64_t
-//   CPPTYPE_UINT64       uint64_t                uint64_t
+//   CPPTYPE_INT32        i32                 i32
+//   CPPTYPE_UINT32       ui32                ui32
+//   CPPTYPE_INT64        i64                 i64
+//   CPPTYPE_UINT64       ui64                ui64
 //   CPPTYPE_DOUBLE       double                  double
 //   CPPTYPE_FLOAT        float                   float
 //   CPPTYPE_BOOL         bool                    bool
-//   CPPTYPE_ENUM         generated enum type     int32_t
+//   CPPTYPE_ENUM         generated enum type     i32
 //   CPPTYPE_STRING       string                  TProtoStringType
 //   CPPTYPE_MESSAGE      generated message type  google::protobuf::Message
 //                        or google::protobuf::Message
 //
-// Note that for enums we use int32_t in the interface.
+// Note that for enums we use i32 in the interface.
 //
 // You can map from T to the actual type using RefTypeTraits:
 //   typedef RefTypeTraits<T>::AccessorValueType ActualType;
@@ -362,7 +362,7 @@ class PROTOBUF_EXPORT RepeatedFieldAccessor {
     // be ActualType. Here we have a ValueType object and want a ActualType
     // pointer. We can't cast a ValueType pointer to an ActualType pointer
     // directly because their type might be different (for enums ValueType
-    // may be a generated enum type while ActualType is int32_t). To be safe
+    // may be a generated enum type while ActualType is i32). To be safe
     // we make a copy to get a temporary ActualType object and use it.
     ActualType tmp = static_cast<ActualType>(value);
     Set(data, index, static_cast<const Value*>(&tmp));
@@ -376,7 +376,7 @@ class PROTOBUF_EXPORT RepeatedFieldAccessor {
     // be ActualType. Here we have a ValueType object and want a ActualType
     // pointer. We can't cast a ValueType pointer to an ActualType pointer
     // directly because their type might be different (for enums ValueType
-    // may be a generated enum type while ActualType is int32_t). To be safe
+    // may be a generated enum type while ActualType is i32). To be safe
     // we make a copy to get a temporary ActualType object and use it.
     ActualType tmp = static_cast<ActualType>(value);
     Add(data, static_cast<const Value*>(&tmp));
@@ -485,10 +485,10 @@ struct PrimitiveTraits {
     static const FieldDescriptor::CppType cpp_type = \
         FieldDescriptor::CPPTYPE_##TYPE;             \
   };
-DEFINE_PRIMITIVE(INT32, int32_t)
-DEFINE_PRIMITIVE(UINT32, uint32_t)
-DEFINE_PRIMITIVE(INT64, int64)
-DEFINE_PRIMITIVE(UINT64, uint64)
+DEFINE_PRIMITIVE(INT32, i32)
+DEFINE_PRIMITIVE(UINT32, ui32)
+DEFINE_PRIMITIVE(INT64, i64)
+DEFINE_PRIMITIVE(UINT64, ui64)
 DEFINE_PRIMITIVE(FLOAT, float)
 DEFINE_PRIMITIVE(DOUBLE, double)
 DEFINE_PRIMITIVE(BOOL, bool)
@@ -512,10 +512,10 @@ struct RefTypeTraits<
     T, typename std::enable_if<is_proto_enum<T>::value>::type> {
   typedef RepeatedFieldRefIterator<T> iterator;
   typedef RepeatedFieldAccessor AccessorType;
-  // We use int32_t for repeated enums in RepeatedFieldAccessor.
-  typedef int32_t AccessorValueType;
+  // We use i32 for repeated enums in RepeatedFieldAccessor.
+  typedef i32 AccessorValueType;
   typedef T IteratorValueType;
-  typedef int32_t* IteratorPointerType;
+  typedef i32* IteratorPointerType;
   static constexpr FieldDescriptor::CppType cpp_type =
       FieldDescriptor::CPPTYPE_ENUM;
   static const Descriptor* GetMessageFieldDescriptor() { return NULL; }
diff --git a/contrib/libs/protobuf/src/google/protobuf/repeated_field.cc b/contrib/libs/protobuf/src/google/protobuf/repeated_field.cc
index 13bbf92603..5c33f4c995 100644
--- a/contrib/libs/protobuf/src/google/protobuf/repeated_field.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/repeated_field.cc
@@ -58,8 +58,8 @@ void** RepeatedPtrFieldBase::InternalExtend(int extend_amount) {
   Arena* arena = GetArena();
   new_size = std::max(internal::kRepeatedFieldLowerClampLimit,
                       std::max(total_size_ * 2, new_size));
-  GOOGLE_CHECK_LE(static_cast<int64_t>(new_size),
-           static_cast<int64_t>(
+  GOOGLE_CHECK_LE(static_cast<i64>(new_size),
+           static_cast<i64>(
                (std::numeric_limits<size_t>::max() - kRepHeaderSize) /
                sizeof(old_rep->elements[0])))
       << "Requested size is too large to fit into size_t.";
@@ -135,10 +135,10 @@ MessageLite* RepeatedPtrFieldBase::AddWeak(const MessageLite* prototype) {
 
 
 template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<bool>;
-template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<int32_t>;
-template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<uint32_t>;
-template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<int64_t>;
-template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<uint64_t>;
+template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<i32>;
+template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<ui32>;
+template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<i64>;
+template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<ui64>;
 template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<float>;
 template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField<double>;
 template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedPtrField<TProtoStringType>;
diff --git a/contrib/libs/protobuf/src/google/protobuf/repeated_field.h b/contrib/libs/protobuf/src/google/protobuf/repeated_field.h
index e0c565e1e2..7cda18dba3 100644
--- a/contrib/libs/protobuf/src/google/protobuf/repeated_field.h
+++ b/contrib/libs/protobuf/src/google/protobuf/repeated_field.h
@@ -146,13 +146,13 @@ inline typename std::enable_if<(kSize == 0), void>::type memswap(char*, char*) {
 
 PROTO_MEMSWAP_DEF_SIZE(uint8_t, 2)
 PROTO_MEMSWAP_DEF_SIZE(uint16_t, 4)
-PROTO_MEMSWAP_DEF_SIZE(uint32_t, 8)
+PROTO_MEMSWAP_DEF_SIZE(ui32, 8)
 
 #ifdef __SIZEOF_INT128__
-PROTO_MEMSWAP_DEF_SIZE(uint64_t, 16)
+PROTO_MEMSWAP_DEF_SIZE(ui64, 16)
 PROTO_MEMSWAP_DEF_SIZE(__uint128_t, (1u << 31))
 #else
-PROTO_MEMSWAP_DEF_SIZE(uint64_t, (1u << 31))
+PROTO_MEMSWAP_DEF_SIZE(ui64, (1u << 31))
 #endif
 
 #undef PROTO_MEMSWAP_DEF_SIZE
@@ -1383,7 +1383,7 @@ inline void RepeatedField<Element>::Set(int index, const Element& value) {
 
 template <typename Element>
 inline void RepeatedField<Element>::Add(const Element& value) {
-  uint32_t size = current_size_;
+  ui32 size = current_size_;
   if (static_cast<int>(size) == total_size_) {
     // value could reference an element of the array. Reserving new space will
     // invalidate the reference. So we must make a copy first.
@@ -1398,7 +1398,7 @@ inline void RepeatedField<Element>::Add(const Element& value) {
 
 template <typename Element>
 inline Element* RepeatedField<Element>::Add() {
-  uint32_t size = current_size_;
+  ui32 size = current_size_;
   if (static_cast<int>(size) == total_size_) Reserve(total_size_ + 1);
   auto ptr = &elements()[size];
   current_size_ = size + 1;
@@ -1645,7 +1645,7 @@ void RepeatedField<Element>::Reserve(int new_size) {
   // this, since Element is supposed to be POD, but a previous version of this
   // code allocated storage with "new Element[size]" and some code uses
   // RepeatedField with non-POD types, relying on constructor invocation. If
-  // Element has a trivial constructor (e.g., int32_t), gcc (tested with -O2)
+  // Element has a trivial constructor (e.g., i32), gcc (tested with -O2)
   // completely removes this loop because the loop body is empty, so this has no
   // effect unless its side-effects are required for correctness.
   // Note that we do this before MoveArray() below because Element's copy
@@ -2946,10 +2946,10 @@ UnsafeArenaAllocatedRepeatedPtrFieldBackInserter(
 
 // Extern declarations of common instantiations to reduce library bloat.
 extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<bool>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<int32_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<uint32_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<int64_t>;
-extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<uint64_t>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<i32>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<ui32>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<i64>;
+extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<ui64>;
 extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<float>;
 extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE RepeatedField<double>;
 extern template class PROTOBUF_EXPORT_TEMPLATE_DECLARE
diff --git a/contrib/libs/protobuf/src/google/protobuf/stubs/int128.cc b/contrib/libs/protobuf/src/google/protobuf/stubs/int128.cc
index f008ce8d26..c8e20c6782 100644
--- a/contrib/libs/protobuf/src/google/protobuf/stubs/int128.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/stubs/int128.cc
@@ -41,8 +41,8 @@
 namespace google {
 namespace protobuf {
 
-const uint128_pod kuint128max = {uint64_t{0xFFFFFFFFFFFFFFFFu},
-                                 uint64_t{0xFFFFFFFFFFFFFFFFu}};
+const uint128_pod kuint128max = {ui64{0xFFFFFFFFFFFFFFFFu},
+                                 ui64{0xFFFFFFFFFFFFFFFFu}};
 
 // Returns the 0-based position of the last set bit (i.e., most significant bit)
 // in the given uint64. The argument may not be 0.
@@ -65,7 +65,7 @@ static inline int Fls64(uint64 n) {
   STEP(uint32, n32, pos, 0x10);
   STEP(uint32, n32, pos, 0x08);
   STEP(uint32, n32, pos, 0x04);
-  return pos + ((uint64_t{0x3333333322221100u} >> (n32 << 2)) & 0x3);
+  return pos + ((ui64{0x3333333322221100u} >> (n32 << 2)) & 0x3);
 }
 #undef STEP
 
@@ -132,17 +132,17 @@ std::ostream& operator<<(std::ostream& o, const uint128& b) {
   switch (flags & std::ios::basefield) {
     case std::ios::hex:
       div =
-          static_cast<uint64>(uint64_t{0x1000000000000000u});  // 16^15
+          static_cast<uint64>(ui64{0x1000000000000000u});  // 16^15
       div_base_log = 15;
       break;
     case std::ios::oct:
       div = static_cast<uint64>(
-          uint64_t{01000000000000000000000u});  // 8^21
+          ui64{01000000000000000000000u});  // 8^21
       div_base_log = 21;
       break;
     default:  // std::ios::dec
       div = static_cast<uint64>(
-          uint64_t{10000000000000000000u});  // 10^19
+          ui64{10000000000000000000u});  // 10^19
       div_base_log = 19;
       break;
   }
diff --git a/contrib/libs/protobuf/src/google/protobuf/stubs/port.h b/contrib/libs/protobuf/src/google/protobuf/stubs/port.h
index bc0be2b828..75448709de 100644
--- a/contrib/libs/protobuf/src/google/protobuf/stubs/port.h
+++ b/contrib/libs/protobuf/src/google/protobuf/stubs/port.h
@@ -144,10 +144,10 @@ typedef ui64 uint64;
 
 static const int32 kint32max = 0x7FFFFFFF;
 static const int32 kint32min = -kint32max - 1;
-static const int64 kint64max = int64_t{0x7FFFFFFFFFFFFFFF};
+static const int64 kint64max = i64{0x7FFFFFFFFFFFFFFF};
 static const int64 kint64min = -kint64max - 1;
 static const uint32 kuint32max = 0xFFFFFFFFu;
-static const uint64 kuint64max = uint64_t{0xFFFFFFFFFFFFFFFFu};
+static const uint64 kuint64max = ui64{0xFFFFFFFFFFFFFFFFu};
 
 #if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) ||\
     defined(MEMORY_SANITIZER)
@@ -156,11 +156,11 @@ static const uint64 kuint64max = uint64_t{0xFFFFFFFFFFFFFFFFu};
 extern "C" {
 #endif  // __cplusplus
 uint16_t __sanitizer_unaligned_load16(const void *p);
-uint32_t __sanitizer_unaligned_load32(const void *p);
-uint64_t __sanitizer_unaligned_load64(const void *p);
+ui32 __sanitizer_unaligned_load32(const void *p);
+ui64 __sanitizer_unaligned_load64(const void *p);
 void __sanitizer_unaligned_store16(void *p, uint16_t v);
-void __sanitizer_unaligned_store32(void *p, uint32_t v);
-void __sanitizer_unaligned_store64(void *p, uint64_t v);
+void __sanitizer_unaligned_store32(void *p, ui32 v);
+void __sanitizer_unaligned_store64(void *p, ui64 v);
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus
@@ -271,14 +271,14 @@ static inline uint32 bswap_32(uint32 x) {
 
 #ifndef bswap_64
 static inline uint64 bswap_64(uint64 x) {
-  return (((x & uint64_t{0xFFu}) << 56) |
-          ((x & uint64_t{0xFF00u}) << 40) |
-          ((x & uint64_t{0xFF0000u}) << 24) |
-          ((x & uint64_t{0xFF000000u}) << 8) |
-          ((x & uint64_t{0xFF00000000u}) >> 8) |
-          ((x & uint64_t{0xFF0000000000u}) >> 24) |
-          ((x & uint64_t{0xFF000000000000u}) >> 40) |
-          ((x & uint64_t{0xFF00000000000000u}) >> 56));
+  return (((x & ui64{0xFFu}) << 56) |
+          ((x & ui64{0xFF00u}) << 40) |
+          ((x & ui64{0xFF0000u}) << 24) |
+          ((x & ui64{0xFF000000u}) << 8) |
+          ((x & ui64{0xFF00000000u}) >> 8) |
+          ((x & ui64{0xFF0000000000u}) >> 24) |
+          ((x & ui64{0xFF000000000000u}) >> 40) |
+          ((x & ui64{0xFF00000000000000u}) >> 56));
 }
 #define bswap_64(x) bswap_64(x)
 #endif
diff --git a/contrib/libs/protobuf/src/google/protobuf/stubs/strutil.cc b/contrib/libs/protobuf/src/google/protobuf/stubs/strutil.cc
index 7a09e582cb..f84ead99c1 100644
--- a/contrib/libs/protobuf/src/google/protobuf/stubs/strutil.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/stubs/strutil.cc
@@ -2353,7 +2353,7 @@ void CleanStringLineEndings(TProtoStringType *str, bool auto_end_last_line) {
 
   for (ptrdiff_t input_pos = 0; input_pos < len;) {
     if (!r_seen && input_pos + 8 < len) {
-      uint64_t v = GOOGLE_UNALIGNED_LOAD64(p + input_pos);
+      ui64 v = GOOGLE_UNALIGNED_LOAD64(p + input_pos);
       // Loop over groups of 8 bytes at a time until we come across
       // a word that has a byte whose value is less than or equal to
       // '\r' (i.e. could contain a \n (0x0a) or a \r (0x0d) ).
diff --git a/contrib/libs/protobuf/src/google/protobuf/stubs/strutil.h b/contrib/libs/protobuf/src/google/protobuf/stubs/strutil.h
index 06610ccfd6..ad08ad8988 100644
--- a/contrib/libs/protobuf/src/google/protobuf/stubs/strutil.h
+++ b/contrib/libs/protobuf/src/google/protobuf/stubs/strutil.h
@@ -41,8 +41,6 @@
 #include <google/protobuf/port_def.inc>
 #include <vector>
 
-#include <util/system/platform.h>
-
 namespace google {
 namespace protobuf {
 
@@ -416,33 +414,12 @@ inline bool safe_strto64(const char* str, int64* value) {
 inline bool safe_strto64(StringPiece str, int64* value) {
   return safe_strto64(str.ToString(), value);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline bool safe_strto64(StringPiece str, int64_t* value) {
-  int64 otherValue;
-  bool ok = safe_strto64(str.ToString(), &otherValue);
-  if (ok) {
-      *value = otherValue;
-  }
-  return ok;
-}
-#endif
-
 inline bool safe_strtou64(const char* str, uint64* value) {
   return safe_strtou64(TProtoStringType(str), value);
 }
 inline bool safe_strtou64(StringPiece str, uint64* value) {
   return safe_strtou64(str.ToString(), value);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline bool safe_strtou64(StringPiece str, uint64_t* value) {
-  uint64 otherValue;
-  bool ok = safe_strtou64(str.ToString(), &otherValue);
-  if (ok) {
-      *value = otherValue;
-  }
-  return ok;
-}
-#endif
 
 PROTOBUF_EXPORT bool safe_strtof(const char* str, float* value);
 PROTOBUF_EXPORT bool safe_strtod(const char* str, double* value);
diff --git a/contrib/libs/protobuf/src/google/protobuf/text_format.cc b/contrib/libs/protobuf/src/google/protobuf/text_format.cc
index d92e99dc0d..7278cc90f4 100644
--- a/contrib/libs/protobuf/src/google/protobuf/text_format.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/text_format.cc
@@ -165,7 +165,7 @@ TextFormat::ParseLocationRange TextFormat::ParseInfoTree::GetLocationRange(
   const std::vector<TextFormat::ParseLocationRange>* locations =
       FindOrNull(locations_, field);
   if (locations == nullptr ||
-      index >= static_cast<int64_t>(locations->size())) {
+      index >= static_cast<i64>(locations->size())) {
     return TextFormat::ParseLocationRange();
   }
 
@@ -180,7 +180,7 @@ TextFormat::ParseInfoTree* TextFormat::ParseInfoTree::GetTreeForNested(
   }
 
   auto it = nested_.find(field);
-  if (it == nested_.end() || index >= static_cast<int64_t>(it->second.size())) {
+  if (it == nested_.end() || index >= static_cast<i64>(it->second.size())) {
     return nullptr;
   }
 
@@ -459,7 +459,7 @@ class TextFormat::Parser::ParserImpl {
     } else {
       DO(ConsumeIdentifier(&field_name));
 
-      int32_t field_number;
+      i32 field_number;
       if (allow_field_number_ && safe_strto32(field_name, &field_number)) {
         if (descriptor->IsExtensionNumber(field_number)) {
           field = finder_
@@ -726,28 +726,28 @@ class TextFormat::Parser::ParserImpl {
 
     switch (field->cpp_type()) {
       case FieldDescriptor::CPPTYPE_INT32: {
-        int64_t value;
+        i64 value;
         DO(ConsumeSignedInteger(&value, kint32max));
-        SET_FIELD(Int32, static_cast<int32_t>(value));
+        SET_FIELD(Int32, static_cast<i32>(value));
         break;
       }
 
       case FieldDescriptor::CPPTYPE_UINT32: {
-        uint64_t value;
+        ui64 value;
         DO(ConsumeUnsignedInteger(&value, kuint32max));
-        SET_FIELD(UInt32, static_cast<uint32_t>(value));
+        SET_FIELD(UInt32, static_cast<ui32>(value));
         break;
       }
 
       case FieldDescriptor::CPPTYPE_INT64: {
-        int64_t value;
+        i64 value;
         DO(ConsumeSignedInteger(&value, kint64max));
         SET_FIELD(Int64, value);
         break;
       }
 
       case FieldDescriptor::CPPTYPE_UINT64: {
-        uint64_t value;
+        ui64 value;
         DO(ConsumeUnsignedInteger(&value, kuint64max));
         SET_FIELD(UInt64, value);
         break;
@@ -776,7 +776,7 @@ class TextFormat::Parser::ParserImpl {
 
       case FieldDescriptor::CPPTYPE_BOOL: {
         if (LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
-          uint64_t value;
+          ui64 value;
           DO(ConsumeUnsignedInteger(&value, 1));
           SET_FIELD(Bool, value);
         } else {
@@ -797,7 +797,7 @@ class TextFormat::Parser::ParserImpl {
 
       case FieldDescriptor::CPPTYPE_ENUM: {
         TProtoStringType value;
-        int64_t int_value = kint64max;
+        i64 int_value = kint64max;
         const EnumDescriptor* enum_type = field->enum_type();
         const EnumValueDescriptor* enum_value = nullptr;
 
@@ -1006,9 +1006,9 @@ class TextFormat::Parser::ParserImpl {
     return true;
   }
 
-  // Consumes a uint64_t and saves its value in the value parameter.
+  // Consumes a ui64 and saves its value in the value parameter.
   // Returns false if the token is not of type INTEGER.
-  bool ConsumeUnsignedInteger(uint64_t* value, uint64_t max_value) {
+  bool ConsumeUnsignedInteger(ui64* value, ui64 max_value) {
     if (!LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
       ReportError("Expected integer, got: " + tokenizer_.current().text);
       return false;
@@ -1024,12 +1024,12 @@ class TextFormat::Parser::ParserImpl {
     return true;
   }
 
-  // Consumes an int64_t and saves its value in the value parameter.
+  // Consumes an i64 and saves its value in the value parameter.
   // Note that since the tokenizer does not support negative numbers,
   // we actually may consume an additional token (for the minus sign) in this
   // method. Returns false if the token is not an integer
   // (signed or otherwise).
-  bool ConsumeSignedInteger(int64_t* value, uint64_t max_value) {
+  bool ConsumeSignedInteger(i64* value, ui64 max_value) {
     bool negative = false;
 
     if (TryConsume("-")) {
@@ -1039,18 +1039,18 @@ class TextFormat::Parser::ParserImpl {
       ++max_value;
     }
 
-    uint64_t unsigned_value;
+    ui64 unsigned_value;
 
     DO(ConsumeUnsignedInteger(&unsigned_value, max_value));
 
     if (negative) {
-      if ((static_cast<uint64_t>(kint64max) + 1) == unsigned_value) {
+      if ((static_cast<ui64>(kint64max) + 1) == unsigned_value) {
         *value = kint64min;
       } else {
-        *value = -static_cast<int64_t>(unsigned_value);
+        *value = -static_cast<i64>(unsigned_value);
       }
     } else {
-      *value = static_cast<int64_t>(unsigned_value);
+      *value = static_cast<i64>(unsigned_value);
     }
 
     return true;
@@ -1058,7 +1058,7 @@ class TextFormat::Parser::ParserImpl {
 
   // Consumes a double and saves its value in the value parameter.
   // Accepts decimal numbers only, rejects hex or oct numbers.
-  bool ConsumeUnsignedDecimalAsDouble(double* value, uint64_t max_value) {
+  bool ConsumeUnsignedDecimalAsDouble(double* value, ui64 max_value) {
     if (!LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
       ReportError("Expected integer, got: " + tokenizer_.current().text);
       return false;
@@ -1070,7 +1070,7 @@ class TextFormat::Parser::ParserImpl {
       return false;
     }
 
-    uint64_t uint64_value;
+    ui64 uint64_value;
     if (io::Tokenizer::ParseInteger(text, max_value, &uint64_value)) {
       *value = static_cast<double>(uint64_value);
     } else {
@@ -1362,7 +1362,7 @@ class TextFormat::Printer::TextGenerator
       if (failed_) return;
     }
 
-    while (static_cast<int64_t>(size) > buffer_size_) {
+    while (static_cast<i64>(size) > buffer_size_) {
       // Data exceeds space in the buffer.  Copy what we can and request a
       // new buffer.
       if (buffer_size_ > 0) {
@@ -1672,16 +1672,16 @@ TextFormat::FieldValuePrinter::~FieldValuePrinter() {}
 TProtoStringType TextFormat::FieldValuePrinter::PrintBool(bool val) const {
   FORWARD_IMPL(PrintBool, val);
 }
-TProtoStringType TextFormat::FieldValuePrinter::PrintInt32(int32_t val) const {
+TProtoStringType TextFormat::FieldValuePrinter::PrintInt32(i32 val) const {
   FORWARD_IMPL(PrintInt32, val);
 }
-TProtoStringType TextFormat::FieldValuePrinter::PrintUInt32(uint32_t val) const {
+TProtoStringType TextFormat::FieldValuePrinter::PrintUInt32(ui32 val) const {
   FORWARD_IMPL(PrintUInt32, val);
 }
-TProtoStringType TextFormat::FieldValuePrinter::PrintInt64(int64 val) const {
+TProtoStringType TextFormat::FieldValuePrinter::PrintInt64(i64 val) const {
   FORWARD_IMPL(PrintInt64, val);
 }
-TProtoStringType TextFormat::FieldValuePrinter::PrintUInt64(uint64 val) const {
+TProtoStringType TextFormat::FieldValuePrinter::PrintUInt64(ui64 val) const {
   FORWARD_IMPL(PrintUInt64, val);
 }
 TProtoStringType TextFormat::FieldValuePrinter::PrintFloat(float val) const {
@@ -1699,7 +1699,7 @@ TProtoStringType TextFormat::FieldValuePrinter::PrintBytes(
   return PrintString(val);
 }
 TProtoStringType TextFormat::FieldValuePrinter::PrintEnum(
-    int32_t val, const TProtoStringType& name) const {
+    i32 val, const TProtoStringType& name) const {
   FORWARD_IMPL(PrintEnum, val, name);
 }
 TProtoStringType TextFormat::FieldValuePrinter::PrintFieldName(
@@ -1732,19 +1732,19 @@ void TextFormat::FastFieldValuePrinter::PrintBool(
   }
 }
 void TextFormat::FastFieldValuePrinter::PrintInt32(
-    int32_t val, BaseTextGenerator* generator) const {
+    i32 val, BaseTextGenerator* generator) const {
   generator->PrintString(StrCat(val));
 }
 void TextFormat::FastFieldValuePrinter::PrintUInt32(
-    uint32_t val, BaseTextGenerator* generator) const {
+    ui32 val, BaseTextGenerator* generator) const {
   generator->PrintString(StrCat(val));
 }
 void TextFormat::FastFieldValuePrinter::PrintInt64(
-    int64 val, BaseTextGenerator* generator) const {
+    i64 val, BaseTextGenerator* generator) const {
   generator->PrintString(StrCat(val));
 }
 void TextFormat::FastFieldValuePrinter::PrintUInt64(
-    uint64 val, BaseTextGenerator* generator) const {
+    ui64 val, BaseTextGenerator* generator) const {
   generator->PrintString(StrCat(val));
 }
 void TextFormat::FastFieldValuePrinter::PrintFloat(
@@ -1756,7 +1756,7 @@ void TextFormat::FastFieldValuePrinter::PrintDouble(
   generator->PrintString(!std::isnan(val) ? SimpleDtoa(val) : "nan");
 }
 void TextFormat::FastFieldValuePrinter::PrintEnum(
-    int32_t val, const TProtoStringType& name, BaseTextGenerator* generator) const {
+    i32 val, const TProtoStringType& name, BaseTextGenerator* generator) const {
   generator->PrintString(name);
 }
 
@@ -1831,19 +1831,19 @@ class FieldValuePrinterWrapper : public TextFormat::FastFieldValuePrinter {
                  TextFormat::BaseTextGenerator* generator) const override {
     generator->PrintString(delegate_->PrintBool(val));
   }
-  void PrintInt32(int32_t val,
+  void PrintInt32(i32 val,
                   TextFormat::BaseTextGenerator* generator) const override {
     generator->PrintString(delegate_->PrintInt32(val));
   }
-  void PrintUInt32(uint32_t val,
+  void PrintUInt32(ui32 val,
                    TextFormat::BaseTextGenerator* generator) const override {
     generator->PrintString(delegate_->PrintUInt32(val));
   }
-  void PrintInt64(int64 val,
+  void PrintInt64(i64 val,
                   TextFormat::BaseTextGenerator* generator) const override {
     generator->PrintString(delegate_->PrintInt64(val));
   }
-  void PrintUInt64(uint64 val,
+  void PrintUInt64(ui64 val,
                    TextFormat::BaseTextGenerator* generator) const override {
     generator->PrintString(delegate_->PrintUInt64(val));
   }
@@ -1863,7 +1863,7 @@ class FieldValuePrinterWrapper : public TextFormat::FastFieldValuePrinter {
                   TextFormat::BaseTextGenerator* generator) const override {
     generator->PrintString(delegate_->PrintBytes(val));
   }
-  void PrintEnum(int32_t val, const TProtoStringType& name,
+  void PrintEnum(i32 val, const TProtoStringType& name,
                  TextFormat::BaseTextGenerator* generator) const override {
     generator->PrintString(delegate_->PrintEnum(val, name));
   }
@@ -2166,23 +2166,23 @@ class MapEntryMessageComparator {
         return first < second;
       }
       case FieldDescriptor::CPPTYPE_INT32: {
-        int32_t first = reflection->GetInt32(*a, field_);
-        int32_t second = reflection->GetInt32(*b, field_);
+        i32 first = reflection->GetInt32(*a, field_);
+        i32 second = reflection->GetInt32(*b, field_);
         return first < second;
       }
       case FieldDescriptor::CPPTYPE_INT64: {
-        int64_t first = reflection->GetInt64(*a, field_);
-        int64_t second = reflection->GetInt64(*b, field_);
+        i64 first = reflection->GetInt64(*a, field_);
+        i64 second = reflection->GetInt64(*b, field_);
         return first < second;
       }
       case FieldDescriptor::CPPTYPE_UINT32: {
-        uint32_t first = reflection->GetUInt32(*a, field_);
-        uint32_t second = reflection->GetUInt32(*b, field_);
+        ui32 first = reflection->GetUInt32(*a, field_);
+        ui32 second = reflection->GetUInt32(*b, field_);
         return first < second;
       }
       case FieldDescriptor::CPPTYPE_UINT64: {
-        uint64_t first = reflection->GetUInt64(*a, field_);
-        uint64_t second = reflection->GetUInt64(*b, field_);
+        ui64 first = reflection->GetUInt64(*a, field_);
+        ui64 second = reflection->GetUInt64(*b, field_);
         return first < second;
       }
       case FieldDescriptor::CPPTYPE_STRING: {
diff --git a/contrib/libs/protobuf/src/google/protobuf/text_format.h b/contrib/libs/protobuf/src/google/protobuf/text_format.h
index fd252be870..070a59e3ec 100644
--- a/contrib/libs/protobuf/src/google/protobuf/text_format.h
+++ b/contrib/libs/protobuf/src/google/protobuf/text_format.h
@@ -126,17 +126,17 @@ class PROTOBUF_EXPORT TextFormat {
     FastFieldValuePrinter();
     virtual ~FastFieldValuePrinter();
     virtual void PrintBool(bool val, BaseTextGenerator* generator) const;
-    virtual void PrintInt32(int32_t val, BaseTextGenerator* generator) const;
-    virtual void PrintUInt32(uint32_t val, BaseTextGenerator* generator) const;
-    virtual void PrintInt64(int64 val, BaseTextGenerator* generator) const;
-    virtual void PrintUInt64(uint64 val, BaseTextGenerator* generator) const;
+    virtual void PrintInt32(i32 val, BaseTextGenerator* generator) const;
+    virtual void PrintUInt32(ui32 val, BaseTextGenerator* generator) const;
+    virtual void PrintInt64(i64 val, BaseTextGenerator* generator) const;
+    virtual void PrintUInt64(ui64 val, BaseTextGenerator* generator) const;
     virtual void PrintFloat(float val, BaseTextGenerator* generator) const;
     virtual void PrintDouble(double val, BaseTextGenerator* generator) const;
     virtual void PrintString(const TProtoStringType& val,
                              BaseTextGenerator* generator) const;
     virtual void PrintBytes(const TProtoStringType& val,
                             BaseTextGenerator* generator) const;
-    virtual void PrintEnum(int32_t val, const TProtoStringType& name,
+    virtual void PrintEnum(i32 val, const TProtoStringType& name,
                            BaseTextGenerator* generator) const;
     virtual void PrintFieldName(const Message& message, int field_index,
                                 int field_count, const Reflection* reflection,
@@ -171,15 +171,15 @@ class PROTOBUF_EXPORT TextFormat {
     FieldValuePrinter();
     virtual ~FieldValuePrinter();
     virtual TProtoStringType PrintBool(bool val) const;
-    virtual TProtoStringType PrintInt32(int32_t val) const;
-    virtual TProtoStringType PrintUInt32(uint32_t val) const;
-    virtual TProtoStringType PrintInt64(int64 val) const;
-    virtual TProtoStringType PrintUInt64(uint64 val) const;
+    virtual TProtoStringType PrintInt32(i32 val) const;
+    virtual TProtoStringType PrintUInt32(ui32 val) const;
+    virtual TProtoStringType PrintInt64(i64 val) const;
+    virtual TProtoStringType PrintUInt64(ui64 val) const;
     virtual TProtoStringType PrintFloat(float val) const;
     virtual TProtoStringType PrintDouble(double val) const;
     virtual TProtoStringType PrintString(const TProtoStringType& val) const;
     virtual TProtoStringType PrintBytes(const TProtoStringType& val) const;
-    virtual TProtoStringType PrintEnum(int32_t val, const TProtoStringType& name) const;
+    virtual TProtoStringType PrintEnum(i32 val, const TProtoStringType& name) const;
     virtual TProtoStringType PrintFieldName(const Message& message,
                                        const Reflection* reflection,
                                        const FieldDescriptor* field) const;
@@ -341,7 +341,7 @@ class PROTOBUF_EXPORT TextFormat {
     // property of TextFormat::Printer.  That is, from the printed message, we
     // cannot fully recover the original string field any more.
     void SetTruncateStringFieldLongerThan(
-        const int64_t truncate_string_field_longer_than) {
+        const i64 truncate_string_field_longer_than) {
       truncate_string_field_longer_than_ = truncate_string_field_longer_than;
     }
 
@@ -431,7 +431,7 @@ class PROTOBUF_EXPORT TextFormat {
     bool hide_unknown_fields_;
     bool print_message_fields_in_index_order_;
     bool expand_any_;
-    int64_t truncate_string_field_longer_than_;
+    i64 truncate_string_field_longer_than_;
 
     std::unique_ptr<const FastFieldValuePrinter> default_field_value_printer_;
     typedef std::map<const FieldDescriptor*,
diff --git a/contrib/libs/protobuf/src/google/protobuf/timestamp.pb.cc b/contrib/libs/protobuf/src/google/protobuf/timestamp.pb.cc
index a7ab3b9b23..965094916b 100644
--- a/contrib/libs/protobuf/src/google/protobuf/timestamp.pb.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/timestamp.pb.cc
@@ -19,7 +19,7 @@ PROTOBUF_PRAGMA_INIT_SEG
 PROTOBUF_NAMESPACE_OPEN
 constexpr Timestamp::Timestamp(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
-  : seconds_(int64_t{0})
+  : seconds_(i64{0})
   , nanos_(0){}
 struct TimestampDefaultTypeInternal {
   constexpr TimestampDefaultTypeInternal()
diff --git a/contrib/libs/protobuf/src/google/protobuf/timestamp.pb.h b/contrib/libs/protobuf/src/google/protobuf/timestamp.pb.h
index 3b4971a20b..1e1ff0e09e 100644
--- a/contrib/libs/protobuf/src/google/protobuf/timestamp.pb.h
+++ b/contrib/libs/protobuf/src/google/protobuf/timestamp.pb.h
@@ -230,7 +230,7 @@ class PROTOBUF_EXPORT Timestamp final :
 
 // int64 seconds = 1;
 inline void Timestamp::clear_seconds() {
-  seconds_ = int64_t{0};
+  seconds_ = i64{0};
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 Timestamp::_internal_seconds() const {
   return seconds_;
diff --git a/contrib/libs/protobuf/src/google/protobuf/unknown_field_set.cc b/contrib/libs/protobuf/src/google/protobuf/unknown_field_set.cc
index 9664de42c8..c43aa4dc37 100644
--- a/contrib/libs/protobuf/src/google/protobuf/unknown_field_set.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/unknown_field_set.cc
@@ -132,7 +132,7 @@ size_t UnknownFieldSet::SpaceUsedLong() const {
   return sizeof(*this) + SpaceUsedExcludingSelf();
 }
 
-void UnknownFieldSet::AddVarint(int number, uint64_t value) {
+void UnknownFieldSet::AddVarint(int number, ui64 value) {
   UnknownField field;
   field.number_ = number;
   field.SetType(UnknownField::TYPE_VARINT);
@@ -140,7 +140,7 @@ void UnknownFieldSet::AddVarint(int number, uint64_t value) {
   fields_.push_back(field);
 }
 
-void UnknownFieldSet::AddFixed32(int number, uint32_t value) {
+void UnknownFieldSet::AddFixed32(int number, ui32 value) {
   UnknownField field;
   field.number_ = number;
   field.SetType(UnknownField::TYPE_FIXED32);
@@ -148,7 +148,7 @@ void UnknownFieldSet::AddFixed32(int number, uint32_t value) {
   fields_.push_back(field);
 }
 
-void UnknownFieldSet::AddFixed64(int number, uint64_t value) {
+void UnknownFieldSet::AddFixed64(int number, ui64 value) {
   UnknownField field;
   field.number_ = number;
   field.SetType(UnknownField::TYPE_FIXED64);
@@ -285,24 +285,24 @@ class UnknownFieldParserHelper {
   explicit UnknownFieldParserHelper(UnknownFieldSet* unknown)
       : unknown_(unknown) {}
 
-  void AddVarint(uint32_t num, uint64_t value) {
+  void AddVarint(ui32 num, ui64 value) {
     unknown_->AddVarint(num, value);
   }
-  void AddFixed64(uint32_t num, uint64_t value) {
+  void AddFixed64(ui32 num, ui64 value) {
     unknown_->AddFixed64(num, value);
   }
-  const char* ParseLengthDelimited(uint32_t num, const char* ptr,
+  const char* ParseLengthDelimited(ui32 num, const char* ptr,
                                    ParseContext* ctx) {
     TProtoStringType* s = unknown_->AddLengthDelimited(num);
     int size = ReadSize(&ptr);
     GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
     return ctx->ReadString(ptr, size, s);
   }
-  const char* ParseGroup(uint32_t num, const char* ptr, ParseContext* ctx) {
+  const char* ParseGroup(ui32 num, const char* ptr, ParseContext* ctx) {
     UnknownFieldParserHelper child(unknown_->AddGroup(num));
     return ctx->ParseGroup(&child, ptr, num * 8 + 3);
   }
-  void AddFixed32(uint32_t num, uint32_t value) {
+  void AddFixed32(ui32 num, ui32 value) {
     unknown_->AddFixed32(num, value);
   }
 
@@ -320,7 +320,7 @@ const char* UnknownGroupParse(UnknownFieldSet* unknown, const char* ptr,
   return WireFormatParser(field_parser, ptr, ctx);
 }
 
-const char* UnknownFieldParse(uint64_t tag, UnknownFieldSet* unknown,
+const char* UnknownFieldParse(ui64 tag, UnknownFieldSet* unknown,
                               const char* ptr, ParseContext* ctx) {
   UnknownFieldParserHelper field_parser(unknown);
   return FieldParser(tag, field_parser, ptr, ctx);
diff --git a/contrib/libs/protobuf/src/google/protobuf/unknown_field_set.h b/contrib/libs/protobuf/src/google/protobuf/unknown_field_set.h
index bc4dc34f7f..04cb319f71 100644
--- a/contrib/libs/protobuf/src/google/protobuf/unknown_field_set.h
+++ b/contrib/libs/protobuf/src/google/protobuf/unknown_field_set.h
@@ -136,9 +136,9 @@ class PROTOBUF_EXPORT UnknownFieldSet {
 
   // Adding fields ---------------------------------------------------
 
-  void AddVarint(int number, uint64_t value);
-  void AddFixed32(int number, uint32_t value);
-  void AddFixed64(int number, uint64_t value);
+  void AddVarint(int number, ui64 value);
+  void AddFixed32(int number, ui32 value);
+  void AddFixed64(int number, ui64 value);
   void AddLengthDelimited(int number, const TProtoStringType& value);
   TProtoStringType* AddLengthDelimited(int number);
   UnknownFieldSet* AddGroup(int number);
@@ -209,10 +209,10 @@ class PROTOBUF_EXPORT UnknownFieldSet {
 
 namespace internal {
 
-inline void WriteVarint(uint32_t num, uint64_t val, UnknownFieldSet* unknown) {
+inline void WriteVarint(ui32 num, ui64 val, UnknownFieldSet* unknown) {
   unknown->AddVarint(num, val);
 }
-inline void WriteLengthDelimited(uint32_t num, StringPiece val,
+inline void WriteLengthDelimited(ui32 num, StringPiece val,
                                  UnknownFieldSet* unknown) {
   unknown->AddLengthDelimited(num)->assign(val.data(), val.size());
 }
@@ -221,7 +221,7 @@ PROTOBUF_EXPORT
 const char* UnknownGroupParse(UnknownFieldSet* unknown, const char* ptr,
                               ParseContext* ctx);
 PROTOBUF_EXPORT
-const char* UnknownFieldParse(uint64_t tag, UnknownFieldSet* unknown,
+const char* UnknownFieldParse(ui64 tag, UnknownFieldSet* unknown,
                               const char* ptr, ParseContext* ctx);
 
 }  // namespace internal
@@ -246,15 +246,15 @@ class PROTOBUF_EXPORT UnknownField {
   // Accessors -------------------------------------------------------
   // Each method works only for UnknownFields of the corresponding type.
 
-  inline uint64_t varint() const;
-  inline uint32_t fixed32() const;
-  inline uint64_t fixed64() const;
+  inline ui64 varint() const;
+  inline ui32 fixed32() const;
+  inline ui64 fixed64() const;
   inline const TProtoStringType& length_delimited() const;
   inline const UnknownFieldSet& group() const;
 
-  inline void set_varint(uint64_t value);
-  inline void set_fixed32(uint32_t value);
-  inline void set_fixed64(uint64_t value);
+  inline void set_varint(ui64 value);
+  inline void set_fixed32(ui32 value);
+  inline void set_fixed64(ui64 value);
   inline void set_length_delimited(const TProtoStringType& value);
   inline TProtoStringType* mutable_length_delimited();
   inline UnknownFieldSet* mutable_group();
@@ -287,12 +287,12 @@ class PROTOBUF_EXPORT UnknownField {
     TProtoStringType* string_value;
   };
 
-  uint32_t number_;
-  uint32_t type_;
+  ui32 number_;
+  ui32 type_;
   union {
-    uint64_t varint_;
-    uint32_t fixed32_;
-    uint64_t fixed64_;
+    ui64 varint_;
+    ui32 fixed32_;
+    ui64 fixed64_;
     mutable union LengthDelimited length_delimited_;
     UnknownFieldSet* group_;
   } data_;
@@ -342,15 +342,15 @@ inline UnknownField::Type UnknownField::type() const {
   return static_cast<Type>(type_);
 }
 
-inline uint64_t UnknownField::varint() const {
+inline ui64 UnknownField::varint() const {
   assert(type() == TYPE_VARINT);
   return data_.varint_;
 }
-inline uint32_t UnknownField::fixed32() const {
+inline ui32 UnknownField::fixed32() const {
   assert(type() == TYPE_FIXED32);
   return data_.fixed32_;
 }
-inline uint64_t UnknownField::fixed64() const {
+inline ui64 UnknownField::fixed64() const {
   assert(type() == TYPE_FIXED64);
   return data_.fixed64_;
 }
@@ -363,15 +363,15 @@ inline const UnknownFieldSet& UnknownField::group() const {
   return *data_.group_;
 }
 
-inline void UnknownField::set_varint(uint64_t value) {
+inline void UnknownField::set_varint(ui64 value) {
   assert(type() == TYPE_VARINT);
   data_.varint_ = value;
 }
-inline void UnknownField::set_fixed32(uint32_t value) {
+inline void UnknownField::set_fixed32(ui32 value) {
   assert(type() == TYPE_FIXED32);
   data_.fixed32_ = value;
 }
-inline void UnknownField::set_fixed64(uint64_t value) {
+inline void UnknownField::set_fixed64(ui64 value) {
   assert(type() == TYPE_FIXED64);
   data_.fixed64_ = value;
 }
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/field_comparator.h b/contrib/libs/protobuf/src/google/protobuf/util/field_comparator.h
index 434400eb45..b2b0df8c5a 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/field_comparator.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/field_comparator.h
@@ -203,13 +203,13 @@ class PROTOBUF_EXPORT SimpleFieldComparator : public FieldComparator {
   // CompareFloat.
   bool CompareFloat(const FieldDescriptor& field, float value_1, float value_2);
 
-  bool CompareInt32(const FieldDescriptor& /* unused */, int32_t value_1,
-                    int32_t value_2) {
+  bool CompareInt32(const FieldDescriptor& /* unused */, i32 value_1,
+                    i32 value_2) {
     return value_1 == value_2;
   }
 
-  bool CompareInt64(const FieldDescriptor& /* unused */, int64_t value_1,
-                    int64_t value_2) {
+  bool CompareInt64(const FieldDescriptor& /* unused */, i64 value_1,
+                    i64 value_2) {
     return value_1 == value_2;
   }
 
@@ -218,13 +218,13 @@ class PROTOBUF_EXPORT SimpleFieldComparator : public FieldComparator {
     return value_1 == value_2;
   }
 
-  bool CompareUInt32(const FieldDescriptor& /* unused */, uint32_t value_1,
-                     uint32_t value_2) {
+  bool CompareUInt32(const FieldDescriptor& /* unused */, ui32 value_1,
+                     ui32 value_2) {
     return value_1 == value_2;
   }
 
-  bool CompareUInt64(const FieldDescriptor& /* unused */, uint64_t value_1,
-                     uint64_t value_2) {
+  bool CompareUInt64(const FieldDescriptor& /* unused */, ui64 value_1,
+                     ui64 value_2) {
     return value_1 == value_2;
   }
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/field_mask_util.cc b/contrib/libs/protobuf/src/google/protobuf/util/field_mask_util.cc
index 1e69f8e4f7..29e620ecd9 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/field_mask_util.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/field_mask_util.cc
@@ -552,7 +552,7 @@ void FieldMaskTree::MergeMessage(const Node* node, const Message& source,
 
 void FieldMaskTree::AddRequiredFieldPath(Node* node,
                                          const Descriptor* descriptor) {
-  const int32_t field_count = descriptor->field_count();
+  const i32 field_count = descriptor->field_count();
   for (int index = 0; index < field_count; ++index) {
     const FieldDescriptor* field = descriptor->field(index);
     if (field->is_required()) {
@@ -589,7 +589,7 @@ bool FieldMaskTree::TrimMessage(const Node* node, Message* message) {
   GOOGLE_DCHECK(!node->children.empty());
   const Reflection* reflection = message->GetReflection();
   const Descriptor* descriptor = message->GetDescriptor();
-  const int32_t field_count = descriptor->field_count();
+  const i32 field_count = descriptor->field_count();
   bool modified = false;
   for (int index = 0; index < field_count; ++index) {
     const FieldDescriptor* field = descriptor->field(index);
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/field_mask_util.h b/contrib/libs/protobuf/src/google/protobuf/util/field_mask_util.h
index 70f8f55446..265c8b95b2 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/field_mask_util.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/field_mask_util.h
@@ -59,7 +59,7 @@ class PROTOBUF_EXPORT FieldMaskUtil {
   // Populates the FieldMask with the paths corresponding to the fields with the
   // given numbers, after checking that all field numbers are valid.
   template <typename T>
-  static void FromFieldNumbers(const std::vector<int64_t>& field_numbers,
+  static void FromFieldNumbers(const std::vector<i64>& field_numbers,
                                FieldMask* out) {
     for (const auto field_number : field_numbers) {
       const FieldDescriptor* field_desc =
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/constants.h b/contrib/libs/protobuf/src/google/protobuf/util/internal/constants.h
index 65f1a34024..21a6b83e1c 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/constants.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/constants.h
@@ -52,19 +52,19 @@ const char kRfc3339TimeFormat[] = "%E4Y-%m-%dT%H:%M:%S";
 const char kRfc3339TimeFormatNoPadding[] = "%Y-%m-%dT%H:%M:%S";
 
 // Minimum seconds allowed in a google.protobuf.Timestamp value.
-const int64_t kTimestampMinSeconds = -62135596800LL;
+const i64 kTimestampMinSeconds = -62135596800LL;
 
 // Maximum seconds allowed in a google.protobuf.Timestamp value.
-const int64_t kTimestampMaxSeconds = 253402300799LL;
+const i64 kTimestampMaxSeconds = 253402300799LL;
 
 // Minimum seconds allowed in a google.protobuf.Duration value.
-const int64_t kDurationMinSeconds = -315576000000LL;
+const i64 kDurationMinSeconds = -315576000000LL;
 
 // Maximum seconds allowed in a google.protobuf.Duration value.
-const int64_t kDurationMaxSeconds = 315576000000LL;
+const i64 kDurationMaxSeconds = 315576000000LL;
 
 // Nano seconds in a second.
-const int32_t kNanosPerSecond = 1000000000;
+const i32 kNanosPerSecond = 1000000000;
 
 // Type url representing NULL values in google.protobuf.Struct type.
 const char kStructNullValueTypeUrl[] =
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/datapiece.cc b/contrib/libs/protobuf/src/google/protobuf/util/internal/datapiece.cc
index 777dadf820..785f1041fe 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/datapiece.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/datapiece.cc
@@ -109,56 +109,56 @@ util::StatusOr<float> DoubleToFloat(double before) {
 
 }  // namespace
 
-util::StatusOr<int32_t> DataPiece::ToInt32() const {
+util::StatusOr<i32> DataPiece::ToInt32() const {
   if (type_ == TYPE_STRING)
-    return StringToNumber<int32>(safe_strto32);
+    return StringToNumber<i32>(safe_strto32);
 
   if (type_ == TYPE_DOUBLE)
-    return FloatingPointToIntConvertAndCheck<int32_t, double>(double_);
+    return FloatingPointToIntConvertAndCheck<i32, double>(double_);
 
   if (type_ == TYPE_FLOAT)
-    return FloatingPointToIntConvertAndCheck<int32_t, float>(float_);
+    return FloatingPointToIntConvertAndCheck<i32, float>(float_);
 
-  return GenericConvert<int32_t>();
+  return GenericConvert<i32>();
 }
 
-util::StatusOr<uint32_t> DataPiece::ToUint32() const {
+util::StatusOr<ui32> DataPiece::ToUint32() const {
   if (type_ == TYPE_STRING)
-    return StringToNumber<uint32>(safe_strtou32);
+    return StringToNumber<ui32>(safe_strtou32);
 
   if (type_ == TYPE_DOUBLE)
-    return FloatingPointToIntConvertAndCheck<uint32_t, double>(double_);
+    return FloatingPointToIntConvertAndCheck<ui32, double>(double_);
 
   if (type_ == TYPE_FLOAT)
-    return FloatingPointToIntConvertAndCheck<uint32_t, float>(float_);
+    return FloatingPointToIntConvertAndCheck<ui32, float>(float_);
 
-  return GenericConvert<uint32_t>();
+  return GenericConvert<ui32>();
 }
 
-util::StatusOr<int64_t> DataPiece::ToInt64() const {
+util::StatusOr<i64> DataPiece::ToInt64() const {
   if (type_ == TYPE_STRING)
-    return StringToNumber<int64_t>(safe_strto64);
+    return StringToNumber<i64>(safe_strto64);
 
   if (type_ == TYPE_DOUBLE)
-    return FloatingPointToIntConvertAndCheck<int64_t, double>(double_);
+    return FloatingPointToIntConvertAndCheck<i64, double>(double_);
 
   if (type_ == TYPE_FLOAT)
-    return FloatingPointToIntConvertAndCheck<int64_t, float>(float_);
+    return FloatingPointToIntConvertAndCheck<i64, float>(float_);
 
-  return GenericConvert<int64_t>();
+  return GenericConvert<i64>();
 }
 
-util::StatusOr<uint64_t> DataPiece::ToUint64() const {
+util::StatusOr<ui64> DataPiece::ToUint64() const {
   if (type_ == TYPE_STRING)
-    return StringToNumber<uint64_t>(safe_strtou64);
+    return StringToNumber<ui64>(safe_strtou64);
 
   if (type_ == TYPE_DOUBLE)
-    return FloatingPointToIntConvertAndCheck<uint64_t, double>(double_);
+    return FloatingPointToIntConvertAndCheck<ui64, double>(double_);
 
   if (type_ == TYPE_FLOAT)
-    return FloatingPointToIntConvertAndCheck<uint64_t, float>(float_);
+    return FloatingPointToIntConvertAndCheck<ui64, float>(float_);
 
-  return GenericConvert<uint64_t>();
+  return GenericConvert<ui64>();
 }
 
 util::StatusOr<double> DataPiece::ToDouble() const {
@@ -284,7 +284,7 @@ util::StatusOr<int> DataPiece::ToEnum(const google::protobuf::Enum* enum_type,
     if (value != nullptr) return value->number();
 
     // Check if int version of enum is sent as string.
-    util::StatusOr<int32_t> int_value = ToInt32();
+    util::StatusOr<i32> int_value = ToInt32();
     if (int_value.ok()) {
       if (const google::protobuf::EnumValue* enum_value =
               FindEnumValueByNumberOrNull(enum_type, int_value.value())) {
@@ -332,13 +332,13 @@ template <typename To>
 util::StatusOr<To> DataPiece::GenericConvert() const {
   switch (type_) {
     case TYPE_INT32:
-      return NumberConvertAndCheck<To, int32_t>(i32_);
+      return NumberConvertAndCheck<To, i32>(i32_);
     case TYPE_INT64:
-      return NumberConvertAndCheck<To, int64_t>(i64_);
+      return NumberConvertAndCheck<To, i64>(i64_);
     case TYPE_UINT32:
-      return NumberConvertAndCheck<To, uint32_t>(u32_);
+      return NumberConvertAndCheck<To, ui32>(u32_);
     case TYPE_UINT64:
-      return NumberConvertAndCheck<To, uint64_t>(u64_);
+      return NumberConvertAndCheck<To, ui64>(u64_);
     case TYPE_DOUBLE:
       return NumberConvertAndCheck<To, double>(double_);
     case TYPE_FLOAT:
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/datapiece.h b/contrib/libs/protobuf/src/google/protobuf/util/internal/datapiece.h
index ac0029e44b..f93afedfec 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/datapiece.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/datapiece.h
@@ -76,21 +76,13 @@ class PROTOBUF_EXPORT DataPiece {
   };
 
   // Constructors and Destructor
-  explicit DataPiece(const int32_t value)
+  explicit DataPiece(const i32 value)
       : type_(TYPE_INT32), i32_(value), use_strict_base64_decoding_(false) {}
-#if defined(_32_) && (defined(_darwin_) || defined(_ios))
-  explicit DataPiece(const int32 value)
-      : type_(TYPE_INT32), i32_(value), use_strict_base64_decoding_(false) {}
-#endif
-  explicit DataPiece(const int64_t value)
-      : type_(TYPE_INT64), i64_(value), use_strict_base64_decoding_(false) {}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  explicit DataPiece(const int64 value)
+  explicit DataPiece(const i64 value)
       : type_(TYPE_INT64), i64_(value), use_strict_base64_decoding_(false) {}
-#endif
-  explicit DataPiece(const uint32_t value)
+  explicit DataPiece(const ui32 value)
       : type_(TYPE_UINT32), u32_(value), use_strict_base64_decoding_(false) {}
-  explicit DataPiece(const uint64_t value)
+  explicit DataPiece(const ui64 value)
       : type_(TYPE_UINT64), u64_(value), use_strict_base64_decoding_(false) {}
   explicit DataPiece(const double value)
       : type_(TYPE_DOUBLE),
@@ -134,16 +126,16 @@ class PROTOBUF_EXPORT DataPiece {
 
 
   // Parses, casts or converts the value stored in the DataPiece into an int32.
-  util::StatusOr<int32_t> ToInt32() const;
+  util::StatusOr<i32> ToInt32() const;
 
   // Parses, casts or converts the value stored in the DataPiece into a uint32.
-  util::StatusOr<uint32_t> ToUint32() const;
+  util::StatusOr<ui32> ToUint32() const;
 
   // Parses, casts or converts the value stored in the DataPiece into an int64.
-  util::StatusOr<int64_t> ToInt64() const;
+  util::StatusOr<i64> ToInt64() const;
 
   // Parses, casts or converts the value stored in the DataPiece into a uint64.
-  util::StatusOr<uint64_t> ToUint64() const;
+  util::StatusOr<ui64> ToUint64() const;
 
   // Parses, casts or converts the value stored in the DataPiece into a double.
   util::StatusOr<double> ToDouble() const;
@@ -170,7 +162,7 @@ class PROTOBUF_EXPORT DataPiece {
   DataPiece();
 
   // Helper to create NULL or ENUM types.
-  DataPiece(Type type, int32_t val)
+  DataPiece(Type type, i32 val)
       : type_(type), i32_(val), use_strict_base64_decoding_(false) {}
 
   // Same as the ToEnum() method above but with additional flag to ignore
@@ -202,10 +194,10 @@ class PROTOBUF_EXPORT DataPiece {
 
   // Stored piece of data.
   union {
-    int32_t i32_;
-    int64_t i64_;
-    uint32_t u32_;
-    uint64_t u64_;
+    i32 i32_;
+    i64 i64_;
+    ui32 u32_;
+    ui64 u64_;
     double double_;
     float float_;
     bool bool_;
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/default_value_objectwriter.cc b/contrib/libs/protobuf/src/google/protobuf/util/internal/default_value_objectwriter.cc
index c4734269a2..0301433b8a 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/default_value_objectwriter.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/default_value_objectwriter.cc
@@ -86,7 +86,7 @@ DefaultValueObjectWriter* DefaultValueObjectWriter::RenderBool(
 }
 
 DefaultValueObjectWriter* DefaultValueObjectWriter::RenderInt32(
-    StringPiece name, int32_t value) {
+    StringPiece name, i32 value) {
   if (current_ == nullptr) {
     ow_->RenderInt32(name, value);
   } else {
@@ -96,7 +96,7 @@ DefaultValueObjectWriter* DefaultValueObjectWriter::RenderInt32(
 }
 
 DefaultValueObjectWriter* DefaultValueObjectWriter::RenderUint32(
-    StringPiece name, uint32_t value) {
+    StringPiece name, ui32 value) {
   if (current_ == nullptr) {
     ow_->RenderUint32(name, value);
   } else {
@@ -106,7 +106,7 @@ DefaultValueObjectWriter* DefaultValueObjectWriter::RenderUint32(
 }
 
 DefaultValueObjectWriter* DefaultValueObjectWriter::RenderInt64(
-    StringPiece name, int64_t value) {
+    StringPiece name, i64 value) {
   if (current_ == nullptr) {
     ow_->RenderInt64(name, value);
   } else {
@@ -116,7 +116,7 @@ DefaultValueObjectWriter* DefaultValueObjectWriter::RenderInt64(
 }
 
 DefaultValueObjectWriter* DefaultValueObjectWriter::RenderUint64(
-    StringPiece name, uint64_t value) {
+    StringPiece name, ui64 value) {
   if (current_ == nullptr) {
     ow_->RenderUint64(name, value);
   } else {
@@ -461,20 +461,20 @@ DataPiece DefaultValueObjectWriter::CreateDefaultDataPieceForField(
     case google::protobuf::Field::TYPE_INT64:
     case google::protobuf::Field::TYPE_SINT64:
     case google::protobuf::Field::TYPE_SFIXED64: {
-      return DataPiece(ConvertTo<int64_t>(
-          field.default_value(), &DataPiece::ToInt64, static_cast<int64_t>(0)));
+      return DataPiece(ConvertTo<i64>(
+          field.default_value(), &DataPiece::ToInt64, static_cast<i64>(0)));
     }
     case google::protobuf::Field::TYPE_UINT64:
     case google::protobuf::Field::TYPE_FIXED64: {
-      return DataPiece(ConvertTo<uint64_t>(field.default_value(),
+      return DataPiece(ConvertTo<ui64>(field.default_value(),
                                            &DataPiece::ToUint64,
-                                           static_cast<uint64_t>(0)));
+                                           static_cast<ui64>(0)));
     }
     case google::protobuf::Field::TYPE_INT32:
     case google::protobuf::Field::TYPE_SINT32:
     case google::protobuf::Field::TYPE_SFIXED32: {
-      return DataPiece(ConvertTo<int32_t>(
-          field.default_value(), &DataPiece::ToInt32, static_cast<int32_t>(0)));
+      return DataPiece(ConvertTo<i32>(
+          field.default_value(), &DataPiece::ToInt32, static_cast<i32>(0)));
     }
     case google::protobuf::Field::TYPE_BOOL: {
       return DataPiece(
@@ -488,9 +488,9 @@ DataPiece DefaultValueObjectWriter::CreateDefaultDataPieceForField(
     }
     case google::protobuf::Field::TYPE_UINT32:
     case google::protobuf::Field::TYPE_FIXED32: {
-      return DataPiece(ConvertTo<uint32_t>(field.default_value(),
+      return DataPiece(ConvertTo<ui32>(field.default_value(),
                                            &DataPiece::ToUint32,
-                                           static_cast<uint32_t>(0)));
+                                           static_cast<ui32>(0)));
     }
     case google::protobuf::Field::TYPE_ENUM: {
       return FindEnumDefault(field, typeinfo, use_ints_for_enums);
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/default_value_objectwriter.h b/contrib/libs/protobuf/src/google/protobuf/util/internal/default_value_objectwriter.h
index ff8af3df22..f9b57f65cf 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/default_value_objectwriter.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/default_value_objectwriter.h
@@ -96,16 +96,16 @@ class PROTOBUF_EXPORT DefaultValueObjectWriter : public ObjectWriter {
                                        bool value) override;
 
   DefaultValueObjectWriter* RenderInt32(StringPiece name,
-                                        int32_t value) override;
+                                        i32 value) override;
 
   DefaultValueObjectWriter* RenderUint32(StringPiece name,
-                                         uint32_t value) override;
+                                         ui32 value) override;
 
   DefaultValueObjectWriter* RenderInt64(StringPiece name,
-                                        int64_t value) override;
+                                        i64 value) override;
 
   DefaultValueObjectWriter* RenderUint64(StringPiece name,
-                                         uint64_t value) override;
+                                         ui64 value) override;
 
   DefaultValueObjectWriter* RenderDouble(StringPiece name,
                                          double value) override;
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/json_escaping.cc b/contrib/libs/protobuf/src/google/protobuf/util/internal/json_escaping.cc
index e4fa8cf788..f7fa2cff20 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/json_escaping.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/json_escaping.cc
@@ -79,7 +79,7 @@ static const char kCommonEscapes[160][7] = {
 
 // Determines if the given char value is a unicode surrogate code unit (either
 // high-surrogate or low-surrogate).
-inline bool IsSurrogate(uint32_t c) {
+inline bool IsSurrogate(ui32 c) {
   // Optimized form of:
   // return c >= kMinHighSurrogate && c <= kMaxLowSurrogate;
   // (Reduced from 3 ALU instructions to 2 ALU instructions)
@@ -88,13 +88,13 @@ inline bool IsSurrogate(uint32_t c) {
 
 // Returns true if the given unicode code point cp is a valid
 // unicode code point (i.e. in the range 0 <= cp <= kMaxCodePoint).
-inline bool IsValidCodePoint(uint32_t cp) {
+inline bool IsValidCodePoint(ui32 cp) {
   return cp <= JsonEscaping::kMaxCodePoint;
 }
 
 // Returns the low surrogate for the given unicode code point. The result is
 // meaningless if the given code point is not a supplementary character.
-inline uint16_t ToLowSurrogate(uint32_t cp) {
+inline uint16_t ToLowSurrogate(ui32 cp) {
   return (cp &
           (JsonEscaping::kMaxLowSurrogate - JsonEscaping::kMinLowSurrogate)) +
          JsonEscaping::kMinLowSurrogate;
@@ -102,7 +102,7 @@ inline uint16_t ToLowSurrogate(uint32_t cp) {
 
 // Returns the high surrogate for the given unicode code point. The result is
 // meaningless if the given code point is not a supplementary character.
-inline uint16_t ToHighSurrogate(uint32_t cp) {
+inline uint16_t ToHighSurrogate(ui32 cp) {
   return (cp >> 10) + (JsonEscaping::kMinHighSurrogate -
                        (JsonEscaping::kMinSupplementaryCodePoint >> 10));
 }
@@ -127,7 +127,7 @@ inline uint16_t ToHighSurrogate(uint32_t cp) {
 // Returns false if we encounter an invalid UTF-8 string. Returns true
 // otherwise, including the case when we reach the end of the input (str)
 // before a complete unicode code point is read.
-bool ReadCodePoint(StringPiece str, int index, uint32_t* cp,
+bool ReadCodePoint(StringPiece str, int index, ui32* cp,
                    int* num_left, int* num_read) {
   if (*num_left == 0) {
     // Last read was complete. Start reading a new unicode code point.
@@ -180,7 +180,7 @@ bool ReadCodePoint(StringPiece str, int index, uint32_t* cp,
     *num_read = 0;
   }
   while (*num_left > 0 && index < str.size()) {
-    uint32_t ch = static_cast<uint8_t>(str[index++]);
+    ui32 ch = static_cast<uint8_t>(str[index++]);
     --(*num_left);
     ++(*num_read);
     *cp = (*cp << 6) | (ch & 0x3f);
@@ -206,7 +206,7 @@ StringPiece ToHex(uint16_t cp, char* buffer) {
 // Stores the 32-bit unicode code point as its hexadecimal digits in buffer
 // and returns a StringPiece that points to this buffer. The input buffer needs
 // to be at least 12 bytes long.
-StringPiece ToSurrogateHex(uint32_t cp, char* buffer) {
+StringPiece ToSurrogateHex(ui32 cp, char* buffer) {
   uint16_t low = ToLowSurrogate(cp);
   uint16_t high = ToHighSurrogate(cp);
 
@@ -236,7 +236,7 @@ StringPiece ToSurrogateHex(uint32_t cp, char* buffer) {
 //
 // If the given unicode code point does not need escaping, an empty
 // StringPiece is returned.
-StringPiece EscapeCodePoint(uint32_t cp, char* buffer) {
+StringPiece EscapeCodePoint(ui32 cp, char* buffer) {
   if (cp < 0xa0) return kCommonEscapes[cp];
   switch (cp) {
     // These are not required by json spec
@@ -274,7 +274,7 @@ StringPiece EscapeCodePoint(uint32_t cp, char* buffer) {
 // Tries to escape the given code point first. If the given code point
 // does not need to be escaped, but force_output is true, then render
 // the given multi-byte code point in UTF8 in the buffer and returns it.
-StringPiece EscapeCodePoint(uint32_t cp, char* buffer,
+StringPiece EscapeCodePoint(ui32 cp, char* buffer,
                                   bool force_output) {
   StringPiece sp = EscapeCodePoint(cp, buffer);
   if (force_output && sp.empty()) {
@@ -304,7 +304,7 @@ StringPiece EscapeCodePoint(uint32_t cp, char* buffer,
 void JsonEscaping::Escape(strings::ByteSource* input,
                           strings::ByteSink* output) {
   char buffer[12] = "\\udead\\ubee";
-  uint32_t cp = 0;   // Current unicode code point.
+  ui32 cp = 0;   // Current unicode code point.
   int num_left = 0;  // Num of chars to read to complete the code point.
   while (input->Available() > 0) {
     StringPiece str = input->Peek();
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/json_escaping.h b/contrib/libs/protobuf/src/google/protobuf/util/internal/json_escaping.h
index 38cb645ee6..b09ed09b30 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/json_escaping.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/json_escaping.h
@@ -65,15 +65,15 @@ class JsonEscaping {
 
   // The minimum value of a unicode supplementary code point.
   // See http://www.unicode.org/glossary/#supplementary_code_point
-  static constexpr uint32_t kMinSupplementaryCodePoint = 0x010000;
+  static constexpr ui32 kMinSupplementaryCodePoint = 0x010000;
 
   // The minimum value of a unicode code point.
   // See http://www.unicode.org/glossary/#code_point
-  static constexpr uint32_t kMinCodePoint = 0x000000;
+  static constexpr ui32 kMinCodePoint = 0x000000;
 
   // The maximum value of a unicode code point.
   // See http://www.unicode.org/glossary/#code_point
-  static constexpr uint32_t kMaxCodePoint = 0x10ffff;
+  static constexpr ui32 kMaxCodePoint = 0x10ffff;
 
   JsonEscaping() {}
   virtual ~JsonEscaping() {}
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/json_objectwriter.cc b/contrib/libs/protobuf/src/google/protobuf/util/internal/json_objectwriter.cc
index 3a9b11ceca..a14676dfc7 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/json_objectwriter.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/json_objectwriter.cc
@@ -87,17 +87,17 @@ JsonObjectWriter* JsonObjectWriter::RenderBool(StringPiece name,
 }
 
 JsonObjectWriter* JsonObjectWriter::RenderInt32(StringPiece name,
-                                                int32_t value) {
+                                                i32 value) {
   return RenderSimple(name, StrCat(value));
 }
 
 JsonObjectWriter* JsonObjectWriter::RenderUint32(StringPiece name,
-                                                 uint32_t value) {
+                                                 ui32 value) {
   return RenderSimple(name, StrCat(value));
 }
 
 JsonObjectWriter* JsonObjectWriter::RenderInt64(StringPiece name,
-                                                int64_t value) {
+                                                i64 value) {
   WritePrefix(name);
   WriteChar('"');
   WriteRawString(StrCat(value));
@@ -106,7 +106,7 @@ JsonObjectWriter* JsonObjectWriter::RenderInt64(StringPiece name,
 }
 
 JsonObjectWriter* JsonObjectWriter::RenderUint64(StringPiece name,
-                                                 uint64_t value) {
+                                                 ui64 value) {
   WritePrefix(name);
   WriteChar('"');
   WriteRawString(StrCat(value));
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/json_objectwriter.h b/contrib/libs/protobuf/src/google/protobuf/util/internal/json_objectwriter.h
index 9088659be7..608a38a552 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/json_objectwriter.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/json_objectwriter.h
@@ -119,12 +119,12 @@ class PROTOBUF_EXPORT JsonObjectWriter : public StructuredObjectWriter {
   JsonObjectWriter* StartList(StringPiece name) override;
   JsonObjectWriter* EndList() override;
   JsonObjectWriter* RenderBool(StringPiece name, bool value) override;
-  JsonObjectWriter* RenderInt32(StringPiece name, int32_t value) override;
+  JsonObjectWriter* RenderInt32(StringPiece name, i32 value) override;
   JsonObjectWriter* RenderUint32(StringPiece name,
-                                 uint32_t value) override;
-  JsonObjectWriter* RenderInt64(StringPiece name, int64_t value) override;
+                                 ui32 value) override;
+  JsonObjectWriter* RenderInt64(StringPiece name, i64 value) override;
   JsonObjectWriter* RenderUint64(StringPiece name,
-                                 uint64_t value) override;
+                                 ui64 value) override;
   JsonObjectWriter* RenderDouble(StringPiece name, double value) override;
   JsonObjectWriter* RenderFloat(StringPiece name, float value) override;
   JsonObjectWriter* RenderString(StringPiece name,
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/json_stream_parser.h b/contrib/libs/protobuf/src/google/protobuf/util/internal/json_stream_parser.h
index 96cdd954ce..22e6280896 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/json_stream_parser.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/json_stream_parser.h
@@ -157,8 +157,8 @@ class PROTOBUF_EXPORT JsonStreamParser {
     Type type;
     union {
       double double_val;
-      int64_t int_val;
-      uint64_t uint_val;
+      i64 int_val;
+      ui64 uint_val;
     };
   };
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/object_writer.h b/contrib/libs/protobuf/src/google/protobuf/util/internal/object_writer.h
index 917a28041f..0a5f4f5651 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/object_writer.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/object_writer.h
@@ -81,18 +81,18 @@ class PROTOBUF_EXPORT ObjectWriter {
   virtual ObjectWriter* RenderBool(StringPiece name, bool value) = 0;
 
   // Renders an 32-bit integer value.
-  virtual ObjectWriter* RenderInt32(StringPiece name, int32_t value) = 0;
+  virtual ObjectWriter* RenderInt32(StringPiece name, i32 value) = 0;
 
   // Renders an 32-bit unsigned integer value.
   virtual ObjectWriter* RenderUint32(StringPiece name,
-                                     uint32_t value) = 0;
+                                     ui32 value) = 0;
 
   // Renders a 64-bit integer value.
-  virtual ObjectWriter* RenderInt64(StringPiece name, int64_t value) = 0;
+  virtual ObjectWriter* RenderInt64(StringPiece name, i64 value) = 0;
 
   // Renders an 64-bit unsigned integer value.
   virtual ObjectWriter* RenderUint64(StringPiece name,
-                                     uint64_t value) = 0;
+                                     ui64 value) = 0;
 
 
   // Renders a double value.
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/proto_writer.cc b/contrib/libs/protobuf/src/google/protobuf/util/internal/proto_writer.cc
index 9257b1081f..5e0d40d7b9 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/proto_writer.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/proto_writer.cc
@@ -121,7 +121,7 @@ namespace {
 // Writes an INT32 field, including tag to the stream.
 inline util::Status WriteInt32(int field_number, const DataPiece& data,
                                CodedOutputStream* stream) {
-  util::StatusOr<int32_t> i32 = data.ToInt32();
+  util::StatusOr<i32> i32 = data.ToInt32();
   if (i32.ok()) {
     WireFormatLite::WriteInt32(field_number, i32.value(), stream);
   }
@@ -131,7 +131,7 @@ inline util::Status WriteInt32(int field_number, const DataPiece& data,
 // writes an SFIXED32 field, including tag, to the stream.
 inline util::Status WriteSFixed32(int field_number, const DataPiece& data,
                                   CodedOutputStream* stream) {
-  util::StatusOr<int32_t> i32 = data.ToInt32();
+  util::StatusOr<i32> i32 = data.ToInt32();
   if (i32.ok()) {
     WireFormatLite::WriteSFixed32(field_number, i32.value(), stream);
   }
@@ -141,7 +141,7 @@ inline util::Status WriteSFixed32(int field_number, const DataPiece& data,
 // Writes an SINT32 field, including tag, to the stream.
 inline util::Status WriteSInt32(int field_number, const DataPiece& data,
                                 CodedOutputStream* stream) {
-  util::StatusOr<int32_t> i32 = data.ToInt32();
+  util::StatusOr<i32> i32 = data.ToInt32();
   if (i32.ok()) {
     WireFormatLite::WriteSInt32(field_number, i32.value(), stream);
   }
@@ -151,7 +151,7 @@ inline util::Status WriteSInt32(int field_number, const DataPiece& data,
 // Writes a FIXED32 field, including tag, to the stream.
 inline util::Status WriteFixed32(int field_number, const DataPiece& data,
                                  CodedOutputStream* stream) {
-  util::StatusOr<uint32_t> u32 = data.ToUint32();
+  util::StatusOr<ui32> u32 = data.ToUint32();
   if (u32.ok()) {
     WireFormatLite::WriteFixed32(field_number, u32.value(), stream);
   }
@@ -161,7 +161,7 @@ inline util::Status WriteFixed32(int field_number, const DataPiece& data,
 // Writes a UINT32 field, including tag, to the stream.
 inline util::Status WriteUInt32(int field_number, const DataPiece& data,
                                 CodedOutputStream* stream) {
-  util::StatusOr<uint32_t> u32 = data.ToUint32();
+  util::StatusOr<ui32> u32 = data.ToUint32();
   if (u32.ok()) {
     WireFormatLite::WriteUInt32(field_number, u32.value(), stream);
   }
@@ -171,7 +171,7 @@ inline util::Status WriteUInt32(int field_number, const DataPiece& data,
 // Writes an INT64 field, including tag, to the stream.
 inline util::Status WriteInt64(int field_number, const DataPiece& data,
                                CodedOutputStream* stream) {
-  util::StatusOr<int64_t> i64 = data.ToInt64();
+  util::StatusOr<i64> i64 = data.ToInt64();
   if (i64.ok()) {
     WireFormatLite::WriteInt64(field_number, i64.value(), stream);
   }
@@ -181,7 +181,7 @@ inline util::Status WriteInt64(int field_number, const DataPiece& data,
 // Writes an SFIXED64 field, including tag, to the stream.
 inline util::Status WriteSFixed64(int field_number, const DataPiece& data,
                                   CodedOutputStream* stream) {
-  util::StatusOr<int64_t> i64 = data.ToInt64();
+  util::StatusOr<i64> i64 = data.ToInt64();
   if (i64.ok()) {
     WireFormatLite::WriteSFixed64(field_number, i64.value(), stream);
   }
@@ -191,7 +191,7 @@ inline util::Status WriteSFixed64(int field_number, const DataPiece& data,
 // Writes an SINT64 field, including tag, to the stream.
 inline util::Status WriteSInt64(int field_number, const DataPiece& data,
                                 CodedOutputStream* stream) {
-  util::StatusOr<int64_t> i64 = data.ToInt64();
+  util::StatusOr<i64> i64 = data.ToInt64();
   if (i64.ok()) {
     WireFormatLite::WriteSInt64(field_number, i64.value(), stream);
   }
@@ -201,7 +201,7 @@ inline util::Status WriteSInt64(int field_number, const DataPiece& data,
 // Writes a FIXED64 field, including tag, to the stream.
 inline util::Status WriteFixed64(int field_number, const DataPiece& data,
                                  CodedOutputStream* stream) {
-  util::StatusOr<uint64_t> u64 = data.ToUint64();
+  util::StatusOr<ui64> u64 = data.ToUint64();
   if (u64.ok()) {
     WireFormatLite::WriteFixed64(field_number, u64.value(), stream);
   }
@@ -211,7 +211,7 @@ inline util::Status WriteFixed64(int field_number, const DataPiece& data,
 // Writes a UINT64 field, including tag, to the stream.
 inline util::Status WriteUInt64(int field_number, const DataPiece& data,
                                 CodedOutputStream* stream) {
-  util::StatusOr<uint64_t> u64 = data.ToUint64();
+  util::StatusOr<ui64> u64 = data.ToUint64();
   if (u64.ok()) {
     WireFormatLite::WriteUInt64(field_number, u64.value(), stream);
   }
@@ -430,11 +430,11 @@ TProtoStringType ProtoWriter::ProtoElement::ToString() const {
   return loc;
 }
 
-bool ProtoWriter::ProtoElement::IsOneofIndexTaken(int32_t index) {
+bool ProtoWriter::ProtoElement::IsOneofIndexTaken(i32 index) {
   return oneof_indices_[index];
 }
 
-void ProtoWriter::ProtoElement::TakeOneofIndex(int32_t index) {
+void ProtoWriter::ProtoElement::TakeOneofIndex(i32 index) {
   oneof_indices_[index] = true;
 }
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/proto_writer.h b/contrib/libs/protobuf/src/google/protobuf/util/internal/proto_writer.h
index f10e73be35..763428af13 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/proto_writer.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/proto_writer.h
@@ -83,16 +83,16 @@ class PROTOBUF_EXPORT ProtoWriter : public StructuredObjectWriter {
   ProtoWriter* RenderBool(StringPiece name, bool value) override {
     return RenderDataPiece(name, DataPiece(value));
   }
-  ProtoWriter* RenderInt32(StringPiece name, int32_t value) override {
+  ProtoWriter* RenderInt32(StringPiece name, i32 value) override {
     return RenderDataPiece(name, DataPiece(value));
   }
-  ProtoWriter* RenderUint32(StringPiece name, uint32_t value) override {
+  ProtoWriter* RenderUint32(StringPiece name, ui32 value) override {
     return RenderDataPiece(name, DataPiece(value));
   }
-  ProtoWriter* RenderInt64(StringPiece name, int64_t value) override {
+  ProtoWriter* RenderInt64(StringPiece name, i64 value) override {
     return RenderDataPiece(name, DataPiece(value));
   }
-  ProtoWriter* RenderUint64(StringPiece name, uint64_t value) override {
+  ProtoWriter* RenderUint64(StringPiece name, ui64 value) override {
     return RenderDataPiece(name, DataPiece(value));
   }
   ProtoWriter* RenderDouble(StringPiece name, double value) override {
@@ -205,11 +205,11 @@ class PROTOBUF_EXPORT ProtoWriter : public StructuredObjectWriter {
     }
 
     // Returns true if the index is already taken by a preceding oneof input.
-    bool IsOneofIndexTaken(int32_t index);
+    bool IsOneofIndexTaken(i32 index);
 
     // Marks the oneof 'index' as taken. Future inputs to this oneof will
     // generate an error.
-    void TakeOneofIndex(int32_t index);
+    void TakeOneofIndex(i32 index);
 
     bool proto3() { return proto3_; }
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectsource.cc b/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectsource.cc
index da423a7dc7..a9824fa77b 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectsource.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectsource.cc
@@ -81,7 +81,7 @@ const google::protobuf::EnumValue* FindEnumValueByNumber(
     const google::protobuf::Enum& tech_enum, int number);
 
 // Utility function to format nanos.
-const TProtoStringType FormatNanos(uint32_t nanos, bool with_trailing_zeros);
+const TProtoStringType FormatNanos(ui32 nanos, bool with_trailing_zeros);
 
 util::StatusOr<TProtoStringType> MapKeyDefaultValueAsString(
     const google::protobuf::Field& field) {
@@ -146,7 +146,7 @@ util::Status ProtoStreamObjectSource::NamedWriteTo(StringPiece name,
 }
 
 const google::protobuf::Field* ProtoStreamObjectSource::FindAndVerifyField(
-    const google::protobuf::Type& type, uint32_t tag) const {
+    const google::protobuf::Type& type, ui32 tag) const {
   // Lookup the new field in the type by tag number.
   const google::protobuf::Field* field = FindFieldByNumber(type, tag >> 3);
   // Verify if the field corresponds to the wire type in tag.
@@ -167,7 +167,7 @@ const google::protobuf::Field* ProtoStreamObjectSource::FindAndVerifyField(
 
 util::Status ProtoStreamObjectSource::WriteMessage(
     const google::protobuf::Type& type, StringPiece name,
-    const uint32_t end_tag, bool include_start_and_end,
+    const ui32 end_tag, bool include_start_and_end,
     ObjectWriter* ow) const {
 
   const TypeRenderer* type_renderer = FindTypeRenderer(type.name());
@@ -178,7 +178,7 @@ util::Status ProtoStreamObjectSource::WriteMessage(
   const google::protobuf::Field* field = nullptr;
   TProtoStringType field_name;
   // last_tag set to dummy value that is different from tag.
-  uint32_t tag = stream_->ReadTag(), last_tag = tag + 1;
+  ui32 tag = stream_->ReadTag(), last_tag = tag + 1;
   UnknownFieldSet unknown_fields;
 
 
@@ -229,10 +229,10 @@ util::Status ProtoStreamObjectSource::WriteMessage(
   return util::Status();
 }
 
-util::StatusOr<uint32_t> ProtoStreamObjectSource::RenderList(
+util::StatusOr<ui32> ProtoStreamObjectSource::RenderList(
     const google::protobuf::Field* field, StringPiece name,
-    uint32_t list_tag, ObjectWriter* ow) const {
-  uint32_t tag_to_return = 0;
+    ui32 list_tag, ObjectWriter* ow) const {
+  ui32 tag_to_return = 0;
   ow->StartList(name);
   if (IsPackable(*field) &&
       list_tag ==
@@ -251,19 +251,19 @@ util::StatusOr<uint32_t> ProtoStreamObjectSource::RenderList(
   return tag_to_return;
 }
 
-util::StatusOr<uint32_t> ProtoStreamObjectSource::RenderMap(
+util::StatusOr<ui32> ProtoStreamObjectSource::RenderMap(
     const google::protobuf::Field* field, StringPiece name,
-    uint32_t list_tag, ObjectWriter* ow) const {
+    ui32 list_tag, ObjectWriter* ow) const {
   const google::protobuf::Type* field_type =
       typeinfo_->GetTypeByTypeUrl(field->type_url());
-  uint32_t tag_to_return = 0;
+  ui32 tag_to_return = 0;
   do {
     // Render map entry message type.
-    uint32 buffer32;
+    ui32 buffer32;
     stream_->ReadVarint32(&buffer32);  // message length
     int old_limit = stream_->PushLimit(buffer32);
     TProtoStringType map_key;
-    for (uint32_t tag = stream_->ReadTag(); tag != 0;
+    for (ui32 tag = stream_->ReadTag(); tag != 0;
          tag = stream_->ReadTag()) {
       const google::protobuf::Field* field =
           FindAndVerifyField(*field_type, tag);
@@ -300,7 +300,7 @@ util::StatusOr<uint32_t> ProtoStreamObjectSource::RenderMap(
 
 util::Status ProtoStreamObjectSource::RenderPacked(
     const google::protobuf::Field* field, ObjectWriter* ow) const {
-  uint32 length;
+  ui32 length;
   stream_->ReadVarint32(&length);
   int old_limit = stream_->PushLimit(length);
   while (stream_->BytesUntilLimit() > 0) {
@@ -313,9 +313,9 @@ util::Status ProtoStreamObjectSource::RenderPacked(
 util::Status ProtoStreamObjectSource::RenderTimestamp(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  std::pair<int64_t, int32_t> p = os->ReadSecondsAndNanos(type);
-  int64_t seconds = p.first;
-  int32_t nanos = p.second;
+  std::pair<i64, i32> p = os->ReadSecondsAndNanos(type);
+  i64 seconds = p.first;
+  i32 nanos = p.second;
   if (seconds > kTimestampMaxSeconds || seconds < kTimestampMinSeconds) {
     return util::InternalError(StrCat(
         "Timestamp seconds exceeds limit for field: ", field_name));
@@ -335,9 +335,9 @@ util::Status ProtoStreamObjectSource::RenderTimestamp(
 util::Status ProtoStreamObjectSource::RenderDuration(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  std::pair<int64_t, int32_t> p = os->ReadSecondsAndNanos(type);
-  int64_t seconds = p.first;
-  int32_t nanos = p.second;
+  std::pair<i64, i32> p = os->ReadSecondsAndNanos(type);
+  i64 seconds = p.first;
+  i32 nanos = p.second;
   if (seconds > kDurationMaxSeconds || seconds < kDurationMinSeconds) {
     return util::InternalError(
         StrCat("Duration seconds exceeds limit for field: ", field_name));
@@ -377,8 +377,8 @@ util::Status ProtoStreamObjectSource::RenderDuration(
 util::Status ProtoStreamObjectSource::RenderDouble(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  uint32_t tag = os->stream_->ReadTag();
-  uint64 buffer64 = 0;  // default value of Double wrapper value
+  ui32 tag = os->stream_->ReadTag();
+  ui64 buffer64 = 0;  // default value of Double wrapper value
   if (tag != 0) {
     os->stream_->ReadLittleEndian64(&buffer64);
     os->stream_->ReadTag();
@@ -390,8 +390,8 @@ util::Status ProtoStreamObjectSource::RenderDouble(
 util::Status ProtoStreamObjectSource::RenderFloat(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  uint32_t tag = os->stream_->ReadTag();
-  uint32 buffer32 = 0;  // default value of Float wrapper value
+  ui32 tag = os->stream_->ReadTag();
+  ui32 buffer32 = 0;  // default value of Float wrapper value
   if (tag != 0) {
     os->stream_->ReadLittleEndian32(&buffer32);
     os->stream_->ReadTag();
@@ -403,60 +403,60 @@ util::Status ProtoStreamObjectSource::RenderFloat(
 util::Status ProtoStreamObjectSource::RenderInt64(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  uint32_t tag = os->stream_->ReadTag();
-  uint64 buffer64 = 0;  // default value of Int64 wrapper value
+  ui32 tag = os->stream_->ReadTag();
+  ui64 buffer64 = 0;  // default value of Int64 wrapper value
   if (tag != 0) {
     os->stream_->ReadVarint64(&buffer64);
     os->stream_->ReadTag();
   }
-  ow->RenderInt64(field_name, bit_cast<int64_t>(buffer64));
+  ow->RenderInt64(field_name, bit_cast<i64>(buffer64));
   return util::Status();
 }
 
 util::Status ProtoStreamObjectSource::RenderUInt64(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  uint32_t tag = os->stream_->ReadTag();
-  uint64 buffer64 = 0;  // default value of UInt64 wrapper value
+  ui32 tag = os->stream_->ReadTag();
+  ui64 buffer64 = 0;  // default value of UInt64 wrapper value
   if (tag != 0) {
     os->stream_->ReadVarint64(&buffer64);
     os->stream_->ReadTag();
   }
-  ow->RenderUint64(field_name, bit_cast<uint64_t>(buffer64));
+  ow->RenderUint64(field_name, bit_cast<ui64>(buffer64));
   return util::Status();
 }
 
 util::Status ProtoStreamObjectSource::RenderInt32(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  uint32_t tag = os->stream_->ReadTag();
-  uint32 buffer32 = 0;  // default value of Int32 wrapper value
+  ui32 tag = os->stream_->ReadTag();
+  ui32 buffer32 = 0;  // default value of Int32 wrapper value
   if (tag != 0) {
     os->stream_->ReadVarint32(&buffer32);
     os->stream_->ReadTag();
   }
-  ow->RenderInt32(field_name, bit_cast<int32_t>(buffer32));
+  ow->RenderInt32(field_name, bit_cast<i32>(buffer32));
   return util::Status();
 }
 
 util::Status ProtoStreamObjectSource::RenderUInt32(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  uint32_t tag = os->stream_->ReadTag();
-  uint32 buffer32 = 0;  // default value of UInt32 wrapper value
+  ui32 tag = os->stream_->ReadTag();
+  ui32 buffer32 = 0;  // default value of UInt32 wrapper value
   if (tag != 0) {
     os->stream_->ReadVarint32(&buffer32);
     os->stream_->ReadTag();
   }
-  ow->RenderUint32(field_name, bit_cast<uint32_t>(buffer32));
+  ow->RenderUint32(field_name, bit_cast<ui32>(buffer32));
   return util::Status();
 }
 
 util::Status ProtoStreamObjectSource::RenderBool(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  uint32_t tag = os->stream_->ReadTag();
-  uint64 buffer64 = 0;  // results in 'false' value as default, which is the
+  ui32 tag = os->stream_->ReadTag();
+  ui64 buffer64 = 0;  // results in 'false' value as default, which is the
                           // default value of Bool wrapper
   if (tag != 0) {
     os->stream_->ReadVarint64(&buffer64);
@@ -469,8 +469,8 @@ util::Status ProtoStreamObjectSource::RenderBool(
 util::Status ProtoStreamObjectSource::RenderString(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  uint32_t tag = os->stream_->ReadTag();
-  uint32 buffer32;
+  ui32 tag = os->stream_->ReadTag();
+  ui32 buffer32;
   TProtoStringType str;  // default value of empty for String wrapper
   if (tag != 0) {
     os->stream_->ReadVarint32(&buffer32);  // string size.
@@ -484,8 +484,8 @@ util::Status ProtoStreamObjectSource::RenderString(
 util::Status ProtoStreamObjectSource::RenderBytes(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  uint32_t tag = os->stream_->ReadTag();
-  uint32 buffer32;
+  ui32 tag = os->stream_->ReadTag();
+  ui32 buffer32;
   TProtoStringType str;
   if (tag != 0) {
     os->stream_->ReadVarint32(&buffer32);
@@ -500,7 +500,7 @@ util::Status ProtoStreamObjectSource::RenderStruct(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
   const google::protobuf::Field* field = nullptr;
-  uint32_t tag = os->stream_->ReadTag();
+  ui32 tag = os->stream_->ReadTag();
   ow->StartObject(field_name);
   while (tag != 0) {
     field = os->FindAndVerifyField(type, tag);
@@ -523,7 +523,7 @@ util::Status ProtoStreamObjectSource::RenderStructValue(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
   const google::protobuf::Field* field = nullptr;
-  for (uint32_t tag = os->stream_->ReadTag(); tag != 0;
+  for (ui32 tag = os->stream_->ReadTag(); tag != 0;
        tag = os->stream_->ReadTag()) {
     field = os->FindAndVerifyField(type, tag);
     if (field == nullptr) {
@@ -539,7 +539,7 @@ util::Status ProtoStreamObjectSource::RenderStructValue(
 util::Status ProtoStreamObjectSource::RenderStructListValue(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  uint32_t tag = os->stream_->ReadTag();
+  ui32 tag = os->stream_->ReadTag();
 
   // Render empty list when we find empty ListValue message.
   if (tag == 0) {
@@ -564,7 +564,7 @@ util::Status ProtoStreamObjectSource::RenderAny(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
   // An Any is of the form { string type_url = 1; bytes value = 2; }
-  uint32_t tag;
+  ui32 tag;
   TProtoStringType type_url;
   TProtoStringType value;
 
@@ -579,12 +579,12 @@ util::Status ProtoStreamObjectSource::RenderAny(
     // //google/protobuf/any.proto
     if (field->number() == 1) {
       // read type_url
-      uint32 type_url_size;
+      ui32 type_url_size;
       os->stream_->ReadVarint32(&type_url_size);
       os->stream_->ReadString(&type_url, type_url_size);
     } else if (field->number() == 2) {
       // read value
-      uint32 value_size;
+      ui32 value_size;
       os->stream_->ReadVarint32(&value_size);
       os->stream_->ReadString(&value, value_size);
     }
@@ -638,9 +638,9 @@ util::Status ProtoStreamObjectSource::RenderFieldMask(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
   TProtoStringType combined;
-  uint32 buffer32;
-  uint32_t paths_field_tag = 0;
-  for (uint32_t tag = os->stream_->ReadTag(); tag != 0;
+  ui32 buffer32;
+  ui32 paths_field_tag = 0;
+  for (ui32 tag = os->stream_->ReadTag(); tag != 0;
        tag = os->stream_->ReadTag()) {
     if (paths_field_tag == 0) {
       const google::protobuf::Field* field = os->FindAndVerifyField(type, tag);
@@ -727,7 +727,7 @@ util::Status ProtoStreamObjectSource::RenderField(
   // and ends up using a lot of stack space. Keep the stack usage of this
   // message small in order to preserve stack space and not crash.
   if (field->kind() == google::protobuf::Field::TYPE_MESSAGE) {
-    uint32 buffer32;
+    ui32 buffer32;
     stream_->ReadVarint32(&buffer32);  // message length
     int old_limit = stream_->PushLimit(buffer32);
     // Get the nested message type for this field.
@@ -766,8 +766,8 @@ util::Status ProtoStreamObjectSource::RenderNonMessageField(
     const google::protobuf::Field* field, StringPiece field_name,
     ObjectWriter* ow) const {
   // Temporary buffers of different types.
-  uint32 buffer32 = 0;
-  uint64 buffer64 = 0;
+  ui32 buffer32 = 0;
+  ui64 buffer64 = 0;
   TProtoStringType strbuffer;
   switch (field->kind()) {
     case google::protobuf::Field::TYPE_BOOL: {
@@ -777,7 +777,7 @@ util::Status ProtoStreamObjectSource::RenderNonMessageField(
     }
     case google::protobuf::Field::TYPE_INT32: {
       stream_->ReadVarint32(&buffer32);
-      ow->RenderInt32(field_name, bit_cast<int32_t>(buffer32));
+      ow->RenderInt32(field_name, bit_cast<i32>(buffer32));
       break;
     }
     case google::protobuf::Field::TYPE_INT64: {
@@ -787,7 +787,7 @@ util::Status ProtoStreamObjectSource::RenderNonMessageField(
     }
     case google::protobuf::Field::TYPE_UINT32: {
       stream_->ReadVarint32(&buffer32);
-      ow->RenderUint32(field_name, bit_cast<uint32_t>(buffer32));
+      ow->RenderUint32(field_name, bit_cast<ui32>(buffer32));
       break;
     }
     case google::protobuf::Field::TYPE_UINT64: {
@@ -807,7 +807,7 @@ util::Status ProtoStreamObjectSource::RenderNonMessageField(
     }
     case google::protobuf::Field::TYPE_SFIXED32: {
       stream_->ReadLittleEndian32(&buffer32);
-      ow->RenderInt32(field_name, bit_cast<int32_t>(buffer32));
+      ow->RenderInt32(field_name, bit_cast<i32>(buffer32));
       break;
     }
     case google::protobuf::Field::TYPE_SFIXED64: {
@@ -817,7 +817,7 @@ util::Status ProtoStreamObjectSource::RenderNonMessageField(
     }
     case google::protobuf::Field::TYPE_FIXED32: {
       stream_->ReadLittleEndian32(&buffer32);
-      ow->RenderUint32(field_name, bit_cast<uint32_t>(buffer32));
+      ow->RenderUint32(field_name, bit_cast<ui32>(buffer32));
       break;
     }
     case google::protobuf::Field::TYPE_FIXED64: {
@@ -895,85 +895,85 @@ const TProtoStringType ProtoStreamObjectSource::ReadFieldValueAsString(
   TProtoStringType result;
   switch (field.kind()) {
     case google::protobuf::Field::TYPE_BOOL: {
-      uint64 buffer64;
+      ui64 buffer64;
       stream_->ReadVarint64(&buffer64);
       result = buffer64 != 0 ? "true" : "false";
       break;
     }
     case google::protobuf::Field::TYPE_INT32: {
-      uint32 buffer32;
+      ui32 buffer32;
       stream_->ReadVarint32(&buffer32);
-      result = StrCat(bit_cast<int32_t>(buffer32));
+      result = StrCat(bit_cast<i32>(buffer32));
       break;
     }
     case google::protobuf::Field::TYPE_INT64: {
-      uint64 buffer64;
+      ui64 buffer64;
       stream_->ReadVarint64(&buffer64);
-      result = StrCat(bit_cast<int64_t>(buffer64));
+      result = StrCat(bit_cast<i64>(buffer64));
       break;
     }
     case google::protobuf::Field::TYPE_UINT32: {
-      uint32 buffer32;
+      ui32 buffer32;
       stream_->ReadVarint32(&buffer32);
-      result = StrCat(bit_cast<uint32_t>(buffer32));
+      result = StrCat(bit_cast<ui32>(buffer32));
       break;
     }
     case google::protobuf::Field::TYPE_UINT64: {
-      uint64 buffer64;
+      ui64 buffer64;
       stream_->ReadVarint64(&buffer64);
-      result = StrCat(bit_cast<uint64_t>(buffer64));
+      result = StrCat(bit_cast<ui64>(buffer64));
       break;
     }
     case google::protobuf::Field::TYPE_SINT32: {
-      uint32 buffer32;
+      ui32 buffer32;
       stream_->ReadVarint32(&buffer32);
       result = StrCat(WireFormatLite::ZigZagDecode32(buffer32));
       break;
     }
     case google::protobuf::Field::TYPE_SINT64: {
-      uint64 buffer64;
+      ui64 buffer64;
       stream_->ReadVarint64(&buffer64);
       result = StrCat(WireFormatLite::ZigZagDecode64(buffer64));
       break;
     }
     case google::protobuf::Field::TYPE_SFIXED32: {
-      uint32 buffer32;
+      ui32 buffer32;
       stream_->ReadLittleEndian32(&buffer32);
-      result = StrCat(bit_cast<int32_t>(buffer32));
+      result = StrCat(bit_cast<i32>(buffer32));
       break;
     }
     case google::protobuf::Field::TYPE_SFIXED64: {
-      uint64 buffer64;
+      ui64 buffer64;
       stream_->ReadLittleEndian64(&buffer64);
-      result = StrCat(bit_cast<int64_t>(buffer64));
+      result = StrCat(bit_cast<i64>(buffer64));
       break;
     }
     case google::protobuf::Field::TYPE_FIXED32: {
-      uint32 buffer32;
+      ui32 buffer32;
       stream_->ReadLittleEndian32(&buffer32);
-      result = StrCat(bit_cast<uint32_t>(buffer32));
+      result = StrCat(bit_cast<ui32>(buffer32));
       break;
     }
     case google::protobuf::Field::TYPE_FIXED64: {
-      uint64 buffer64;
+      ui64 buffer64;
       stream_->ReadLittleEndian64(&buffer64);
-      result = StrCat(bit_cast<uint64_t>(buffer64));
+      result = StrCat(bit_cast<ui64>(buffer64));
       break;
     }
     case google::protobuf::Field::TYPE_FLOAT: {
-      uint32 buffer32;
+      ui32 buffer32;
       stream_->ReadLittleEndian32(&buffer32);
       result = SimpleFtoa(bit_cast<float>(buffer32));
       break;
     }
     case google::protobuf::Field::TYPE_DOUBLE: {
-      uint64 buffer64;
+      ui64 buffer64;
       stream_->ReadLittleEndian64(&buffer64);
       result = SimpleDtoa(bit_cast<double>(buffer64));
       break;
     }
     case google::protobuf::Field::TYPE_ENUM: {
-      uint32 buffer32;
+      ui32 buffer32;
       stream_->ReadVarint32(&buffer32);
       // Get the nested enum type for this field.
       // TODO(skarvaje): Avoid string manipulation. Find ways to speed this
@@ -991,13 +991,13 @@ const TProtoStringType ProtoStreamObjectSource::ReadFieldValueAsString(
       break;
     }
     case google::protobuf::Field::TYPE_STRING: {
-      uint32 buffer32;
+      ui32 buffer32;
       stream_->ReadVarint32(&buffer32);  // string size.
       stream_->ReadString(&result, buffer32);
       break;
     }
     case google::protobuf::Field::TYPE_BYTES: {
-      uint32 buffer32;
+      ui32 buffer32;
       stream_->ReadVarint32(&buffer32);  // bytes size.
       stream_->ReadString(&result, buffer32);
       break;
@@ -1018,13 +1018,13 @@ bool ProtoStreamObjectSource::IsMap(
          util::converter::IsMap(field, *field_type);
 }
 
-std::pair<int64_t, int32_t> ProtoStreamObjectSource::ReadSecondsAndNanos(
+std::pair<i64, i32> ProtoStreamObjectSource::ReadSecondsAndNanos(
     const google::protobuf::Type& type) const {
-  uint64 seconds = 0;
-  uint32 nanos = 0;
-  uint32_t tag = 0;
-  int64_t signed_seconds = 0;
-  int32_t signed_nanos = 0;
+  ui64 seconds = 0;
+  ui32 nanos = 0;
+  ui32 tag = 0;
+  i64 signed_seconds = 0;
+  i32 signed_nanos = 0;
 
   for (tag = stream_->ReadTag(); tag != 0; tag = stream_->ReadTag()) {
     const google::protobuf::Field* field = FindAndVerifyField(type, tag);
@@ -1037,14 +1037,14 @@ std::pair<int64_t, int32_t> ProtoStreamObjectSource::ReadSecondsAndNanos(
     if (field->number() == 1) {
       // read seconds
       stream_->ReadVarint64(&seconds);
-      signed_seconds = bit_cast<int64_t>(seconds);
+      signed_seconds = bit_cast<i64>(seconds);
     } else if (field->number() == 2) {
       // read nanos
       stream_->ReadVarint32(&nanos);
-      signed_nanos = bit_cast<int32_t>(nanos);
+      signed_nanos = bit_cast<i32>(nanos);
     }
   }
-  return std::pair<int64_t, int32_t>(signed_seconds, signed_nanos);
+  return std::pair<i64, i32>(signed_seconds, signed_nanos);
 }
 
 util::Status ProtoStreamObjectSource::IncrementRecursionDepth(
@@ -1091,7 +1091,7 @@ const google::protobuf::EnumValue* FindEnumValueByNumber(
 
 // TODO(skarvaje): Look into optimizing this by not doing computation on
 // double.
-const TProtoStringType FormatNanos(uint32_t nanos, bool with_trailing_zeros) {
+const TProtoStringType FormatNanos(ui32 nanos, bool with_trailing_zeros) {
   if (nanos == 0) {
     return with_trailing_zeros ? ".000" : "";
   }
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectsource.h b/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectsource.h
index 32aa500b09..393d0111f3 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectsource.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectsource.h
@@ -143,20 +143,20 @@ class PROTOBUF_EXPORT ProtoStreamObjectSource : public ObjectSource {
   // already inside of an object, and skip calling StartObject and EndObject.
   virtual util::Status WriteMessage(const google::protobuf::Type& type,
                                     StringPiece name,
-                                    const uint32_t end_tag,
+                                    const ui32 end_tag,
                                     bool include_start_and_end,
                                     ObjectWriter* ow) const;
 
   // Renders a repeating field (packed or unpacked).  Returns the next tag after
   // reading all sequential repeating elements. The caller should use this tag
   // before reading more tags from the stream.
-  virtual util::StatusOr<uint32_t> RenderList(
+  virtual util::StatusOr<ui32> RenderList(
       const google::protobuf::Field* field, StringPiece name,
-      uint32_t list_tag, ObjectWriter* ow) const;
+      ui32 list_tag, ObjectWriter* ow) const;
 
   // Looks up a field and verify its consistency with wire type in tag.
   const google::protobuf::Field* FindAndVerifyField(
-      const google::protobuf::Type& type, uint32_t tag) const;
+      const google::protobuf::Type& type, ui32 tag) const;
 
   // Renders a field value to the ObjectWriter.
   virtual util::Status RenderField(const google::protobuf::Field* field,
@@ -189,8 +189,8 @@ class PROTOBUF_EXPORT ProtoStreamObjectSource : public ObjectSource {
   // Renders a NWP map.
   // Returns the next tag after reading all map entries. The caller should use
   // this tag before reading more tags from the stream.
-  util::StatusOr<uint32_t> RenderMap(const google::protobuf::Field* field,
-                                     StringPiece name, uint32_t list_tag,
+  util::StatusOr<ui32> RenderMap(const google::protobuf::Field* field,
+                                     StringPiece name, ui32 list_tag,
                                      ObjectWriter* ow) const;
 
   // Renders a packed repeating field. A packed field is stored as:
@@ -283,7 +283,7 @@ class PROTOBUF_EXPORT ProtoStreamObjectSource : public ObjectSource {
 
   // Utility to read int64 and int32 values from a message type in stream_.
   // Used for reading google.protobuf.Timestamp and Duration messages.
-  std::pair<int64_t, int32_t> ReadSecondsAndNanos(
+  std::pair<i64, i32> ReadSecondsAndNanos(
       const google::protobuf::Type& type) const;
 
   // Helper function to check recursion depth and increment it. It will return
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectwriter.cc b/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectwriter.cc
index 5ac24d0ac0..17486baf0d 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectwriter.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/protostream_objectwriter.cc
@@ -129,7 +129,7 @@ void SplitSecondsAndNanos(StringPiece input, StringPiece* seconds,
 Status GetNanosFromStringPiece(StringPiece s_nanos,
                                const char* parse_failure_message,
                                const char* exceeded_limit_message,
-                               int32_t* nanos) {
+                               i32* nanos) {
   *nanos = 0;
 
   // Count the number of leading 0s and consume them.
@@ -137,7 +137,7 @@ Status GetNanosFromStringPiece(StringPiece s_nanos,
   while (s_nanos.Consume("0")) {
     num_leading_zeros++;
   }
-  int32 i_nanos = 0;
+  i32 i_nanos = 0;
   // 's_nanos' contains fractional seconds -- i.e. 'nanos' is equal to
   // "0." + s_nanos.ToString() seconds. An int32 is used for the
   // conversion to 'nanos', rather than a double, so that there is no
@@ -156,11 +156,11 @@ Status GetNanosFromStringPiece(StringPiece s_nanos,
   if (i_nanos > 0) {
     // 'scale' is the number of digits to the right of the decimal
     // point in "0." + s_nanos.ToString()
-    int32_t scale = num_leading_zeros + s_nanos.size();
+    i32 scale = num_leading_zeros + s_nanos.size();
     // 'conversion' converts i_nanos into nanoseconds.
     // conversion = kNanosPerSecond / static_cast<int32>(std::pow(10, scale))
     // For efficiency, we precompute the conversion factor.
-    int32_t conversion = 0;
+    i32 conversion = 0;
     switch (scale) {
       case 1:
         conversion = 100000000;
@@ -920,7 +920,7 @@ Status ProtoStreamObjectWriter::RenderStructValue(ProtoStreamObjectWriter* ow,
   switch (data.type()) {
     case DataPiece::TYPE_INT32: {
       if (ow->options_.struct_integers_as_strings) {
-        util::StatusOr<int32_t> int_value = data.ToInt32();
+        util::StatusOr<i32> int_value = data.ToInt32();
         if (int_value.ok()) {
           ow->ProtoWriter::RenderDataPiece(
               "string_value",
@@ -933,7 +933,7 @@ Status ProtoStreamObjectWriter::RenderStructValue(ProtoStreamObjectWriter* ow,
     }
     case DataPiece::TYPE_UINT32: {
       if (ow->options_.struct_integers_as_strings) {
-        util::StatusOr<uint32_t> int_value = data.ToUint32();
+        util::StatusOr<ui32> int_value = data.ToUint32();
         if (int_value.ok()) {
           ow->ProtoWriter::RenderDataPiece(
               "string_value",
@@ -948,7 +948,7 @@ Status ProtoStreamObjectWriter::RenderStructValue(ProtoStreamObjectWriter* ow,
       // If the option to treat integers as strings is set, then render them as
       // strings. Otherwise, fallback to rendering them as double.
       if (ow->options_.struct_integers_as_strings) {
-        util::StatusOr<int64_t> int_value = data.ToInt64();
+        util::StatusOr<i64> int_value = data.ToInt64();
         if (int_value.ok()) {
           ow->ProtoWriter::RenderDataPiece(
               "string_value", DataPiece(StrCat(int_value.value()), true));
@@ -962,7 +962,7 @@ Status ProtoStreamObjectWriter::RenderStructValue(ProtoStreamObjectWriter* ow,
       // If the option to treat integers as strings is set, then render them as
       // strings. Otherwise, fallback to rendering them as double.
       if (ow->options_.struct_integers_as_strings) {
-        util::StatusOr<uint64_t> int_value = data.ToUint64();
+        util::StatusOr<ui64> int_value = data.ToUint64();
         if (int_value.ok()) {
           ow->ProtoWriter::RenderDataPiece(
               "string_value", DataPiece(StrCat(int_value.value()), true));
@@ -1091,13 +1091,13 @@ Status ProtoStreamObjectWriter::RenderDuration(ProtoStreamObjectWriter* ow,
 
   StringPiece s_secs, s_nanos;
   SplitSecondsAndNanos(value, &s_secs, &s_nanos);
-  uint64_t unsigned_seconds;
+  ui64 unsigned_seconds;
   if (!safe_strtou64(s_secs, &unsigned_seconds)) {
     return util::InvalidArgumentError(
         "Invalid duration format, failed to parse seconds");
   }
 
-  int32_t nanos = 0;
+  i32 nanos = 0;
   Status nanos_status = GetNanosFromStringPiece(
       s_nanos, "Invalid duration format, failed to parse nano seconds",
       "Duration value exceeds limits", &nanos);
@@ -1106,7 +1106,7 @@ Status ProtoStreamObjectWriter::RenderDuration(ProtoStreamObjectWriter* ow,
   }
   nanos = sign * nanos;
 
-  int64_t seconds = sign * unsigned_seconds;
+  i64 seconds = sign * unsigned_seconds;
   if (seconds > kDurationMaxSeconds || seconds < kDurationMinSeconds ||
       nanos <= -kNanosPerSecond || nanos >= kNanosPerSecond) {
     return util::InvalidArgumentError("Duration value exceeds limits");
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/utility.cc b/contrib/libs/protobuf/src/google/protobuf/util/internal/utility.cc
index acceb63347..f7470986b8 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/utility.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/utility.cc
@@ -66,9 +66,9 @@ bool GetBoolOptionOrDefault(
   return GetBoolFromAny(opt->value());
 }
 
-int64_t GetInt64OptionOrDefault(
+i64 GetInt64OptionOrDefault(
     const RepeatedPtrField<google::protobuf::Option>& options,
-    StringPiece option_name, int64_t default_value) {
+    StringPiece option_name, i64 default_value) {
   const google::protobuf::Option* opt = FindOptionOrNull(options, option_name);
   if (opt == nullptr) {
     return default_value;
@@ -109,7 +109,7 @@ bool GetBoolFromAny(const google::protobuf::Any& any) {
   return b.value();
 }
 
-int64_t GetInt64FromAny(const google::protobuf::Any& any) {
+i64 GetInt64FromAny(const google::protobuf::Any& any) {
   google::protobuf::Int64Value i;
   ParseFromAny(any.value(), &i);
   return i.value();
@@ -182,7 +182,7 @@ const google::protobuf::Field* FindJsonFieldInTypeOrNull(
 }
 
 const google::protobuf::Field* FindFieldInTypeByNumberOrNull(
-    const google::protobuf::Type* type, int32_t number) {
+    const google::protobuf::Type* type, i32 number) {
   if (type != nullptr) {
     for (int i = 0; i < type->fields_size(); ++i) {
       const google::protobuf::Field& field = type->fields(i);
@@ -208,7 +208,7 @@ const google::protobuf::EnumValue* FindEnumValueByNameOrNull(
 }
 
 const google::protobuf::EnumValue* FindEnumValueByNumberOrNull(
-    const google::protobuf::Enum* enum_type, int32_t value) {
+    const google::protobuf::Enum* enum_type, i32 value) {
   if (enum_type != nullptr) {
     for (int i = 0; i < enum_type->enumvalue_size(); ++i) {
       const google::protobuf::EnumValue& enum_value = enum_type->enumvalue(i);
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/internal/utility.h b/contrib/libs/protobuf/src/google/protobuf/util/internal/utility.h
index f1a1cf44d4..b1ef54c2f6 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/internal/utility.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/internal/utility.h
@@ -54,7 +54,7 @@ namespace util {
 namespace converter {
 
 // Size of "type.googleapis.com"
-static const int64_t kTypeUrlSize = 19;
+static const i64 kTypeUrlSize = 19;
 
 // Finds the tech option identified by option_name. Parses the boolean value and
 // returns it.
@@ -65,9 +65,9 @@ PROTOBUF_EXPORT bool GetBoolOptionOrDefault(
 
 // Returns int64 option value. If the option isn't found, returns the
 // default_value.
-PROTOBUF_EXPORT int64_t GetInt64OptionOrDefault(
+PROTOBUF_EXPORT i64 GetInt64OptionOrDefault(
     const RepeatedPtrField<google::protobuf::Option>& options,
-    StringPiece option_name, int64_t default_value);
+    StringPiece option_name, i64 default_value);
 
 // Returns double option value. If the option isn't found, returns the
 // default_value.
@@ -88,7 +88,7 @@ PROTOBUF_EXPORT TProtoStringType GetStringOptionOrDefault(
 PROTOBUF_EXPORT bool GetBoolFromAny(const google::protobuf::Any& any);
 
 // Returns int64 value contained in Any type.
-PROTOBUF_EXPORT int64_t GetInt64FromAny(const google::protobuf::Any& any);
+PROTOBUF_EXPORT i64 GetInt64FromAny(const google::protobuf::Any& any);
 
 // Returns double value contained in Any type.
 PROTOBUF_EXPORT double GetDoubleFromAny(const google::protobuf::Any& any);
@@ -128,7 +128,7 @@ const google::protobuf::Field* FindJsonFieldInTypeOrNull(
 
 // Similar to FindFieldInTypeOrNull, but this looks up fields by number.
 const google::protobuf::Field* FindFieldInTypeByNumberOrNull(
-    const google::protobuf::Type* type, int32_t number);
+    const google::protobuf::Type* type, i32 number);
 
 // Finds and returns the EnumValue identified by enum_name in the passed tech
 // Enum object. Returns nullptr if none found.
@@ -138,7 +138,7 @@ const google::protobuf::EnumValue* FindEnumValueByNameOrNull(
 // Finds and returns the EnumValue identified by value in the passed tech
 // Enum object. Returns nullptr if none found.
 const google::protobuf::EnumValue* FindEnumValueByNumberOrNull(
-    const google::protobuf::Enum* enum_type, int32_t value);
+    const google::protobuf::Enum* enum_type, i32 value);
 
 // Finds and returns the EnumValue identified by enum_name without underscore in
 // the passed tech Enum object. Returns nullptr if none found.
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/message_differencer.cc b/contrib/libs/protobuf/src/google/protobuf/util/message_differencer.cc
index 2599359ac1..32385c6173 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/message_differencer.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/message_differencer.cc
@@ -73,7 +73,7 @@ class NumDiffsReporter : public google::protobuf::util::MessageDifferencer::Repo
   NumDiffsReporter() : num_diffs_(0) {}
 
   // Returns the total number of diffs.
-  int32_t GetNumDiffs() const { return num_diffs_; }
+  i32 GetNumDiffs() const { return num_diffs_; }
   void Reset() { num_diffs_ = 0; }
 
   // Report that a field has been added into Message2.
@@ -101,7 +101,7 @@ class NumDiffsReporter : public google::protobuf::util::MessageDifferencer::Repo
   }
 
  private:
-  int32_t num_diffs_;
+  i32 num_diffs_;
 };
 
 // When comparing a repeated field as map, MultipleFieldMapKeyComparator can
@@ -147,7 +147,7 @@ class MessageDifferencer::MultipleFieldsMapKeyComparator
       int path_index) const {
     const FieldDescriptor* field = key_field_path[path_index];
     std::vector<SpecificField> current_parent_fields(parent_fields);
-    if (path_index == static_cast<int64_t>(key_field_path.size() - 1)) {
+    if (path_index == static_cast<i64>(key_field_path.size() - 1)) {
       if (field->is_map()) {
         return message_differencer_->CompareMapField(message1, message2, field,
                                                      &current_parent_fields);
@@ -1780,9 +1780,9 @@ bool MessageDifferencer::MatchRepeatedFieldIndices(
   Reporter* reporter = reporter_;
   reporter_ = NULL;
   NumDiffsReporter num_diffs_reporter;
-  std::vector<int32_t> num_diffs_list1;
+  std::vector<i32> num_diffs_list1;
   if (is_treated_as_smart_set) {
-    num_diffs_list1.assign(count1, std::numeric_limits<int32_t>::max());
+    num_diffs_list1.assign(count1, std::numeric_limits<i32>::max());
   }
 
   bool success = true;
@@ -1850,7 +1850,7 @@ bool MessageDifferencer::MatchRepeatedFieldIndices(
           } else if (repeated_field->cpp_type() ==
                      FieldDescriptor::CPPTYPE_MESSAGE) {
             // Replace with the one with fewer diffs.
-            const int32_t num_diffs = num_diffs_reporter.GetNumDiffs();
+            const i32 num_diffs = num_diffs_reporter.GetNumDiffs();
             if (num_diffs < num_diffs_list1[i]) {
               // If j has been already matched to some element, ensure the
               // current num_diffs is smaller.
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/time_util.cc b/contrib/libs/protobuf/src/google/protobuf/util/time_util.cc
index 1b2056a785..5a09bee943 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/time_util.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/util/time_util.cc
@@ -59,10 +59,10 @@ static const int kSecondsPerMinute = 60;  // Note that we ignore leap seconds.
 static const int kSecondsPerHour = 3600;
 
 template <typename T>
-T CreateNormalized(int64_t seconds, int64_t nanos);
+T CreateNormalized(i64 seconds, i64 nanos);
 
 template <>
-Timestamp CreateNormalized(int64_t seconds, int64_t nanos) {
+Timestamp CreateNormalized(i64 seconds, i64 nanos) {
   // Make sure nanos is in the range.
   if (nanos <= -kNanosPerSecond || nanos >= kNanosPerSecond) {
     seconds += nanos / kNanosPerSecond;
@@ -77,12 +77,12 @@ Timestamp CreateNormalized(int64_t seconds, int64_t nanos) {
          seconds <= TimeUtil::kTimestampMaxSeconds);
   Timestamp result;
   result.set_seconds(seconds);
-  result.set_nanos(static_cast<int32_t>(nanos));
+  result.set_nanos(static_cast<i32>(nanos));
   return result;
 }
 
 template <>
-Duration CreateNormalized(int64_t seconds, int64_t nanos) {
+Duration CreateNormalized(i64 seconds, i64 nanos) {
   // Make sure nanos is in the range.
   if (nanos <= -kNanosPerSecond || nanos >= kNanosPerSecond) {
     seconds += nanos / kNanosPerSecond;
@@ -100,13 +100,13 @@ Duration CreateNormalized(int64_t seconds, int64_t nanos) {
          seconds <= TimeUtil::kDurationMaxSeconds);
   Duration result;
   result.set_seconds(seconds);
-  result.set_nanos(static_cast<int32_t>(nanos));
+  result.set_nanos(static_cast<i32>(nanos));
   return result;
 }
 
 // Format nanoseconds with either 3, 6, or 9 digits depending on the required
 // precision to represent the exact value.
-TProtoStringType FormatNanos(int32_t nanos) {
+TProtoStringType FormatNanos(i32 nanos) {
   if (nanos % kNanosPerMillisecond == 0) {
     return StringPrintf("%03d", nanos / kNanosPerMillisecond);
   } else if (nanos % kNanosPerMicrosecond == 0) {
@@ -129,9 +129,9 @@ void CurrentTime(int64* seconds, int32* nanos) {
 }
 
 // Truncates the remainder part after division.
-int64_t RoundTowardZero(int64_t value, int64_t divider) {
-  int64_t result = value / divider;
-  int64_t remainder = value % divider;
+i64 RoundTowardZero(i64 value, i64 divider) {
+  i64 result = value / divider;
+  i64 remainder = value % divider;
   // Before C++11, the sign of the remainder is implementation dependent if
   // any of the operands is negative. Here we try to enforce C++11's "rounded
   // toward zero" semantics. For example, for (-5) / 2 an implementation may
@@ -148,10 +148,10 @@ int64_t RoundTowardZero(int64_t value, int64_t divider) {
 // Actually define these static const integers. Required by C++ standard (but
 // some compilers don't like it).
 #ifndef _MSC_VER
-const int64_t TimeUtil::kTimestampMinSeconds;
-const int64_t TimeUtil::kTimestampMaxSeconds;
-const int64_t TimeUtil::kDurationMaxSeconds;
-const int64_t TimeUtil::kDurationMinSeconds;
+const i64 TimeUtil::kTimestampMinSeconds;
+const i64 TimeUtil::kTimestampMaxSeconds;
+const i64 TimeUtil::kDurationMaxSeconds;
+const i64 TimeUtil::kDurationMinSeconds;
 #endif  // !_MSC_VER
 
 TProtoStringType TimeUtil::ToString(const Timestamp& timestamp) {
@@ -159,8 +159,8 @@ TProtoStringType TimeUtil::ToString(const Timestamp& timestamp) {
 }
 
 bool TimeUtil::FromString(const TProtoStringType& value, Timestamp* timestamp) {
-  int64 seconds;
-  int32 nanos;
+  i64 seconds;
+  i32 nanos;
   if (!ParseTime(value, &seconds, &nanos)) {
     return false;
   }
@@ -169,8 +169,8 @@ bool TimeUtil::FromString(const TProtoStringType& value, Timestamp* timestamp) {
 }
 
 Timestamp TimeUtil::GetCurrentTime() {
-  int64 seconds;
-  int32 nanos;
+  i64 seconds;
+  i32 nanos;
   CurrentTime(&seconds, &nanos);
   return CreateNormalized<Timestamp>(seconds, nanos);
 }
@@ -179,8 +179,8 @@ Timestamp TimeUtil::GetEpoch() { return Timestamp(); }
 
 TProtoStringType TimeUtil::ToString(const Duration& duration) {
   TProtoStringType result;
-  int64_t seconds = duration.seconds();
-  int32_t nanos = duration.nanos();
+  i64 seconds = duration.seconds();
+  i32 nanos = duration.nanos();
   if (seconds < 0 || nanos < 0) {
     result += "-";
     seconds = -seconds;
@@ -194,8 +194,8 @@ TProtoStringType TimeUtil::ToString(const Duration& duration) {
   return result;
 }
 
-static int64_t Pow(int64_t x, int y) {
-  int64_t result = 1;
+static i64 Pow(i64 x, int y) {
+  i64 result = 1;
   for (int i = 0; i < y; ++i) {
     result *= x;
   }
@@ -220,11 +220,11 @@ bool TimeUtil::FromString(const TProtoStringType& value, Duration* duration) {
     nanos_part = value.substr(pos + 1, value.length() - pos - 2);
   }
   char* end;
-  int64_t seconds = strto64(seconds_part.c_str(), &end, 10);
+  i64 seconds = strto64(seconds_part.c_str(), &end, 10);
   if (end != seconds_part.c_str() + seconds_part.length()) {
     return false;
   }
-  int64_t nanos = strto64(nanos_part.c_str(), &end, 10);
+  i64 nanos = strto64(nanos_part.c_str(), &end, 10);
   if (end != nanos_part.c_str() + nanos_part.length()) {
     return false;
   }
@@ -235,106 +235,106 @@ bool TimeUtil::FromString(const TProtoStringType& value, Duration* duration) {
     nanos = -nanos;
   }
   duration->set_seconds(seconds);
-  duration->set_nanos(static_cast<int32_t>(nanos));
+  duration->set_nanos(static_cast<i32>(nanos));
   return true;
 }
 
-Duration TimeUtil::NanosecondsToDuration(int64_t nanos) {
+Duration TimeUtil::NanosecondsToDuration(i64 nanos) {
   return CreateNormalized<Duration>(nanos / kNanosPerSecond,
                                     nanos % kNanosPerSecond);
 }
 
-Duration TimeUtil::MicrosecondsToDuration(int64_t micros) {
+Duration TimeUtil::MicrosecondsToDuration(i64 micros) {
   return CreateNormalized<Duration>(
       micros / kMicrosPerSecond,
       (micros % kMicrosPerSecond) * kNanosPerMicrosecond);
 }
 
-Duration TimeUtil::MillisecondsToDuration(int64_t millis) {
+Duration TimeUtil::MillisecondsToDuration(i64 millis) {
   return CreateNormalized<Duration>(
       millis / kMillisPerSecond,
       (millis % kMillisPerSecond) * kNanosPerMillisecond);
 }
 
-Duration TimeUtil::SecondsToDuration(int64_t seconds) {
+Duration TimeUtil::SecondsToDuration(i64 seconds) {
   return CreateNormalized<Duration>(seconds, 0);
 }
 
-Duration TimeUtil::MinutesToDuration(int64_t minutes) {
+Duration TimeUtil::MinutesToDuration(i64 minutes) {
   return CreateNormalized<Duration>(minutes * kSecondsPerMinute, 0);
 }
 
-Duration TimeUtil::HoursToDuration(int64_t hours) {
+Duration TimeUtil::HoursToDuration(i64 hours) {
   return CreateNormalized<Duration>(hours * kSecondsPerHour, 0);
 }
 
-int64_t TimeUtil::DurationToNanoseconds(const Duration& duration) {
+i64 TimeUtil::DurationToNanoseconds(const Duration& duration) {
   return duration.seconds() * kNanosPerSecond + duration.nanos();
 }
 
-int64_t TimeUtil::DurationToMicroseconds(const Duration& duration) {
+i64 TimeUtil::DurationToMicroseconds(const Duration& duration) {
   return duration.seconds() * kMicrosPerSecond +
          RoundTowardZero(duration.nanos(), kNanosPerMicrosecond);
 }
 
-int64_t TimeUtil::DurationToMilliseconds(const Duration& duration) {
+i64 TimeUtil::DurationToMilliseconds(const Duration& duration) {
   return duration.seconds() * kMillisPerSecond +
          RoundTowardZero(duration.nanos(), kNanosPerMillisecond);
 }
 
-int64_t TimeUtil::DurationToSeconds(const Duration& duration) {
+i64 TimeUtil::DurationToSeconds(const Duration& duration) {
   return duration.seconds();
 }
 
-int64_t TimeUtil::DurationToMinutes(const Duration& duration) {
+i64 TimeUtil::DurationToMinutes(const Duration& duration) {
   return RoundTowardZero(duration.seconds(), kSecondsPerMinute);
 }
 
-int64_t TimeUtil::DurationToHours(const Duration& duration) {
+i64 TimeUtil::DurationToHours(const Duration& duration) {
   return RoundTowardZero(duration.seconds(), kSecondsPerHour);
 }
 
-Timestamp TimeUtil::NanosecondsToTimestamp(int64_t nanos) {
+Timestamp TimeUtil::NanosecondsToTimestamp(i64 nanos) {
   return CreateNormalized<Timestamp>(nanos / kNanosPerSecond,
                                      nanos % kNanosPerSecond);
 }
 
-Timestamp TimeUtil::MicrosecondsToTimestamp(int64_t micros) {
+Timestamp TimeUtil::MicrosecondsToTimestamp(i64 micros) {
   return CreateNormalized<Timestamp>(
       micros / kMicrosPerSecond,
       micros % kMicrosPerSecond * kNanosPerMicrosecond);
 }
 
-Timestamp TimeUtil::MillisecondsToTimestamp(int64_t millis) {
+Timestamp TimeUtil::MillisecondsToTimestamp(i64 millis) {
   return CreateNormalized<Timestamp>(
       millis / kMillisPerSecond,
       millis % kMillisPerSecond * kNanosPerMillisecond);
 }
 
-Timestamp TimeUtil::SecondsToTimestamp(int64_t seconds) {
+Timestamp TimeUtil::SecondsToTimestamp(i64 seconds) {
   return CreateNormalized<Timestamp>(seconds, 0);
 }
 
-int64_t TimeUtil::TimestampToNanoseconds(const Timestamp& timestamp) {
+i64 TimeUtil::TimestampToNanoseconds(const Timestamp& timestamp) {
   return timestamp.seconds() * kNanosPerSecond + timestamp.nanos();
 }
 
-int64_t TimeUtil::TimestampToMicroseconds(const Timestamp& timestamp) {
+i64 TimeUtil::TimestampToMicroseconds(const Timestamp& timestamp) {
   return timestamp.seconds() * kMicrosPerSecond +
          RoundTowardZero(timestamp.nanos(), kNanosPerMicrosecond);
 }
 
-int64_t TimeUtil::TimestampToMilliseconds(const Timestamp& timestamp) {
+i64 TimeUtil::TimestampToMilliseconds(const Timestamp& timestamp) {
   return timestamp.seconds() * kMillisPerSecond +
          RoundTowardZero(timestamp.nanos(), kNanosPerMillisecond);
 }
 
-int64_t TimeUtil::TimestampToSeconds(const Timestamp& timestamp) {
+i64 TimeUtil::TimestampToSeconds(const Timestamp& timestamp) {
   return timestamp.seconds();
 }
 
 Timestamp TimeUtil::TimeTToTimestamp(time_t value) {
-  return CreateNormalized<Timestamp>(static_cast<int64_t>(value), 0);
+  return CreateNormalized<Timestamp>(static_cast<i64>(value), 0);
 }
 
 time_t TimeUtil::TimestampToTimeT(const Timestamp& value) {
@@ -384,20 +384,20 @@ using ::PROTOBUF_NAMESPACE_ID::util::kNanosPerSecond;
 void ToUint128(const Duration& value, uint128* result, bool* negative) {
   if (value.seconds() < 0 || value.nanos() < 0) {
     *negative = true;
-    *result = static_cast<uint64>(-value.seconds());
-    *result = *result * kNanosPerSecond + static_cast<uint32>(-value.nanos());
+    *result = static_cast<ui64>(-value.seconds());
+    *result = *result * kNanosPerSecond + static_cast<ui32>(-value.nanos());
   } else {
     *negative = false;
-    *result = static_cast<uint64>(value.seconds());
-    *result = *result * kNanosPerSecond + static_cast<uint32>(value.nanos());
+    *result = static_cast<ui64>(value.seconds());
+    *result = *result * kNanosPerSecond + static_cast<ui32>(value.nanos());
   }
 }
 
 void ToDuration(const uint128& value, bool negative, Duration* duration) {
-  int64_t seconds =
-      static_cast<int64_t>(Uint128Low64(value / kNanosPerSecond));
-  int32_t nanos =
-      static_cast<int32_t>(Uint128Low64(value % kNanosPerSecond));
+  i64 seconds =
+      static_cast<i64>(Uint128Low64(value / kNanosPerSecond));
+  i32 nanos =
+      static_cast<i32>(Uint128Low64(value % kNanosPerSecond));
   if (negative) {
     seconds = -seconds;
     nanos = -nanos;
@@ -419,15 +419,15 @@ Duration& operator-=(Duration& d1, const Duration& d2) {  // NOLINT
   return d1;
 }
 
-Duration& operator*=(Duration& d, int64_t r) {  // NOLINT
+Duration& operator*=(Duration& d, i64 r) {  // NOLINT
   bool negative;
   uint128 value;
   ToUint128(d, &value, &negative);
   if (r > 0) {
-    value *= static_cast<uint64>(r);
+    value *= static_cast<ui64>(r);
   } else {
     negative = !negative;
-    value *= static_cast<uint64>(-r);
+    value *= static_cast<ui64>(-r);
   }
   ToDuration(value, negative, &d);
   return d;
@@ -435,8 +435,8 @@ Duration& operator*=(Duration& d, int64_t r) {  // NOLINT
 
 Duration& operator*=(Duration& d, double r) {  // NOLINT
   double result = (d.seconds() * 1.0 + 1.0 * d.nanos() / kNanosPerSecond) * r;
-  int64_t seconds = static_cast<int64_t>(result);
-  int32_t nanos = static_cast<int32_t>((result - seconds) * kNanosPerSecond);
+  i64 seconds = static_cast<i64>(result);
+  i32 nanos = static_cast<i32>((result - seconds) * kNanosPerSecond);
   // Note that we normalize here not just because nanos can have a different
   // sign from seconds but also that nanos can be any arbitrary value when
   // overflow happens (i.e., the result is a much larger value than what
@@ -445,15 +445,15 @@ Duration& operator*=(Duration& d, double r) {  // NOLINT
   return d;
 }
 
-Duration& operator/=(Duration& d, int64_t r) {  // NOLINT
+Duration& operator/=(Duration& d, i64 r) {  // NOLINT
   bool negative;
   uint128 value;
   ToUint128(d, &value, &negative);
   if (r > 0) {
-    value /= static_cast<uint64>(r);
+    value /= static_cast<ui64>(r);
   } else {
     negative = !negative;
-    value /= static_cast<uint64>(-r);
+    value /= static_cast<ui64>(-r);
   }
   ToDuration(value, negative, &d);
   return d;
@@ -479,12 +479,12 @@ Duration& operator%=(Duration& d1, const Duration& d2) {  // NOLINT
   return d1;
 }
 
-int64_t operator/(const Duration& d1, const Duration& d2) {
+i64 operator/(const Duration& d1, const Duration& d2) {
   bool negative1, negative2;
   uint128 value1, value2;
   ToUint128(d1, &value1, &negative1);
   ToUint128(d2, &value2, &negative2);
-  int64_t result = Uint128Low64(value1 / value2);
+  i64 result = Uint128Low64(value1 / value2);
   if (negative1 != negative2) {
     result = -result;
   }
diff --git a/contrib/libs/protobuf/src/google/protobuf/util/time_util.h b/contrib/libs/protobuf/src/google/protobuf/util/time_util.h
index 0a297e9e64..c3f4f60aff 100644
--- a/contrib/libs/protobuf/src/google/protobuf/util/time_util.h
+++ b/contrib/libs/protobuf/src/google/protobuf/util/time_util.h
@@ -68,11 +68,11 @@ class PROTOBUF_EXPORT TimeUtil {
   // The min/max Timestamp/Duration values we support.
   //
   // For "0001-01-01T00:00:00Z".
-  static const int64_t kTimestampMinSeconds = -62135596800LL;
+  static const i64 kTimestampMinSeconds = -62135596800LL;
   // For "9999-12-31T23:59:59.999999999Z".
-  static const int64_t kTimestampMaxSeconds = 253402300799LL;
-  static const int64_t kDurationMinSeconds = -315576000000LL;
-  static const int64_t kDurationMaxSeconds = 315576000000LL;
+  static const i64 kTimestampMaxSeconds = 253402300799LL;
+  static const i64 kDurationMinSeconds = -315576000000LL;
+  static const i64 kDurationMaxSeconds = 315576000000LL;
 
   // Converts Timestamp to/from RFC 3339 date string format.
   // Generated output will always be Z-normalized and uses 3, 6 or 9
@@ -111,12 +111,12 @@ class PROTOBUF_EXPORT TimeUtil {
 
   // Converts between Duration and integer types. The behavior is undefined if
   // the input value is not in the valid range of Duration.
-  static Duration NanosecondsToDuration(int64_t nanos);
-  static Duration MicrosecondsToDuration(int64_t micros);
-  static Duration MillisecondsToDuration(int64_t millis);
-  static Duration SecondsToDuration(int64_t seconds);
-  static Duration MinutesToDuration(int64_t minutes);
-  static Duration HoursToDuration(int64_t hours);
+  static Duration NanosecondsToDuration(i64 nanos);
+  static Duration MicrosecondsToDuration(i64 micros);
+  static Duration MillisecondsToDuration(i64 millis);
+  static Duration SecondsToDuration(i64 seconds);
+  static Duration MinutesToDuration(i64 minutes);
+  static Duration HoursToDuration(i64 hours);
   // Result will be truncated towards zero. For example, "-1.5s" will be
   // truncated to "-1s", and "1.5s" to "1s" when converting to seconds.
   // It's undefined behavior if the input duration is not valid or the result
@@ -124,28 +124,28 @@ class PROTOBUF_EXPORT TimeUtil {
   // valid range of Duration, or have an invalid nanos value (i.e., larger
   // than 999999999, less than -999999999, or have a different sign from the
   // seconds part).
-  static int64_t DurationToNanoseconds(const Duration& duration);
-  static int64_t DurationToMicroseconds(const Duration& duration);
-  static int64_t DurationToMilliseconds(const Duration& duration);
-  static int64_t DurationToSeconds(const Duration& duration);
-  static int64_t DurationToMinutes(const Duration& duration);
-  static int64_t DurationToHours(const Duration& duration);
+  static i64 DurationToNanoseconds(const Duration& duration);
+  static i64 DurationToMicroseconds(const Duration& duration);
+  static i64 DurationToMilliseconds(const Duration& duration);
+  static i64 DurationToSeconds(const Duration& duration);
+  static i64 DurationToMinutes(const Duration& duration);
+  static i64 DurationToHours(const Duration& duration);
   // Creates Timestamp from integer types. The integer value indicates the
   // time elapsed from Epoch time. The behavior is undefined if the input
   // value is not in the valid range of Timestamp.
-  static Timestamp NanosecondsToTimestamp(int64_t nanos);
-  static Timestamp MicrosecondsToTimestamp(int64_t micros);
-  static Timestamp MillisecondsToTimestamp(int64_t millis);
-  static Timestamp SecondsToTimestamp(int64_t seconds);
+  static Timestamp NanosecondsToTimestamp(i64 nanos);
+  static Timestamp MicrosecondsToTimestamp(i64 micros);
+  static Timestamp MillisecondsToTimestamp(i64 millis);
+  static Timestamp SecondsToTimestamp(i64 seconds);
   // Result will be truncated down to the nearest integer value. For example,
   // with "1969-12-31T23:59:59.9Z", TimestampToMilliseconds() returns -100
   // and TimestampToSeconds() returns -1. It's undefined behavior if the input
   // Timestamp is not valid (i.e., its seconds part or nanos part does not fall
   // in the valid range) or the return value doesn't fit into int64.
-  static int64_t TimestampToNanoseconds(const Timestamp& timestamp);
-  static int64_t TimestampToMicroseconds(const Timestamp& timestamp);
-  static int64_t TimestampToMilliseconds(const Timestamp& timestamp);
-  static int64_t TimestampToSeconds(const Timestamp& timestamp);
+  static i64 TimestampToNanoseconds(const Timestamp& timestamp);
+  static i64 TimestampToMicroseconds(const Timestamp& timestamp);
+  static i64 TimestampToMilliseconds(const Timestamp& timestamp);
+  static i64 TimestampToSeconds(const Timestamp& timestamp);
 
   // Conversion to/from other time/date types. Note that these types may
   // have a different precision and time range from Timestamp/Duration.
@@ -177,19 +177,19 @@ PROTOBUF_EXPORT Duration& operator+=(Duration& d1,
                                      const Duration& d2);  // NOLINT
 PROTOBUF_EXPORT Duration& operator-=(Duration& d1,
                                      const Duration& d2);     // NOLINT
-PROTOBUF_EXPORT Duration& operator*=(Duration& d, int64_t r);  // NOLINT
+PROTOBUF_EXPORT Duration& operator*=(Duration& d, i64 r);  // NOLINT
 PROTOBUF_EXPORT Duration& operator*=(Duration& d, double r);  // NOLINT
-PROTOBUF_EXPORT Duration& operator/=(Duration& d, int64_t r);  // NOLINT
+PROTOBUF_EXPORT Duration& operator/=(Duration& d, i64 r);  // NOLINT
 PROTOBUF_EXPORT Duration& operator/=(Duration& d, double r);  // NOLINT
 // Overload for other integer types.
 template <typename T>
 Duration& operator*=(Duration& d, T r) {  // NOLINT
-  int64_t x = r;
+  i64 x = r;
   return d *= x;
 }
 template <typename T>
 Duration& operator/=(Duration& d, T r) {  // NOLINT
-  int64_t x = r;
+  i64 x = r;
   return d /= x;
 }
 PROTOBUF_EXPORT Duration& operator%=(Duration& d1,
@@ -244,7 +244,7 @@ template <typename T>
 inline Duration operator/(Duration d, T r) {
   return d /= r;
 }
-PROTOBUF_EXPORT int64_t operator/(const Duration& d1, const Duration& d2);
+PROTOBUF_EXPORT i64 operator/(const Duration& d1, const Duration& d2);
 
 inline Duration operator%(const Duration& d1, const Duration& d2) {
   Duration result = d1;
diff --git a/contrib/libs/protobuf/src/google/protobuf/wire_format.cc b/contrib/libs/protobuf/src/google/protobuf/wire_format.cc
index 0f265b2eb7..27d21dd613 100644
--- a/contrib/libs/protobuf/src/google/protobuf/wire_format.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/wire_format.cc
@@ -70,7 +70,7 @@ static size_t MapValueRefDataOnlyByteSize(const FieldDescriptor* field,
 // ===================================================================
 
 bool UnknownFieldSetFieldSkipper::SkipField(io::CodedInputStream* input,
-                                            uint32_t tag) {
+                                            ui32 tag) {
   return WireFormat::SkipField(input, tag, unknown_fields_);
 }
 
@@ -82,7 +82,7 @@ void UnknownFieldSetFieldSkipper::SkipUnknownEnum(int field_number, int value) {
   unknown_fields_->AddVarint(field_number, value);
 }
 
-bool WireFormat::SkipField(io::CodedInputStream* input, uint32_t tag,
+bool WireFormat::SkipField(io::CodedInputStream* input, ui32 tag,
                            UnknownFieldSet* unknown_fields) {
   int number = WireFormatLite::GetTagFieldNumber(tag);
   // Field number 0 is illegal.
@@ -90,19 +90,19 @@ bool WireFormat::SkipField(io::CodedInputStream* input, uint32_t tag,
 
   switch (WireFormatLite::GetTagWireType(tag)) {
     case WireFormatLite::WIRETYPE_VARINT: {
-      uint64_t value;
+      ui64 value;
       if (!input->ReadVarint64(&value)) return false;
       if (unknown_fields != NULL) unknown_fields->AddVarint(number, value);
       return true;
     }
     case WireFormatLite::WIRETYPE_FIXED64: {
-      uint64_t value;
+      ui64 value;
       if (!input->ReadLittleEndian64(&value)) return false;
       if (unknown_fields != NULL) unknown_fields->AddFixed64(number, value);
       return true;
     }
     case WireFormatLite::WIRETYPE_LENGTH_DELIMITED: {
-      uint32_t length;
+      ui32 length;
       if (!input->ReadVarint32(&length)) return false;
       if (unknown_fields == NULL) {
         if (!input->Skip(length)) return false;
@@ -134,7 +134,7 @@ bool WireFormat::SkipField(io::CodedInputStream* input, uint32_t tag,
       return false;
     }
     case WireFormatLite::WIRETYPE_FIXED32: {
-      uint32_t value;
+      ui32 value;
       if (!input->ReadLittleEndian32(&value)) return false;
       if (unknown_fields != NULL) unknown_fields->AddFixed32(number, value);
       return true;
@@ -148,7 +148,7 @@ bool WireFormat::SkipField(io::CodedInputStream* input, uint32_t tag,
 bool WireFormat::SkipMessage(io::CodedInputStream* input,
                              UnknownFieldSet* unknown_fields) {
   while (true) {
-    uint32_t tag = input->ReadTag();
+    ui32 tag = input->ReadTag();
     if (tag == 0) {
       // End of input.  This is a valid place to end, so return true.
       return true;
@@ -166,11 +166,11 @@ bool WireFormat::SkipMessage(io::CodedInputStream* input,
 }
 
 bool WireFormat::ReadPackedEnumPreserveUnknowns(io::CodedInputStream* input,
-                                                uint32_t field_number,
+                                                ui32 field_number,
                                                 bool (*is_valid)(int),
                                                 UnknownFieldSet* unknown_fields,
                                                 RepeatedField<int>* values) {
-  uint32_t length;
+  ui32 length;
   if (!input->ReadVarint32(&length)) return false;
   io::CodedInputStream::Limit limit = input->PushLimit(length);
   while (input->BytesUntilLimit() > 0) {
@@ -278,12 +278,12 @@ size_t WireFormat::ComputeUnknownFieldsSize(
       case UnknownField::TYPE_FIXED32:
         size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
             field.number(), WireFormatLite::WIRETYPE_FIXED32));
-        size += sizeof(int32_t);
+        size += sizeof(i32);
         break;
       case UnknownField::TYPE_FIXED64:
         size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
             field.number(), WireFormatLite::WIRETYPE_FIXED64));
-        size += sizeof(int64);
+        size += sizeof(i64);
         break;
       case UnknownField::TYPE_LENGTH_DELIMITED:
         size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
@@ -334,7 +334,7 @@ bool WireFormat::ParseAndMergePartial(io::CodedInputStream* input,
   const Reflection* message_reflection = message->GetReflection();
 
   while (true) {
-    uint32_t tag = input->ReadTag();
+    ui32 tag = input->ReadTag();
     if (tag == 0) {
       // End of input.  This is a valid place to end, so return true.
       return true;
@@ -380,15 +380,15 @@ bool WireFormat::ParseAndMergePartial(io::CodedInputStream* input,
 }
 
 bool WireFormat::SkipMessageSetField(io::CodedInputStream* input,
-                                     uint32_t field_number,
+                                     ui32 field_number,
                                      UnknownFieldSet* unknown_fields) {
-  uint32_t length;
+  ui32 length;
   if (!input->ReadVarint32(&length)) return false;
   return input->ReadString(unknown_fields->AddLengthDelimited(field_number),
                            length);
 }
 
-bool WireFormat::ParseAndMergeMessageSetField(uint32_t field_number,
+bool WireFormat::ParseAndMergeMessageSetField(ui32 field_number,
                                               const FieldDescriptor* field,
                                               Message* message,
                                               io::CodedInputStream* input) {
@@ -415,7 +415,7 @@ static bool StrictUtf8Check(const FieldDescriptor* field) {
 }
 
 bool WireFormat::ParseAndMergeField(
-    uint32_t tag,
+    ui32 tag,
     const FieldDescriptor* field,  // May be NULL for unknown
     Message* message, io::CodedInputStream* input) {
   const Reflection* message_reflection = message->GetReflection();
@@ -441,7 +441,7 @@ bool WireFormat::ParseAndMergeField(
     return SkipField(input, tag,
                      message_reflection->MutableUnknownFields(message));
   } else if (value_format == PACKED_FORMAT) {
-    uint32_t length;
+    ui32 length;
     if (!input->ReadVarint32(&length)) return false;
     io::CodedInputStream::Limit limit = input->PushLimit(length);
 
@@ -459,17 +459,17 @@ bool WireFormat::ParseAndMergeField(
     break;                                                                     \
   }
 
-      HANDLE_PACKED_TYPE(INT32, int32_t, Int32)
-      HANDLE_PACKED_TYPE(INT64, int64, Int64)
-      HANDLE_PACKED_TYPE(SINT32, int32_t, Int32)
-      HANDLE_PACKED_TYPE(SINT64, int64, Int64)
-      HANDLE_PACKED_TYPE(UINT32, uint32_t, UInt32)
-      HANDLE_PACKED_TYPE(UINT64, uint64, UInt64)
+      HANDLE_PACKED_TYPE(INT32, i32, Int32)
+      HANDLE_PACKED_TYPE(INT64, i64, Int64)
+      HANDLE_PACKED_TYPE(SINT32, i32, Int32)
+      HANDLE_PACKED_TYPE(SINT64, i64, Int64)
+      HANDLE_PACKED_TYPE(UINT32, ui32, UInt32)
+      HANDLE_PACKED_TYPE(UINT64, ui64, UInt64)
 
-      HANDLE_PACKED_TYPE(FIXED32, uint32_t, UInt32)
-      HANDLE_PACKED_TYPE(FIXED64, uint64, UInt64)
-      HANDLE_PACKED_TYPE(SFIXED32, int32_t, Int32)
-      HANDLE_PACKED_TYPE(SFIXED64, int64, Int64)
+      HANDLE_PACKED_TYPE(FIXED32, ui32, UInt32)
+      HANDLE_PACKED_TYPE(FIXED64, ui64, UInt64)
+      HANDLE_PACKED_TYPE(SFIXED32, i32, Int32)
+      HANDLE_PACKED_TYPE(SFIXED64, i64, Int64)
 
       HANDLE_PACKED_TYPE(FLOAT, float, Float)
       HANDLE_PACKED_TYPE(DOUBLE, double, Double)
@@ -494,7 +494,7 @@ bool WireFormat::ParseAndMergeField(
             } else {
               // The enum value is not one of the known values.  Add it to the
               // UnknownFieldSet.
-              int64_t sign_extended_value = static_cast<int64_t>(value);
+              i64 sign_extended_value = static_cast<i64>(value);
               message_reflection->MutableUnknownFields(message)->AddVarint(
                   WireFormatLite::GetTagFieldNumber(tag), sign_extended_value);
             }
@@ -532,17 +532,17 @@ bool WireFormat::ParseAndMergeField(
     break;                                                                    \
   }
 
-      HANDLE_TYPE(INT32, int32_t, Int32)
-      HANDLE_TYPE(INT64, int64, Int64)
-      HANDLE_TYPE(SINT32, int32_t, Int32)
-      HANDLE_TYPE(SINT64, int64, Int64)
-      HANDLE_TYPE(UINT32, uint32_t, UInt32)
-      HANDLE_TYPE(UINT64, uint64, UInt64)
+      HANDLE_TYPE(INT32, i32, Int32)
+      HANDLE_TYPE(INT64, i64, Int64)
+      HANDLE_TYPE(SINT32, i32, Int32)
+      HANDLE_TYPE(SINT64, i64, Int64)
+      HANDLE_TYPE(UINT32, ui32, UInt32)
+      HANDLE_TYPE(UINT64, ui64, UInt64)
 
-      HANDLE_TYPE(FIXED32, uint32_t, UInt32)
-      HANDLE_TYPE(FIXED64, uint64, UInt64)
-      HANDLE_TYPE(SFIXED32, int32_t, Int32)
-      HANDLE_TYPE(SFIXED64, int64, Int64)
+      HANDLE_TYPE(FIXED32, ui32, UInt32)
+      HANDLE_TYPE(FIXED64, ui64, UInt64)
+      HANDLE_TYPE(SFIXED32, i32, Int32)
+      HANDLE_TYPE(SFIXED64, i64, Int64)
 
       HANDLE_TYPE(FLOAT, float, Float)
       HANDLE_TYPE(DOUBLE, double, Double)
@@ -641,7 +641,7 @@ bool WireFormat::ParseAndMergeMessageSetItem(io::CodedInputStream* input,
       return ParseAndMergeMessageSetField(type_id, field, message, input);
     }
 
-    bool SkipField(uint32_t tag, io::CodedInputStream* input) {
+    bool SkipField(ui32 tag, io::CodedInputStream* input) {
       return WireFormat::SkipField(input, tag, NULL);
     }
 
@@ -661,13 +661,13 @@ struct WireFormat::MessageSetParser {
     State state = State::kNoTag;
 
     TProtoStringType payload;
-    uint32_t type_id = 0;
+    ui32 type_id = 0;
     while (!ctx->Done(&ptr)) {
       // We use 64 bit tags in order to allow typeid's that span the whole
       // range of 32 bit numbers.
-      uint32_t tag = static_cast<uint8_t>(*ptr++);
+      ui32 tag = static_cast<uint8_t>(*ptr++);
       if (tag == WireFormatLite::kMessageSetTypeIdTag) {
-        uint64_t tmp;
+        ui64 tmp;
         ptr = ParseBigVarint(ptr, &tmp);
         GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
         if (state == State::kNoTag) {
@@ -706,7 +706,7 @@ struct WireFormat::MessageSetParser {
         continue;
       } else if (tag == WireFormatLite::kMessageSetMessageTag) {
         if (state == State::kNoTag) {
-          int32_t size = ReadSize(&ptr);
+          i32 size = ReadSize(&ptr);
           GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
           ptr = ctx->ReadString(ptr, size, &payload);
           GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
@@ -723,11 +723,11 @@ struct WireFormat::MessageSetParser {
             }
           }
           ptr = WireFormat::_InternalParseAndMergeField(
-              msg, ptr, ctx, static_cast<uint64_t>(type_id) * 8 + 2, reflection,
+              msg, ptr, ctx, static_cast<ui64>(type_id) * 8 + 2, reflection,
               field);
           state = State::kDone;
         } else {
-          int32_t size = ReadSize(&ptr);
+          i32 size = ReadSize(&ptr);
           GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
           ptr = ctx->Skip(ptr, size);
           GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
@@ -750,7 +750,7 @@ struct WireFormat::MessageSetParser {
 
   const char* ParseMessageSet(const char* ptr, internal::ParseContext* ctx) {
     while (!ctx->Done(&ptr)) {
-      uint32_t tag;
+      ui32 tag;
       ptr = ReadTag(ptr, &tag);
       if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr;
       if (tag == 0 || (tag & 7) == WireFormatLite::WIRETYPE_END_GROUP) {
@@ -796,7 +796,7 @@ const char* WireFormat::_InternalParse(Message* msg, const char* ptr,
     return message_set.ParseMessageSet(ptr, ctx);
   }
   while (!ctx->Done(&ptr)) {
-    uint32_t tag;
+    ui32 tag;
     ptr = ReadTag(ptr, &tag);
     if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr;
     if (tag == 0 || (tag & 7) == WireFormatLite::WIRETYPE_END_GROUP) {
@@ -825,7 +825,7 @@ const char* WireFormat::_InternalParse(Message* msg, const char* ptr,
 }
 
 const char* WireFormat::_InternalParseAndMergeField(
-    Message* msg, const char* ptr, internal::ParseContext* ctx, uint64_t tag,
+    Message* msg, const char* ptr, internal::ParseContext* ctx, ui64 tag,
     const Reflection* reflection, const FieldDescriptor* field) {
   if (field == nullptr) {
     // unknown field set parser takes 64bit tags, because message set type ids
@@ -846,17 +846,17 @@ const char* WireFormat::_InternalParseAndMergeField(
     return ptr;                                                             \
   }
 
-        HANDLE_PACKED_TYPE(INT32, int32_t, Int32)
-        HANDLE_PACKED_TYPE(INT64, int64, Int64)
-        HANDLE_PACKED_TYPE(SINT32, int32_t, SInt32)
-        HANDLE_PACKED_TYPE(SINT64, int64, SInt64)
-        HANDLE_PACKED_TYPE(UINT32, uint32_t, UInt32)
-        HANDLE_PACKED_TYPE(UINT64, uint64, UInt64)
+        HANDLE_PACKED_TYPE(INT32, i32, Int32)
+        HANDLE_PACKED_TYPE(INT64, i64, Int64)
+        HANDLE_PACKED_TYPE(SINT32, i32, SInt32)
+        HANDLE_PACKED_TYPE(SINT64, i64, SInt64)
+        HANDLE_PACKED_TYPE(UINT32, ui32, UInt32)
+        HANDLE_PACKED_TYPE(UINT64, ui64, UInt64)
 
-        HANDLE_PACKED_TYPE(FIXED32, uint32_t, Fixed32)
-        HANDLE_PACKED_TYPE(FIXED64, uint64, Fixed64)
-        HANDLE_PACKED_TYPE(SFIXED32, int32_t, SFixed32)
-        HANDLE_PACKED_TYPE(SFIXED64, int64, SFixed64)
+        HANDLE_PACKED_TYPE(FIXED32, ui32, Fixed32)
+        HANDLE_PACKED_TYPE(FIXED64, ui64, Fixed64)
+        HANDLE_PACKED_TYPE(SFIXED32, i32, SFixed32)
+        HANDLE_PACKED_TYPE(SFIXED64, i64, SFixed64)
 
         HANDLE_PACKED_TYPE(FLOAT, float, Float)
         HANDLE_PACKED_TYPE(DOUBLE, double, Double)
@@ -866,14 +866,14 @@ const char* WireFormat::_InternalParseAndMergeField(
 
         case FieldDescriptor::TYPE_ENUM: {
           auto rep_enum =
-              reflection->MutableRepeatedFieldInternal<int32>(msg, field);
+              reflection->MutableRepeatedFieldInternal<int>(msg, field);
           bool open_enum = false;
           if (field->file()->syntax() == FileDescriptor::SYNTAX_PROTO3 ||
               open_enum) {
             ptr = internal::PackedEnumParser(rep_enum, ptr, ctx);
           } else {
             return ctx->ReadPackedVarint(
-                ptr, [rep_enum, field, reflection, msg](uint64_t val) {
+                ptr, [rep_enum, field, reflection, msg](ui64 val) {
                   if (field->enum_type()->FindValueByNumber(val) != nullptr) {
                     rep_enum->Add(val);
                   } else {
@@ -916,14 +916,14 @@ const char* WireFormat::_InternalParseAndMergeField(
     return ptr;                                           \
   }
 
-    HANDLE_TYPE(BOOL, uint64_t, Bool)
-    HANDLE_TYPE(INT32, uint32_t, Int32)
-    HANDLE_TYPE(INT64, uint64, Int64)
-    HANDLE_TYPE(UINT32, uint32_t, UInt32)
-    HANDLE_TYPE(UINT64, uint64, UInt64)
+    HANDLE_TYPE(BOOL, ui64, Bool)
+    HANDLE_TYPE(INT32, ui32, Int32)
+    HANDLE_TYPE(INT64, ui64, Int64)
+    HANDLE_TYPE(UINT32, ui32, UInt32)
+    HANDLE_TYPE(UINT64, ui64, UInt64)
 
     case FieldDescriptor::TYPE_SINT32: {
-      int32_t value = ReadVarintZigZag32(&ptr);
+      i32 value = ReadVarintZigZag32(&ptr);
       if (ptr == nullptr) return nullptr;
       if (field->is_repeated()) {
         reflection->AddInt32(msg, field, value);
@@ -933,7 +933,7 @@ const char* WireFormat::_InternalParseAndMergeField(
       return ptr;
     }
     case FieldDescriptor::TYPE_SINT64: {
-      int64_t value = ReadVarintZigZag64(&ptr);
+      i64 value = ReadVarintZigZag64(&ptr);
       if (ptr == nullptr) return nullptr;
       if (field->is_repeated()) {
         reflection->AddInt64(msg, field, value);
@@ -956,10 +956,10 @@ const char* WireFormat::_InternalParseAndMergeField(
     return ptr;                                           \
   }
 
-      HANDLE_TYPE(FIXED32, uint32_t, UInt32)
-      HANDLE_TYPE(FIXED64, uint64, UInt64)
-      HANDLE_TYPE(SFIXED32, int32_t, Int32)
-      HANDLE_TYPE(SFIXED64, int64, Int64)
+      HANDLE_TYPE(FIXED32, ui32, UInt32)
+      HANDLE_TYPE(FIXED64, ui64, UInt64)
+      HANDLE_TYPE(SFIXED32, i32, Int32)
+      HANDLE_TYPE(SFIXED64, i64, Int64)
 
       HANDLE_TYPE(FLOAT, float, Float)
       HANDLE_TYPE(DOUBLE, double, Double)
@@ -967,7 +967,7 @@ const char* WireFormat::_InternalParseAndMergeField(
 #undef HANDLE_TYPE
 
     case FieldDescriptor::TYPE_ENUM: {
-      uint32_t value;
+      ui32 value;
       ptr = VarintParse(ptr, &value);
       if (ptr == nullptr) return nullptr;
       if (field->is_repeated()) {
@@ -1297,13 +1297,13 @@ uint8_t* WireFormat::InternalSerializeField(const FieldDescriptor* field,
     break;                                                                     \
   }
 
-      HANDLE_PRIMITIVE_TYPE(INT32, int32_t, Int32, Int32)
-      HANDLE_PRIMITIVE_TYPE(INT64, int64, Int64, Int64)
-      HANDLE_PRIMITIVE_TYPE(SINT32, int32_t, SInt32, Int32)
-      HANDLE_PRIMITIVE_TYPE(SINT64, int64, SInt64, Int64)
-      HANDLE_PRIMITIVE_TYPE(UINT32, uint32_t, UInt32, UInt32)
-      HANDLE_PRIMITIVE_TYPE(UINT64, uint64, UInt64, UInt64)
-      HANDLE_PRIMITIVE_TYPE(ENUM, int32, Enum, Enum)
+      HANDLE_PRIMITIVE_TYPE(INT32, i32, Int32, Int32)
+      HANDLE_PRIMITIVE_TYPE(INT64, i64, Int64, Int64)
+      HANDLE_PRIMITIVE_TYPE(SINT32, i32, SInt32, Int32)
+      HANDLE_PRIMITIVE_TYPE(SINT64, i64, SInt64, Int64)
+      HANDLE_PRIMITIVE_TYPE(UINT32, ui32, UInt32, UInt32)
+      HANDLE_PRIMITIVE_TYPE(UINT64, ui64, UInt64, UInt64)
+      HANDLE_PRIMITIVE_TYPE(ENUM, int, Enum, Enum)
 
 #undef HANDLE_PRIMITIVE_TYPE
 #define HANDLE_PRIMITIVE_TYPE(TYPE, CPPTYPE, TYPE_METHOD, CPPTYPE_METHOD)      \
@@ -1314,10 +1314,10 @@ uint8_t* WireFormat::InternalSerializeField(const FieldDescriptor* field,
     break;                                                                     \
   }
 
-      HANDLE_PRIMITIVE_TYPE(FIXED32, uint32_t, Fixed32, UInt32)
-      HANDLE_PRIMITIVE_TYPE(FIXED64, uint64, Fixed64, UInt64)
-      HANDLE_PRIMITIVE_TYPE(SFIXED32, int32_t, SFixed32, Int32)
-      HANDLE_PRIMITIVE_TYPE(SFIXED64, int64, SFixed64, Int64)
+      HANDLE_PRIMITIVE_TYPE(FIXED32, ui32, Fixed32, UInt32)
+      HANDLE_PRIMITIVE_TYPE(FIXED64, ui64, Fixed64, UInt64)
+      HANDLE_PRIMITIVE_TYPE(SFIXED32, i32, SFixed32, Int32)
+      HANDLE_PRIMITIVE_TYPE(SFIXED64, i64, SFixed64, Int64)
 
       HANDLE_PRIMITIVE_TYPE(FLOAT, float, Float, Float)
       HANDLE_PRIMITIVE_TYPE(DOUBLE, double, Double, Double)
@@ -1345,17 +1345,17 @@ uint8_t* WireFormat::InternalSerializeField(const FieldDescriptor* field,
     break;                                                                    \
   }
 
-      HANDLE_PRIMITIVE_TYPE(INT32, int32_t, Int32, Int32)
-      HANDLE_PRIMITIVE_TYPE(INT64, int64, Int64, Int64)
-      HANDLE_PRIMITIVE_TYPE(SINT32, int32_t, SInt32, Int32)
-      HANDLE_PRIMITIVE_TYPE(SINT64, int64, SInt64, Int64)
-      HANDLE_PRIMITIVE_TYPE(UINT32, uint32_t, UInt32, UInt32)
-      HANDLE_PRIMITIVE_TYPE(UINT64, uint64, UInt64, UInt64)
-
-      HANDLE_PRIMITIVE_TYPE(FIXED32, uint32_t, Fixed32, UInt32)
-      HANDLE_PRIMITIVE_TYPE(FIXED64, uint64, Fixed64, UInt64)
-      HANDLE_PRIMITIVE_TYPE(SFIXED32, int32_t, SFixed32, Int32)
-      HANDLE_PRIMITIVE_TYPE(SFIXED64, int64, SFixed64, Int64)
+      HANDLE_PRIMITIVE_TYPE(INT32, i32, Int32, Int32)
+      HANDLE_PRIMITIVE_TYPE(INT64, i64, Int64, Int64)
+      HANDLE_PRIMITIVE_TYPE(SINT32, i32, SInt32, Int32)
+      HANDLE_PRIMITIVE_TYPE(SINT64, i64, SInt64, Int64)
+      HANDLE_PRIMITIVE_TYPE(UINT32, ui32, UInt32, UInt32)
+      HANDLE_PRIMITIVE_TYPE(UINT64, ui64, UInt64, UInt64)
+
+      HANDLE_PRIMITIVE_TYPE(FIXED32, ui32, Fixed32, UInt32)
+      HANDLE_PRIMITIVE_TYPE(FIXED64, ui64, Fixed64, UInt64)
+      HANDLE_PRIMITIVE_TYPE(SFIXED32, i32, SFixed32, Int32)
+      HANDLE_PRIMITIVE_TYPE(SFIXED64, i64, SFixed64, Int64)
 
       HANDLE_PRIMITIVE_TYPE(FLOAT, float, Float, Float)
       HANDLE_PRIMITIVE_TYPE(DOUBLE, double, Double, Double)
diff --git a/contrib/libs/protobuf/src/google/protobuf/wire_format.h b/contrib/libs/protobuf/src/google/protobuf/wire_format.h
index 7ca217a11b..7089087441 100644
--- a/contrib/libs/protobuf/src/google/protobuf/wire_format.h
+++ b/contrib/libs/protobuf/src/google/protobuf/wire_format.h
@@ -148,7 +148,7 @@ class PROTOBUF_EXPORT WireFormat {
   // Skips a field value of the given WireType.  The input should start
   // positioned immediately after the tag.  If unknown_fields is non-NULL,
   // the contents of the field will be added to it.
-  static bool SkipField(io::CodedInputStream* input, uint32_t tag,
+  static bool SkipField(io::CodedInputStream* input, ui32 tag,
                         UnknownFieldSet* unknown_fields);
 
   // Reads and ignores a message from the input.  If unknown_fields is
@@ -160,7 +160,7 @@ class PROTOBUF_EXPORT WireFormat {
   // for which is_valid(value) returns false are appended to
   // unknown_fields_stream.
   static bool ReadPackedEnumPreserveUnknowns(io::CodedInputStream* input,
-                                             uint32_t field_number,
+                                             ui32 field_number,
                                              bool (*is_valid)(int),
                                              UnknownFieldSet* unknown_fields,
                                              RepeatedField<int>* values);
@@ -219,12 +219,12 @@ class PROTOBUF_EXPORT WireFormat {
   //
   // This is different from MakeTag(field->number(), field->type()) in the
   // case of packed repeated fields.
-  static uint32_t MakeTag(const FieldDescriptor* field);
+  static ui32 MakeTag(const FieldDescriptor* field);
 
   // Parse a single field.  The input should start out positioned immediately
   // after the tag.
   static bool ParseAndMergeField(
-      uint32_t tag,
+      ui32 tag,
       const FieldDescriptor* field,  // May be NULL for unknown
       Message* message, io::CodedInputStream* input);
 
@@ -287,18 +287,18 @@ class PROTOBUF_EXPORT WireFormat {
   struct MessageSetParser;
   // Skip a MessageSet field.
   static bool SkipMessageSetField(io::CodedInputStream* input,
-                                  uint32_t field_number,
+                                  ui32 field_number,
                                   UnknownFieldSet* unknown_fields);
 
   // Parse a MessageSet field.
-  static bool ParseAndMergeMessageSetField(uint32_t field_number,
+  static bool ParseAndMergeMessageSetField(ui32 field_number,
                                            const FieldDescriptor* field,
                                            Message* message,
                                            io::CodedInputStream* input);
   // Parses the value from the wire that belongs to tag.
   static const char* _InternalParseAndMergeField(Message* msg, const char* ptr,
                                                  internal::ParseContext* ctx,
-                                                 uint64_t tag,
+                                                 ui64 tag,
                                                  const Reflection* reflection,
                                                  const FieldDescriptor* field);
 
@@ -313,7 +313,7 @@ class PROTOBUF_EXPORT UnknownFieldSetFieldSkipper : public FieldSkipper {
   ~UnknownFieldSetFieldSkipper() override {}
 
   // implements FieldSkipper -----------------------------------------
-  bool SkipField(io::CodedInputStream* input, uint32_t tag) override;
+  bool SkipField(io::CodedInputStream* input, ui32 tag) override;
   bool SkipMessage(io::CodedInputStream* input) override;
   void SkipUnknownEnum(int field_number, int value) override;
 
@@ -340,7 +340,7 @@ inline WireFormatLite::WireType WireFormat::WireTypeForFieldType(
       static_cast<WireFormatLite::FieldType>(implicit_cast<int>(type)));
 }
 
-inline uint32_t WireFormat::MakeTag(const FieldDescriptor* field) {
+inline ui32 WireFormat::MakeTag(const FieldDescriptor* field) {
   return WireFormatLite::MakeTag(field->number(), WireTypeForField(field));
 }
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/wire_format_lite.cc b/contrib/libs/protobuf/src/google/protobuf/wire_format_lite.cc
index 7661c9d27e..510aee31b8 100644
--- a/contrib/libs/protobuf/src/google/protobuf/wire_format_lite.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/wire_format_lite.cc
@@ -120,22 +120,22 @@ const WireFormatLite::WireType
         WireFormatLite::WIRETYPE_VARINT,            // TYPE_SINT64
 };
 
-bool WireFormatLite::SkipField(io::CodedInputStream* input, uint32_t tag) {
+bool WireFormatLite::SkipField(io::CodedInputStream* input, ui32 tag) {
   // Field number 0 is illegal.
   if (WireFormatLite::GetTagFieldNumber(tag) == 0) return false;
   switch (WireFormatLite::GetTagWireType(tag)) {
     case WireFormatLite::WIRETYPE_VARINT: {
-      uint64_t value;
+      ui64 value;
       if (!input->ReadVarint64(&value)) return false;
       return true;
     }
     case WireFormatLite::WIRETYPE_FIXED64: {
-      uint64_t value;
+      ui64 value;
       if (!input->ReadLittleEndian64(&value)) return false;
       return true;
     }
     case WireFormatLite::WIRETYPE_LENGTH_DELIMITED: {
-      uint32_t length;
+      ui32 length;
       if (!input->ReadVarint32(&length)) return false;
       if (!input->Skip(length)) return false;
       return true;
@@ -156,7 +156,7 @@ bool WireFormatLite::SkipField(io::CodedInputStream* input, uint32_t tag) {
       return false;
     }
     case WireFormatLite::WIRETYPE_FIXED32: {
-      uint32_t value;
+      ui32 value;
       if (!input->ReadLittleEndian32(&value)) return false;
       return true;
     }
@@ -166,27 +166,27 @@ bool WireFormatLite::SkipField(io::CodedInputStream* input, uint32_t tag) {
   }
 }
 
-bool WireFormatLite::SkipField(io::CodedInputStream* input, uint32_t tag,
+bool WireFormatLite::SkipField(io::CodedInputStream* input, ui32 tag,
                                io::CodedOutputStream* output) {
   // Field number 0 is illegal.
   if (WireFormatLite::GetTagFieldNumber(tag) == 0) return false;
   switch (WireFormatLite::GetTagWireType(tag)) {
     case WireFormatLite::WIRETYPE_VARINT: {
-      uint64_t value;
+      ui64 value;
       if (!input->ReadVarint64(&value)) return false;
       output->WriteVarint32(tag);
       output->WriteVarint64(value);
       return true;
     }
     case WireFormatLite::WIRETYPE_FIXED64: {
-      uint64_t value;
+      ui64 value;
       if (!input->ReadLittleEndian64(&value)) return false;
       output->WriteVarint32(tag);
       output->WriteLittleEndian64(value);
       return true;
     }
     case WireFormatLite::WIRETYPE_LENGTH_DELIMITED: {
-      uint32_t length;
+      ui32 length;
       if (!input->ReadVarint32(&length)) return false;
       output->WriteVarint32(tag);
       output->WriteVarint32(length);
@@ -213,7 +213,7 @@ bool WireFormatLite::SkipField(io::CodedInputStream* input, uint32_t tag,
       return false;
     }
     case WireFormatLite::WIRETYPE_FIXED32: {
-      uint32_t value;
+      ui32 value;
       if (!input->ReadLittleEndian32(&value)) return false;
       output->WriteVarint32(tag);
       output->WriteLittleEndian32(value);
@@ -227,7 +227,7 @@ bool WireFormatLite::SkipField(io::CodedInputStream* input, uint32_t tag,
 
 bool WireFormatLite::SkipMessage(io::CodedInputStream* input) {
   while (true) {
-    uint32_t tag = input->ReadTag();
+    ui32 tag = input->ReadTag();
     if (tag == 0) {
       // End of input.  This is a valid place to end, so return true.
       return true;
@@ -247,7 +247,7 @@ bool WireFormatLite::SkipMessage(io::CodedInputStream* input) {
 bool WireFormatLite::SkipMessage(io::CodedInputStream* input,
                                  io::CodedOutputStream* output) {
   while (true) {
-    uint32_t tag = input->ReadTag();
+    ui32 tag = input->ReadTag();
     if (tag == 0) {
       // End of input.  This is a valid place to end, so return true.
       return true;
@@ -265,7 +265,7 @@ bool WireFormatLite::SkipMessage(io::CodedInputStream* input,
   }
 }
 
-bool FieldSkipper::SkipField(io::CodedInputStream* input, uint32_t tag) {
+bool FieldSkipper::SkipField(io::CodedInputStream* input, ui32 tag) {
   return WireFormatLite::SkipField(input, tag);
 }
 
@@ -278,7 +278,7 @@ void FieldSkipper::SkipUnknownEnum(int /* field_number */, int /* value */) {
 }
 
 bool CodedOutputStreamFieldSkipper::SkipField(io::CodedInputStream* input,
-                                              uint32_t tag) {
+                                              ui32 tag) {
   return WireFormatLite::SkipField(input, tag, unknown_fields_);
 }
 
@@ -295,7 +295,7 @@ void CodedOutputStreamFieldSkipper::SkipUnknownEnum(int field_number,
 bool WireFormatLite::ReadPackedEnumPreserveUnknowns(
     io::CodedInputStream* input, int field_number, bool (*is_valid)(int),
     io::CodedOutputStream* unknown_fields_stream, RepeatedField<int>* values) {
-  uint32_t length;
+  ui32 length;
   if (!input->ReadVarint32(&length)) return false;
   io::CodedInputStream::Limit limit = input->PushLimit(length);
   while (input->BytesUntilLimit() > 0) {
@@ -306,7 +306,7 @@ bool WireFormatLite::ReadPackedEnumPreserveUnknowns(
     if (is_valid == NULL || is_valid(value)) {
       values->Add(value);
     } else {
-      uint32_t tag = WireFormatLite::MakeTag(field_number,
+      ui32 tag = WireFormatLite::MakeTag(field_number,
                                              WireFormatLite::WIRETYPE_VARINT);
       unknown_fields_stream->WriteVarint32(tag);
       unknown_fields_stream->WriteVarint32(value);
@@ -327,19 +327,19 @@ void EncodeFixedSizeValue(double v, uint8_t* dest) {
   WireFormatLite::WriteDoubleNoTagToArray(v, dest);
 }
 
-void EncodeFixedSizeValue(uint32_t v, uint8_t* dest) {
+void EncodeFixedSizeValue(ui32 v, uint8_t* dest) {
   WireFormatLite::WriteFixed32NoTagToArray(v, dest);
 }
 
-void EncodeFixedSizeValue(uint64_t v, uint8_t* dest) {
+void EncodeFixedSizeValue(ui64 v, uint8_t* dest) {
   WireFormatLite::WriteFixed64NoTagToArray(v, dest);
 }
 
-void EncodeFixedSizeValue(int32_t v, uint8_t* dest) {
+void EncodeFixedSizeValue(i32 v, uint8_t* dest) {
   WireFormatLite::WriteSFixed32NoTagToArray(v, dest);
 }
 
-void EncodeFixedSizeValue(int64_t v, uint8_t* dest) {
+void EncodeFixedSizeValue(i64 v, uint8_t* dest) {
   WireFormatLite::WriteSFixed64NoTagToArray(v, dest);
 }
 
@@ -379,24 +379,24 @@ void WireFormatLite::WriteDoubleArray(const double* a, int n,
   WriteArray<double>(a, n, output);
 }
 
-void WireFormatLite::WriteFixed32Array(const uint32_t* a, int n,
+void WireFormatLite::WriteFixed32Array(const ui32* a, int n,
                                        io::CodedOutputStream* output) {
-  WriteArray<uint32_t>(a, n, output);
+  WriteArray<ui32>(a, n, output);
 }
 
-void WireFormatLite::WriteFixed64Array(const uint64_t* a, int n,
+void WireFormatLite::WriteFixed64Array(const ui64* a, int n,
                                        io::CodedOutputStream* output) {
-  WriteArray<uint64_t>(a, n, output);
+  WriteArray<ui64>(a, n, output);
 }
 
-void WireFormatLite::WriteSFixed32Array(const int32_t* a, int n,
+void WireFormatLite::WriteSFixed32Array(const i32* a, int n,
                                         io::CodedOutputStream* output) {
-  WriteArray<int32_t>(a, n, output);
+  WriteArray<i32>(a, n, output);
 }
 
-void WireFormatLite::WriteSFixed64Array(const int64_t* a, int n,
+void WireFormatLite::WriteSFixed64Array(const i64* a, int n,
                                         io::CodedOutputStream* output) {
-  WriteArray<int64_t>(a, n, output);
+  WriteArray<i64>(a, n, output);
 }
 
 void WireFormatLite::WriteBoolArray(const bool* a, int n,
@@ -404,52 +404,52 @@ void WireFormatLite::WriteBoolArray(const bool* a, int n,
   WriteArray<bool>(a, n, output);
 }
 
-void WireFormatLite::WriteInt32(int field_number, int32_t value,
+void WireFormatLite::WriteInt32(int field_number, i32 value,
                                 io::CodedOutputStream* output) {
   WriteTag(field_number, WIRETYPE_VARINT, output);
   WriteInt32NoTag(value, output);
 }
-void WireFormatLite::WriteInt64(int field_number, int64_t value,
+void WireFormatLite::WriteInt64(int field_number, i64 value,
                                 io::CodedOutputStream* output) {
   WriteTag(field_number, WIRETYPE_VARINT, output);
   WriteInt64NoTag(value, output);
 }
-void WireFormatLite::WriteUInt32(int field_number, uint32_t value,
+void WireFormatLite::WriteUInt32(int field_number, ui32 value,
                                  io::CodedOutputStream* output) {
   WriteTag(field_number, WIRETYPE_VARINT, output);
   WriteUInt32NoTag(value, output);
 }
-void WireFormatLite::WriteUInt64(int field_number, uint64_t value,
+void WireFormatLite::WriteUInt64(int field_number, ui64 value,
                                  io::CodedOutputStream* output) {
   WriteTag(field_number, WIRETYPE_VARINT, output);
   WriteUInt64NoTag(value, output);
 }
-void WireFormatLite::WriteSInt32(int field_number, int32_t value,
+void WireFormatLite::WriteSInt32(int field_number, i32 value,
                                  io::CodedOutputStream* output) {
   WriteTag(field_number, WIRETYPE_VARINT, output);
   WriteSInt32NoTag(value, output);
 }
-void WireFormatLite::WriteSInt64(int field_number, int64_t value,
+void WireFormatLite::WriteSInt64(int field_number, i64 value,
                                  io::CodedOutputStream* output) {
   WriteTag(field_number, WIRETYPE_VARINT, output);
   WriteSInt64NoTag(value, output);
 }
-void WireFormatLite::WriteFixed32(int field_number, uint32_t value,
+void WireFormatLite::WriteFixed32(int field_number, ui32 value,
                                   io::CodedOutputStream* output) {
   WriteTag(field_number, WIRETYPE_FIXED32, output);
   WriteFixed32NoTag(value, output);
 }
-void WireFormatLite::WriteFixed64(int field_number, uint64_t value,
+void WireFormatLite::WriteFixed64(int field_number, ui64 value,
                                   io::CodedOutputStream* output) {
   WriteTag(field_number, WIRETYPE_FIXED64, output);
   WriteFixed64NoTag(value, output);
 }
-void WireFormatLite::WriteSFixed32(int field_number, int32_t value,
+void WireFormatLite::WriteSFixed32(int field_number, i32 value,
                                    io::CodedOutputStream* output) {
   WriteTag(field_number, WIRETYPE_FIXED32, output);
   WriteSFixed32NoTag(value, output);
 }
-void WireFormatLite::WriteSFixed64(int field_number, int64_t value,
+void WireFormatLite::WriteSFixed64(int field_number, i64 value,
                                    io::CodedOutputStream* output) {
   WriteTag(field_number, WIRETYPE_FIXED64, output);
   WriteSFixed64NoTag(value, output);
@@ -551,7 +551,7 @@ PROTOBUF_NDEBUG_INLINE static bool ReadBytesToString(
     io::CodedInputStream* input, TProtoStringType* value);
 inline static bool ReadBytesToString(io::CodedInputStream* input,
                                      TProtoStringType* value) {
-  uint32_t length;
+  ui32 length;
   return input->ReadVarint32(&length) && input->ReadString(value, length);
 }
 
@@ -614,10 +614,10 @@ static size_t VarintSize(const T* data, const int n) {
       "Cannot SignExtended unsigned types");
   static_assert(!(SignExtended && ZigZag),
                 "Cannot SignExtended and ZigZag on the same type");
-  uint32_t sum = n;
-  uint32_t msb_sum = 0;
+  ui32 sum = n;
+  ui32 msb_sum = 0;
   for (int i = 0; i < n; i++) {
-    uint32_t x = data[i];
+    ui32 x = data[i];
     if (ZigZag) {
       x = WireFormatLite::ZigZagEncode32(x);
     } else if (SignExtended) {
@@ -642,16 +642,16 @@ static size_t VarintSize64(const T* data, const int n) {
   // is_unsigned<T> => !ZigZag
   static_assert(!ZigZag || !std::is_unsigned<T>::value,
                 "Cannot ZigZag encode unsigned types");
-  uint64_t sum = n;
+  ui64 sum = n;
   for (int i = 0; i < n; i++) {
-    uint64_t x = data[i];
+    ui64 x = data[i];
     if (ZigZag) {
       x = WireFormatLite::ZigZagEncode64(x);
     }
     // First step is a binary search, we can't branch in sse so we use the
     // result of the compare to adjust sum and appropriately. This code is
     // written to make clang recognize the vectorization.
-    uint64_t tmp = x >= (static_cast<uint64_t>(1) << 35) ? -1 : 0;
+    ui64 tmp = x >= (static_cast<ui64>(1) << 35) ? -1 : 0;
     sum += 5 & tmp;
     x >>= 35 & tmp;
     if (x > 0x7F) sum++;
@@ -667,15 +667,15 @@ static size_t VarintSize64(const T* data, const int n) {
 // varint size routine for each element is faster.
 // Hence we enable it only for clang
 #if defined(__SSE__) && defined(__clang__)
-size_t WireFormatLite::Int32Size(const RepeatedField<int32_t>& value) {
+size_t WireFormatLite::Int32Size(const RepeatedField<i32>& value) {
   return VarintSize<false, true>(value.data(), value.size());
 }
 
-size_t WireFormatLite::UInt32Size(const RepeatedField<uint32_t>& value) {
+size_t WireFormatLite::UInt32Size(const RepeatedField<ui32>& value) {
   return VarintSize<false, false>(value.data(), value.size());
 }
 
-size_t WireFormatLite::SInt32Size(const RepeatedField<int32_t>& value) {
+size_t WireFormatLite::SInt32Size(const RepeatedField<i32>& value) {
   return VarintSize<true, false>(value.data(), value.size());
 }
 
@@ -686,7 +686,7 @@ size_t WireFormatLite::EnumSize(const RepeatedField<int>& value) {
 
 #else  // !(defined(__SSE4_1__) && defined(__clang__))
 
-size_t WireFormatLite::Int32Size(const RepeatedField<int32_t>& value) {
+size_t WireFormatLite::Int32Size(const RepeatedField<i32>& value) {
   size_t out = 0;
   const int n = value.size();
   for (int i = 0; i < n; i++) {
@@ -695,7 +695,7 @@ size_t WireFormatLite::Int32Size(const RepeatedField<int32_t>& value) {
   return out;
 }
 
-size_t WireFormatLite::UInt32Size(const RepeatedField<uint32_t>& value) {
+size_t WireFormatLite::UInt32Size(const RepeatedField<ui32>& value) {
   size_t out = 0;
   const int n = value.size();
   for (int i = 0; i < n; i++) {
@@ -704,7 +704,7 @@ size_t WireFormatLite::UInt32Size(const RepeatedField<uint32_t>& value) {
   return out;
 }
 
-size_t WireFormatLite::SInt32Size(const RepeatedField<int32_t>& value) {
+size_t WireFormatLite::SInt32Size(const RepeatedField<i32>& value) {
   size_t out = 0;
   const int n = value.size();
   for (int i = 0; i < n; i++) {
@@ -730,35 +730,21 @@ size_t WireFormatLite::EnumSize(const RepeatedField<int>& value) {
 // enable this.
 #define USE_SSE_FOR_64_BIT_INTEGER_ARRAYS 0
 #if USE_SSE_FOR_64_BIT_INTEGER_ARRAYS
-size_t WireFormatLite::Int64Size(const RepeatedField<int64>& value) {
+size_t WireFormatLite::Int64Size(const RepeatedField<i64>& value) {
   return VarintSize64<false>(value.data(), value.size());
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-size_t WireFormatLite::Int64Size(const RepeatedField<int64_t>& value) {
-  return VarintSize64<false>(value.data(), value.size());
-}
-#endif
 
-size_t WireFormatLite::UInt64Size(const RepeatedField<uint64>& value) {
-  return VarintSize64<false>(value.data(), value.size());
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-size_t WireFormatLite::UInt64Size(const RepeatedField<uint64_t>& value) {
+size_t WireFormatLite::UInt64Size(const RepeatedField<ui64>& value) {
   return VarintSize64<false>(value.data(), value.size());
 }
-#endif
-size_t WireFormatLite::SInt64Size(const RepeatedField<int64>& value) {
-  return VarintSize64<true>(value.data(), value.size());
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-size_t WireFormatLite::SInt64Size(const RepeatedField<int64_t>& value) {
+
+size_t WireFormatLite::SInt64Size(const RepeatedField<i64>& value) {
   return VarintSize64<true>(value.data(), value.size());
 }
-#endif
 
 #else
 
-size_t WireFormatLite::Int64Size(const RepeatedField<int64>& value) {
+size_t WireFormatLite::Int64Size(const RepeatedField<i64>& value) {
   size_t out = 0;
   const int n = value.size();
   for (int i = 0; i < n; i++) {
@@ -767,18 +753,7 @@ size_t WireFormatLite::Int64Size(const RepeatedField<int64>& value) {
   return out;
 }
 
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-size_t WireFormatLite::Int64Size(const RepeatedField<int64_t>& value) {
-  size_t out = 0;
-  const int n = value.size();
-  for (int i = 0; i < n; i++) {
-    out += Int64Size(value.Get(i));
-  }
-  return out;
-}
-#endif
-
-size_t WireFormatLite::UInt64Size(const RepeatedField<uint64>& value) {
+size_t WireFormatLite::UInt64Size(const RepeatedField<ui64>& value) {
   size_t out = 0;
   const int n = value.size();
   for (int i = 0; i < n; i++) {
@@ -786,18 +761,8 @@ size_t WireFormatLite::UInt64Size(const RepeatedField<uint64>& value) {
   }
   return out;
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-size_t WireFormatLite::UInt64Size(const RepeatedField<uint64_t>& value) {
-  size_t out = 0;
-  const int n = value.size();
-  for (int i = 0; i < n; i++) {
-    out += UInt64Size(value.Get(i));
-  }
-  return out;
-}
-#endif
 
-size_t WireFormatLite::SInt64Size(const RepeatedField<int64>& value) {
+size_t WireFormatLite::SInt64Size(const RepeatedField<i64>& value) {
   size_t out = 0;
   const int n = value.size();
   for (int i = 0; i < n; i++) {
@@ -805,16 +770,6 @@ size_t WireFormatLite::SInt64Size(const RepeatedField<int64>& value) {
   }
   return out;
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-size_t WireFormatLite::SInt64Size(const RepeatedField<int64_t>& value) {
-  size_t out = 0;
-  const int n = value.size();
-  for (int i = 0; i < n; i++) {
-    out += SInt64Size(value.Get(i));
-  }
-  return out;
-}
-#endif
 
 #endif
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/wire_format_lite.h b/contrib/libs/protobuf/src/google/protobuf/wire_format_lite.h
index 7412457369..2b560919a7 100644
--- a/contrib/libs/protobuf/src/google/protobuf/wire_format_lite.h
+++ b/contrib/libs/protobuf/src/google/protobuf/wire_format_lite.h
@@ -153,16 +153,16 @@ class PROTOBUF_EXPORT WireFormatLite {
   // Number of bits in a tag which identify the wire type.
   static constexpr int kTagTypeBits = 3;
   // Mask for those bits.
-  static constexpr uint32_t kTagTypeMask = (1 << kTagTypeBits) - 1;
+  static constexpr ui32 kTagTypeMask = (1 << kTagTypeBits) - 1;
 
   // Helper functions for encoding and decoding tags.  (Inlined below and in
   // _inl.h)
   //
   // This is different from MakeTag(field->number(), field->type()) in the
   // case of packed repeated fields.
-  constexpr static uint32_t MakeTag(int field_number, WireType type);
-  static WireType GetTagWireType(uint32_t tag);
-  static int GetTagFieldNumber(uint32_t tag);
+  constexpr static ui32 MakeTag(int field_number, WireType type);
+  static WireType GetTagWireType(ui32 tag);
+  static int GetTagFieldNumber(ui32 tag);
 
   // Compute the byte size of a tag.  For groups, this includes both the start
   // and end tags.
@@ -173,12 +173,12 @@ class PROTOBUF_EXPORT WireFormatLite {
   // positioned immediately after the tag.  Skipped values are simply
   // discarded, not recorded anywhere.  See WireFormat::SkipField() for a
   // version that records to an UnknownFieldSet.
-  static bool SkipField(io::CodedInputStream* input, uint32_t tag);
+  static bool SkipField(io::CodedInputStream* input, ui32 tag);
 
   // Skips a field value with the given tag.  The input should start
   // positioned immediately after the tag. Skipped values are recorded to a
   // CodedOutputStream.
-  static bool SkipField(io::CodedInputStream* input, uint32_t tag,
+  static bool SkipField(io::CodedInputStream* input, ui32 tag,
                         io::CodedOutputStream* output);
 
   // Reads and ignores a message from the input.  Skipped values are simply
@@ -196,7 +196,7 @@ class PROTOBUF_EXPORT WireFormatLite {
   // as a switch case or a template input.  WireFormatLite::MakeTag() is more
   // type-safe, though, so prefer it if possible.
 #define GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(FIELD_NUMBER, TYPE) \
-  static_cast<uint32_t>((static_cast<uint32_t>(FIELD_NUMBER) << 3) | (TYPE))
+  static_cast<ui32>((static_cast<ui32>(FIELD_NUMBER) << 3) | (TYPE))
 
   // These are the tags for the old MessageSet format, which was defined as:
   //   message MessageSet {
@@ -223,10 +223,10 @@ class PROTOBUF_EXPORT WireFormatLite {
   // Helper functions for converting between floats/doubles and IEEE-754
   // uint32s/uint64s so that they can be written.  (Assumes your platform
   // uses IEEE-754 floats.)
-  static uint32_t EncodeFloat(float value);
-  static float DecodeFloat(uint32_t value);
-  static uint64_t EncodeDouble(double value);
-  static double DecodeDouble(uint64_t value);
+  static ui32 EncodeFloat(float value);
+  static float DecodeFloat(ui32 value);
+  static ui64 EncodeDouble(double value);
+  static double DecodeDouble(ui64 value);
 
   // Helper functions for mapping signed integers to unsigned integers in
   // such a way that numbers with small magnitudes will encode to smaller
@@ -234,10 +234,10 @@ class PROTOBUF_EXPORT WireFormatLite {
   // number and varint-encode it, it will always take 10 bytes, defeating
   // the purpose of varint.  So, for the "sint32" and "sint64" field types,
   // we ZigZag-encode the values.
-  static uint32_t ZigZagEncode32(int32_t n);
-  static int32_t ZigZagDecode32(uint32_t n);
-  static uint64_t ZigZagEncode64(int64_t n);
-  static int64_t ZigZagDecode64(uint64_t n);
+  static ui32 ZigZagEncode32(i32 n);
+  static i32 ZigZagDecode32(ui32 n);
+  static ui64 ZigZagEncode64(i64 n);
+  static i64 ZigZagDecode64(ui64 n);
 
   // =================================================================
   // Methods for reading/writing individual field.
@@ -257,13 +257,13 @@ class PROTOBUF_EXPORT WireFormatLite {
   // protocol compiler.
   template <typename CType, enum FieldType DeclaredType>
   PROTOBUF_NDEBUG_INLINE static bool ReadRepeatedPrimitive(
-      int tag_size, uint32_t tag, io::CodedInputStream* input,
+      int tag_size, ui32 tag, io::CodedInputStream* input,
       RepeatedField<CType>* value);
 
   // Identical to ReadRepeatedPrimitive, except will not inline the
   // implementation.
   template <typename CType, enum FieldType DeclaredType>
-  static bool ReadRepeatedPrimitiveNoInline(int tag_size, uint32_t tag,
+  static bool ReadRepeatedPrimitiveNoInline(int tag_size, ui32 tag,
                                             io::CodedInputStream* input,
                                             RepeatedField<CType>* value);
 
@@ -346,45 +346,25 @@ class PROTOBUF_EXPORT WireFormatLite {
 
   // Write fields, without tags.
   PROTOBUF_NDEBUG_INLINE static void WriteInt32NoTag(
-      int32_t value, io::CodedOutputStream* output);
+      i32 value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteInt64NoTag(
-      int64 value, io::CodedOutputStream* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-    PROTOBUF_NDEBUG_INLINE static void WriteInt64NoTag(
-      int64_t value, io::CodedOutputStream* output);
-#endif
+      i64 value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteUInt32NoTag(
-      uint32_t value, io::CodedOutputStream* output);
-  PROTOBUF_NDEBUG_INLINE static void WriteUInt64NoTag(
-      uint64 value, io::CodedOutputStream* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
+      ui32 value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteUInt64NoTag(
-      uint64_t value, io::CodedOutputStream* output);
-#endif
+      ui64 value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteSInt32NoTag(
-      int32_t value, io::CodedOutputStream* output);
+      i32 value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteSInt64NoTag(
-      int64 value, io::CodedOutputStream* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  PROTOBUF_NDEBUG_INLINE static void WriteSInt64NoTag(
-      int64_t value, io::CodedOutputStream* output);
-#endif
+      i64 value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteFixed32NoTag(
-      uint32_t value, io::CodedOutputStream* output);
+      ui32 value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteFixed64NoTag(
-      uint64 value, io::CodedOutputStream* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  PROTOBUF_NDEBUG_INLINE static void WriteFixed64NoTag(
-      uint64_t value, io::CodedOutputStream* output);
-#endif
+      ui64 value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteSFixed32NoTag(
-      int32_t value, io::CodedOutputStream* output);
+      i32 value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteSFixed64NoTag(
-      int64 value, io::CodedOutputStream* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  PROTOBUF_NDEBUG_INLINE static void WriteSFixed64NoTag(
-      int64_t value, io::CodedOutputStream* output);
-#endif
+      i64 value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteFloatNoTag(
       float value, io::CodedOutputStream* output);
   PROTOBUF_NDEBUG_INLINE static void WriteDoubleNoTag(
@@ -399,37 +379,37 @@ class PROTOBUF_EXPORT WireFormatLite {
                               io::CodedOutputStream* output);
   static void WriteDoubleArray(const double* a, int n,
                                io::CodedOutputStream* output);
-  static void WriteFixed32Array(const uint32_t* a, int n,
+  static void WriteFixed32Array(const ui32* a, int n,
                                 io::CodedOutputStream* output);
-  static void WriteFixed64Array(const uint64_t* a, int n,
+  static void WriteFixed64Array(const ui64* a, int n,
                                 io::CodedOutputStream* output);
-  static void WriteSFixed32Array(const int32_t* a, int n,
+  static void WriteSFixed32Array(const i32* a, int n,
                                  io::CodedOutputStream* output);
-  static void WriteSFixed64Array(const int64_t* a, int n,
+  static void WriteSFixed64Array(const i64* a, int n,
                                  io::CodedOutputStream* output);
   static void WriteBoolArray(const bool* a, int n,
                              io::CodedOutputStream* output);
 
   // Write fields, including tags.
-  static void WriteInt32(int field_number, int32_t value,
+  static void WriteInt32(int field_number, i32 value,
                          io::CodedOutputStream* output);
-  static void WriteInt64(int field_number, int64_t value,
+  static void WriteInt64(int field_number, i64 value,
                          io::CodedOutputStream* output);
-  static void WriteUInt32(int field_number, uint32_t value,
+  static void WriteUInt32(int field_number, ui32 value,
                           io::CodedOutputStream* output);
-  static void WriteUInt64(int field_number, uint64_t value,
+  static void WriteUInt64(int field_number, ui64 value,
                           io::CodedOutputStream* output);
-  static void WriteSInt32(int field_number, int32_t value,
+  static void WriteSInt32(int field_number, i32 value,
                           io::CodedOutputStream* output);
-  static void WriteSInt64(int field_number, int64_t value,
+  static void WriteSInt64(int field_number, i64 value,
                           io::CodedOutputStream* output);
-  static void WriteFixed32(int field_number, uint32_t value,
+  static void WriteFixed32(int field_number, ui32 value,
                            io::CodedOutputStream* output);
-  static void WriteFixed64(int field_number, uint64_t value,
+  static void WriteFixed64(int field_number, ui64 value,
                            io::CodedOutputStream* output);
-  static void WriteSFixed32(int field_number, int32_t value,
+  static void WriteSFixed32(int field_number, i32 value,
                             io::CodedOutputStream* output);
-  static void WriteSFixed64(int field_number, int64_t value,
+  static void WriteSFixed64(int field_number, i64 value,
                             io::CodedOutputStream* output);
   static void WriteFloat(int field_number, float value,
                          io::CodedOutputStream* output);
@@ -481,45 +461,25 @@ class PROTOBUF_EXPORT WireFormatLite {
 
   // Write fields, without tags.
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32NoTagToArray(
-      int32_t value, uint8_t* target);
+      i32 value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64NoTagToArray(
-      int64 value, uint8_t* target);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64NoTagToArray(
-      int64_t value, uint8_t* target);
-#endif
+      i64 value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32NoTagToArray(
-      uint32_t value, uint8_t* target);
+      ui32 value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64NoTagToArray(
-      uint64 value, uint8_t* target);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64NoTagToArray(
-      uint64_t value, uint8_t* target);
-#endif
+      ui64 value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32NoTagToArray(
-      int32_t value, uint8_t* target);
+      i32 value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64NoTagToArray(
-      int64 value, uint8_t* target);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64NoTagToArray(
-      int64_t value, uint8_t* target);
-#endif
+      i64 value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32NoTagToArray(
-      uint32_t value, uint8_t* target);
+      ui32 value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64NoTagToArray(
-      uint64 value, uint8_t* target);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64NoTagToArray(
-      uint64_t value, uint8_t* target);
-#endif
+      ui64 value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32NoTagToArray(
-      int32_t value, uint8_t* target);
+      i32 value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64NoTagToArray(
-      int64 value, uint8_t* target);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64NoTagToArray(
-      int64_t value, uint8_t* target);
-#endif
+      i64 value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatNoTagToArray(
       float value, uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleNoTagToArray(
@@ -540,45 +500,25 @@ class PROTOBUF_EXPORT WireFormatLite {
       uint8_t* target);
 
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32NoTagToArray(
-      const RepeatedField<int32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64NoTagToArray(
-      const RepeatedField<int64>& value, uint8_t* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
+      const RepeatedField<i32>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64NoTagToArray(
-      const RepeatedField<int64_t>& value, uint8_t* output);
-#endif
+      const RepeatedField<i64>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32NoTagToArray(
-      const RepeatedField<uint32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64NoTagToArray(
-      const RepeatedField<uint64>& value, uint8_t* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
+      const RepeatedField<ui32>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64NoTagToArray(
-      const RepeatedField<uint64_t>& value, uint8_t* output);
-#endif
+      const RepeatedField<ui64>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32NoTagToArray(
-      const RepeatedField<int32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64NoTagToArray(
-      const RepeatedField<int64>& value, uint8_t* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
+      const RepeatedField<i32>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64NoTagToArray(
-      const RepeatedField<int64_t>& value, uint8_t* output);
-#endif
+      const RepeatedField<i64>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32NoTagToArray(
-      const RepeatedField<uint32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64NoTagToArray(
-      const RepeatedField<uint64>& value, uint8_t* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
+      const RepeatedField<ui32>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64NoTagToArray(
-      const RepeatedField<uint64_t>& value, uint8_t* output);
-#endif
+      const RepeatedField<ui64>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32NoTagToArray(
-      const RepeatedField<int32_t>& value, uint8_t* output);
-  PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64NoTagToArray(
-      const RepeatedField<int64>& value, uint8_t* output);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
+      const RepeatedField<i32>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64NoTagToArray(
-      const RepeatedField<int64_t>& value, uint8_t* output);
-#endif
+      const RepeatedField<i64>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatNoTagToArray(
       const RepeatedField<float>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleNoTagToArray(
@@ -590,34 +530,34 @@ class PROTOBUF_EXPORT WireFormatLite {
 
   // Write fields, including tags.
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32ToArray(int field_number,
-                                                           int32_t value,
+                                                           i32 value,
                                                            uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64ToArray(int field_number,
-                                                           int64_t value,
+                                                           i64 value,
                                                            uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32ToArray(int field_number,
-                                                            uint32_t value,
+                                                            ui32 value,
                                                             uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64ToArray(int field_number,
-                                                            uint64_t value,
+                                                            ui64 value,
                                                             uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32ToArray(int field_number,
-                                                            int32_t value,
+                                                            i32 value,
                                                             uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64ToArray(int field_number,
-                                                            int64_t value,
+                                                            i64 value,
                                                             uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32ToArray(int field_number,
-                                                             uint32_t value,
+                                                             ui32 value,
                                                              uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64ToArray(int field_number,
-                                                             uint64_t value,
+                                                             ui64 value,
                                                              uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32ToArray(int field_number,
-                                                              int32_t value,
+                                                              i32 value,
                                                               uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64ToArray(int field_number,
-                                                              int64_t value,
+                                                              i64 value,
                                                               uint8_t* target);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatToArray(int field_number,
                                                            float value,
@@ -638,25 +578,25 @@ class PROTOBUF_EXPORT WireFormatLite {
       uint8_t* (*Writer)(int, T, uint8_t*), uint8_t* target);
 
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt32ToArray(
-      int field_number, const RepeatedField<int32_t>& value, uint8_t* output);
+      int field_number, const RepeatedField<i32>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteInt64ToArray(
-      int field_number, const RepeatedField<int64_t>& value, uint8_t* output);
+      int field_number, const RepeatedField<i64>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt32ToArray(
-      int field_number, const RepeatedField<uint32_t>& value, uint8_t* output);
+      int field_number, const RepeatedField<ui32>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteUInt64ToArray(
-      int field_number, const RepeatedField<uint64_t>& value, uint8_t* output);
+      int field_number, const RepeatedField<ui64>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt32ToArray(
-      int field_number, const RepeatedField<int32_t>& value, uint8_t* output);
+      int field_number, const RepeatedField<i32>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSInt64ToArray(
-      int field_number, const RepeatedField<int64_t>& value, uint8_t* output);
+      int field_number, const RepeatedField<i64>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed32ToArray(
-      int field_number, const RepeatedField<uint32_t>& value, uint8_t* output);
+      int field_number, const RepeatedField<ui32>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFixed64ToArray(
-      int field_number, const RepeatedField<uint64_t>& value, uint8_t* output);
+      int field_number, const RepeatedField<ui64>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed32ToArray(
-      int field_number, const RepeatedField<int32_t>& value, uint8_t* output);
+      int field_number, const RepeatedField<i32>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteSFixed64ToArray(
-      int field_number, const RepeatedField<int64_t>& value, uint8_t* output);
+      int field_number, const RepeatedField<i64>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteFloatToArray(
       int field_number, const RepeatedField<float>& value, uint8_t* output);
   PROTOBUF_NDEBUG_INLINE static uint8_t* WriteDoubleToArray(
@@ -703,7 +643,7 @@ class PROTOBUF_EXPORT WireFormatLite {
         target,
         value.GetCachedSize() +
             static_cast<int>(2 * io::CodedOutputStream::VarintSize32(
-                                     static_cast<uint32_t>(field_number) << 3)),
+                                     static_cast<ui32>(field_number) << 3)),
         io::CodedOutputStream::IsDefaultSerializationDeterministic());
     return InternalWriteGroup(field_number, value, target, &stream);
   }
@@ -713,7 +653,7 @@ class PROTOBUF_EXPORT WireFormatLite {
     io::EpsCopyOutputStream stream(
         target,
         size + static_cast<int>(io::CodedOutputStream::VarintSize32(
-                                    static_cast<uint32_t>(field_number) << 3) +
+                                    static_cast<ui32>(field_number) << 3) +
                                 io::CodedOutputStream::VarintSize32(size)),
         io::CodedOutputStream::IsDefaultSerializationDeterministic());
     return InternalWriteMessage(field_number, value, target, &stream);
@@ -723,42 +663,27 @@ class PROTOBUF_EXPORT WireFormatLite {
   // the tag, so you must also call TagSize().  (This is because, for repeated
   // fields, you should only call TagSize() once and multiply it by the element
   // count, but you may have to call XxSize() for each individual element.)
-  static inline size_t Int32Size(int32_t value);
-  static inline size_t Int64Size(int64 value);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  static inline size_t Int64Size(int64_t value);
-#endif
-  static inline size_t UInt32Size(uint32_t value);
-  static inline size_t UInt64Size(uint64 value);
-  static inline size_t SInt32Size(int32_t value);
-  static inline size_t SInt64Size(int64 value);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  static inline size_t SInt64Size(int64_t value);
-#endif
+  static inline size_t Int32Size(i32 value);
+  static inline size_t Int64Size(i64 value);
+  static inline size_t UInt32Size(ui32 value);
+  static inline size_t UInt64Size(ui64 value);
+  static inline size_t SInt32Size(i32 value);
+  static inline size_t SInt64Size(i64 value);
   static inline size_t EnumSize(int value);
-  static inline size_t Int32SizePlusOne(int32_t value);
-  static inline size_t Int64SizePlusOne(int64_t value);
-  static inline size_t UInt32SizePlusOne(uint32_t value);
-  static inline size_t UInt64SizePlusOne(uint64_t value);
-  static inline size_t SInt32SizePlusOne(int32_t value);
-  static inline size_t SInt64SizePlusOne(int64_t value);
+  static inline size_t Int32SizePlusOne(i32 value);
+  static inline size_t Int64SizePlusOne(i64 value);
+  static inline size_t UInt32SizePlusOne(ui32 value);
+  static inline size_t UInt64SizePlusOne(ui64 value);
+  static inline size_t SInt32SizePlusOne(i32 value);
+  static inline size_t SInt64SizePlusOne(i64 value);
   static inline size_t EnumSizePlusOne(int value);
 
-  static size_t Int32Size(const RepeatedField<int32_t>& value);
-  static size_t Int64Size(const RepeatedField<int64>& value);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  static size_t Int64Size(const RepeatedField<int64_t>& value);
-#endif
-  static size_t UInt32Size(const RepeatedField<uint32_t>& value);
-  static size_t UInt64Size(const RepeatedField<uint64>& value);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  static size_t UInt64Size(const RepeatedField<uint64_t>& value);
-#endif
-  static size_t SInt32Size(const RepeatedField<int32_t>& value);
-  static size_t SInt64Size(const RepeatedField<int64>& value);
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-  static size_t SInt64Size(const RepeatedField<int64_t>& value);
-#endif
+  static size_t Int32Size(const RepeatedField<i32>& value);
+  static size_t Int64Size(const RepeatedField<i64>& value);
+  static size_t UInt32Size(const RepeatedField<ui32>& value);
+  static size_t UInt64Size(const RepeatedField<ui64>& value);
+  static size_t SInt32Size(const RepeatedField<i32>& value);
+  static size_t SInt64Size(const RepeatedField<i64>& value);
   static size_t EnumSize(const RepeatedField<int>& value);
 
   // These types always have the same size.
@@ -796,7 +721,7 @@ class PROTOBUF_EXPORT WireFormatLite {
   // can be read using potentially faster paths.
   template <typename CType, enum FieldType DeclaredType>
   PROTOBUF_NDEBUG_INLINE static bool ReadRepeatedFixedSizePrimitive(
-      int tag_size, uint32_t tag, io::CodedInputStream* input,
+      int tag_size, ui32 tag, io::CodedInputStream* input,
       RepeatedField<CType>* value);
 
   // Like ReadRepeatedFixedSizePrimitive but for packed primitive fields.
@@ -822,7 +747,7 @@ class PROTOBUF_EXPORT FieldSkipper {
   virtual ~FieldSkipper() {}
 
   // Skip a field whose tag has already been consumed.
-  virtual bool SkipField(io::CodedInputStream* input, uint32_t tag);
+  virtual bool SkipField(io::CodedInputStream* input, ui32 tag);
 
   // Skip an entire message or group, up to an end-group tag (which is consumed)
   // or end-of-stream.
@@ -843,7 +768,7 @@ class PROTOBUF_EXPORT CodedOutputStreamFieldSkipper : public FieldSkipper {
   ~CodedOutputStreamFieldSkipper() override {}
 
   // implements FieldSkipper -----------------------------------------
-  bool SkipField(io::CodedInputStream* input, uint32_t tag) override;
+  bool SkipField(io::CodedInputStream* input, ui32 tag) override;
   bool SkipMessage(io::CodedInputStream* input) override;
   void SkipUnknownEnum(int field_number, int value) override;
 
@@ -858,23 +783,23 @@ inline WireFormatLite::CppType WireFormatLite::FieldTypeToCppType(
   return kFieldTypeToCppTypeMap[type];
 }
 
-constexpr inline uint32_t WireFormatLite::MakeTag(int field_number,
+constexpr inline ui32 WireFormatLite::MakeTag(int field_number,
                                                   WireType type) {
   return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
 }
 
-inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32_t tag) {
+inline WireFormatLite::WireType WireFormatLite::GetTagWireType(ui32 tag) {
   return static_cast<WireType>(tag & kTagTypeMask);
 }
 
-inline int WireFormatLite::GetTagFieldNumber(uint32_t tag) {
+inline int WireFormatLite::GetTagFieldNumber(ui32 tag) {
   return static_cast<int>(tag >> kTagTypeBits);
 }
 
 inline size_t WireFormatLite::TagSize(int field_number,
                                       WireFormatLite::FieldType type) {
   size_t result = io::CodedOutputStream::VarintSize32(
-      static_cast<uint32_t>(field_number << kTagTypeBits));
+      static_cast<ui32>(field_number << kTagTypeBits));
   if (type == TYPE_GROUP) {
     // Groups have both a start and an end tag.
     return result * 2;
@@ -883,19 +808,19 @@ inline size_t WireFormatLite::TagSize(int field_number,
   }
 }
 
-inline uint32_t WireFormatLite::EncodeFloat(float value) {
-  return bit_cast<uint32_t>(value);
+inline ui32 WireFormatLite::EncodeFloat(float value) {
+  return bit_cast<ui32>(value);
 }
 
-inline float WireFormatLite::DecodeFloat(uint32_t value) {
+inline float WireFormatLite::DecodeFloat(ui32 value) {
   return bit_cast<float>(value);
 }
 
-inline uint64_t WireFormatLite::EncodeDouble(double value) {
-  return bit_cast<uint64_t>(value);
+inline ui64 WireFormatLite::EncodeDouble(double value) {
+  return bit_cast<ui64>(value);
 }
 
-inline double WireFormatLite::DecodeDouble(uint64_t value) {
+inline double WireFormatLite::DecodeDouble(ui64 value) {
   return bit_cast<double>(value);
 }
 
@@ -910,7 +835,7 @@ inline double WireFormatLite::DecodeDouble(uint64_t value) {
 // in such a way that those with a small absolute value will have smaller
 // encoded values, making them appropriate for encoding using varint.
 //
-//       int32_t ->     uint32_t
+//       i32 ->     ui32
 // -------------------------
 //           0 ->          0
 //          -1 ->          1
@@ -923,26 +848,26 @@ inline double WireFormatLite::DecodeDouble(uint64_t value) {
 //        >> encode >>
 //        << decode <<
 
-inline uint32_t WireFormatLite::ZigZagEncode32(int32_t n) {
+inline ui32 WireFormatLite::ZigZagEncode32(i32 n) {
   // Note:  the right-shift must be arithmetic
   // Note:  left shift must be unsigned because of overflow
-  return (static_cast<uint32_t>(n) << 1) ^ static_cast<uint32_t>(n >> 31);
+  return (static_cast<ui32>(n) << 1) ^ static_cast<ui32>(n >> 31);
 }
 
-inline int32_t WireFormatLite::ZigZagDecode32(uint32_t n) {
+inline i32 WireFormatLite::ZigZagDecode32(ui32 n) {
   // Note:  Using unsigned types prevent undefined behavior
-  return static_cast<int32_t>((n >> 1) ^ (~(n & 1) + 1));
+  return static_cast<i32>((n >> 1) ^ (~(n & 1) + 1));
 }
 
-inline uint64_t WireFormatLite::ZigZagEncode64(int64_t n) {
+inline ui64 WireFormatLite::ZigZagEncode64(i64 n) {
   // Note:  the right-shift must be arithmetic
   // Note:  left shift must be unsigned because of overflow
-  return (static_cast<uint64_t>(n) << 1) ^ static_cast<uint64_t>(n >> 63);
+  return (static_cast<ui64>(n) << 1) ^ static_cast<ui64>(n >> 63);
 }
 
-inline int64_t WireFormatLite::ZigZagDecode64(uint64_t n) {
+inline i64 WireFormatLite::ZigZagDecode64(ui64 n) {
   // Note:  Using unsigned types prevent undefined behavior
-  return static_cast<int64_t>((n >> 1) ^ (~(n & 1) + 1));
+  return static_cast<i64>((n >> 1) ^ (~(n & 1) + 1));
 }
 
 // String is for UTF-8 text only, but, even so, ReadString() can simply
@@ -973,130 +898,83 @@ inline size_t ComputeUnknownMessageSetItemsSize(
 // Implementation details of ReadPrimitive.
 
 template <>
-inline bool WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_INT32>(
-    io::CodedInputStream* input, int32_t* value) {
-  uint32_t temp;
+inline bool WireFormatLite::ReadPrimitive<i32, WireFormatLite::TYPE_INT32>(
+    io::CodedInputStream* input, i32* value) {
+  ui32 temp;
   if (!input->ReadVarint32(&temp)) return false;
-  *value = static_cast<int32_t>(temp);
+  *value = static_cast<i32>(temp);
   return true;
 }
 template <>
-inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_INT64>(
-    io::CodedInputStream* input, int64* value) {
-  uint64 temp;
+inline bool WireFormatLite::ReadPrimitive<i64, WireFormatLite::TYPE_INT64>(
+    io::CodedInputStream* input, i64* value) {
+  ui64 temp;
   if (!input->ReadVarint64(&temp)) return false;
-  *value = static_cast<int64>(temp);
+  *value = static_cast<i64>(temp);
   return true;
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-template <>
-inline bool WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_INT64>(
-    io::CodedInputStream* input, int64_t* value) {
-  uint64_t temp;
-  if (!input->ReadVarint64(&temp)) return false;
-  *value = static_cast<int64_t>(temp);
-  return true;
-}
-#endif
 template <>
 inline bool
-WireFormatLite::ReadPrimitive<uint32_t, WireFormatLite::TYPE_UINT32>(
-    io::CodedInputStream* input, uint32_t* value) {
+WireFormatLite::ReadPrimitive<ui32, WireFormatLite::TYPE_UINT32>(
+    io::CodedInputStream* input, ui32* value) {
   return input->ReadVarint32(value);
 }
 template <>
 inline bool
-WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_UINT64>(
-    io::CodedInputStream* input, uint64* value) {
+WireFormatLite::ReadPrimitive<ui64, WireFormatLite::TYPE_UINT64>(
+    io::CodedInputStream* input, ui64* value) {
   return input->ReadVarint64(value);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
 template <>
-inline bool
-WireFormatLite::ReadPrimitive<uint64_t, WireFormatLite::TYPE_UINT64>(
-    io::CodedInputStream* input, uint64_t* value) {
-  return input->ReadVarint64(value);
-}
-#endif
-template <>
-inline bool WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_SINT32>(
-    io::CodedInputStream* input, int32_t* value) {
-  uint32_t temp;
+inline bool WireFormatLite::ReadPrimitive<i32, WireFormatLite::TYPE_SINT32>(
+    io::CodedInputStream* input, i32* value) {
+  ui32 temp;
   if (!input->ReadVarint32(&temp)) return false;
   *value = ZigZagDecode32(temp);
   return true;
 }
 template <>
-inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SINT64>(
-    io::CodedInputStream* input, int64* value) {
-  uint64 temp;
-  if (!input->ReadVarint64(&temp)) return false;
-  *value = ZigZagDecode64(temp);
-  return true;
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-template <>
-inline bool WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_SINT64>(
-    io::CodedInputStream* input, int64_t* value) {
-  uint64_t temp;
+inline bool WireFormatLite::ReadPrimitive<i64, WireFormatLite::TYPE_SINT64>(
+    io::CodedInputStream* input, i64* value) {
+  ui64 temp;
   if (!input->ReadVarint64(&temp)) return false;
   *value = ZigZagDecode64(temp);
   return true;
 }
-#endif
 template <>
 inline bool
-WireFormatLite::ReadPrimitive<uint32_t, WireFormatLite::TYPE_FIXED32>(
-    io::CodedInputStream* input, uint32_t* value) {
+WireFormatLite::ReadPrimitive<ui32, WireFormatLite::TYPE_FIXED32>(
+    io::CodedInputStream* input, ui32* value) {
   return input->ReadLittleEndian32(value);
 }
 template <>
 inline bool
-WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_FIXED64>(
-    io::CodedInputStream* input, uint64* value) {
-  return input->ReadLittleEndian64(value);
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-template <>
-inline bool
-WireFormatLite::ReadPrimitive<uint64_t, WireFormatLite::TYPE_FIXED64>(
-    io::CodedInputStream* input, uint64_t* value) {
+WireFormatLite::ReadPrimitive<ui64, WireFormatLite::TYPE_FIXED64>(
+    io::CodedInputStream* input, ui64* value) {
   return input->ReadLittleEndian64(value);
 }
-#endif
 template <>
 inline bool
-WireFormatLite::ReadPrimitive<int32_t, WireFormatLite::TYPE_SFIXED32>(
-    io::CodedInputStream* input, int32_t* value) {
-  uint32_t temp;
+WireFormatLite::ReadPrimitive<i32, WireFormatLite::TYPE_SFIXED32>(
+    io::CodedInputStream* input, i32* value) {
+  ui32 temp;
   if (!input->ReadLittleEndian32(&temp)) return false;
-  *value = static_cast<int32_t>(temp);
+  *value = static_cast<i32>(temp);
   return true;
 }
 template <>
 inline bool
-WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SFIXED64>(
-    io::CodedInputStream* input, int64* value) {
-  uint64 temp;
+WireFormatLite::ReadPrimitive<i64, WireFormatLite::TYPE_SFIXED64>(
+    io::CodedInputStream* input, i64* value) {
+  ui64 temp;
   if (!input->ReadLittleEndian64(&temp)) return false;
-  *value = static_cast<int64>(temp);
+  *value = static_cast<i64>(temp);
   return true;
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-template <>
-inline bool
-WireFormatLite::ReadPrimitive<int64_t, WireFormatLite::TYPE_SFIXED64>(
-    io::CodedInputStream* input, int64_t* value) {
-  uint64_t temp;
-  if (!input->ReadLittleEndian64(&temp)) return false;
-  *value = static_cast<int64_t>(temp);
-  return true;
-}
-#endif
 template <>
 inline bool WireFormatLite::ReadPrimitive<float, WireFormatLite::TYPE_FLOAT>(
     io::CodedInputStream* input, float* value) {
-  uint32_t temp;
+  ui32 temp;
   if (!input->ReadLittleEndian32(&temp)) return false;
   *value = DecodeFloat(temp);
   return true;
@@ -1104,7 +982,7 @@ inline bool WireFormatLite::ReadPrimitive<float, WireFormatLite::TYPE_FLOAT>(
 template <>
 inline bool WireFormatLite::ReadPrimitive<double, WireFormatLite::TYPE_DOUBLE>(
     io::CodedInputStream* input, double* value) {
-  uint64_t temp;
+  ui64 temp;
   if (!input->ReadLittleEndian64(&temp)) return false;
   *value = DecodeDouble(temp);
   return true;
@@ -1112,7 +990,7 @@ inline bool WireFormatLite::ReadPrimitive<double, WireFormatLite::TYPE_DOUBLE>(
 template <>
 inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
     io::CodedInputStream* input, bool* value) {
-  uint64_t temp;
+  ui64 temp;
   if (!input->ReadVarint64(&temp)) return false;
   *value = temp != 0;
   return true;
@@ -1120,7 +998,7 @@ inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
 template <>
 inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
     io::CodedInputStream* input, int* value) {
-  uint32_t temp;
+  ui32 temp;
   if (!input->ReadVarint32(&temp)) return false;
   *value = static_cast<int>(temp);
   return true;
@@ -1128,58 +1006,39 @@ inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
 
 template <>
 inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<uint32_t, WireFormatLite::TYPE_FIXED32>(
-    const uint8_t* buffer, uint32_t* value) {
+WireFormatLite::ReadPrimitiveFromArray<ui32, WireFormatLite::TYPE_FIXED32>(
+    const uint8_t* buffer, ui32* value) {
   return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
 }
 template <>
 inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<uint64, WireFormatLite::TYPE_FIXED64>(
-    const uint8_t* buffer, uint64* value) {
-  return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-template <>
-inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<uint64_t, WireFormatLite::TYPE_FIXED64>(
-    const uint8_t* buffer, uint64_t* value) {
+WireFormatLite::ReadPrimitiveFromArray<ui64, WireFormatLite::TYPE_FIXED64>(
+    const uint8_t* buffer, ui64* value) {
   return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
 }
-#endif
 template <>
 inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<int32_t, WireFormatLite::TYPE_SFIXED32>(
-    const uint8_t* buffer, int32_t* value) {
-  uint32_t temp;
+WireFormatLite::ReadPrimitiveFromArray<i32, WireFormatLite::TYPE_SFIXED32>(
+    const uint8_t* buffer, i32* value) {
+  ui32 temp;
   buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
-  *value = static_cast<int32_t>(temp);
-  return buffer;
-}
-template <>
-inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<int64, WireFormatLite::TYPE_SFIXED64>(
-    const uint8_t* buffer, int64* value) {
-  uint64_t temp;
-  buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
-  *value = static_cast<int64_t>(temp);
+  *value = static_cast<i32>(temp);
   return buffer;
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
 template <>
 inline const uint8_t*
-WireFormatLite::ReadPrimitiveFromArray<int64_t, WireFormatLite::TYPE_SFIXED64>(
-    const uint8_t* buffer, int64_t* value) {
-  uint64_t temp;
+WireFormatLite::ReadPrimitiveFromArray<i64, WireFormatLite::TYPE_SFIXED64>(
+    const uint8_t* buffer, i64* value) {
+  ui64 temp;
   buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
-  *value = static_cast<int64_t>(temp);
+  *value = static_cast<i64>(temp);
   return buffer;
 }
-#endif
 template <>
 inline const uint8_t*
 WireFormatLite::ReadPrimitiveFromArray<float, WireFormatLite::TYPE_FLOAT>(
     const uint8_t* buffer, float* value) {
-  uint32_t temp;
+  ui32 temp;
   buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
   *value = DecodeFloat(temp);
   return buffer;
@@ -1188,7 +1047,7 @@ template <>
 inline const uint8_t*
 WireFormatLite::ReadPrimitiveFromArray<double, WireFormatLite::TYPE_DOUBLE>(
     const uint8_t* buffer, double* value) {
-  uint64_t temp;
+  ui64 temp;
   buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
   *value = DecodeDouble(temp);
   return buffer;
@@ -1197,7 +1056,7 @@ WireFormatLite::ReadPrimitiveFromArray<double, WireFormatLite::TYPE_DOUBLE>(
 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 inline bool WireFormatLite::ReadRepeatedPrimitive(
     int,  // tag_size, unused.
-    uint32_t tag, io::CodedInputStream* input, RepeatedField<CType>* values) {
+    ui32 tag, io::CodedInputStream* input, RepeatedField<CType>* values) {
   CType value;
   if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
   values->Add(value);
@@ -1212,7 +1071,7 @@ inline bool WireFormatLite::ReadRepeatedPrimitive(
 
 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
-    int tag_size, uint32_t tag, io::CodedInputStream* input,
+    int tag_size, ui32 tag, io::CodedInputStream* input,
     RepeatedField<CType>* values) {
   GOOGLE_DCHECK_EQ(UInt32Size(tag), static_cast<size_t>(tag_size));
   CType value;
@@ -1261,17 +1120,17 @@ inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
   template <>                                                             \
   inline bool WireFormatLite::ReadRepeatedPrimitive<                      \
       CPPTYPE, WireFormatLite::DECLARED_TYPE>(                            \
-      int tag_size, uint32_t tag, io::CodedInputStream* input,            \
+      int tag_size, ui32 tag, io::CodedInputStream* input,            \
       RepeatedField<CPPTYPE>* values) {                                   \
     return ReadRepeatedFixedSizePrimitive<CPPTYPE,                        \
                                           WireFormatLite::DECLARED_TYPE>( \
         tag_size, tag, input, values);                                    \
   }
 
-READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint32_t, TYPE_FIXED32)
-READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint64_t, TYPE_FIXED64)
-READ_REPEATED_FIXED_SIZE_PRIMITIVE(int32_t, TYPE_SFIXED32)
-READ_REPEATED_FIXED_SIZE_PRIMITIVE(int64_t, TYPE_SFIXED64)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(ui32, TYPE_FIXED32)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(ui64, TYPE_FIXED64)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(i32, TYPE_SFIXED32)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(i64, TYPE_SFIXED64)
 READ_REPEATED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
 READ_REPEATED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
 
@@ -1279,7 +1138,7 @@ READ_REPEATED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
 
 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 bool WireFormatLite::ReadRepeatedPrimitiveNoInline(
-    int tag_size, uint32_t tag, io::CodedInputStream* input,
+    int tag_size, ui32 tag, io::CodedInputStream* input,
     RepeatedField<CType>* value) {
   return ReadRepeatedPrimitive<CType, DeclaredType>(tag_size, tag, input,
                                                     value);
@@ -1321,13 +1180,13 @@ inline bool WireFormatLite::ReadPackedFixedSizePrimitive(
   // -1               >= 0   Use fast path if length <= Limit.
   // >= 0             -1     Use slow path.
   // >= 0             >= 0   Use fast path if length <= min(both limits).
-  int64_t bytes_limit = input->BytesUntilTotalBytesLimit();
+  i64 bytes_limit = input->BytesUntilTotalBytesLimit();
   if (bytes_limit == -1) {
     bytes_limit = input->BytesUntilLimit();
   } else {
     // parentheses around (std::min) prevents macro expansion of min(...)
     bytes_limit =
-        (std::min)(bytes_limit, static_cast<int64_t>(input->BytesUntilLimit()));
+        (std::min)(bytes_limit, static_cast<i64>(input->BytesUntilLimit()));
   }
   if (bytes_limit >= new_bytes) {
     // Fast-path that pre-allocates *values to the final size.
@@ -1372,10 +1231,10 @@ inline bool WireFormatLite::ReadPackedFixedSizePrimitive(
         input, values);                                                        \
   }
 
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint32_t, TYPE_FIXED32)
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint64_t, TYPE_FIXED64)
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int32_t, TYPE_SFIXED32)
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int64_t, TYPE_SFIXED64)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(ui32, TYPE_FIXED32)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(ui64, TYPE_FIXED64)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(i32, TYPE_SFIXED32)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(i64, TYPE_SFIXED64)
 READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
 READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
 
@@ -1421,76 +1280,46 @@ inline void WireFormatLite::WriteTag(int field_number, WireType type,
   output->WriteTag(MakeTag(field_number, type));
 }
 
-inline void WireFormatLite::WriteInt32NoTag(int32_t value,
+inline void WireFormatLite::WriteInt32NoTag(i32 value,
                                             io::CodedOutputStream* output) {
   output->WriteVarint32SignExtended(value);
 }
-inline void WireFormatLite::WriteInt64NoTag(int64 value,
+inline void WireFormatLite::WriteInt64NoTag(i64 value,
                                             io::CodedOutputStream* output) {
-  output->WriteVarint64(static_cast<uint64>(value));
+  output->WriteVarint64(static_cast<ui64>(value));
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline void WireFormatLite::WriteInt64NoTag(int64_t value,
-                                            io::CodedOutputStream* output) {
-  output->WriteVarint64(static_cast<uint64_t>(value));
-}
-#endif
-inline void WireFormatLite::WriteUInt32NoTag(uint32_t value,
+inline void WireFormatLite::WriteUInt32NoTag(ui32 value,
                                              io::CodedOutputStream* output) {
   output->WriteVarint32(value);
 }
-inline void WireFormatLite::WriteUInt64NoTag(uint64 value,
+inline void WireFormatLite::WriteUInt64NoTag(ui64 value,
                                              io::CodedOutputStream* output) {
   output->WriteVarint64(value);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline void WireFormatLite::WriteUInt64NoTag(uint64_t value,
-                                             io::CodedOutputStream* output) {
-  output->WriteVarint64(value);
-}
-#endif
-inline void WireFormatLite::WriteSInt32NoTag(int32_t value,
+inline void WireFormatLite::WriteSInt32NoTag(i32 value,
                                              io::CodedOutputStream* output) {
   output->WriteVarint32(ZigZagEncode32(value));
 }
-inline void WireFormatLite::WriteSInt64NoTag(int64 value,
-                                             io::CodedOutputStream* output) {
-  output->WriteVarint64(ZigZagEncode64(value));
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline void WireFormatLite::WriteSInt64NoTag(int64_t value,
+inline void WireFormatLite::WriteSInt64NoTag(i64 value,
                                              io::CodedOutputStream* output) {
   output->WriteVarint64(ZigZagEncode64(value));
 }
-#endif
-inline void WireFormatLite::WriteFixed32NoTag(uint32_t value,
+inline void WireFormatLite::WriteFixed32NoTag(ui32 value,
                                               io::CodedOutputStream* output) {
   output->WriteLittleEndian32(value);
 }
-inline void WireFormatLite::WriteFixed64NoTag(uint64 value,
-                                              io::CodedOutputStream* output) {
-  output->WriteLittleEndian64(value);
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline void WireFormatLite::WriteFixed64NoTag(uint64_t value,
+inline void WireFormatLite::WriteFixed64NoTag(ui64 value,
                                               io::CodedOutputStream* output) {
   output->WriteLittleEndian64(value);
 }
-#endif
-inline void WireFormatLite::WriteSFixed32NoTag(int32_t value,
+inline void WireFormatLite::WriteSFixed32NoTag(i32 value,
                                                io::CodedOutputStream* output) {
-  output->WriteLittleEndian32(static_cast<uint32_t>(value));
+  output->WriteLittleEndian32(static_cast<ui32>(value));
 }
-inline void WireFormatLite::WriteSFixed64NoTag(int64 value,
+inline void WireFormatLite::WriteSFixed64NoTag(i64 value,
                                                io::CodedOutputStream* output) {
-  output->WriteLittleEndian64(static_cast<uint64>(value));
+  output->WriteLittleEndian64(static_cast<ui64>(value));
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline void WireFormatLite::WriteSFixed64NoTag(int64_t value,
-                                               io::CodedOutputStream* output) {
-  output->WriteLittleEndian64(static_cast<uint64_t>(value));
-}
-#endif
 inline void WireFormatLite::WriteFloatNoTag(float value,
                                             io::CodedOutputStream* output) {
   output->WriteLittleEndian32(EncodeFloat(value));
@@ -1536,84 +1365,51 @@ inline uint8_t* WireFormatLite::WriteTagToArray(int field_number, WireType type,
                                                 target);
 }
 
-inline uint8_t* WireFormatLite::WriteInt32NoTagToArray(int32_t value,
+inline uint8_t* WireFormatLite::WriteInt32NoTagToArray(i32 value,
                                                        uint8_t* target) {
   return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
 }
-inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(int64 value,
+inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(i64 value,
                                                        uint8_t* target) {
   return io::CodedOutputStream::WriteVarint64ToArray(
-      static_cast<uint64>(value), target);
+      static_cast<ui64>(value), target);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(int64_t value,
-                                                       uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint64ToArray(
-      static_cast<uint64_t>(value), target);
-}
-#endif
-inline uint8_t* WireFormatLite::WriteUInt32NoTagToArray(uint32_t value,
+inline uint8_t* WireFormatLite::WriteUInt32NoTagToArray(ui32 value,
                                                         uint8_t* target) {
   return io::CodedOutputStream::WriteVarint32ToArray(value, target);
 }
-inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(uint64 value,
+inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(ui64 value,
                                                         uint8_t* target) {
   return io::CodedOutputStream::WriteVarint64ToArray(value, target);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(uint64_t value,
-                                                        uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint64ToArray(value, target);
-}
-#endif
-inline uint8_t* WireFormatLite::WriteSInt32NoTagToArray(int32_t value,
+inline uint8_t* WireFormatLite::WriteSInt32NoTagToArray(i32 value,
                                                         uint8_t* target) {
   return io::CodedOutputStream::WriteVarint32ToArray(ZigZagEncode32(value),
                                                      target);
 }
-inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(int64 value,
-                                                        uint8_t* target) {
-  return io::CodedOutputStream::WriteVarint64ToArray(ZigZagEncode64(value),
-                                                     target);
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(int64_t value,
+inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(i64 value,
                                                         uint8_t* target) {
   return io::CodedOutputStream::WriteVarint64ToArray(ZigZagEncode64(value),
                                                      target);
 }
-#endif
-inline uint8_t* WireFormatLite::WriteFixed32NoTagToArray(uint32_t value,
+inline uint8_t* WireFormatLite::WriteFixed32NoTagToArray(ui32 value,
                                                          uint8_t* target) {
   return io::CodedOutputStream::WriteLittleEndian32ToArray(value, target);
 }
-inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(uint64 value,
+inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(ui64 value,
                                                          uint8_t* target) {
   return io::CodedOutputStream::WriteLittleEndian64ToArray(value, target);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(uint64_t value,
-                                                         uint8_t* target) {
-  return io::CodedOutputStream::WriteLittleEndian64ToArray(value, target);
-}
-#endif
-inline uint8_t* WireFormatLite::WriteSFixed32NoTagToArray(int32_t value,
+inline uint8_t* WireFormatLite::WriteSFixed32NoTagToArray(i32 value,
                                                           uint8_t* target) {
   return io::CodedOutputStream::WriteLittleEndian32ToArray(
-      static_cast<uint32_t>(value), target);
+      static_cast<ui32>(value), target);
 }
-inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(int64 value,
+inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(i64 value,
                                                           uint8_t* target) {
   return io::CodedOutputStream::WriteLittleEndian64ToArray(
-      static_cast<uint64>(value), target);
+      static_cast<ui64>(value), target);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(int64_t value,
-                                                          uint8_t* target) {
-  return io::CodedOutputStream::WriteLittleEndian64ToArray(
-      static_cast<uint64_t>(value), target);
-}
-#endif
 inline uint8_t* WireFormatLite::WriteFloatNoTagToArray(float value,
                                                        uint8_t* target) {
   return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value),
@@ -1669,75 +1465,45 @@ inline uint8_t* WireFormatLite::WriteFixedNoTagToArray(
 }
 
 inline uint8_t* WireFormatLite::WriteInt32NoTagToArray(
-    const RepeatedField<int32_t>& value, uint8_t* target) {
+    const RepeatedField<i32>& value, uint8_t* target) {
   return WritePrimitiveNoTagToArray(value, WriteInt32NoTagToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(
-    const RepeatedField<int64>& value, uint8_t* target) {
+    const RepeatedField<i64>& value, uint8_t* target) {
   return WritePrimitiveNoTagToArray(value, WriteInt64NoTagToArray, target);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline uint8_t* WireFormatLite::WriteInt64NoTagToArray(
-    const RepeatedField<int64_t>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteInt64NoTagToArray, target);
-}
-#endif
 inline uint8_t* WireFormatLite::WriteUInt32NoTagToArray(
-    const RepeatedField<uint32_t>& value, uint8_t* target) {
+    const RepeatedField<ui32>& value, uint8_t* target) {
   return WritePrimitiveNoTagToArray(value, WriteUInt32NoTagToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(
-    const RepeatedField<uint64>& value, uint8_t* target) {
+    const RepeatedField<ui64>& value, uint8_t* target) {
   return WritePrimitiveNoTagToArray(value, WriteUInt64NoTagToArray, target);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline uint8_t* WireFormatLite::WriteUInt64NoTagToArray(
-    const RepeatedField<uint64_t>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteUInt64NoTagToArray, target);
-}
-#endif
 inline uint8_t* WireFormatLite::WriteSInt32NoTagToArray(
-    const RepeatedField<int32_t>& value, uint8_t* target) {
+    const RepeatedField<i32>& value, uint8_t* target) {
   return WritePrimitiveNoTagToArray(value, WriteSInt32NoTagToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(
-    const RepeatedField<int64>& value, uint8_t* target) {
+    const RepeatedField<i64>& value, uint8_t* target) {
   return WritePrimitiveNoTagToArray(value, WriteSInt64NoTagToArray, target);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline uint8_t* WireFormatLite::WriteSInt64NoTagToArray(
-    const RepeatedField<int64_t>& value, uint8_t* target) {
-  return WritePrimitiveNoTagToArray(value, WriteSInt64NoTagToArray, target);
-}
-#endif
 inline uint8_t* WireFormatLite::WriteFixed32NoTagToArray(
-    const RepeatedField<uint32_t>& value, uint8_t* target) {
+    const RepeatedField<ui32>& value, uint8_t* target) {
   return WriteFixedNoTagToArray(value, WriteFixed32NoTagToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(
-    const RepeatedField<uint64>& value, uint8_t* target) {
+    const RepeatedField<ui64>& value, uint8_t* target) {
   return WriteFixedNoTagToArray(value, WriteFixed64NoTagToArray, target);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline uint8_t* WireFormatLite::WriteFixed64NoTagToArray(
-    const RepeatedField<uint64_t>& value, uint8_t* target) {
-  return WriteFixedNoTagToArray(value, WriteFixed64NoTagToArray, target);
-}
-#endif
 inline uint8_t* WireFormatLite::WriteSFixed32NoTagToArray(
-    const RepeatedField<int32_t>& value, uint8_t* target) {
+    const RepeatedField<i32>& value, uint8_t* target) {
   return WriteFixedNoTagToArray(value, WriteSFixed32NoTagToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(
-    const RepeatedField<int64>& value, uint8_t* target) {
+    const RepeatedField<i64>& value, uint8_t* target) {
   return WriteFixedNoTagToArray(value, WriteSFixed64NoTagToArray, target);
 }
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline uint8_t* WireFormatLite::WriteSFixed64NoTagToArray(
-    const RepeatedField<int64_t>& value, uint8_t* target) {
-  return WriteFixedNoTagToArray(value, WriteSFixed64NoTagToArray, target);
-}
-#endif
 inline uint8_t* WireFormatLite::WriteFloatNoTagToArray(
     const RepeatedField<float>& value, uint8_t* target) {
   return WriteFixedNoTagToArray(value, WriteFloatNoTagToArray, target);
@@ -1756,61 +1522,61 @@ inline uint8_t* WireFormatLite::WriteEnumNoTagToArray(
 }
 
 inline uint8_t* WireFormatLite::WriteInt32ToArray(int field_number,
-                                                  int32_t value,
+                                                  i32 value,
                                                   uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
   return WriteInt32NoTagToArray(value, target);
 }
 inline uint8_t* WireFormatLite::WriteInt64ToArray(int field_number,
-                                                  int64_t value,
+                                                  i64 value,
                                                   uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
   return WriteInt64NoTagToArray(value, target);
 }
 inline uint8_t* WireFormatLite::WriteUInt32ToArray(int field_number,
-                                                   uint32_t value,
+                                                   ui32 value,
                                                    uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
   return WriteUInt32NoTagToArray(value, target);
 }
 inline uint8_t* WireFormatLite::WriteUInt64ToArray(int field_number,
-                                                   uint64_t value,
+                                                   ui64 value,
                                                    uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
   return WriteUInt64NoTagToArray(value, target);
 }
 inline uint8_t* WireFormatLite::WriteSInt32ToArray(int field_number,
-                                                   int32_t value,
+                                                   i32 value,
                                                    uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
   return WriteSInt32NoTagToArray(value, target);
 }
 inline uint8_t* WireFormatLite::WriteSInt64ToArray(int field_number,
-                                                   int64_t value,
+                                                   i64 value,
                                                    uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
   return WriteSInt64NoTagToArray(value, target);
 }
 inline uint8_t* WireFormatLite::WriteFixed32ToArray(int field_number,
-                                                    uint32_t value,
+                                                    ui32 value,
                                                     uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
   return WriteFixed32NoTagToArray(value, target);
 }
 inline uint8_t* WireFormatLite::WriteFixed64ToArray(int field_number,
-                                                    uint64_t value,
+                                                    ui64 value,
                                                     uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
   return WriteFixed64NoTagToArray(value, target);
 }
 inline uint8_t* WireFormatLite::WriteSFixed32ToArray(int field_number,
-                                                     int32_t value,
+                                                     i32 value,
                                                      uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
   return WriteSFixed32NoTagToArray(value, target);
 }
 inline uint8_t* WireFormatLite::WriteSFixed64ToArray(int field_number,
-                                                     int64_t value,
+                                                     i64 value,
                                                      uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
   return WriteSFixed64NoTagToArray(value, target);
@@ -1856,46 +1622,46 @@ inline uint8_t* WireFormatLite::WritePrimitiveToArray(
 }
 
 inline uint8_t* WireFormatLite::WriteInt32ToArray(
-    int field_number, const RepeatedField<int32_t>& value, uint8_t* target) {
+    int field_number, const RepeatedField<i32>& value, uint8_t* target) {
   return WritePrimitiveToArray(field_number, value, WriteInt32ToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteInt64ToArray(
-    int field_number, const RepeatedField<int64_t>& value, uint8_t* target) {
+    int field_number, const RepeatedField<i64>& value, uint8_t* target) {
   return WritePrimitiveToArray(field_number, value, WriteInt64ToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteUInt32ToArray(
-    int field_number, const RepeatedField<uint32_t>& value, uint8_t* target) {
+    int field_number, const RepeatedField<ui32>& value, uint8_t* target) {
   return WritePrimitiveToArray(field_number, value, WriteUInt32ToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteUInt64ToArray(
-    int field_number, const RepeatedField<uint64_t>& value, uint8_t* target) {
+    int field_number, const RepeatedField<ui64>& value, uint8_t* target) {
   return WritePrimitiveToArray(field_number, value, WriteUInt64ToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteSInt32ToArray(
-    int field_number, const RepeatedField<int32_t>& value, uint8_t* target) {
+    int field_number, const RepeatedField<i32>& value, uint8_t* target) {
   return WritePrimitiveToArray(field_number, value, WriteSInt32ToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteSInt64ToArray(
-    int field_number, const RepeatedField<int64_t>& value, uint8_t* target) {
+    int field_number, const RepeatedField<i64>& value, uint8_t* target) {
   return WritePrimitiveToArray(field_number, value, WriteSInt64ToArray, target);
 }
 inline uint8_t* WireFormatLite::WriteFixed32ToArray(
-    int field_number, const RepeatedField<uint32_t>& value, uint8_t* target) {
+    int field_number, const RepeatedField<ui32>& value, uint8_t* target) {
   return WritePrimitiveToArray(field_number, value, WriteFixed32ToArray,
                                target);
 }
 inline uint8_t* WireFormatLite::WriteFixed64ToArray(
-    int field_number, const RepeatedField<uint64_t>& value, uint8_t* target) {
+    int field_number, const RepeatedField<ui64>& value, uint8_t* target) {
   return WritePrimitiveToArray(field_number, value, WriteFixed64ToArray,
                                target);
 }
 inline uint8_t* WireFormatLite::WriteSFixed32ToArray(
-    int field_number, const RepeatedField<int32_t>& value, uint8_t* target) {
+    int field_number, const RepeatedField<i32>& value, uint8_t* target) {
   return WritePrimitiveToArray(field_number, value, WriteSFixed32ToArray,
                                target);
 }
 inline uint8_t* WireFormatLite::WriteSFixed64ToArray(
-    int field_number, const RepeatedField<int64_t>& value, uint8_t* target) {
+    int field_number, const RepeatedField<i64>& value, uint8_t* target) {
   return WritePrimitiveToArray(field_number, value, WriteSFixed64ToArray,
                                target);
 }
@@ -1948,7 +1714,7 @@ inline uint8_t* WireFormatLite::InternalWriteMessage(
     io::EpsCopyOutputStream* stream) {
   target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
   target = io::CodedOutputStream::WriteVarint32ToArrayOutOfLine(
-      static_cast<uint32_t>(value.GetCachedSize()), target);
+      static_cast<ui32>(value.GetCachedSize()), target);
   return value._InternalSerialize(target, stream);
 }
 
@@ -1969,7 +1735,7 @@ inline uint8_t* WireFormatLite::InternalWriteMessageNoVirtualToArray(
     uint8_t* target) {
   target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
   target = io::CodedOutputStream::WriteVarint32ToArray(
-      static_cast<uint32_t>(
+      static_cast<ui32>(
           value.MessageType_WorkAroundCppLookupDefect::GetCachedSize()),
       target);
   return value
@@ -1979,54 +1745,44 @@ inline uint8_t* WireFormatLite::InternalWriteMessageNoVirtualToArray(
 
 // ===================================================================
 
-inline size_t WireFormatLite::Int32Size(int32_t value) {
+inline size_t WireFormatLite::Int32Size(i32 value) {
   return io::CodedOutputStream::VarintSize32SignExtended(value);
 }
-inline size_t WireFormatLite::Int64Size(int64 value) {
-  return io::CodedOutputStream::VarintSize64(static_cast<uint64_t>(value));
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline size_t WireFormatLite::Int64Size(int64_t value) {
-  return io::CodedOutputStream::VarintSize64(static_cast<uint64_t>(value));
+inline size_t WireFormatLite::Int64Size(i64 value) {
+  return io::CodedOutputStream::VarintSize64(static_cast<ui64>(value));
 }
-#endif
-inline size_t WireFormatLite::UInt32Size(uint32_t value) {
+inline size_t WireFormatLite::UInt32Size(ui32 value) {
   return io::CodedOutputStream::VarintSize32(value);
 }
-inline size_t WireFormatLite::UInt64Size(uint64 value) {
+inline size_t WireFormatLite::UInt64Size(ui64 value) {
   return io::CodedOutputStream::VarintSize64(value);
 }
-inline size_t WireFormatLite::SInt32Size(int32_t value) {
+inline size_t WireFormatLite::SInt32Size(i32 value) {
   return io::CodedOutputStream::VarintSize32(ZigZagEncode32(value));
 }
-inline size_t WireFormatLite::SInt64Size(int64 value) {
-  return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
-}
-#if defined(_64_) && (defined(_darwin_) || defined(_ios_))
-inline size_t WireFormatLite::SInt64Size(int64_t value) {
+inline size_t WireFormatLite::SInt64Size(i64 value) {
   return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
 }
-#endif
 inline size_t WireFormatLite::EnumSize(int value) {
   return io::CodedOutputStream::VarintSize32SignExtended(value);
 }
-inline size_t WireFormatLite::Int32SizePlusOne(int32_t value) {
+inline size_t WireFormatLite::Int32SizePlusOne(i32 value) {
   return io::CodedOutputStream::VarintSize32SignExtendedPlusOne(value);
 }
-inline size_t WireFormatLite::Int64SizePlusOne(int64_t value) {
+inline size_t WireFormatLite::Int64SizePlusOne(i64 value) {
   return io::CodedOutputStream::VarintSize64PlusOne(
-      static_cast<uint64_t>(value));
+      static_cast<ui64>(value));
 }
-inline size_t WireFormatLite::UInt32SizePlusOne(uint32_t value) {
+inline size_t WireFormatLite::UInt32SizePlusOne(ui32 value) {
   return io::CodedOutputStream::VarintSize32PlusOne(value);
 }
-inline size_t WireFormatLite::UInt64SizePlusOne(uint64_t value) {
+inline size_t WireFormatLite::UInt64SizePlusOne(ui64 value) {
   return io::CodedOutputStream::VarintSize64PlusOne(value);
 }
-inline size_t WireFormatLite::SInt32SizePlusOne(int32_t value) {
+inline size_t WireFormatLite::SInt32SizePlusOne(i32 value) {
   return io::CodedOutputStream::VarintSize32PlusOne(ZigZagEncode32(value));
 }
-inline size_t WireFormatLite::SInt64SizePlusOne(int64_t value) {
+inline size_t WireFormatLite::SInt64SizePlusOne(i64 value) {
   return io::CodedOutputStream::VarintSize64PlusOne(ZigZagEncode64(value));
 }
 inline size_t WireFormatLite::EnumSizePlusOne(int value) {
@@ -2066,11 +1822,11 @@ inline size_t WireFormatLite::MessageSizeNoVirtual(
 
 inline size_t WireFormatLite::LengthDelimitedSize(size_t length) {
   // The static_cast here prevents an error in certain compiler configurations
-  // but is not technically correct--if length is too large to fit in a uint32_t
+  // but is not technically correct--if length is too large to fit in a ui32
   // then it will be silently truncated. We will need to fix this if we ever
   // decide to start supporting serialized messages greater than 2 GiB in size.
   return length +
-         io::CodedOutputStream::VarintSize32(static_cast<uint32_t>(length));
+         io::CodedOutputStream::VarintSize32(static_cast<ui32>(length));
 }
 
 template <typename MS>
@@ -2079,7 +1835,7 @@ bool ParseMessageSetItemImpl(io::CodedInputStream* input, MS ms) {
   //   required int32 type_id = 2;
   //   required data message = 3;
 
-  uint32_t last_type_id = 0;
+  ui32 last_type_id = 0;
 
   // If we see message data before the type_id, we'll append it to this so
   // we can parse it later.
@@ -2089,12 +1845,12 @@ bool ParseMessageSetItemImpl(io::CodedInputStream* input, MS ms) {
   State state = State::kNoTag;
 
   while (true) {
-    const uint32_t tag = input->ReadTagNoLastTag();
+    const ui32 tag = input->ReadTagNoLastTag();
     if (tag == 0) return false;
 
     switch (tag) {
       case WireFormatLite::kMessageSetTypeIdTag: {
-        uint32_t type_id;
+        ui32 type_id;
         if (!input->ReadVarint32(&type_id)) return false;
         if (state == State::kNoTag) {
           last_type_id = type_id;
@@ -2125,10 +1881,10 @@ bool ParseMessageSetItemImpl(io::CodedInputStream* input, MS ms) {
           state = State::kDone;
         } else if (state == State::kNoTag) {
           // We haven't seen a type_id yet.  Append this data to message_data.
-          uint32_t length;
+          ui32 length;
           if (!input->ReadVarint32(&length)) return false;
-          if (static_cast<int32_t>(length) < 0) return false;
-          uint32_t size = static_cast<uint32_t>(
+          if (static_cast<i32>(length) < 0) return false;
+          ui32 size = static_cast<ui32>(
               length + io::CodedOutputStream::VarintSize32(length));
           message_data.resize(size);
           auto ptr = reinterpret_cast<uint8_t*>(&message_data[0]);
diff --git a/contrib/libs/protobuf/src/google/protobuf/wrappers.pb.cc b/contrib/libs/protobuf/src/google/protobuf/wrappers.pb.cc
index d1322e96ab..3b1ad529ef 100644
--- a/contrib/libs/protobuf/src/google/protobuf/wrappers.pb.cc
+++ b/contrib/libs/protobuf/src/google/protobuf/wrappers.pb.cc
@@ -43,7 +43,7 @@ struct FloatValueDefaultTypeInternal {
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FloatValueDefaultTypeInternal _FloatValue_default_instance_;
 constexpr Int64Value::Int64Value(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
-  : value_(int64_t{0}){}
+  : value_(i64{0}){}
 struct Int64ValueDefaultTypeInternal {
   constexpr Int64ValueDefaultTypeInternal()
     : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
@@ -55,7 +55,7 @@ struct Int64ValueDefaultTypeInternal {
 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Int64ValueDefaultTypeInternal _Int64Value_default_instance_;
 constexpr UInt64Value::UInt64Value(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
-  : value_(uint64_t{0u}){}
+  : value_(ui64{0u}){}
 struct UInt64ValueDefaultTypeInternal {
   constexpr UInt64ValueDefaultTypeInternal()
     : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
@@ -627,7 +627,7 @@ Int64Value::Int64Value(const Int64Value& from)
 }
 
 void Int64Value::SharedCtor() {
-value_ = int64_t{0};
+value_ = i64{0};
 }
 
 Int64Value::~Int64Value() {
@@ -657,7 +657,7 @@ void Int64Value::Clear() {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  value_ = int64_t{0};
+  value_ = i64{0};
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
@@ -805,7 +805,7 @@ UInt64Value::UInt64Value(const UInt64Value& from)
 }
 
 void UInt64Value::SharedCtor() {
-value_ = uint64_t{0u};
+value_ = ui64{0u};
 }
 
 UInt64Value::~UInt64Value() {
@@ -835,7 +835,7 @@ void UInt64Value::Clear() {
   // Prevent compiler warnings about cached_has_bits being unused
   (void) cached_has_bits;
 
-  value_ = uint64_t{0u};
+  value_ = ui64{0u};
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
 
diff --git a/contrib/libs/protobuf/src/google/protobuf/wrappers.pb.h b/contrib/libs/protobuf/src/google/protobuf/wrappers.pb.h
index 4027d32865..5299a843fb 100644
--- a/contrib/libs/protobuf/src/google/protobuf/wrappers.pb.h
+++ b/contrib/libs/protobuf/src/google/protobuf/wrappers.pb.h
@@ -1453,7 +1453,7 @@ inline void FloatValue::set_value(float value) {
 
 // int64 value = 1;
 inline void Int64Value::clear_value() {
-  value_ = int64_t{0};
+  value_ = i64{0};
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 Int64Value::_internal_value() const {
   return value_;
@@ -1477,7 +1477,7 @@ inline void Int64Value::set_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
 
 // uint64 value = 1;
 inline void UInt64Value::clear_value() {
-  value_ = uint64_t{0u};
+  value_ = ui64{0u};
 }
 inline ::PROTOBUF_NAMESPACE_ID::uint64 UInt64Value::_internal_value() const {
   return value_;
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/command_line_interface.cc b/contrib/libs/protoc/src/google/protobuf/compiler/command_line_interface.cc
index c1ae224e22..35c9cc914e 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/command_line_interface.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/command_line_interface.cc
@@ -201,7 +201,7 @@ bool GetProtocAbsolutePath(TProtoStringType* path) {
   int len = 0;
 
   char dirtybuffer[PATH_MAX];
-  uint32_t size = sizeof(dirtybuffer);
+  ui32 size = sizeof(dirtybuffer);
   if (_NSGetExecutablePath(dirtybuffer, &size) == 0) {
     realpath(dirtybuffer, buffer);
     len = strlen(buffer);
@@ -2149,7 +2149,7 @@ Parse PROTO_FILES and generate output based on the options given:
 }
 
 bool CommandLineInterface::EnforceProto3OptionalSupport(
-    const TProtoStringType& codegen_name, uint64_t supported_features,
+    const TProtoStringType& codegen_name, ui64 supported_features,
     const std::vector<const FileDescriptor*>& parsed_files) const {
   bool supports_proto3_optional =
       supported_features & CodeGenerator::FEATURE_PROTO3_OPTIONAL;
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/command_line_interface.h b/contrib/libs/protoc/src/google/protobuf/compiler/command_line_interface.h
index 337475c693..0e601a4777 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/command_line_interface.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/command_line_interface.h
@@ -230,7 +230,7 @@ class PROTOC_EXPORT CommandLineInterface {
   // Fails if these files use proto3 optional and the code generator doesn't
   // support it. This is a permanent check.
   bool EnforceProto3OptionalSupport(
-      const TProtoStringType& codegen_name, uint64_t supported_features,
+      const TProtoStringType& codegen_name, ui64 supported_features,
       const std::vector<const FileDescriptor*>& parsed_files) const;
 
 
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_enum.cc b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_enum.cc
index 0d3da32158..4f97b1c5e1 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_enum.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_enum.cc
@@ -53,13 +53,13 @@ namespace {
 // is kint32max, GOOGLE_ARRAYSIZE will overflow. In such cases we should omit the
 // generation of the GOOGLE_ARRAYSIZE constant.
 bool ShouldGenerateArraySize(const EnumDescriptor* descriptor) {
-  int32_t max_value = descriptor->value(0)->number();
+  i32 max_value = descriptor->value(0)->number();
   for (int i = 0; i < descriptor->value_count(); i++) {
     if (descriptor->value(i)->number() > max_value) {
       max_value = descriptor->value(i)->number();
     }
   }
-  return max_value != std::numeric_limits<int32_t>::max();
+  return max_value != std::numeric_limits<i32>::max();
 }
 
 // Returns the number of unique numeric enum values. This is less than
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_field.cc b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_field.cc
index 22e2a8a4a6..0cc2dc4175 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_field.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_field.cc
@@ -269,7 +269,7 @@ void SetCommonFieldVariables(const FieldDescriptor* descriptor,
   (*variables)["}"] = "";
 }
 
-void FieldGenerator::SetHasBitIndex(int32_t has_bit_index) {
+void FieldGenerator::SetHasBitIndex(i32 has_bit_index) {
   if (!HasHasbit(descriptor_)) {
     GOOGLE_CHECK_EQ(has_bit_index, -1);
     return;
@@ -282,7 +282,7 @@ void FieldGenerator::SetHasBitIndex(int32_t has_bit_index) {
       strings::Hex(1u << (has_bit_index % 32), strings::ZERO_PAD_8), "u;");
 }
 
-void FieldGenerator::SetInlinedStringIndex(int32_t inlined_string_index) {
+void FieldGenerator::SetInlinedStringIndex(i32 inlined_string_index) {
   if (!IsStringInlined(descriptor_, options_)) {
     GOOGLE_CHECK_EQ(inlined_string_index, -1);
     return;
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_field.h b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_field.h
index d263b10e70..90236d48ae 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_field.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_field.h
@@ -183,8 +183,8 @@ class FieldGenerator {
 
   virtual bool IsInlined() const { return false; }
 
-  void SetHasBitIndex(int32_t has_bit_index);
-  void SetInlinedStringIndex(int32_t inlined_string_index);
+  void SetHasBitIndex(i32 has_bit_index);
+  void SetInlinedStringIndex(i32 inlined_string_index);
 
  protected:
   const FieldDescriptor* descriptor_;
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_helpers.cc b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_helpers.cc
index 308b3164a4..53f46a229b 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_helpers.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_helpers.cc
@@ -635,7 +635,7 @@ const char* DeclaredTypeMethodName(FieldDescriptor::Type type) {
 }
 
 TProtoStringType Int32ToString(int number) {
-  if (number == std::numeric_limits<int32_t>::min()) {
+  if (number == std::numeric_limits<i32>::min()) {
     // This needs to be special-cased, see explanation here:
     // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52661
     return StrCat(number + 1, " - 1");
@@ -644,8 +644,8 @@ TProtoStringType Int32ToString(int number) {
   }
 }
 
-static TProtoStringType Int64ToString(int64_t number) {
-  if (number == std::numeric_limits<int64_t>::min()) {
+static TProtoStringType Int64ToString(i64 number) {
+  if (number == std::numeric_limits<i64>::min()) {
     // This needs to be special-cased, see explanation here:
     // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52661
     return StrCat("int64_t{", number + 1, "} - 1");
@@ -653,7 +653,7 @@ static TProtoStringType Int64ToString(int64_t number) {
   return StrCat("int64_t{", number, "}");
 }
 
-static TProtoStringType UInt64ToString(uint64_t number) {
+static TProtoStringType UInt64ToString(ui64 number) {
   return StrCat("uint64_t{", number, "u}");
 }
 
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_message.cc b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_message.cc
index 7d1535f3b9..98ba9a393a 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_message.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_message.cc
@@ -83,7 +83,7 @@ static constexpr int kNoHasbit = -1;
 // masks is allowed to be shorter than _has_bits_, but at least one element of
 // masks must be non-zero.
 TProtoStringType ConditionalToCheckBitmasks(
-    const std::vector<uint32_t>& masks, bool return_success = true,
+    const std::vector<ui32>& masks, bool return_success = true,
     StringPiece has_bits_var = "_has_bits_") {
   std::vector<TProtoStringType> parts;
   for (int i = 0; i < masks.size(); i++) {
@@ -422,23 +422,23 @@ std::vector<std::vector<const FieldDescriptor*>> CollectFields(
 // Returns a bit mask based on has_bit index of "fields" that are typically on
 // the same chunk. It is used in a group presence check where _has_bits_ is
 // masked to tell if any thing in "fields" is present.
-uint32_t GenChunkMask(const std::vector<const FieldDescriptor*>& fields,
+ui32 GenChunkMask(const std::vector<const FieldDescriptor*>& fields,
                       const std::vector<int>& has_bit_indices) {
   GOOGLE_CHECK(!fields.empty());
   int first_index_offset = has_bit_indices[fields.front()->index()] / 32;
-  uint32_t chunk_mask = 0;
+  ui32 chunk_mask = 0;
   for (auto field : fields) {
     // "index" defines where in the _has_bits_ the field appears.
     int index = has_bit_indices[field->index()];
     GOOGLE_CHECK_EQ(first_index_offset, index / 32);
-    chunk_mask |= static_cast<uint32_t>(1) << (index % 32);
+    chunk_mask |= static_cast<ui32>(1) << (index % 32);
   }
   GOOGLE_CHECK_NE(0, chunk_mask);
   return chunk_mask;
 }
 
 // Return the number of bits set in n, a non-negative integer.
-static int popcnt(uint32_t n) {
+static int popcnt(ui32 n) {
   int result = 0;
   while (n != 0) {
     result += (n & 1);
@@ -524,7 +524,7 @@ void ColdChunkSkipper::OnStartChunk(int chunk, int cached_has_word_index,
   format("if (PROTOBUF_PREDICT_FALSE(");
   int first_word = HasbitWord(chunk, 0);
   while (chunk < limit_chunk_) {
-    uint32_t mask = 0;
+    ui32 mask = 0;
     int this_word = HasbitWord(chunk, 0);
     // Generate mask for chunks on the same word.
     for (; chunk < limit_chunk_ && HasbitWord(chunk, 0) == this_word; chunk++) {
@@ -2088,7 +2088,7 @@ namespace {
 
 // We need to calculate for each field what function the table driven code
 // should use to serialize it. This returns the index in a lookup table.
-uint32_t CalcFieldNum(const FieldGenerator& generator,
+ui32 CalcFieldNum(const FieldGenerator& generator,
                       const FieldDescriptor* field, const Options& options) {
   bool is_a_map = IsMapEntryMessage(field->containing_type());
   int type = field->type();
@@ -2143,7 +2143,7 @@ int MessageGenerator::GenerateFieldMetadata(io::Printer* printer) {
       const FieldDescriptor* field = sorted[i];
       const FieldGenerator& generator = field_generators_.get(field);
 
-      uint32_t tag = internal::WireFormatLite::MakeTag(
+      ui32 tag = internal::WireFormatLite::MakeTag(
           field->number(), WireFormat::WireTypeForFieldType(field->type()));
 
       std::map<TProtoStringType, TProtoStringType> vars;
@@ -2200,7 +2200,7 @@ int MessageGenerator::GenerateFieldMetadata(io::Printer* printer) {
     if (i == sorted.size()) break;
     const FieldDescriptor* field = sorted[i];
 
-    uint32_t tag = internal::WireFormatLite::MakeTag(
+    ui32 tag = internal::WireFormatLite::MakeTag(
         field->number(), WireFormat::WireTypeForFieldType(field->type()));
     if (field->is_packed()) {
       tag = internal::WireFormatLite::MakeTag(
@@ -2263,7 +2263,7 @@ int MessageGenerator::GenerateFieldMetadata(io::Printer* printer) {
           tag);
     } else if (field->real_containing_oneof()) {
       format.Set("oneofoffset",
-                 sizeof(uint32_t) * field->containing_oneof()->index());
+                 sizeof(ui32) * field->containing_oneof()->index());
       format(
           "{PROTOBUF_FIELD_OFFSET($classtype$, $field_name$_), $1$,"
           " PROTOBUF_FIELD_OFFSET($classtype$, _oneof_case_) + "
@@ -2374,7 +2374,7 @@ void MessageGenerator::GenerateClassMethods(io::Printer* printer) {
     }
   }
   if (num_required_fields_ > 0) {
-    const std::vector<uint32_t> masks_for_has_bits = RequiredFieldsBitMask();
+    const std::vector<ui32> masks_for_has_bits = RequiredFieldsBitMask();
     format(
         "static bool MissingRequiredFields(const HasBits& has_bits) "
         "{\n"
@@ -3285,7 +3285,7 @@ void MessageGenerator::GenerateClear(io::Printer* printer) {
 
     if (have_outer_if) {
       // Emit an if() that will let us skip the whole chunk if none are set.
-      uint32_t chunk_mask = GenChunkMask(chunk, has_bit_indices_);
+      ui32 chunk_mask = GenChunkMask(chunk, has_bit_indices_);
       TProtoStringType chunk_mask_str =
           StrCat(strings::Hex(chunk_mask, strings::ZERO_PAD_8));
 
@@ -3599,7 +3599,7 @@ void MessageGenerator::GenerateClassSpecificMergeFrom(io::Printer* printer) {
 
     if (have_outer_if) {
       // Emit an if() that will let us skip the whole chunk if none are set.
-      uint32_t chunk_mask = GenChunkMask(chunk, has_bit_indices_);
+      ui32 chunk_mask = GenChunkMask(chunk, has_bit_indices_);
       TProtoStringType chunk_mask_str =
           StrCat(strings::Hex(chunk_mask, strings::ZERO_PAD_8));
 
@@ -4220,9 +4220,9 @@ void MessageGenerator::GenerateSerializeWithCachedSizesBodyShuffled(
   format("}\n");
 }
 
-std::vector<uint32_t> MessageGenerator::RequiredFieldsBitMask() const {
+std::vector<ui32> MessageGenerator::RequiredFieldsBitMask() const {
   const int array_size = HasBitsSize();
-  std::vector<uint32_t> masks(array_size, 0);
+  std::vector<ui32> masks(array_size, 0);
 
   for (auto field : FieldRange(descriptor_)) {
     if (!field->is_required()) {
@@ -4230,7 +4230,7 @@ std::vector<uint32_t> MessageGenerator::RequiredFieldsBitMask() const {
     }
 
     const int has_bit_index = has_bit_indices_[field->index()];
-    masks[has_bit_index / 32] |= static_cast<uint32_t>(1)
+    masks[has_bit_index / 32] |= static_cast<ui32>(1)
                                  << (has_bit_index % 32);
   }
   return masks;
@@ -4315,7 +4315,7 @@ void MessageGenerator::GenerateByteSize(io::Printer* printer) {
   // present then the fast path executes; otherwise the slow path executes.
   if (num_required_fields_ > 1) {
     // The fast path works if all required fields are present.
-    const std::vector<uint32_t> masks_for_has_bits = RequiredFieldsBitMask();
+    const std::vector<ui32> masks_for_has_bits = RequiredFieldsBitMask();
     format("if ($1$) {  // All required fields are present.\n",
            ConditionalToCheckBitmasks(masks_for_has_bits));
     format.Indent();
@@ -4371,7 +4371,7 @@ void MessageGenerator::GenerateByteSize(io::Printer* printer) {
 
     if (have_outer_if) {
       // Emit an if() that will let us skip the whole chunk if none are set.
-      uint32_t chunk_mask = GenChunkMask(chunk, has_bit_indices_);
+      ui32 chunk_mask = GenChunkMask(chunk, has_bit_indices_);
       TProtoStringType chunk_mask_str =
           StrCat(strings::Hex(chunk_mask, strings::ZERO_PAD_8));
 
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_message.h b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_message.h
index 1e4e942d69..8bd87df416 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_message.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_message.h
@@ -183,7 +183,7 @@ class MessageGenerator {
   int HasByteIndex(const FieldDescriptor* a) const;
   int HasWordIndex(const FieldDescriptor* a) const;
   bool SameHasByte(const FieldDescriptor* a, const FieldDescriptor* b) const;
-  std::vector<uint32_t> RequiredFieldsBitMask() const;
+  std::vector<ui32> RequiredFieldsBitMask() const;
 
   const Descriptor* descriptor_;
   int index_in_file_messages_;
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_parse_function_generator.cc b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_parse_function_generator.cc
index 93d44864c3..d8c8739035 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_parse_function_generator.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_parse_function_generator.cc
@@ -66,7 +66,7 @@ bool HasInternalAccessors(const FieldOptions::CType ctype) {
   return ctype == FieldOptions::STRING || ctype == FieldOptions::CORD;
 }
 
-int TagSize(uint32_t field_number) {
+int TagSize(ui32 field_number) {
   if (field_number < 16) return 1;
   GOOGLE_CHECK_LT(field_number, (1 << 14))
       << "coded tag for " << field_number << " too big for uint16_t";
@@ -109,7 +109,7 @@ TProtoStringType MessageTcParseFunctionName(const FieldDescriptor* field,
 
 TProtoStringType FieldParseFunctionName(const FieldDescriptor* field,
                                    const Options& options,
-                                   uint32_t table_size_log2);
+                                   ui32 table_size_log2);
 
 }  // namespace
 
@@ -152,7 +152,7 @@ TailCallTableInfo::TailCallTableInfo(const Descriptor* descriptor,
     //   byte 0   byte 1
     //   1nnnnttt 0nnnnnnn
     //    ^^^^^^^  ^^^^^^^
-    uint32_t tag = WireFormat::MakeTag(field);
+    ui32 tag = WireFormat::MakeTag(field);
     if (tag >= 1 << 14) {
       continue;
     } else if (tag >= 1 << 7) {
@@ -167,7 +167,7 @@ TailCallTableInfo::TailCallTableInfo(const Descriptor* descriptor,
     //   ^^^^^
     // This means that any field number that does not fit in the lower 4 bits
     // will always have the top bit of its table index asserted:
-    uint32_t idx = (tag >> 3) & (table_size - 1);
+    ui32 idx = (tag >> 3) & (table_size - 1);
     // If this entry in the table is already used, then this field will be
     // handled by the generated fallback function.
     if (!fast_path_fields[idx].func_name.empty()) continue;
@@ -834,7 +834,7 @@ void ParseFunctionGenerator::GenerateFieldBody(
         {{"put_field", StrCat("set_", FieldName(field))},
          {"mutable_field", StrCat("mutable_", FieldName(field))}});
   }
-  uint32_t tag = WireFormatLite::MakeTag(field->number(), wiretype);
+  ui32 tag = WireFormatLite::MakeTag(field->number(), wiretype);
   switch (wiretype) {
     case WireFormatLite::WIRETYPE_VARINT: {
       TProtoStringType type = PrimitiveTypeName(options_, field->cpp_type());
@@ -925,15 +925,15 @@ void ParseFunctionGenerator::GenerateFieldBody(
 
 // Returns the tag for this field and in case of repeated packable fields,
 // sets a fallback tag in fallback_tag_ptr.
-static uint32_t ExpectedTag(const FieldDescriptor* field,
-                            uint32_t* fallback_tag_ptr) {
-  uint32_t expected_tag;
+static ui32 ExpectedTag(const FieldDescriptor* field,
+                            ui32* fallback_tag_ptr) {
+  ui32 expected_tag;
   if (field->is_packable()) {
     auto expected_wiretype = WireFormat::WireTypeForFieldType(field->type());
     expected_tag = WireFormatLite::MakeTag(field->number(), expected_wiretype);
     GOOGLE_CHECK(expected_wiretype != WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
     auto fallback_wiretype = WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
-    uint32_t fallback_tag =
+    ui32 fallback_tag =
         WireFormatLite::MakeTag(field->number(), fallback_wiretype);
 
     if (field->is_packed()) std::swap(expected_tag, fallback_tag);
@@ -996,9 +996,9 @@ void ParseFunctionGenerator::GenerateParseIterationBody(
             descriptor->extension_range(i);
         if (i > 0) format(" ||\n    ");
 
-        uint32_t start_tag = WireFormatLite::MakeTag(
+        ui32 start_tag = WireFormatLite::MakeTag(
             range->start, static_cast<WireFormatLite::WireType>(0));
-        uint32_t end_tag = WireFormatLite::MakeTag(
+        ui32 end_tag = WireFormatLite::MakeTag(
             range->end, static_cast<WireFormatLite::WireType>(0));
 
         if (range->end > FieldDescriptor::kMaxNumber) {
@@ -1035,13 +1035,13 @@ void ParseFunctionGenerator::GenerateFieldSwitch(
     PrintFieldComment(format, field);
     format("case $1$:\n", field->number());
     format.Indent();
-    uint32_t fallback_tag = 0;
-    uint32_t expected_tag = ExpectedTag(field, &fallback_tag);
+    ui32 fallback_tag = 0;
+    ui32 expected_tag = ExpectedTag(field, &fallback_tag);
     format("if (PROTOBUF_PREDICT_TRUE(static_cast<$uint8$>(tag) == $1$)) {\n",
            expected_tag & 0xFF);
     format.Indent();
     auto wiretype = WireFormatLite::GetTagWireType(expected_tag);
-    uint32_t tag = WireFormatLite::MakeTag(field->number(), wiretype);
+    ui32 tag = WireFormatLite::MakeTag(field->number(), wiretype);
     int tag_size = io::CodedOutputStream::VarintSize32(tag);
     bool is_repeat = ShouldRepeat(field, wiretype);
     if (is_repeat) {
@@ -1087,7 +1087,7 @@ namespace {
 
 TProtoStringType FieldParseFunctionName(const FieldDescriptor* field,
                                    const Options& options,
-                                   uint32_t table_size_log2) {
+                                   ui32 table_size_log2) {
   ParseCardinality card =  //
       field->is_packed()               ? ParseCardinality::kPacked
       : field->is_repeated()           ? ParseCardinality::kRepeated
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_parse_function_generator.h b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_parse_function_generator.h
index 34c8fc488b..71eb82626f 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_parse_function_generator.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/cpp/cpp_parse_function_generator.h
@@ -65,7 +65,7 @@ struct TailCallTableInfo {
   // Table size.
   int table_size_log2;
   // Mask for has-bits of required fields.
-  uint32_t has_hasbits_required_mask;
+  ui32 has_hasbits_required_mask;
   // True if a generated fallback function is required instead of generic.
   bool use_generated_fallback;
 };
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_enum.h b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_enum.h
index e409c2e4b2..dcbfba36df 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_enum.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_enum.h
@@ -63,4 +63,3 @@ class EnumGenerator : public SourceGeneratorBase {
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_ENUM_H__
-
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_enum_field.h b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_enum_field.h
index e282d72390..b887a28734 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_enum_field.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_enum_field.h
@@ -80,4 +80,3 @@ class EnumOneofFieldGenerator : public PrimitiveOneofFieldGenerator {
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_ENUM_FIELD_H__
-
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_field_base.h b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_field_base.h
index aa1184c423..154f67ae9c 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_field_base.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_field_base.h
@@ -108,4 +108,3 @@ class FieldGeneratorBase : public SourceGeneratorBase {
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_FIELD_BASE_H__
-
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_map_field.h b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_map_field.h
index 9b5e214e6d..e8212498c9 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_map_field.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_map_field.h
@@ -72,4 +72,3 @@ class MapFieldGenerator : public FieldGeneratorBase {
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_MAP_FIELD_H__
-
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_message_field.h b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_message_field.h
index 1436fe2008..1da8bea08d 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_message_field.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_message_field.h
@@ -90,4 +90,3 @@ class MessageOneofFieldGenerator : public MessageFieldGenerator {
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_MESSAGE_FIELD_H__
-
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_primitive_field.h b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_primitive_field.h
index a2c11050e2..f0dbfad791 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_primitive_field.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_primitive_field.h
@@ -94,4 +94,3 @@ class PrimitiveOneofFieldGenerator : public PrimitiveFieldGenerator {
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_PRIMITIVE_FIELD_H__
-
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.h b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.h
index 2e265702fb..23d3c0daba 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.h
@@ -76,4 +76,3 @@ class RepeatedEnumFieldGenerator : public FieldGeneratorBase {
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_REPEATED_ENUM_FIELD_H__
-
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.h b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.h
index a2267adf3d..c584f2bd6f 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.h
@@ -76,4 +76,3 @@ class RepeatedMessageFieldGenerator : public FieldGeneratorBase {
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_REPEATED_MESSAGE_FIELD_H__
-
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h
index d432f37b2f..36be81d069 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h
@@ -72,4 +72,3 @@ class RepeatedPrimitiveFieldGenerator : public FieldGeneratorBase {
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_REPEATED_PRIMITIVE_FIELD_H__
-
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_source_generator_base.h b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_source_generator_base.h
index 5938d5d1fd..9206cd3309 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_source_generator_base.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/csharp/csharp_source_generator_base.h
@@ -68,4 +68,3 @@ class SourceGeneratorBase {
 }  // namespace google
 
 #endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_SOURCE_GENERATOR_BASE_H__
-
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_enum_field.cc b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_enum_field.cc
index 318c820198..9c32e1821b 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_enum_field.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_enum_field.cc
@@ -70,7 +70,7 @@ void SetEnumVariables(const FieldDescriptor* descriptor, int messageBitIndex,
   (*variables)["default_number"] =
       StrCat(descriptor->default_value_enum()->number());
   (*variables)["tag"] = StrCat(
-      static_cast<int32_t>(internal::WireFormat::MakeTag(descriptor)));
+      static_cast<i32>(internal::WireFormat::MakeTag(descriptor)));
   (*variables)["tag_size"] = StrCat(
       internal::WireFormat::TagSize(descriptor->number(), GetType(descriptor)));
   // TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_enum_field_lite.cc b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_enum_field_lite.cc
index 91b6b4842e..73ef7ddfa4 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_enum_field_lite.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_enum_field_lite.cc
@@ -77,7 +77,7 @@ void SetEnumVariables(const FieldDescriptor* descriptor, int messageBitIndex,
   (*variables)["default_number"] =
       StrCat(descriptor->default_value_enum()->number());
   (*variables)["tag"] = StrCat(
-      static_cast<int32_t>(internal::WireFormat::MakeTag(descriptor)));
+      static_cast<i32>(internal::WireFormat::MakeTag(descriptor)));
   (*variables)["tag_size"] = StrCat(
       internal::WireFormat::TagSize(descriptor->number(), GetType(descriptor)));
   // TODO(birdo): Add @deprecated javadoc when generating javadoc is supported
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.cc b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.cc
index a498388ade..161565a62d 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.cc
@@ -576,11 +576,11 @@ TProtoStringType DefaultValue(const FieldDescriptor* field, bool immutable,
       return StrCat(field->default_value_int32());
     case FieldDescriptor::CPPTYPE_UINT32:
       // Need to print as a signed int since Java has no unsigned.
-      return StrCat(static_cast<int32_t>(field->default_value_uint32()));
+      return StrCat(static_cast<i32>(field->default_value_uint32()));
     case FieldDescriptor::CPPTYPE_INT64:
       return StrCat(field->default_value_int64()) + "L";
     case FieldDescriptor::CPPTYPE_UINT64:
-      return StrCat(static_cast<int64_t>(field->default_value_uint64())) +
+      return StrCat(static_cast<i64>(field->default_value_uint64())) +
              "L";
     case FieldDescriptor::CPPTYPE_DOUBLE: {
       double value = field->default_value_double();
@@ -972,7 +972,7 @@ bool HasRepeatedFields(const Descriptor* descriptor) {
 //
 // Note that we only use code points in [0x0000, 0xD7FF] and [0xE000, 0xFFFF].
 // There will be no surrogate pairs in the encoded character sequence.
-void WriteUInt32ToUtf16CharSequence(uint32_t number,
+void WriteUInt32ToUtf16CharSequence(ui32 number,
                                     std::vector<uint16_t>* output) {
   // For values in [0x0000, 0xD7FF], only use one char to encode it.
   if (number < 0xD800) {
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.h b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.h
index 5acc729c1d..487b43f13e 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_helpers.h
@@ -426,12 +426,12 @@ inline TProtoStringType GeneratedCodeVersionSuffix() {
   return "V3";
 }
 
-void WriteUInt32ToUtf16CharSequence(uint32_t number,
+void WriteUInt32ToUtf16CharSequence(ui32 number,
                                     std::vector<uint16_t>* output);
 
 inline void WriteIntToUtf16CharSequence(int value,
                                         std::vector<uint16_t>* output) {
-  WriteUInt32ToUtf16CharSequence(static_cast<uint32_t>(value), output);
+  WriteUInt32ToUtf16CharSequence(static_cast<ui32>(value), output);
 }
 
 // Escape a UTF-16 character so it can be embedded in a Java string literal.
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_message.cc b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_message.cc
index 3cc9c24e90..b245106ab7 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_message.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_message.cc
@@ -1222,11 +1222,11 @@ void ImmutableMessageGenerator::GenerateParsingConstructor(
 
   for (int i = 0; i < descriptor_->field_count(); i++) {
     const FieldDescriptor* field = sorted_fields[i];
-    uint32_t tag = WireFormatLite::MakeTag(
+    ui32 tag = WireFormatLite::MakeTag(
         field->number(), WireFormat::WireTypeForFieldType(field->type()));
 
     printer->Print("case $tag$: {\n", "tag",
-                   StrCat(static_cast<int32_t>(tag)));
+                   StrCat(static_cast<i32>(tag)));
     printer->Indent();
 
     field_generators_.get(field).GenerateParsingCode(printer);
@@ -1239,10 +1239,10 @@ void ImmutableMessageGenerator::GenerateParsingConstructor(
     if (field->is_packable()) {
       // To make packed = true wire compatible, we generate parsing code from a
       // packed version of this field regardless of field->options().packed().
-      uint32_t packed_tag = WireFormatLite::MakeTag(
+      ui32 packed_tag = WireFormatLite::MakeTag(
           field->number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
       printer->Print("case $tag$: {\n", "tag",
-                     StrCat(static_cast<int32_t>(packed_tag)));
+                     StrCat(static_cast<i32>(packed_tag)));
       printer->Indent();
 
       field_generators_.get(field).GenerateParsingCodeFromPacked(printer);
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_primitive_field.cc b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_primitive_field.cc
index ab550761b1..a90dc71d0a 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_primitive_field.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_primitive_field.cc
@@ -114,7 +114,7 @@ void SetPrimitiveVariables(const FieldDescriptor* descriptor,
   (*variables)["capitalized_type"] =
       GetCapitalizedType(descriptor, /* immutable = */ true);
   (*variables)["tag"] =
-      StrCat(static_cast<int32_t>(WireFormat::MakeTag(descriptor)));
+      StrCat(static_cast<i32>(WireFormat::MakeTag(descriptor)));
   (*variables)["tag_size"] = StrCat(
       WireFormat::TagSize(descriptor->number(), GetType(descriptor)));
   if (IsReferenceType(GetJavaType(descriptor))) {
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_primitive_field_lite.cc b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_primitive_field_lite.cc
index 35f78fce9e..16ad9881c9 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_primitive_field_lite.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_primitive_field_lite.cc
@@ -80,7 +80,7 @@ void SetPrimitiveVariables(const FieldDescriptor* descriptor,
   (*variables)["capitalized_type"] =
       GetCapitalizedType(descriptor, /* immutable = */ true);
   (*variables)["tag"] =
-      StrCat(static_cast<int32_t>(WireFormat::MakeTag(descriptor)));
+      StrCat(static_cast<i32>(WireFormat::MakeTag(descriptor)));
   (*variables)["tag_size"] = StrCat(
       WireFormat::TagSize(descriptor->number(), GetType(descriptor)));
   (*variables)["required"] = descriptor->is_required() ? "true" : "false";
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_string_field.cc b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_string_field.cc
index ac17bb77fd..6b4b058eba 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_string_field.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_string_field.cc
@@ -73,7 +73,7 @@ void SetPrimitiveVariables(const FieldDescriptor* descriptor,
       "= " + ImmutableDefaultValue(descriptor, name_resolver);
   (*variables)["capitalized_type"] = "String";
   (*variables)["tag"] =
-      StrCat(static_cast<int32_t>(WireFormat::MakeTag(descriptor)));
+      StrCat(static_cast<i32>(WireFormat::MakeTag(descriptor)));
   (*variables)["tag_size"] = StrCat(
       WireFormat::TagSize(descriptor->number(), GetType(descriptor)));
   (*variables)["null_check"] =
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_string_field_lite.cc b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_string_field_lite.cc
index bfaedeba9a..b448ae8930 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/java/java_string_field_lite.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/java/java_string_field_lite.cc
@@ -74,7 +74,7 @@ void SetPrimitiveVariables(const FieldDescriptor* descriptor,
       "= " + ImmutableDefaultValue(descriptor, name_resolver);
   (*variables)["capitalized_type"] = "java.lang.String";
   (*variables)["tag"] =
-      StrCat(static_cast<int32_t>(WireFormat::MakeTag(descriptor)));
+      StrCat(static_cast<i32>(WireFormat::MakeTag(descriptor)));
   (*variables)["tag_size"] = StrCat(
       WireFormat::TagSize(descriptor->number(), GetType(descriptor)));
   // We use `x.getClass()` as a null check because it generates less bytecode
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/parser.cc b/contrib/libs/protoc/src/google/protobuf/compiler/parser.cc
index fa3dffbdb6..0e8d1fe6e3 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/parser.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/parser.cc
@@ -242,9 +242,9 @@ bool Parser::ConsumeIdentifier(TProtoStringType* output, const char* error) {
 
 bool Parser::ConsumeInteger(int* output, const char* error) {
   if (LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
-    uint64 value = 0;
+    ui64 value = 0;
     if (!io::Tokenizer::ParseInteger(input_->current().text,
-                                     std::numeric_limits<int32_t>::max(),
+                                     std::numeric_limits<i32>::max(),
                                      &value)) {
       AddError("Integer out of range.");
       // We still return true because we did, in fact, parse an integer.
@@ -260,29 +260,27 @@ bool Parser::ConsumeInteger(int* output, const char* error) {
 
 bool Parser::ConsumeSignedInteger(int* output, const char* error) {
   bool is_negative = false;
-  uint64_t max_value = std::numeric_limits<int32_t>::max();
+  ui64 max_value = std::numeric_limits<i32>::max();
   if (TryConsume("-")) {
     is_negative = true;
     max_value += 1;
   }
-  uint64_t value = 0;
+  ui64 value = 0;
   DO(ConsumeInteger64(max_value, &value, error));
   if (is_negative) value *= -1;
   *output = value;
   return true;
 }
 
-bool Parser::ConsumeInteger64(uint64_t max_value, uint64_t* output,
+bool Parser::ConsumeInteger64(ui64 max_value, ui64* output,
                               const char* error) {
   if (LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
-    uint64 parsed;
     if (!io::Tokenizer::ParseInteger(input_->current().text, max_value,
-                                     &parsed)) {
+                                     output)) {
       AddError("Integer out of range.");
       // We still return true because we did, in fact, parse an integer.
-      parsed = 0;
+      *output = 0;
     }
-    *output = parsed;
     input_->Next();
     return true;
   } else {
@@ -298,9 +296,9 @@ bool Parser::ConsumeNumber(double* output, const char* error) {
     return true;
   } else if (LookingAtType(io::Tokenizer::TYPE_INTEGER)) {
     // Also accept integers.
-    uint64 value = 0;
+    ui64 value = 0;
     if (!io::Tokenizer::ParseInteger(input_->current().text,
-                                     std::numeric_limits<uint64_t>::max(),
+                                     std::numeric_limits<ui64>::max(),
                                      &value)) {
       AddError("Integer out of range.");
       // We still return true because we did, in fact, parse a number.
@@ -829,7 +827,7 @@ bool IsMessageSetWireFormatMessage(const DescriptorProto& message) {
 void AdjustExtensionRangesWithMaxEndNumber(DescriptorProto* message) {
   const bool is_message_set = IsMessageSetWireFormatMessage(*message);
   const int max_extension_number = is_message_set
-                                       ? std::numeric_limits<int32_t>::max()
+                                       ? std::numeric_limits<i32>::max()
                                        : FieldDescriptor::kMaxNumber + 1;
   for (int i = 0; i < message->extension_range_size(); ++i) {
     if (message->extension_range(i).end() == kMaxRangeSentinel) {
@@ -844,7 +842,7 @@ void AdjustExtensionRangesWithMaxEndNumber(DescriptorProto* message) {
 void AdjustReservedRangesWithMaxEndNumber(DescriptorProto* message) {
   const bool is_message_set = IsMessageSetWireFormatMessage(*message);
   const int max_field_number = is_message_set
-                                   ? std::numeric_limits<int32_t>::max()
+                                   ? std::numeric_limits<i32>::max()
                                    : FieldDescriptor::kMaxNumber + 1;
   for (int i = 0; i < message->reserved_range_size(); ++i) {
     if (message->reserved_range(i).end() == kMaxRangeSentinel) {
@@ -1261,11 +1259,11 @@ bool Parser::ParseDefaultAssignment(
     case FieldDescriptorProto::TYPE_SINT64:
     case FieldDescriptorProto::TYPE_SFIXED32:
     case FieldDescriptorProto::TYPE_SFIXED64: {
-      uint64_t max_value = std::numeric_limits<int64_t>::max();
+      ui64 max_value = std::numeric_limits<i64>::max();
       if (field->type() == FieldDescriptorProto::TYPE_INT32 ||
           field->type() == FieldDescriptorProto::TYPE_SINT32 ||
           field->type() == FieldDescriptorProto::TYPE_SFIXED32) {
-        max_value = std::numeric_limits<int32_t>::max();
+        max_value = std::numeric_limits<i32>::max();
       }
 
       // These types can be negative.
@@ -1275,7 +1273,7 @@ bool Parser::ParseDefaultAssignment(
         ++max_value;
       }
       // Parse the integer to verify that it is not out-of-range.
-      uint64_t value;
+      ui64 value;
       DO(ConsumeInteger64(max_value, &value,
                           "Expected integer for field default value."));
       // And stringify it again.
@@ -1287,10 +1285,10 @@ bool Parser::ParseDefaultAssignment(
     case FieldDescriptorProto::TYPE_UINT64:
     case FieldDescriptorProto::TYPE_FIXED32:
     case FieldDescriptorProto::TYPE_FIXED64: {
-      uint64_t max_value = std::numeric_limits<uint64_t>::max();
+      ui64 max_value = std::numeric_limits<ui64>::max();
       if (field->type() == FieldDescriptorProto::TYPE_UINT32 ||
           field->type() == FieldDescriptorProto::TYPE_FIXED32) {
-        max_value = std::numeric_limits<uint32_t>::max();
+        max_value = std::numeric_limits<ui32>::max();
       }
 
       // Numeric, not negative.
@@ -1298,7 +1296,7 @@ bool Parser::ParseDefaultAssignment(
         AddError("Unsigned field can't have negative default value.");
       }
       // Parse the integer to verify that it is not out-of-range.
-      uint64_t value;
+      ui64 value;
       DO(ConsumeInteger64(max_value, &value,
                           "Expected integer for field default value."));
       // And stringify it again.
@@ -1530,17 +1528,17 @@ bool Parser::ParseOption(Message* options,
       }
 
       case io::Tokenizer::TYPE_INTEGER: {
-        uint64_t value;
-        uint64_t max_value =
+        ui64 value;
+        ui64 max_value =
             is_negative
-                ? static_cast<uint64_t>(std::numeric_limits<int64_t>::max()) + 1
-                : std::numeric_limits<uint64_t>::max();
+                ? static_cast<ui64>(std::numeric_limits<i64>::max()) + 1
+                : std::numeric_limits<ui64>::max();
         DO(ConsumeInteger64(max_value, &value, "Expected integer."));
         if (is_negative) {
           value_location.AddPath(
               UninterpretedOption::kNegativeIntValueFieldNumber);
           uninterpreted_option->set_negative_int_value(
-              static_cast<int64_t>(-value));
+              static_cast<i64>(-value));
         } else {
           value_location.AddPath(
               UninterpretedOption::kPositiveIntValueFieldNumber);
@@ -2340,8 +2338,8 @@ bool Parser::ParsePackage(FileDescriptorProto* file,
 }
 
 bool Parser::ParseImport(RepeatedPtrField<TProtoStringType>* dependency,
-                         RepeatedField<int32_t>* public_dependency,
-                         RepeatedField<int32_t>* weak_dependency,
+                         RepeatedField<i32>* public_dependency,
+                         RepeatedField<i32>* weak_dependency,
                          const LocationRecorder& root_location,
                          const FileDescriptorProto* containing_file) {
   LocationRecorder location(root_location,
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/parser.h b/contrib/libs/protoc/src/google/protobuf/compiler/parser.h
index ca42449a95..b7c487405b 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/parser.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/parser.h
@@ -175,7 +175,7 @@ class PROTOBUF_EXPORT Parser {
   bool ConsumeSignedInteger(int* output, const char* error);
   // Consume a 64-bit integer and store its value in "output".  If the value
   // is greater than max_value, an error will be reported.
-  bool ConsumeInteger64(uint64_t max_value, uint64_t* output,
+  bool ConsumeInteger64(ui64 max_value, ui64* output,
                         const char* error);
   // Consume a number and store its value in "output".  This will accept
   // tokens of either INTEGER or FLOAT type.
@@ -327,8 +327,8 @@ class PROTOBUF_EXPORT Parser {
                     const LocationRecorder& root_location,
                     const FileDescriptorProto* containing_file);
   bool ParseImport(RepeatedPtrField<TProtoStringType>* dependency,
-                   RepeatedField<int32_t>* public_dependency,
-                   RepeatedField<int32_t>* weak_dependency,
+                   RepeatedField<i32>* public_dependency,
+                   RepeatedField<i32>* weak_dependency,
                    const LocationRecorder& root_location,
                    const FileDescriptorProto* containing_file);
 
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/plugin.pb.cc b/contrib/libs/protoc/src/google/protobuf/compiler/plugin.pb.cc
index d7f4aea2e6..cf849bb168 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/plugin.pb.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/plugin.pb.cc
@@ -67,7 +67,7 @@ constexpr CodeGeneratorResponse::CodeGeneratorResponse(
   ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
   : file_()
   , error_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
-  , supported_features_(uint64_t{0u}){}
+  , supported_features_(ui64{0u}){}
 struct CodeGeneratorResponseDefaultTypeInternal {
   constexpr CodeGeneratorResponseDefaultTypeInternal()
     : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
@@ -1282,7 +1282,7 @@ CodeGeneratorResponse::CodeGeneratorResponse(const CodeGeneratorResponse& from)
 
 void CodeGeneratorResponse::SharedCtor() {
 error_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
-supported_features_ = uint64_t{0u};
+supported_features_ = ui64{0u};
 }
 
 CodeGeneratorResponse::~CodeGeneratorResponse() {
@@ -1318,7 +1318,7 @@ void CodeGeneratorResponse::Clear() {
   if (cached_has_bits & 0x00000001u) {
     error_.ClearNonDefaultToEmpty();
   }
-  supported_features_ = uint64_t{0u};
+  supported_features_ = ui64{0u};
   _has_bits_.Clear();
   _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 }
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/plugin.pb.h b/contrib/libs/protoc/src/google/protobuf/compiler/plugin.pb.h
index 3b198910a1..63d5f0b323 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/plugin.pb.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/plugin.pb.h
@@ -1741,7 +1741,7 @@ inline bool CodeGeneratorResponse::has_supported_features() const {
   return _internal_has_supported_features();
 }
 inline void CodeGeneratorResponse::clear_supported_features() {
-  supported_features_ = uint64_t{0u};
+  supported_features_ = ui64{0u};
   _has_bits_[0] &= ~0x00000002u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::uint64 CodeGeneratorResponse::_internal_supported_features() const {
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/zip_writer.cc b/contrib/libs/protoc/src/google/protobuf/compiler/zip_writer.cc
index 40bac12e40..2a7fa391fc 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/zip_writer.cc
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/zip_writer.cc
@@ -47,7 +47,7 @@ namespace compiler {
 // see https://msdn.microsoft.com/en-us/library/9kkf9tah.aspx
 static const uint16_t kDosEpoch = 1 << 5 | 1;
 
-static const uint32_t kCRC32Table[256] = {
+static const ui32 kCRC32Table[256] = {
     0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
     0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
     0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
@@ -92,8 +92,8 @@ static const uint32_t kCRC32Table[256] = {
     0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
     0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
 
-static uint32_t ComputeCRC32(const TProtoStringType& buf) {
-  uint32_t x = ~0U;
+static ui32 ComputeCRC32(const TProtoStringType& buf) {
+  ui32 x = ~0U;
   for (int i = 0; i < buf.size(); ++i) {
     unsigned char c = buf[i];
     x = kCRC32Table[(x ^ c) & 0xff] ^ (x >> 8);
@@ -145,16 +145,16 @@ bool ZipWriter::Write(const TProtoStringType& filename,
 
 bool ZipWriter::WriteDirectory() {
   uint16_t num_entries = files_.size();
-  uint32_t dir_ofs = raw_output_->ByteCount();
+  ui32 dir_ofs = raw_output_->ByteCount();
 
   // write central directory
   io::CodedOutputStream output(raw_output_);
   for (int i = 0; i < num_entries; ++i) {
     const TProtoStringType& filename = files_[i].name;
     uint16_t filename_size = filename.size();
-    uint32_t crc32 = files_[i].crc32;
-    uint32_t size = files_[i].size;
-    uint32_t offset = files_[i].offset;
+    ui32 crc32 = files_[i].crc32;
+    ui32 size = files_[i].size;
+    ui32 offset = files_[i].offset;
 
     output.WriteLittleEndian32(0x02014b50);  // magic
     WriteShort(&output, 10);                 // version made by
@@ -175,7 +175,7 @@ bool ZipWriter::WriteDirectory() {
     output.WriteLittleEndian32(offset);      // local header offset
     output.WriteString(filename);            // file name
   }
-  uint32_t dir_len = output.ByteCount();
+  ui32 dir_len = output.ByteCount();
 
   // write end of central directory marker
   output.WriteLittleEndian32(0x06054b50);  // magic
diff --git a/contrib/libs/protoc/src/google/protobuf/compiler/zip_writer.h b/contrib/libs/protoc/src/google/protobuf/compiler/zip_writer.h
index a1ce179d89..2d8c0c67b5 100644
--- a/contrib/libs/protoc/src/google/protobuf/compiler/zip_writer.h
+++ b/contrib/libs/protoc/src/google/protobuf/compiler/zip_writer.h
@@ -51,9 +51,9 @@ class ZipWriter {
  private:
   struct FileInfo {
     TProtoStringType name;
-    uint32_t offset;
-    uint32_t size;
-    uint32_t crc32;
+    ui32 offset;
+    ui32 size;
+    ui32 crc32;
   };
 
   io::ZeroCopyOutputStream* raw_output_;