<|instruction|>
Solve the below problem. The solution should start with an abridged problem statement. Then key observations. Then full solution based on the observations. Then C++ and Python implementations with comments.

533. Dice Tower
Time limit per test: 1 second(s)
Memory limit: 262144 kilobytes
input: standard
output: standard

Polycarp loves not only to play games, but to invent ones as well. He has recently been presented with a board game which also had lots of dice. Polycarp quickly noticed an interesting phenomenon: the sum of dots on any two opposite sides equals 7.


The dice

An unfolded die
Polycarp invented the following game. He asks somebody to tell a positive integer n and then he constructs a dice tower putting the dice one on another one. A tower is constructed like that: Polycarp puts a die on the table and then (if he wants) he adds more dice, each time stacking a new die on the top of the tower. The dice in the tower are aligned by their edges so that they form a perfect rectangular parallelepiped. The parallelepiped's height equals the number of dice in the tower and two other dimensions equal 1 (if we accept that a die's side is equal to 1).


An example of a tower whose height equals 3
Polycarp's aim is to build a tower of minimum height given that the sum of points on all its outer surface should equal the given number n (outer surface: the side surface, the top and bottom faces).

Write a program that would determine the minimum number of dice in the required tower by the given number n. Polycarp can construct any towers whose height equals 1 or more.

Input
The only input line contains integer n (1 ≤ n ≤ 106).

Output
Print the only integer — the number of dice in the required tower. If no such tower exists, print -1.

Example(s)
sample input
sample output
50
3

sample input
sample output
7
-1

sample input
sample output
32
2

<|response|>
1. Abridged Problem Statement
Given a positive integer n (1 ≤ n ≤ 10^6), you must build a 1×1×k tower of standard dice (stacked face to face). Each die has opposite faces summing to 7. The sum of all exposed pips (the four side faces of each die, plus the very bottom face of the bottom die and the very top face of the top die) must equal n. Find the minimum k≥1 for which this is possible, or output –1 if no solution exists.

2. Key Observations
- A single die has six faces summing to 1+2+3+4+5+6 = 21.
- In a stacked tower, the interior faces between dice are hidden, so each die contributes exactly its four side faces (the lateral faces) plus—only for the topmost die its top face, and only for the bottommost die its bottom face.
- The sum of any two opposite faces is always 7.
- For each die in the middle of the tower, exactly four side faces are exposed; its top and bottom faces (which sum to 7) are hidden. So each such die contributes 21 – 7 = 14 pips from its four side faces.
- The bottommost die contributes 14 pips from its four sides plus the value x ∈ [1…6] on its bottom face.
- The topmost die contributes 14 pips from its four sides plus the value y ∈ [1…6] on its top face.
- Total exposed pips S = 14·k + x + y, where k is number of dice, x and y are in [1…6].
- Special case k=1: all six faces are exposed, so S≡21. In the formula S = 14·1 + x + y we would have x+y=7 exactly (because top and bottom are opposite faces), yielding S=21.

3. Full Solution Approach
1. If n=21, the answer is k=1 (one die shows all faces).
2. Otherwise assume k≥2. Let k = ⌊n / 14⌋ (the maximum number of "full 14's" not exceeding n) and rem = n − 14·k.
3. We need rem = x + y for some x,y ∈ [1…6]. Hence 2 ≤ rem ≤ 12.
4. If rem falls in [2…12], we can pick x and y to sum to rem, and k is our answer.
5. Otherwise no valid tower exists, print –1.

Edge conditions:
- If k computed as above is 0 (i.e. n<14) and n≠21, it is impossible.
- If k=1 but n≠21, no solution (because a single die always sums to 21).
- If rem<2 or rem>12, no pair of faces can give that sum.

Time complexity is O(1) and memory O(1).

4. C++ Implementation with Detailed Comments

```cpp
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int n;

void read() { cin >> n; }

void solve() {
    // The four side faces of one die always sum to 14 (the six faces sum to 21
    // and the hidden top/bottom pair sums to 7). So a tower of h dice exposes
    // 14 * h dots on its sides, plus the very top face and the very bottom
    // face. For h >= 2 those two extreme faces are independent, each in 1..6,
    // contributing any s in [2, 12]; thus n = 14 * h + s with s = n % 14 forces
    // s to lie in [2, 12]. For h = 1 the top and bottom are opposite faces of
    // the same die and sum to exactly 7, so the only achievable total is 21.

    int num_dice = n / 14;
    int rem = n % 14;

    if(num_dice == 1 && n != 21) {
        cout << -1 << '\n';
    } else if(num_dice == 0 || rem <= 1 || rem == 13) {
        cout << -1 << '\n';
    } else {
        cout << num_dice << '\n';
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}
```

5. Python Implementation with Detailed Comments

```python
def solve():
    # Read the target sum n
    n = int(input().strip())

    # Base splits off as many full '14 per die' as possible
    k = n // 14
    rem = n % 14

    # Case k=1: only possible if the single die shows all faces => sum=21
    if k == 1 and n != 21:
        print(-1)
        return

    # If k=0 => n < 14 (and only n=21 works but that's k=1)
    # If remainder rem <= 1 or rem >= 13 => no way to choose top+bottom faces in [1..6]
    if k == 0 or rem <= 1 or rem >= 13:
        print(-1)
    else:
        # We can pick two face-values x,y in [1..6] summing to rem (2..12)
        print(k)

if __name__ == "__main__":
    solve()
```

Explanation of key steps:
- We immediately handle n=21 as the only valid one-die configuration via the k=1 check.
- For larger n, we greedily use as many 14-pip contributions as possible (each middle die) and then see if the leftover rem can be split into two faces in [1…6].
- If rem is between 2 and 12 inclusive, we succeed with k dice; otherwise, no solution exists.
