feat: Implement 128-bit integer read/write functions in FastIO and add corresponding test

Author: weilycoder

test/many_aplusb_128bit.test.cpp

@@ -0,0 +1,16 @@
+#define PROBLEM "https://judge.yosupo.jp/problem/many_aplusb_128bit"
+
+#include "../weilycoder/fast-io.hpp"
+using namespace weilycoder;
+
+static FastIOFile<> io;
+
+int main() {
+  size_t t = io.read_u64();
+  while (t--) {
+    auto a = io.read_i128();
+    auto b = io.read_i128();
+    io.write_i128_line(a + b);
+  }
+  return 0;
+}

weilycoder/fast-io.hpp

@@ -116,20 +116,36 @@ template <typename Reader, typename Writer, bool debug = false> struct FastIO {
 
   inline void flush() { writer.flush(); }
 
-  inline uint64_t read_u64() {
+  int32_t abs(int32_t x) { return x >= 0 ? x : -x; }
+
+  template <typename utype> inline utype _read_u() {
     char c;
     do
       c = getchar();
     while (c < '0' || c > '9');
-    uint64_t x = 0;
+    utype x = 0;
     do
       x = x * 10 + (c - '0'), c = getchar();
     while (c >= '0' && c <= '9');
     return x;
   }
 
-  inline void write_u64(uint64_t x) {
-    static char buf[20];
+  template <typename itype, typename utype> inline itype _read_i() {
+    char c;
+    bool neg = false;
+    do
+      if ((c = getchar()) == '-')
+        neg = true;
+    while ((c < '0' || c > '9'));
+    utype x = 0;
+    do
+      x = x * 10 + (c - '0'), c = getchar();
+    while (c >= '0' && c <= '9');
+    return static_cast<itype>(neg ? -x : x);
+  }
+
+  template <typename utype, size_t bufsize> inline void _write_u(utype x) {
+    static char buf[bufsize];
     size_t len = 0;
     do
       buf[len++] = '0' + (x % 10), x /= 10;
@@ -138,7 +154,47 @@ template <typename Reader, typename Writer, bool debug = false> struct FastIO {
       putchar(buf[i]);
   }
 
+  template <typename itype, size_t bufsize> inline void _write_i(itype x) {
+    bool neg = x < 0;
+    static char buf[bufsize];
+    size_t len = 0;
+    do
+      buf[len++] = '0' + this->abs(x % 10), x /= 10;
+    while (x);
+    if (neg)
+      putchar('-');
+    for (size_t i = len - 1; ~i; --i)
+      putchar(buf[i]);
+  }
+
+  inline int32_t read_i32() { return _read_i<int32_t, uint32_t>(); }
+  inline uint32_t read_u32() { return _read_u<uint32_t>(); }
+
+  inline void write_i32(int32_t x) { _write_i<int32_t, 10>(x); }
+  inline void write_u32(uint32_t x) { _write_u<uint32_t, 10>(x); }
+
+  inline int64_t read_i64() { return _read_i<int64_t, uint64_t>(); }
+  inline uint64_t read_u64() { return _read_u<uint64_t>(); }
+
+  inline void write_i64(int64_t x) { _write_i<int64_t, 20>(x); }
+  inline void write_u64(uint64_t x) { _write_u<uint64_t, 20>(x); }
+
+  inline __int128 read_i128() { return _read_i<__int128, unsigned __int128>(); }
+  inline unsigned __int128 read_u128() { return _read_u<unsigned __int128>(); }
+
+  inline void write_i128(__int128 x) { _write_i<__int128, 40>(x); }
+  inline void write_u128(unsigned __int128 x) {
+    _write_u<unsigned __int128, 40>(x);
+  }
+
+  inline void write_i32_line(int32_t x) { write_i32(x), putchar('\n'); }
+  inline void write_u32_line(uint32_t x) { write_u32(x), putchar('\n'); }
+  inline void write_i64_line(int64_t x) { write_i64(x), putchar('\n'); }
   inline void write_u64_line(uint64_t x) { write_u64(x), putchar('\n'); }
+  inline void write_i128_line(__int128 x) { write_i128(x), putchar('\n'); }
+  inline void write_u128_line(unsigned __int128 x) {
+    write_u128(x), putchar('\n');
+  }
 };
 
 template <bool debug = false>