func_code_string: #include <bits/stdc++.h>   using namespace std;   using ll = long long;   template <ll mod>   struct ModInt {     ll v;     ll mod_pow(ll x, ll n) const {       return (!n) ? 1 : (mod_pow((x * x) % mod, n / 2) * ((n & 1) ? x : 1)) % mod;     }     ModInt(ll a = 0) : v(a >= mod ? a % mod : a) {}     ModInt operator+(const ModInt& b) const {       return (v + b.v >= mod ? ModInt(v + b.v - mod) : ModInt(v + b.v));     }     ModInt operator-(const ModInt& b) const {       return (v - b.v < 0 ? ModInt(v - b.v + mod) : ModInt(v - b.v));     }     ModInt operator*(const ModInt& b) const { return (v * b.v) % mod; }     ModInt operator/(const ModInt& b) const {       return (v * mod_pow(b.v, mod - 2)) % mod;     }     bool operator==(const ModInt& b) const { return v == b.v; }     ModInt& operator+=(const ModInt& b) {       v += b.v;       if (v >= mod) v -= mod;       return *this;     }     ModInt& operator-=(const ModInt& b) {       v -= b.v;       if (v < 0) v += mod;       return *this;     }     ModInt& operator*=(const ModInt& b) {       (v *= b.v) %= mod;       return *this;     }     ModInt& operator/=(const ModInt& b) {       (v *= mod_pow(b, mod - 2)) %= mod;       return *this;     }     ModInt pow(ll x) { return ModInt(mod_pow(v, x)); }     operator int() const { return int(v); }     operator long long int() const { return v; }   };   template <ll mod>   ostream& operator<<(ostream& out, ModInt<mod> a) {     return out << a.v;   }   template <ll mod>   istream& operator>>(istream& in, ModInt<mod> a) {     in >> a.v;     return in;   }   ll mod_pow(ll n, ll k, ll mod) {     ll res = 1;     for (; k > 0; k >>= 1) {       if (k & 1) (res *= n) %= mod;       (n *= n) %= mod;     }     return res;   }   template <typename NumType>   vector<NumType> get_inv_table(int N, int P) {     vector<NumType> res;     for (int i = 0; i < N; i++) {       res.emplace_back(NumType(mod_pow(i, P - 2, P)));     }     return res;   }   template <typename NumType>   struct LagrangePolynomial {     vector<NumType> x, y, f_table, inv_table;     bool use_inv_table;     LagrangePolynomial() : x(), y() {}     LagrangePolynomial(vector<NumType> x_, vector<NumType> y_,                        bool use_inv_table_ = false, int P = 1000000007)         : x(x_), y(y_), use_inv_table(use_inv_table_) {       int N = x.size();       for (int i = 0; i < N; i++) {         f_table.emplace_back(f(i, x[i]));       }       if (use_inv_table) {         inv_table = get_inv_table<NumType>(P, P);       }     }     NumType f(int i, NumType p) {       int N = x.size();       NumType res(1);       for (int k = 0; k < N; k++) {         if (i == k) continue;         res *= NumType(p - x[k]);       }       return res;     }     NumType interpolate(NumType p) {       int N = x.size();       NumType res(0);       for (int i = 0; i < N; i++) {         if (use_inv_table) {           res += y[i] * f(i, p) * inv_table[int(f_table[i])];         } else {           res += y[i] * f(i, p) / f_table[i];         }       }       return res;     }   };   void ECR065_E() {     const int MOD = 1000003;     using mint = ModInt<MOD>;     const int DEG = 11;     auto eval_expr = [&](vector<mint>& expr, mint x) {       mint base(1), res(0);       for (int i = 0; i < DEG; i++) {         res += expr[i] * base;         base *= x;       }       return res;     };     vector<mint> x, y, expr;     vector<int> raw_expr = {1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0};     for (int i = 0; i < DEG; i++) {       expr.emplace_back(mint(raw_expr[i]));     }     for (int i = 1; i <= DEG; i++) {       x.push_back(mint(i));       cout <<  ?   << i << endl;       int res;       cin >> res;       y.push_back(mint(res));     }     LagrangePolynomial<mint> lp(x, y, true, MOD);     for (int i = 0; i < MOD; i++) {       if (lp.interpolate(i) == mint(0)) {         cout <<  !   << i << endl;         return;       }     }     cout <<  !   << -1 << endl;   }   int main() {     ECR065_E();     return 0;   }   