#include <cstdint>
#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <algorithm>

static const std::array<const char*, 8> LETTER_NAMES = {
    "Phi", "Lambda", "Rho", "Kappa", "Omega", "Sigma", "Pi", "Zeta"
};

/* sigma3(n) = Sum_{d|n} d^3   (0 for n=0) */
uint64_t sigma3(uint64_t n) {
    if (n == 0) return 0;
    uint64_t sum = 0;
    for (uint64_t d = 1; d * d <= n; d++) {
        if (n % d == 0) {
            sum += d * d * d;
            uint64_t c = n / d;
            if (c != d)
                sum += c * c * c;
        }
    }
    return sum;
}

/* Map sigma3 value to Hachimoji letter index 0-7 */
int hachimoji_letter(uint64_t s) {
    return static_cast<int>(s % 8);
}

/* Cartan energy between two Hachimoji letter indices */
int cartan_weight(int a, int b) {
    if (a == b)      return 273;
    if (a / 2 == b / 2) return 256;
    return 0;
}

/* AngrySphinx gate: check if integer list passes energy budget.
   Returns true if collisions <= 1.
   collisions_out and energy_out are set via references. */
struct GateResult {
    bool passed;
    int  collisions;
    int  energy;
};

GateResult angrysphinx_gate(const std::vector<int>& elements) {
    int n = static_cast<int>(elements.size());
    int npairs = n * (n + 1) / 2;
    std::vector<int> sums;
    sums.reserve(npairs);

    for (int i = 0; i < n; i++)
        for (int j = i; j < n; j++)
            sums.push_back(elements[i] + elements[j]);

    int collisions = 0;
    for (size_t i = 0; i < sums.size(); i++)
        for (size_t j = i + 1; j < sums.size(); j++)
            if (sums[i] == sums[j])
                collisions++;

    int raw = 273 + 17 * collisions;
    int energy = (raw < 256 * collisions) ? 0 : (raw - 256 * collisions);

    return { collisions <= 1, collisions, energy };
}

/* Full encoding: compute sigma3, letter index, print row */
void hachimoji_encode(uint64_t n) {
    uint64_t s   = sigma3(n);
    int      idx = hachimoji_letter(s);
    std::cout << "  " << n << "  " << s << "  " << idx
              << "  " << LETTER_NAMES[idx] << "\n";
}

int main() {
    /* ---------- sigma3 assertions ---------- */
    assert(sigma3(0)  == 0);
    assert(sigma3(1)  == 1);
    assert(sigma3(2)  == 9);
    assert(sigma3(3)  == 28);
    assert(sigma3(4)  == 73);
    assert(sigma3(5)  == 126);
    assert(sigma3(6)  == 252);
    assert(sigma3(7)  == 344);
    assert(sigma3(8)  == 585);
    assert(sigma3(9)  == 757);
    assert(sigma3(10) == 1134);

    /* ---------- hachimoji_letter assertions ---------- */
    assert(hachimoji_letter(1)    == 1 % 8);
    assert(hachimoji_letter(9)    == 9 % 8);
    assert(hachimoji_letter(28)   == 28 % 8);
    assert(hachimoji_letter(73)   == 73 % 8);
    assert(hachimoji_letter(126)  == 126 % 8);
    assert(hachimoji_letter(252)  == 252 % 8);
    assert(hachimoji_letter(344)  == 344 % 8);
    assert(hachimoji_letter(585)  == 585 % 8);
    assert(hachimoji_letter(757)  == 757 % 8);
    assert(hachimoji_letter(1134) == 1134 % 8);

    /* ---------- cartan_weight assertions ---------- */
    assert(cartan_weight(0, 0) == 273);
    assert(cartan_weight(0, 1) == 256);
    assert(cartan_weight(0, 2) == 0);
    assert(cartan_weight(2, 3) == 256);
    assert(cartan_weight(3, 5) == 0);
    assert(cartan_weight(7, 7) == 273);

    /* ---------- AngrySphinx gate assertions ---------- */
    {
        auto r = angrysphinx_gate({1, 2});
        assert(r.passed == true);  assert(r.collisions == 0);  assert(r.energy == 273);
    }
    {
        auto r = angrysphinx_gate({1, 2, 3});
        assert(r.passed == true);  assert(r.collisions == 1);  assert(r.energy == 34);
    }
    {
        auto r = angrysphinx_gate({1, 2, 3, 4});
        assert(r.passed == false); assert(r.collisions == 3);  assert(r.energy == 0);
    }

    /* ========== Formatted output ========== */

    std::cout << "\nHachimoji Encoder Test Vector\n";
    std::cout << "=================================\n";
    std::cout << "  n     sigma3    Index  Letter\n";
    std::cout << "  ---   -------   -----  ------\n";
    for (uint64_t n = 1; n <= 10; n++)
        hachimoji_encode(n);

    std::cout << "\nAngrySphinx Gate Tests\n";
    std::cout << "=============================\n";
    std::cout << "  Elements         Passed  Collisions  Energy\n";
    std::cout << "  ---------------  ------  ----------  ------\n";

    std::vector<std::vector<int>> gate_tests = {
        {1, 2}, {1, 2, 3}, {1, 2, 3, 4}
    };
    for (const auto& el : gate_tests) {
        auto r = angrysphinx_gate(el);
        std::cout << "  [";
        for (size_t i = 0; i < el.size(); i++)
            std::cout << (i ? "," : "") << el[i];
        std::cout << "]  "
                  << (r.passed ? "true " : "false") << "      "
                  << r.collisions << "           "
                  << r.energy << "\n";
    }

    /* ---------- cartan matrix display ---------- */
    std::cout << "\nCartan Weight Matrix (8 x 8)\n";
    std::cout << "=============================\n";
    std::cout << "         ";
    for (int b = 0; b < 8; b++)
        std::cout << " " << LETTER_NAMES[b] << "    ";
    std::cout << "\n";
    for (int a = 0; a < 8; a++) {
        std::cout << "  " << LETTER_NAMES[a] << "  ";
        for (int b = 0; b < 8; b++)
            std::cout << " " << cartan_weight(a, b) << "    ";
        std::cout << "\n";
    }

    std::cout << "\nAll assertions passed.\n";
    return 0;
}