Language: C++

const int bases[64] = {257,262,266,275,276,281,285,290,296,302,306,310,311,313,323,333,344,345,350,357,367,370,373,402,423,425,431,440,442,443,454,457,458,462,471,478,481,487,489,492,499,501,502,503,506,514,524,532,535,541,550,552,557,559,562,563,567,570,571,580,592,597,604,612};
const ull mod = 0x1fffffffffffffff, base = bases[chrono::duration_cast<chrono::microseconds>(chrono::system_clock::now().time_since_epoch()).count() & 63];
struct RollingHash {
    vector<ull> hashed, power;
    
    static constexpr ull mask(int a) const { return (1ull << a) - 1; }
    
    inline ull mul(ull a, ull b) const {
        /*ull a31 = a >> 31, b31 = b >> 31;
        a &= mask(31);
        b &= mask(31);
        ull x = a * b31 + b * a31;
        ull ans = (a31 * b31 << 1) + (x >> 30) + ((x & mask(30)) << 31) + a * b;*/
        __uint128_t ans = __uint128_t(a) * b;
        ans = (ans >> 61) + ans & mask(61);
        if(ans >= mod) ans -= mod;
        return ans;
    }
    
    
    RollingHash(const string &s) {
        ll n = s.size();
        hashed.assign(n + 1, 0);
        power.assign(n + 1, 0);
        power[0] = 1;
        rep(n) {
            power[i + 1] = mul(power[i], base);
            hashed[i + 1] = mul(hashed[i], base) + s[i];
            if(hashed[i + 1] >= mod) hashed[i + 1] -= mod;
        }
    }
    
    ull get(ll l, ll r) const {
        ull ret = hashed[r] + mod - mul(hashed[l], power[r - l]);
        if(ret >= mod) ret -= mod;
        return ret;
    }
    
    ull connect(ull h1, ll h2, ll h2len) const {
        ull ret = mul(h1, power[h2len]) + h2;
        if(ret >= mod) ret -= mod;
        return ret;
    }
    
    void connect(const string &s){
        ll n = hashed.size() - 1, m = s.size();
        hashed.resize(n + m + 1);
        power.resize(n + m + 1);
        rep(i, n, n + m) {
            power[i + 1] = mul(power[i], base);
            hashed[i + 1] = mul(hashed[i], base) + s[i - n];
            if(hashed[i + 1] >= mod) hashed[i + 1] -= mod;
        }
    }
    
    ll LCP(const RollingHash &b, ll l1, ll r1, ll l2, ll r2) {
        ll len = min(r1 - l1, r2 - l2);
        ll low = -1, high = len + 1;
        while(high - low > 1) {
            ll mid = (low + high) / 2;
            if(get(l1, l1 + mid) == b.get(l2, l2 + mid)) low = mid;
            else high = mid;
        }
        return low;
    }
};

Compiler output:
a.cc:2:7: error: 'ull' does not name a type
    2 | const ull mod = 0x1fffffffffffffff, base = bases[chrono::duration_cast<chrono::microseconds>(chrono::system_clock::now().time_since_epoch()).count() & 63];
      |       ^~~
a.cc:4:5: error: 'vector' does not name a type
    4 |     vector<ull> hashed, power;
      |     ^~~~~~
a.cc:6:22: error: 'ull' does not name a type
    6 |     static constexpr ull mask(int a) const { return (1ull << a) - 1; }
      |                      ^~~
a.cc:8:12: error: 'ull' does not name a type
    8 |     inline ull mul(ull a, ull b) const {
      |            ^~~
a.cc:21:23: error: 'string' does not name a type
   21 |     RollingHash(const string &s) {
      |                       ^~~~~~
a.cc:33:5: error: 'ull' does not name a type
   33 |     ull get(ll l, ll r) const {
      |     ^~~
a.cc:39:5: error: 'ull' does not name a type
   39 |     ull connect(ull h1, ll h2, ll h2len) const {
      |     ^~~
a.cc:45:24: error: 'string' does not name a type
   45 |     void connect(const string &s){
      |                        ^~~~~~
a.cc:56:5: error: 'll' does not name a type
   56 |     ll LCP(const RollingHash &b, ll l1, ll r1, ll l2, ll r2) {
      |     ^~
a.cc: In constructor 'RollingHash::RollingHash(const int&)':
a.cc:22:9: error: 'll' was not declared in this scope
   22 |         ll n = s.size();
      |         ^~
a.cc:23:9: error: 'hashed' was not declared in this scope
   23 |         hashed.assign(n + 1, 0);
      |         ^~~~~~
a.cc:23:23: error: 'n' was not declared in this scope
   23 |         hashed.assign(n + 1, 0);
      |                       ^
a.cc:24:9: error: 'power' was not declared in this scope
   24 |         power.assign(n + 1, 0);
      |         ^~~~~
a.cc:26:9: error: 'rep' was not declared in this scope
   26 |         rep(n) {
      |         ^~~
a.cc: In member function 'void RollingHash::connect(const int&)':
a.cc:46:9: error: 'll' was not declared in this scope
   46 |         ll n = hashed.size() - 1, m = s.size();
      |         ^~
a.cc:47:9: error: 'hashed' was not declared in this scope
   47 |         hashed.resize(n + m + 1);
      |         ^~~~~~
a.cc:47:23: error: 'n' was not declared in this scope
   47 |         hashed.resize(n + m + 1);
      |                       ^
a.cc:47:27: error: 'm' was not declared in this scope
   47 |         hashed.resize(n + m + 1);
      |                           ^
a.cc:48:9: error: 'power' was not declared in this scope
   48 |         power.resize(n + m + 1);
      |         ^~~~~
a.cc:49:13: error: 'i' was not declared in this scope
   49 |         rep(i, n, n + m) {
      |             ^
a.cc:49:9: error: 'rep' was not declared in this scope
   49 |         rep(i, n, n + m) {
      |         ^~~