#include <stdio.h>
#include <vector>
#include <set>
#include <map>
// Constants
typedef long long int lld;
const lld R = 1000 * 1000 * 1000 + 7; // a^(R-1) = 1 (mod R)
const lld matrixRemainder = R-1;
// Matrix class
class matrix{
public:
// Attributes
int row, col;
std::vector<std::vector<lld>> num;
// Constructor
matrix(int row, int col, int defaultValue = 0){
this->num = std::vector<std::vector<lld>>(row, std::vector<lld>(col, defaultValue));
this->row = row, this->col = col;
}
matrix(std::vector<std::vector<lld>> num){
this->num = num;
this->row = this->num.size();
this->col = this->num[0].size();
}
// Operator
matrix operator *(matrix &another){
if(this->col != another.row){
printf("Wrong size: %d*%d X %d*%d\n", this->row, this->col, another.row, another.col);
throw "Wrong size";
}
matrix newone(this->row, another.col);
for(int r=0; r<newone.row; r++) for(int c=0; c<newone.col; c++){
for(int k=0; k<this->col; k++){
newone.num[r][c] += this->num[r][k] * another.num[k][c];
newone.num[r][c] %= matrixRemainder;
}
} return newone;
}
// Power
matrix operator ^(lld x){
if(x==0){
printf("Not implemented yet.\n");
throw "Not implemented";
}
else if(x==1) return *this;
else{
matrix halfpower = (*this) ^ (x/2);
if(x%2 == 0) return halfpower * halfpower;
else return halfpower * halfpower * (*this);
}
}
};
// Prime related
const int limit = 1<<20;
bool isPrime[limit] = {false, };
std::vector<lld> primes;
// Decomposite given value to primes
std::vector<lld> primeDecomposition(lld x){
std::vector<lld> answer;
for(lld p: primes){
if(x <= 1) break;
else if(x%p == 0){
answer.push_back(p);
while(x%p == 0) x /= p;
}
else if(p*p > x){
answer.push_back(x);
break;
}
} return answer;
}
// Return a^x % R
lld power(lld a, lld x){
if(x==0) return 1;
lld half = power(a, x/2);
if(x%2 == 0) return half*half%R;
else return half*half%R*a%R;
}
// Main function
int main(void){
// Matrix functionality testing
//matrix a1({{1, 2}, {0, 1}}), a2({{3, 2}, {-1, 0}});
//matrix b = a1*a2;
//printf("a1*a2 = \n %lld %lld\n %lld %lld\n", b.num[0][0], b.num[0][1], b.num[1][0], b.num[1][1]);
// Calculate primes
for(int i=2; i<limit; i++) isPrime[i] = true;
for(int i=2; i<limit; i++) if(isPrime[i]){
primes.push_back((lld)i);
for(int j=2*i; j<limit; j+=i) isPrime[j] = false;
}
// Get input
lld n, f[4], c; scanf("%lld %lld %lld %lld %lld", &n, &f[1], &f[2], &f[3], &c);
matrix baseLogPropagate({{1, 1, 1}, {1, 0, 0}, {0, 1, 0}});
matrix totalLogPropagate = baseLogPropagate ^ (n-3);
// Calculate target primes
std::set<lld> knownprimes;
for(int i=1; i<=3; i++) for(lld p: primeDecomposition(f[i])) knownprimes.insert(p);
for(lld p: primeDecomposition(c)) knownprimes.insert(p);
//printf("Known primes: "); for(lld knownprime: knownprimes) printf("%lld, ", knownprime); printf("\n");
// Calculate c^n * f[n]'s prime count: initPrimeCount[x]: f[3-x]'s p-occurrence
std::map<lld, lld> fnPrimeCount;
for(lld p: knownprimes){
matrix initPrimeCount(3, 1);
for(int i=1; i<=3; i++){
for(lld num = f[i]; num%p == 0; num /= p) initPrimeCount.num[3-i][0]++; // f[n]
for(lld num = c; num%p == 0; num /= p) initPrimeCount.num[3-i][0] += i; // c^n
}
matrix lastPrimeCount = totalLogPropagate * initPrimeCount;
fnPrimeCount[p] = lastPrimeCount.num[0][0];
}
// Calculate answer = product(p^fnPrimeCount[p]) * c^(-n)
lld answer = 1;
for(auto pinfo: fnPrimeCount){
//printf("%lld-occurrence = %lld\n", pinfo.first, pinfo.second);
answer *= power(pinfo.first, pinfo.second);
answer %= R;
}
answer *= power(power(c, R-2), n); answer %= R;
printf("%lld\n", answer);
return 0;
}