stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;



int n;

ll ara[100000 + 5];



ll check(ll k) {

    for(int i = 0; i < n; i++)

        k -= k % ara[i];

    return k;

}



int main() {

    cin >> n;

    for(int i = 0; i < n; i++) 

        cin >> ara[i];

    ll lo = 0, hi = 100000000000000, ans = -1;

    while(lo <= hi) {

        ll mid = (lo + hi) / 2;

        ll k = check(mid);

        if(k == 2) {

            ans = mid;

            hi = mid - 1;

        }

        else if(k > 2)

            hi = mid - 1;

        else

            lo = mid + 1;

    }

    

    if(ans != -1)

        cout << ans << " ";

    else {

        cout << -1 << endl;

        return 0;

    }

    

    lo = 0, hi = 100000000000000, ans = -1;

    while(lo <= hi) {

        ll mid = (lo + hi) / 2;

        ll k = check(mid);

        if(k == 2) {

            ans = mid;

            lo = mid + 1;

        }

        else if(k > 2)

            hi = mid - 1;

        else

            lo = mid + 1;

    }

    

    if(ans != -1)

        cout << ans << " ";

    else {

        cout << -1 << endl;

        return 0;

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.126718212476013x):
#include<stdio.h>

int main()

{

	int K,A[100010];

	scanf("%d", &K);

	for (int i = 1; i <= K; i++)

	{

		scanf("%d", &A[i]);

	}

	long long left = 2, right = 2;

	for (int i = K; i > 0; i--)

	{

		left = ((left-1) / A[i] + 1)*A[i];

		right = (right / A[i] + 1)*A[i] - 1;

	}

	if (left > right)

		printf("-1\n");

	else

		printf("%lld %lld\n", left, right);

	return 0;

}
// Slower C++ solution:
    #include<bits/stdc++.h>

    using namespace std;

    const int mxn = 1e5+10;

    int n;

    long long ar[mxn];

     

    int main()

    {

        cin>>n;

        for(int i = 0; i < n; i++)

            cin>>ar[i];

        long long prev = ar[n-1];

        if(prev!=2)

        {

            cout<<"-1"<<endl;

            return 0;

        }

        long long left = 2;

        long long right = 2;

        for(int i = n-1; i >= 0; i--)

        {

    		left = ((left-1)/ar[i] + 1)*ar[i];

    		right = ((right/ar[i])*ar[i]+ar[i]-1);

    		long long tmp = (right/ar[i])*ar[i];

    		

    		if(left > tmp) { cout<<"-1"<<endl; return 0;}

    	}

    	cout<<left<<" "<<right<<endl;

        return 0;

    }

// Faster C++ solution for the same problem (measured speedup: 5.104017069579639x):
#include<stdio.h>

int main()

{

	int K,A[100010];

	scanf("%d", &K);

	for (int i = 1; i <= K; i++)

	{

		scanf("%d", &A[i]);

	}

	long long left = 2, right = 2;

	for (int i = K; i > 0; i--)

	{

		left = ((left-1) / A[i] + 1)*A[i];

		right = (right / A[i] + 1)*A[i] - 1;

	}

	if (left > right)

		printf("-1\n");

	else

		printf("%lld %lld\n", left, right);

	return 0;

}
// Slower C++ solution:
#include "bits/stdc++.h"

using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

const int INF = 1e9;

const ll LINF = 1e18;



/*

<url:https://agc020.contest.atcoder.jp/tasks/agc020_b>

問題文============================================================

 スケートリンクで、一人の大人の司会と N 人の子供がゲームを行います。

 ゲームは K ラウンドからなり、ラウンド i では司会が次のように言います。

 

 Ai 人組を作って！

 

 すると、まだ脱落していない子供たちは Ai 人からなるグループをできるだけ多く組みます。

 一人につき一つのグループにしか入れません。

 グループに入れなかった子供たちは脱落し、その他は次のラウンドに進みます。 ラウンドで誰も脱落しないこともありえます。

 

 最後まで、つまりラウンド K のあとまで残ったのは 2 人で、彼らが勝者となりました。

 

 あなたは A1, A2, ..., AK の値を聞き、N の値は知りませんが、推定してみたくなりました。

 

 ゲームの開始前にいた子供たちの人数として考えられる最小の値と、最大の値を求めてください。

 もしくは、考えられる N の値は存在しないと判定してください。

 



=================================================================



解説=============================================================



 後ろから考える

 

 後ろから考えた時、その時点での最小値と最大値を l,r とすると

 ここで A[i] を見た時 , l と　r の間に A[i]の倍数がなければ -1

 あれば

  l = (l + A[i] - 1)/A[i] * A[i]

  r = (r/A[i] + 1)*A[i] - 1

 となる

 

================================================================

*/

void solve(){

    ll K; cin >> K;

    vector<ll> A(K);

    for(auto &in:A) cin >> in;

    if(A[K-1] != 2){ cout << -1 << endl; return; }

    ll l = 2, r = 2;

    for(ll i = K - 1; i >= 0; i--){

        ll t = (l + A[i] - 1)/A[i] * A[i];

        if(t < l || t > r){

            cout << -1 << endl; return;

        }

        l = t;

        r = (r/A[i] + 1)*A[i] - 1;

    }

    cout << l << " " << r << endl;

}

int main(void) {

	cin.tie(0); ios::sync_with_stdio(false);

    solve();

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.417488560583009x):
#include<cstdio>

long long a[100001],k,cnt,now=2,max=2,min=2;

int main()

{

	scanf("%lld",&k);

	for(int i=1;i<=k;++i)scanf("%lld",a+i);

	for(int i=k;i>=1;--i){

		max=(max/a[i]+1)*a[i]-1;

		min=((min-1)/a[i]+1)*a[i];

		if(max<min){puts("-1");return 0;}

	}

	printf("%lld %lld\n",min,max);

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



using VS = vector<string>;    using LL = long long;

using VI = vector<int>;       using VVI = vector<VI>;

using PII = pair<int, int>;   using PLL = pair<LL, LL>;

using VL = vector<LL>;        using VVL = vector<VL>;



#define ALL(a)  begin((a)),end((a))

#define RALL(a) (a).rbegin(), (a).rend()

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define SZ(a) int((a).size())

#define SORT(c) sort(ALL((c)))

#define RSORT(c) sort(RALL((c)))

#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)

#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)

#define debug(x) cerr << #x << ": " << x << endl

const int INF = 1e9;                          const LL LINF = 1e16;

const LL MOD = 1000000007;                    const double PI = acos(-1.0);

int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 };    int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };



/* -----  2018/03/03  Problem: 020_agc_b / Link: https://agc020.contest.atcoder.jp/tasks/agc020_b?lang=en  ----- */

/* ------問題------



スケートリンクで、一人の大人の司会と N 人の子供がゲームを行います。 ゲームは K ラウンドからなり、ラウンド i では司会が次のように言います。

Ai 人組を作って！

すると、まだ脱落していない子供たちは Ai 人からなるグループをできるだけ多く組みます。 一人につき一つのグループにしか入れません。 グループに入れなかった子供たちは脱落し、その他は次のラウンドに進みます。 ラウンドで誰も脱落しないこともありえます。

最後まで、つまりラウンド K のあとまで残ったのは 2 人で、彼らが勝者となりました。

あなたは A1, A2, ..., AK の値を聞き、N の値は知りませんが、推定してみたくなりました。

ゲームの開始前にいた子供たちの人数として考えられる最小の値と、最大の値を求めてください。もしくは、考えられる N の値は存在しないと判定してください。



-----問題ここまで----- */

/* -----解説等-----



逆から実際の値の範囲を復元していく。

下限は次の条件を満たさないといけないので(a[i]での下限)

上限は条件を満たしていれば少し多くても大丈夫なので(上限 + (a[i]-1))



----解説ここまで---- */



LL N;



LL ans = 0LL;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(false);



	cin >> N;

	VI a(N);

	FOR(i, 0, N) {

		cin >> a[i];

	}

	reverse(ALL(a));

	ans = 1;

	if (a.front() != 2)ans = 0;



	LL L = 2, R = 2;



	FOR(i, 0, N) {

		LL x = (L + a[i] - 1) / a[i] * a[i];

		if (x < L || R < x)ans = 0;

		L = x;

		R = (R / a[i])* a[i] + (a[i] - 1); // 上げる

	}

	if (!ans) {

		cout << -1 << endl;

	}

	else {

		cout << L << " " << R << "\n";

	}

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.434055464083394x):
#include<cstdio>

long long a[100001],k,cnt,now=2,max=2,min=2;

int main()

{

	scanf("%lld",&k);

	for(int i=1;i<=k;++i)scanf("%lld",a+i);

	for(int i=k;i>=1;--i){

		max=(max/a[i]+1)*a[i]-1;

		min=((min-1)/a[i]+1)*a[i];

		if(max<min){puts("-1");return 0;}

	}

	printf("%lld %lld\n",min,max);

	return 0;

}
// Slower C++ solution:
    #include <iostream>

#include<cstdio>

    using namespace std;

    long long NMAX,NMIN;

    int K;

    int A[100005];

    long long eval(long long N){

        for(int i = 1;i <= K;i++){

            N =N - N % A[i];}

        return N;

    }

    int main()

    {

        cin >> K;

        for(int i = 1;i <= K;i++){

            cin >> A[i];

        }

        long long st = 0,dr = 1e18;

        while(dr - st >= 1){

            long long mid = (st + dr) / 2;

            if(eval(mid) >= 2){

                dr = mid;

            }

            else {

                st = mid + 1;

            }

        }

      long long L = dr;

        st = 0,dr = 1e18;

        while(dr - st >= 1){

            long long mid = (st + dr) / 2;

            if(eval(mid) <= 2){

                st = mid + 1;

            }

            else {

                dr = mid;

            }

        }



    long long R = st - 1;

//    cout << L << ' '<< R << endl;

    if(L > R) puts("-1");

    else cout << L << ' '<< R << endl;

        return 0;

    }


// Faster C++ solution for the same problem (measured speedup: 5.099237560708579x):


#include<cstdio>

int n, a[100005];

long long ok(long long x){

    for(int i = 1; i <= n; ++i) x = x - x % a[i];

    return x;

}

int main(){

    scanf("%d", &n);

    for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);

    long long l = 0, r = 1e18;

    while(l <= r){

        long long mid = (l + r) / 2;

        if(ok(mid) >= 2) r = mid - 1;

        else l = mid + 1;

    }

    long long down = l;

    l = 0, r = 1e18;

    while(l <= r){

        long long mid = (l + r) / 2;

        if(ok(mid) <= 2) l = mid + 1;

        else r = mid - 1;

    }

    long long up = r;

    if(up < down) puts("-1");

    else printf("%lld %lld\n", down, up);

    return 0;

}
// Slower C++ solution:
#include <iostream>

#include<cstdio>

using namespace std;

int K, A[100005];

long long eval(long long N){

    for(int i = 1;i <= K;i++) N =N - N % A[i];

    return N;

}

int main(){

    cin >> K;

    for(int i = 1;i <= K;i++) cin >> A[i];

    long long  l = 0, r = 1e18;

    while(l <= r){

        long long  mid = (l + r) / 2;

        if(eval(mid) >= 2) r = mid - 1;

        else l = mid + 1;

    }

    long long L = l;

    l = 0, r = 1e18;

    while(l <= r){

        long long  mid = (l + r) / 2;

        if(eval(mid) <= 2) l = mid + 1;

        else r = mid - 1;

    }

    long long R = r;

    if(L > R) puts("-1");

    else cout << L << ' '<< R << endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.101168786331791x):


#include<cstdio>

int n, a[100005];

long long ok(long long x){

    for(int i = 1; i <= n; ++i) x = x - x % a[i];

    return x;

}

int main(){

    scanf("%d", &n);

    for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);

    long long l = 0, r = 1e18;

    while(l <= r){

        long long mid = (l + r) / 2;

        if(ok(mid) >= 2) r = mid - 1;

        else l = mid + 1;

    }

    long long down = l;

    l = 0, r = 1e18;

    while(l <= r){

        long long mid = (l + r) / 2;

        if(ok(mid) <= 2) l = mid + 1;

        else r = mid - 1;

    }

    long long up = r;

    if(up < down) puts("-1");

    else printf("%lld %lld\n", down, up);

    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <vector>

using namespace std;

typedef long long ll;



inline ll ceiling(ll a, ll m) { return (a + m - 1) / m; }



int main() {

  int k;

  cin >> k;

  vector<ll> a(k + 1);

  for (int i = 1; i <= k; i++) {

    cin >> a[i];

  }

  ll mn = 2;

  ll mx = 2;

  for (int i = k; i > 0; i--) {

    // [L, R]のaの倍数のminは、ceil(L/a)*a

    //                  maxは、floar(R/a)*a

    ll amn = ceiling(mn, a[i]) * a[i];

    ll amx = mx / a[i] * a[i];

    if (amn > mx || amx < mn) {

      cout << -1 << endl;

      return 0;

    }

    mn = amn;

    mx = amx + a[i] - 1;

  }

  cout << mn << " " << mx << endl;

}


// Faster C++ solution for the same problem (measured speedup: 4.905771355679157x):
#include <stdio.h>

typedef long long ll;



int main() {

  int k;

  scanf("%d", &k);

  ll a[100005];

  for (int i = 0; i < k; i++) {

    scanf("%lld", &a[i]);

  }

  ll mn = 2;

  ll mx = 2;

  for (int i = k - 1; i >= 0; i--) {

    // [L, R]のaの倍数のminは、ceil(L/a)*a

    //                  maxは、floar(R/a)*a

    ll amn = (mn + a[i] - 1) / a[i] * a[i];

    ll amx = mx / a[i] * a[i];

    if (amn > mx) {

      printf("%d", -1);

      return 0;

    }

    mn = amn;

    mx = amx + a[i] - 1;

  }

  printf("%lld %lld", mn, mx);

}
// Slower C++ solution:
#include <iostream>

using namespace std;

typedef long long ll;



int main() {

  int k;

  cin >> k;

  ll a[100005];

  for (int i = 0; i < k; i++) {

    cin >> a[i];

  }

  ll mn = 2;

  ll mx = 2;

  for (int i = k - 1; i >= 0; i--) {

    // [L, R]のaの倍数のminは、ceil(L/a)*a

    //                  maxは、floar(R/a)*a

    ll amn = (mn + a[i] - 1) / a[i] * a[i];

    ll amx = mx / a[i] * a[i];

    if (amn > mx) {

      cout << -1 << endl;

      return 0;

    }

    mn = amn;

    mx = amx + a[i] - 1;

  }

  cout << mn << " " << mx << endl;

}


// Faster C++ solution for the same problem (measured speedup: 4.928112328340423x):
#include <stdio.h>

typedef long long ll;



int main() {

  int k;

  scanf("%d", &k);

  ll a[100005];

  for (int i = 0; i < k; i++) {

    scanf("%lld", &a[i]);

  }

  ll mn = 2;

  ll mx = 2;

  for (int i = k - 1; i >= 0; i--) {

    // [L, R]のaの倍数のminは、ceil(L/a)*a

    //                  maxは、floar(R/a)*a

    ll amn = (mn + a[i] - 1) / a[i] * a[i];

    ll amx = mx / a[i] * a[i];

    if (amn > mx) {

      printf("%d", -1);

      return 0;

    }

    mn = amn;

    mx = amx + a[i] - 1;

  }

  printf("%lld %lld", mn, mx);

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define i64 long long

#define inf 1000000000000000000

using namespace std;

i64 ara[100009];





i64 n;

i64 f(i64 mid)

{

    for(i64 i=0; i<n; i++)

    {

        mid= (mid/ara[i])*ara[i];

        //printf("%d / %lld *%d\n",mid,ara[i],ara[i]);



    }



    return mid;



}





int main()



{





    scanf("%lld",&n);

    for(i64 i=0; i<n; i++)

        scanf("%lld",&ara[i]);









    i64 lo=1,hi=1000000000000000000,cnt=0,mid,res1,res2;





    while(cnt++<70)

    {

        mid=(lo+hi)/2;



        if(f(mid)>=2)

            hi=mid;

        else lo=mid;



    }



    if(f(mid)<2) mid++;





    if(f(mid)!=2)

    {

        res1=-1;

    }

    else res1=mid;





    lo=1,hi=1000000000000000000,cnt=0,mid=0;





    while(cnt++<70)

    {

        mid=(lo+hi)/2;



        if(f(mid)>2)

            hi=mid;

        else lo=mid;



    }



    if(f(mid)<2) mid++;



    if(f(mid)!=2)

    {

        res2=-1;

    }

    else

        res2=mid;





    if(res1==-1 || res2==-1)

        printf("-1\n");

    else

        printf("%lld %lld\n",res1,res2);





}


// Faster C++ solution for the same problem (measured speedup: 5.271839915956555x):
#include <stdio.h>



const int maxn = 100005;

int a[maxn];



int main()

{

    int k;

    scanf("%d",&k);

    for (int i = 1; i <= k; i++)

        scanf("%d", &a[i]);

    long long maxm = 2, minm = 2;

    for(int i = k; i > 0; i--)

    {

        if(minm % a[i] != 0)

            minm = minm / a[i] * a[i] + a[i];

        maxm = maxm / a[i] * a[i] + a[i] - 1;

        if(minm > maxm)

            break;

    }

    if(minm <= maxm)

        printf("%lld %lld\n", minm, maxm);

    else

        printf("-1\n");

    return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main(){

    int A[100010],n,i,ans=1;

    cin>>n;

    for(i=1;i<=n;i++) cin>>A[i];

    long long min=2,max=2;

    for(i=n;i>=1;i--){

        max=A[i]*(max/A[i]);

        max=max+A[i]-1;

        min=A[i]*((min-1)/A[i]+1);

        if(max<min){

            ans=0;

            break;

        }

    }

    if(ans==0) cout<<-1<<endl;

    else cout<<min<<" "<<max<<endl;

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.3413435805739224x):
#include <stdio.h>



const int maxn = 100005;

int a[maxn];



int main()

{

    int k;

    scanf("%d",&k);

    for (int i = 1; i <= k; i++)

        scanf("%d", &a[i]);

    long long maxm = 2, minm = 2;

    for(int i = k; i > 0; i--)

    {

        if(minm % a[i] != 0)

            minm = minm / a[i] * a[i] + a[i];

        maxm = maxm / a[i] * a[i] + a[i] - 1;

        if(minm > maxm)

            break;

    }

    if(minm <= maxm)

        printf("%lld %lld\n", minm, maxm);

    else

        printf("-1\n");

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define i64 long long

#define inf 1000000000000000000

using namespace std;

i64 ara[100009];





i64 n;

i64 f(i64 mid)

{

    for(i64 i=0; i<n; i++)

    {

        mid= (mid/ara[i])*ara[i];

        //printf("%d / %lld *%d\n",mid,ara[i],ara[i]);



    }



    return mid;



}





int main()



{





    scanf("%lld",&n);

    for(i64 i=0; i<n; i++)

        scanf("%lld",&ara[i]);









    i64 lo=1,hi=1000000000000000000,cnt=0,mid,res1,res2;





    while(cnt++<70)

    {

        mid=(lo+hi)/2;



        if(f(mid)>=2)

            hi=mid;

        else lo=mid;



    }



    if(f(mid)<2) mid++;





    if(f(mid)!=2)

    {

        res1=-1;

    }

    else res1=mid;





    lo=1,hi=1000000000000000000,cnt=0,mid=0;





    while(cnt++<70)

    {

        mid=(lo+hi)/2;



        if(f(mid)>2)

            hi=mid;

        else lo=mid;



    }



    if(f(mid)<2) mid++;



    if(f(mid)!=2)

    {

        res2=-1;

    }

    else

        res2=mid;





    if(res1==-1 || res2==-1)

        printf("-1\n");

    else

        printf("%lld %lld\n",res1,res2);





}


// Faster C++ solution for the same problem (measured speedup: 5.2748472775632536x):
#include<cstdio>

using namespace std;

long long ma=2,k,a[100005],in=2;

int main()

{

	scanf("%lld",&k);

	for(int i=1;i<=k;i++) scanf("%lld",&a[i]);

	for(long long i=k;i>=1&&ma>=in;i--)

	{

		if(in%a[i]!=0)

		in=1ll*in/a[i]*a[i]+a[i];

		ma=1ll*(ma/a[i]+1)*a[i]-1;

	}

	if(in>ma){printf("-1");return 0;}

	printf("%lld %lld\n",in,ma);

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main(){

    int A[100010],n,i,ans=1;

    cin>>n;

    for(i=1;i<=n;i++) cin>>A[i];

    long long min=2,max=2;

    for(i=n;i>=1;i--){

        max=A[i]*(max/A[i]);

        max=max+A[i]-1;

        min=A[i]*((min-1)/A[i]+1);

        if(max<min){

            ans=0;

            break;

        }

    }

    if(ans==0) cout<<-1<<endl;

    else cout<<min<<" "<<max<<endl;

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.344390591080403x):
#include<cstdio>

using namespace std;

long long ma=2,k,a[100005],in=2;

int main()

{

	scanf("%lld",&k);

	for(int i=1;i<=k;i++) scanf("%lld",&a[i]);

	for(long long i=k;i>=1&&ma>=in;i--)

	{

		if(in%a[i]!=0)

		in=1ll*in/a[i]*a[i]+a[i];

		ma=1ll*(ma/a[i]+1)*a[i]-1;

	}

	if(in>ma){printf("-1");return 0;}

	printf("%lld %lld\n",in,ma);

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define i64 long long

#define inf 1000000000000000000

using namespace std;

i64 ara[100009];





i64 n;

i64 f(i64 mid)

{

    for(i64 i=0; i<n; i++)

    {

        mid= (mid/ara[i])*ara[i];

        //printf("%d / %lld *%d\n",mid,ara[i],ara[i]);



    }



    return mid;



}





int main()



{





    scanf("%lld",&n);

    for(i64 i=0; i<n; i++)

        scanf("%lld",&ara[i]);









    i64 lo=1,hi=1000000000000000000,cnt=0,mid,res1,res2;





    while(cnt++<70)

    {

        mid=(lo+hi)/2;



        if(f(mid)>=2)

            hi=mid;

        else lo=mid;



    }



    if(f(mid)<2) mid++;





    if(f(mid)!=2)

    {

        res1=-1;

    }

    else res1=mid;





    lo=1,hi=1000000000000000000,cnt=0,mid=0;





    while(cnt++<70)

    {

        mid=(lo+hi)/2;



        if(f(mid)>2)

            hi=mid;

        else lo=mid;



    }



    if(f(mid)<2) mid++;



    if(f(mid)!=2)

    {

        res2=-1;

    }

    else

        res2=mid;





    if(res1==-1 || res2==-1)

        printf("-1\n");

    else

        printf("%lld %lld\n",res1,res2);





}


// Faster C++ solution for the same problem (measured speedup: 5.348092545078066x):
#include<cstdio>

#include<cstring>

#include<algorithm>

#define ll long long

#define MN 100005

using namespace std;

inline ll in(){

    ll x=0;bool f=0; char c;

    for (;(c=getchar())<'0'||c>'9';f=c=='-');

    for (x=c-'0';(c=getchar())>='0'&&c<='9';x=(x<<3)+(x<<1)+c-'0');

    return f?-x:x;

}

ll a[MN],n,mx,mn,x,y;

int main()

{

	n=in();

	for (int i=1;i<=n;++i) a[i]=in();a[n+1]=2ll;mn=mx=2ll;

	for (int i=n;i;--i){

		mx/=a[i];if (!mx) {printf("-1");return 0;}

		mx=(mx+1ll)*a[i]-1ll;

		if (mn%a[i]) mn=(mn/a[i]+1ll)*a[i];

	}x=mx,y=mn;

	for (int i=1;i<=n;++i){

		x-=(x%a[i]);y-=(y%a[i]);

	}if (x!=2||y!=2) {printf("-1");return 0;}

	printf("%lld %lld",mn,mx);return 0;

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main(){

    int A[100010],n,i,ans=1;

    cin>>n;

    for(i=1;i<=n;i++) cin>>A[i];

    long long min=2,max=2;

    for(i=n;i>=1;i--){

        max=A[i]*(max/A[i]);

        max=max+A[i]-1;

        min=A[i]*((min-1)/A[i]+1);

        if(max<min){

            ans=0;

            break;

        }

    }

    if(ans==0) cout<<-1<<endl;

    else cout<<min<<" "<<max<<endl;

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.418601520411453x):
#include<cstdio>

#include<cstring>

#include<algorithm>

#define ll long long

#define MN 100005

using namespace std;

inline ll in(){

    ll x=0;bool f=0; char c;

    for (;(c=getchar())<'0'||c>'9';f=c=='-');

    for (x=c-'0';(c=getchar())>='0'&&c<='9';x=(x<<3)+(x<<1)+c-'0');

    return f?-x:x;

}

ll a[MN],n,mx,mn,x,y;

int main()

{

	n=in();

	for (int i=1;i<=n;++i) a[i]=in();a[n+1]=2ll;mn=mx=2ll;

	for (int i=n;i;--i){

		mx/=a[i];if (!mx) {printf("-1");return 0;}

		mx=(mx+1ll)*a[i]-1ll;

		if (mn%a[i]) mn=(mn/a[i]+1ll)*a[i];

	}x=mx,y=mn;

	for (int i=1;i<=n;++i){

		x-=(x%a[i]);y-=(y%a[i]);

	}if (x!=2||y!=2) {printf("-1");return 0;}

	printf("%lld %lld",mn,mx);return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <iostream>

#include <string>

#include <algorithm>

#include <set>

#include <map>

#include <vector>

#include <cstring>

using namespace std;

typedef long long LL;

const int MAXN = 100005;

LL a[MAXN];

int n;

LL judge(LL x)

{

    for(int i=1;i<=n;++i)

        x=x/a[i]*a[i];

    return x;

}

int main()

{

    scanf("%d", &n);

    for(int i=1;i<=n;++i)

        scanf("%lld", &a[i]);

    LL l=2, r=1e15;

    LL mid;

    LL Max=-1, Min=-1;

    while(l<=r)

    {

        mid=(l+r)>>1;

        if(judge(mid)>=2)

            r=mid-1, Min=mid;

        else

            l=mid+1;

    }

    l=2,r=1e15;

    while(l<=r)

    {

        mid=(l+r)>>1;

        if(judge(mid)>2)

            r=mid-1;

        else

            l=mid+1, Max=mid;

    }

    if(judge(Min)!=2||judge(Max)!=2)

        puts("-1");

    else

        printf("%lld %lld\n", Min, Max);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.257098024888571x):
/*令L(i),R(i)表示第i轮过后的最小人数和最大人数。



令X(i)和Y(i)表示区间[L(i),R(i)]中最小的a[i]倍数和最大的a[i]倍数。



L(i-1)=X(i)，R(i-1)=Y(i)+a[i]-1。



X(i)=L(i)/a[i]（上取整），Y(i)=R(i)/a[i]（下取整）。



答案为L(0),R(0)。*/

#include<cstdio>

int n,a[100010];

long long L=2,R=2;

int main(){

    scanf("%d",&n);

    for(int i=1;i<=n;i++)scanf("%d",&a[i]);

    for(int i=n;i>=1;i--){

        L=((L-1)/a[i]+1)*a[i];

        R=R/a[i]*a[i]+a[i]-1;

    }

    if(L>R)printf("-1");

    else printf("%lld %lld",L,R);

    return 0;

}