RIFC in 2-ary, unsigned integers

// RIFC in binary, or 2-ary if you will

#include <iostream>
#include <cmath>


namespace ct_rifc
{
    unsigned long store(unsigned long x)
    {
        unsigned long i = 0;
        unsigned long v = 0;
        unsigned long tree_val = 0;

        for (i = 0; v != x; ++i)
        {
            unsigned long bit = ((x >> i) % 2);

            v += bit * std::pow(2, i);

            unsigned long child_left = tree_val * 2 + 1;
            unsigned long child_right = tree_val * 2 + 2;

            if (bit == 0)
            {
                // left
                //std::cout << "store left\n";
                tree_val = child_left;
            }

            else
            {
                // right
                //std::cout << "store right\n";
                tree_val = child_right;
            }

            //std::cout << "bit = " << bit << "\n";
            //std::cout << "v = " << v << "\n";
            //std::cout << "tree_val = " << tree_val << "\n\n";
        }

        return tree_val / 2;
    }


    unsigned long load(unsigned long x)
    {
        x = x * 2;

        unsigned long x_tmp = x;
        unsigned long v = 0;
        unsigned long levels = 0;

        for (levels = 0; x_tmp != 0; ++levels)
        {
            x_tmp = (x_tmp - 1) / 2;
        }

        for (unsigned long i = 0; x != 0; ++i)
        {
            unsigned long parent = (x - 1) / 2;

            unsigned long child_left = parent * 2 + 1;
            unsigned long child_right = parent * 2 + 2;

            if (x == child_left)
            {
                // std::cout << "load left\n";
                //v += 0 * std::pow(2, levels - i - 1); // mul by zero, nothing.
            }

            else
            {
                //std::cout << "load right\n";
                v += 1 * std::pow(2, levels - i - 1);
            }

            x = parent;
        }

        return v;
    }


    void test()
    {
        for (unsigned long i = 0; i < 256; ++i)
        {
            unsigned long plaintext = i;

            unsigned long ciphertext = store(plaintext);

            unsigned long decrypted = load(ciphertext);

            //std::cout << "plaintext = " << plaintext << "\n";
            //std::cout << "ciphertext = " << ciphertext << "\n";
            //std::cout << "decrypted = " << decrypted << "\n";

            std::cout << "(pt, ct, dt) = " <<
                plaintext << ", " << ciphertext << ", " << decrypted << "\n";

            //std::cout << "\n";

            if (plaintext != decrypted)
            {
                std::cout << "FAILURE!\n";
                break;
            }
        }
    }
}


int main()
{
    {
        ct_rifc::test();

        std::cout << "\n\nFIN!\n";
    }

    //std::cin.get();

    return 0;
}