```
class Solution {
private:
inline int calPow(int a, int b) {
if(b == 0) return 1;
long long t = calPow(a, b / 2);
return b & 1 ? (t * t * a) % 1337 : (t * t) % 1337;
}
public:
int superPow(int a, vector<int>& b) {
if(b.empty()) return 1;
int t = 0, pow = 1;
for(int i = 0; i < 9; i++) {
if(b.empty()) break;
t = t + b.back() * pow;
pow *= 10;
b.pop_back();
}
return calPow(superPow(a, b), 1000000000) * calPow(a, t) % 1337;
}
};
```

## Explain

The **most common solution** is compute it digit by digit, like:

```
calPow(superPow(a, b), 10) * calPow(a, t) % 1337;
```

**However**, there is still a different way to make it faster.

First, We can recursively compute a^2k = (a^k)^2, so for pow(a, b), then any b < 2^31 can be computed within 32 times '%'. It's a widely used **fast pow algorithm**.

Then, **for this problem**, instead of compute it digit by digit, every time we can compute **9 digits** using this algorithm. Make it **9x** faster.

Maybe it's not the fastest algorithm, but it's a common and easy method to make the code faster. As we know, **% operation is very time consuming**. Using this method, we could significantly reduce the usage of % operation.

Also, this trick can be used in other problems when we need to compute extremely large integers.