Language: C++

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
using Pld = pair<ld, ld>;
using vl = vector<ll>;
using vvl = vector<vl>;
using VecP = vector<P>;
using VecB = vector<bool>;
using VecC = vector<char>;
using VecD = vector<ld>;
using VecS = vector<string>;
using Graph = vector<VecP>;
#define REP(i, m, n) for(ll (i) = (m); (i) < (n); ++(i))
#define REPR(i, m, n) for(ll (i) = (m); (i) > (n); --(i))
#define rep(i, n) REP(i, 0, n)
#define R cin>>
#define i64 unsigned long long
#define repr(i, n) REPR(i, n, 0)
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define in(a) insert(a)
#define P(p) cout<<(p)<<endl;
#define ALL(x) (x).begin(),(x).end()
#define ALLR(x) (x).rbegin(),(x).rend()
#define SORT(a) sort((a).begin(), (a).end())
typedef vector<int> vi;
typedef vector<vi> vvl;
typedef vector<long long int> vll;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
typedef pair<ll, ll> pll;
void sonic(){ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);}
void setp(const ll n){cout << fixed << setprecision(n);}
const ll INF = 1e9+1;
const ll LINF = 1e18+1;
const ll mod = 1e9+7;
//const ll MOD = 998244353;
const ld PI = acos(-1);
const ld EPS = 1e-11;
template<typename T> void co(T e){cout << e << "\n";}
template<typename T> void co(const vector<T>& v){for(const auto& e : v)
    { cout << e << " "; } cout << "\n";}
ll gcd(ll a, ll b) {
    if (a < b)swap(a, b);
    if (b == 0) return a;
    unsigned r;
    while ((r = a % b)) {
        a = b;
        b = r;
    }
    return b;
}
ll lcm(ll a, ll b) {
    ll g = gcd(a, b);
    return a * b / g;
}
bool prime(ll n) {
    for (ll i = 2; i <= sqrt(n); i++) {
        if (n%i == 0)return false;
    }
    return n != 1;
}


int pow(int x, int y, int mod){
    int ret=1;
    for(;y;y>>=1,x=1ll*x*x%mod){
        if(y&1) ret=1ll*ret*x%mod;
    }
    return ret;
}
void kill()
{
    cout << "No" << endl;
    exit(0);
}

template <class T>bool chmax(T &a, const T &b){if (a<b){a=b; return 1;} return 0;}
template<class T>bool chmin(T &a, const T &b){if(b<a){a=b;return 1;} return 0;}


vvl mat_mul(vvl a, vvl &b){
    ll m = a.size();
    ll l = b.size();
    vvl ret(m, vl(l, 0));
    rep(i, m) rep(j, l) rep(k, l) ret[i][j] = (ret[i][j] + a[i][k] * b[k][j]) % mod;
    return ret;
}

vvl mat_pow(vvl &x, ll n){
    vvl y = vvl(x.size(), vl(x[0].size(),0));
    while(n > 0){
        if (n&1) y = mat_mul(x, y);
        x = mat_mul(x, x);
        n >>= 1;
    }
}



int main(){
    sonic();
    ll l, a, b, m, d0 = 0, d1;
    R l >> a >> b >> m;
    vvl ret = {{0},{a},{b}};
    REP(i, 1, 19){
        if(pow(10, i) - 1 - a < 0) continue;
        d1 = min((pow(2, 3) - 1 - a) / b + 1, l);
    }

}


Compiler output:
a.cc:32:20: error: conflicting declaration 'typedef class std::vector<std::vector<int> > vvl'
   32 | typedef vector<vi> vvl;
      |                    ^~~
a.cc:8:7: note: previous declaration as 'using vvl = class std::vector<std::vector<long long int> >'
    8 | using vvl = vector<vl>;
      |       ^~~
a.cc: In function 'vvl mat_pow(vvl&, ll)':
a.cc:103:1: warning: no return statement in function returning non-void [-Wreturn-type]
  103 | }
      | ^
a.cc: In function 'int main()':
a.cc:114:17: error: no matching function for call to 'min(__gnu_cxx::__promote<double>::__type, ll&)'
  114 |         d1 = min((pow(2, 3) - 1 - a) / b + 1, l);
      |              ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:114:17: note:   deduced conflicting types for parameter 'const _Tp' ('double' and 'll' {aka 'long long int'})
  114 |         d1 = min((pow(2, 3) - 1 - a) / b + 1, l);
      |              ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:114:17: note:   mismatched types 'std::initializer_list<_Tp>' and 'double'
  114 |         d1 = min((pow(2, 3) - 1 - a) / b + 1, l);
      |              ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~