<p>Given a signed 32-bit integer <code>x</code>, return <code>x</code><em> with its digits reversed</em>. If reversing <code>x</code> causes the value to go outside the signed 32-bit integer range <code>[-2<sup>31</sup>, 2<sup>31</sup> - 1]</code>, then return <code>0</code>.</p>

<p><strong>Assume the environment does not allow you to store 64-bit integers (signed or unsigned).</strong></p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> x = 123
<strong>Output:</strong> 321
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> x = -123
<strong>Output:</strong> -321
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> x = 120
<strong>Output:</strong> 21
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>-2<sup>31</sup> &lt;= x &lt;= 2<sup>31</sup> - 1</code></li>
</ul>

class Solution {
private:
    bool overflowNum(const int& digit, const int& n) {
      if (digit > 2 && n > 8) return true;
      return false;
    }

    bool overflowNum(const int& max_num, const int& a, const int& b) {
      if (a > max_num - b) return true;
      return false;
    }
public:
    int reverse(int x) {
       int max_num = numeric_limits<int>::max();
       bool neg = x < 0 ? true : false;
      //  x = x < 0 ? -x : x;
       int rev_num = 0;
       vector<int> digits;
       while (x) {
         digits.push_back(abs(x % 10));
         x /= 10;
       }
       bool leading_zero = true;
       int pos = digits.size();
       for (const int& digit : digits) {
         pos -= 1;
         cout << digit << ": " << pos << "\n";
         if (digit == 0 && leading_zero) continue;
         if (overflowNum(digit, pos)) return 0;
         int n = digit * pow(10, pos);
         if (overflowNum(max_num, rev_num, n)) return 0;
         rev_num += n;
       }
       if (neg) return -rev_num;
       return rev_num;
    }
};
8900