#include <bits/stdc++.h>
#define int long long int
#define endl '\n'
#define pb push_back
#define mod 1000000007
#define db(i) cout<<i<<" ";
#define db1(i) cout<<"("<<i<<")";
#define db2(i) cout<<"["<<i<<"]";
#define db3(i) cout<<"{"<<i<<"}";
#define ff first 
#define ss second
#define vv vector
#define pp pair
#define pi acos(-1);
#define printarr(a,n) cout<<"[";for(int i=0;i<n;i++){db1(a[i]);}cout<<"]";
#define printarr2d(a,n,m) for(int i=0;i<n;i++){for(int j=0;j<m;j++){db(a[i][j]);}cout<<"\n";}
#define inf LLONG_MAX
#define ninf LLONG_MIN
#define MAXN 100001 
#define mem(a,n,v) for(int i=0;i<n;i++){a[i]=v;}

using namespace std;


//..................................................................................................//

vector<int> prime;
int fprime=0;

void seiveprime(int n) 
{
    fprime=123;
    bool pr[n+1];
    memset(pr, true, sizeof(pr)); 
    for (int p=2; p*p<=n; p++){ 
        if (pr[p] == true) {
            for (int i=p*p; i<=n; i += p) 
                pr[i] = false; 
        } 
    } 
    for (int p=2; p<=n; p++) 
       if (pr[p]) 
          prime.pb(p); 
} 

//...................................................................................................//

vector<pp<int,int>> primefactors(int n)  
{  
    vector<pp<int,int>> v;
    int co=0;
    while (n % 2 == 0)  
    {  
        co++;
        n = n/2;  
    }  
    if(co>0)
    v.pb({2,co});
    for (int i = 3; i <= sqrt(n); i = i + 2)  
    {  
        co=0;
        while (n % i == 0)  
        {
            co++;
            n = n/i;  
        }  
        if(co>0)
        {
            v.pb({i,co});
        }
    }
    if (n > 2)  
        v.pb({n,1});  
   return v;
}

//.................................................................................................................//
  
  
  
// int spf[MAXN]; 

// void seive() 
// { 
//     spf[1] = 1; 
//     for (int i=2; i<MAXN; i++) 
//         spf[i] = i; 
//     for (int i=4; i<MAXN; i+=2) 
//         spf[i] = 2; 
  
//     for (int i=3; i*i<MAXN; i++) 
//     { 
//         if (spf[i] == i) 
//         {
//             for (int j=i*i; j<MAXN; j+=i) 
//                 if (spf[j]==j) 
//                     spf[j] = i; 
//         } 
//     } 
// } 

// //call seive
// vector<pp<int,int>> seiveprimefactors(int x) 
// { 
//     int i=0;
//     vector<pp<int,int>> ret; 
//     while (x != 1) 
//     { 
//         if(i==0)
//         {
//             ret.push_back({spf[x],1});
//             i++;
//         }
//         else
//         {
//             int si=ret.size()-1;
//             if(spf[x]==ret[si].ff)
//             {
//                   ret[si].ss++;
//             }
//             else
//             {
//                 ret.pb({spf[x],1});
//             }
//         }
//         x = x / spf[x]; 
//     } 
    
    
//     return ret; 
    
// } 


//......................................................................................//


bool isprime(int n)
{
    for(int i=2;i<=sqrt(n);i++)
        if(n%i==0)
        return false;
    return true;
}

//........................................................................................//

int maxarr(int *a,int n)
{
    int val=a[0];
    for(int i=1;i<n;i++)
    {
        if(val<a[i])
        {
            val=a[i];
        }
    }
    return val;
}

//..........................................................................................//

int minarr(int *a,int n)
{
    int val=a[0];
    for(int i=1;i<n;i++)
    {
        if(val>a[i])
        {
            val=a[i];
        }
    }
    return val;
}

//..........................................................................................//


int gcd(int a, int b) 
{ 
    if (b == 0) 
        return a; 
    return gcd(b, a % b);  
} 

//............................................................................................//

int power(int x, int y, unsigned int p=ULLONG_MAX)  
{  
    int res = 1;     
    x = x % p; 
    if (x == 0) 
      return 0; 
    while (y > 0)  
    {    
        if (y & 1)  
           res = (res*x) % p;  
        y = y>>1; 
        x = (x*x) % p;  
    }  
    return res;  
}

//................................................................................................//
bool cmp(const pair<int,int> &a,const pair<int,int> &b)
{
    if(a.ss<b.ss)
        return true;
    else if(a.ss>b.ss)
        return false;
    else
    {
        if(a.ff<b.ff)
            return true;
        else
            return false;
    }
    
}
bool cmp1(const pair<int,int> &a,const pair<int,int> &b)
{
    return (a.ss<b.ss);
}


//..................................................................................................//

void binary(int no)
{
    if(no>0)
    {
        binary(no/2);
        cout<<no%2;
    }
}

//..................................................................................................//
//..................................................................................................//
//..................................................................................................//
//...                                                                                            ...//
//...                                                                                            ...//
//...                              Done By:                                                      ...//
//...                                     C V Karthik                                            ...//
//...                                                                                            ...//
//...                                                                                            ...//
//...                                                                                            ...//
//...                                                                                            ...//
//..................................................................................................//
//..................................................................................................//
//..................................................................................................//





//if no test cases add coments for reading

string multiply(string num1, string num2) 
{ 
    int len1 = num1.size(); 
    int len2 = num2.size(); 
    if (len1 == 0 || len2 == 0) 
    return "0"; 
    vector<int> result(len1 + len2, 0);
    int i_n1 = 0;  
    int i_n2 = 0;  
      
    // Go from right to left in num1 
    for (int i=len1-1; i>=0; i--) 
    { 
        int carry = 0; 
        int n1 = num1[i] - '0'; 
  
        // To shift position to left after every 
        // multiplication of a digit in num2 
        i_n2 = 0;  
          
        // Go from right to left in num2              
        for (int j=len2-1; j>=0; j--) 
        { 
            // Take current digit of second number 
            int n2 = num2[j] - '0'; 
  
            // Multiply with current digit of first number 
            // and add result to previously stored result 
            // at current position.  
            int sum = n1*n2 + result[i_n1 + i_n2] + carry; 
  
            // Carry for next iteration 
            carry = sum/10; 
  
            // Store result 
            result[i_n1 + i_n2] = sum % 10; 
  
            i_n2++; 
        } 
  
        // store carry in next cell 
        if (carry > 0) 
            result[i_n1 + i_n2] += carry; 
  
        // To shift position to left after every 
        // multiplication of a digit in num1. 
        i_n1++; 
    } 
  
    // ignore '0's from the right 
    int i = result.size() - 1; 
    while (i>=0 && result[i] == 0) 
    i--; 
  
    // If all were '0's - means either both or 
    // one of num1 or num2 were '0' 
    if (i == -1) 
    return "0"; 
  
    // generate the result string 
    string s = ""; 
      
    while (i >= 0) 
        s += std::to_string(result[i--]); 
  
    return s; 
} 


string longDivision(string number, int divisor) 
{ 
    // As result can be very large store it in string 
    string ans; 
  
    // Find prefix of number that is larger 
    // than divisor. 
    int idx = 0; 
    int temp = number[idx] - '0'; 
    while (temp < divisor) 
        temp = temp * 10 + (number[++idx] - '0'); 
  
    // Repeatedly divide divisor with temp. After 
    // every division, update temp to include one 
    // more digit. 
    while (number.size() > idx) { 
        // Store result in answer i.e. temp / divisor 
        ans += (temp / divisor) + '0'; 
  
        // Take next digit of number 
        temp = (temp % divisor) * 10 + number[++idx] - '0'; 
    } 
  
    // If divisor is greater than number 
    if (ans.length() == 0) 
        return "0"; 
  
    // else return ans 
    return ans; 
} 



signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int t=1;
    //cin>>t;
    while(t--)
    {
      int n;
      cin>>n;
      int a[n];
      for(int i=0;i<n;i++)
      {
          cin>>a[i];
      }
      int max=inf,min=0,co=1000;
      for(int i=0;i<n-1;i++)
      {
          if(a[i]<a[i+1])
          {
              int s=co/a[i];
              co=co%a[i];
              co+=(s*a[i+1]);
          }
          
      }
      cout<<co;
      
     
       
    }
   
}


Measured memory_bytes: 3664