halton.h

Go to the documentation of this file.

#pragma once
 
#include "Core/SampleGenerator/Halton/halton_fwd.h"
#include "Math/math.h"
#include "Math/math_table.h"
#include "Math/Random/Quasi/radical_inverse.h"
#include "Math/Random/shuffle.h"
#include "Math/hash.h"
 
#include <Common/assertion.h>
#include <Common/primitive_type.h>
#include <Common/logging.h>
 
#include <cstddef>
#include <limits>
#include <memory>
#include <utility>
 
namespace ph::halton_detail
{
 
static_assert(MAX_DIMENSIONS <= math::table::PRIME.size());
 
static_assert(math::table::PRIME[MAX_DIMENSIONS] <= std::numeric_limits<TableDigit>::max(),
    "`TableDigit` may overflow. Consider using a larger type.");
 
inline PermutationTable make_table(const std::size_t size)
{
    return std::make_unique<TableDigit[]>(size);
}
 
class FixedPermuter final
{
public:
    static PermutationTable makeTable(const std::size_t dimIndex)
    {
        const auto base = math::table::PRIME[dimIndex];
 
        // Every digit value has an entry
        const std::size_t tableSize = base;
        auto table = make_table(tableSize);
 
        /*PH_DEFAULT_LOG(
            "Halton fixed permuter table size = {}, memory used = {} bytes",
            tableSize, tableSize * sizeof(TableDigit));*/
 
        // Generate random permutation/mapping for each digit value
        for(TableDigit digit = 0; digit < base; ++digit)
        {
            table[digit] = digit;
        }
        math::shuffle_durstenfeld(table.get(), table.get() + base);
 
        return table;
    }
 
    explicit FixedPermuter(const PermutationTable& table)
        : m_table(table)
    {}
 
    template<auto BASE>
    uint64 operator () (const uint64 /* dimIndex */, const uint64 digit) const
    {
        return m_table[digit];
    }
 
private:
    const PermutationTable& m_table;
};
 
class PerDigitPermuter final
{
public:
    static PermutationTable makeTable(const std::size_t dimIndex)
    {
        const auto base = math::table::PRIME[dimIndex];
        const auto maxDigits = math::radical_inverse_detail::num_meaningful_digits<real>(base);
 
        // Each digit index has its own digit value mapping
        const std::size_t tableSize = base * maxDigits;
        auto table = make_table(tableSize);
 
        /*PH_DEFAULT_LOG(
            "Halton per-digit permuter table size = {}, memory used = {} bytes",
            tableSize, tableSize * sizeof(TableDigit));*/
 
        for(TableDigit digitIndex = 0; digitIndex < maxDigits; ++digitIndex)
        {
            // Generate random digit permutation/mapping for each digit value
            for(TableDigit digit = 0; digit < base; ++digit)
            {
                table[digitIndex * base + digit] = digit;
            }
 
            math::shuffle_durstenfeld(
                table.get() + digitIndex * base,
                table.get() + (digitIndex + 1) * base);
        }
 
        return table;
    }
 
    explicit PerDigitPermuter(const PermutationTable& table)
        : m_table(table)
        , m_currentDigitIndex(0)
    {}
 
    template<auto BASE>
    uint64 operator () (const uint64 /* dimIndex */, const uint64 digit)
    {
        PH_ASSERT_LT(m_currentDigitIndex, math::radical_inverse_detail::num_meaningful_digits<real>(BASE));
 
        const auto permutedDigit = m_table[m_currentDigitIndex * BASE + digit];
        ++m_currentDigitIndex;
        return permutedDigit;
    }
 
private:
    const PermutationTable& m_table;
    TableDigit m_currentDigitIndex;
};
 
class OwenScrambledPermuter final
{
public:
    explicit OwenScrambledPermuter(const uint64 dimIndex)
        : m_currentHash(math::moremur_bit_mix_64((dimIndex << 4) + 1))
        , m_scrambledDigits(0)
#if PH_DEBUG
        , m_currentDigitIndex(0)
#endif
    {}
 
    template<auto BASE>
    uint64 operator () (const uint64 /* dimIndex */, const uint64 digit)
    {
        PH_ASSERT_LT(m_currentDigitIndex, math::radical_inverse_detail::num_meaningful_digits<real>(BASE));
 
        // Incorporate previous digits into the hash
        m_currentHash = math::moremur_bit_mix_64(m_currentHash ^ m_scrambledDigits);
 
        const auto scrambledDigit = math::permuted_index(
            static_cast<uint32>(digit), static_cast<uint32>(BASE), static_cast<uint32>(m_currentHash));
 
        // Push the new digit
        m_scrambledDigits = m_scrambledDigits * BASE + scrambledDigit;
 
#if PH_DEBUG
        ++m_currentDigitIndex;
#endif
        return scrambledDigit;
    }
 
private:
    uint64 m_currentHash;
    uint64 m_scrambledDigits;
#if PH_DEBUG
    TableDigit m_currentDigitIndex;
#endif
}; 
 
inline real radical_inverse(const uint64 dimIndex, const uint64 value)
{
    PH_ASSERT_LT(dimIndex, MAX_DIMENSIONS);
 
    switch(dimIndex)
    {
    default: PH_ASSERT_UNREACHABLE_SECTION(); return 0.0_r;
    case 0: return math::radical_inverse<math::table::PRIME[0], real>(value);
    case 1: return math::radical_inverse<math::table::PRIME[1], real>(value);
    case 2: return math::radical_inverse<math::table::PRIME[2], real>(value);
    case 3: return math::radical_inverse<math::table::PRIME[3], real>(value);
    case 4: return math::radical_inverse<math::table::PRIME[4], real>(value);
    case 5: return math::radical_inverse<math::table::PRIME[5], real>(value);
    case 6: return math::radical_inverse<math::table::PRIME[6], real>(value);
    case 7: return math::radical_inverse<math::table::PRIME[7], real>(value);
    case 8: return math::radical_inverse<math::table::PRIME[8], real>(value);
    case 9: return math::radical_inverse<math::table::PRIME[9], real>(value);
    case 10: return math::radical_inverse<math::table::PRIME[10], real>(value);
    case 11: return math::radical_inverse<math::table::PRIME[11], real>(value);
    case 12: return math::radical_inverse<math::table::PRIME[12], real>(value);
    case 13: return math::radical_inverse<math::table::PRIME[13], real>(value);
    case 14: return math::radical_inverse<math::table::PRIME[14], real>(value);
    case 15: return math::radical_inverse<math::table::PRIME[15], real>(value);
    case 16: return math::radical_inverse<math::table::PRIME[16], real>(value);
    case 17: return math::radical_inverse<math::table::PRIME[17], real>(value);
    case 18: return math::radical_inverse<math::table::PRIME[18], real>(value);
    case 19: return math::radical_inverse<math::table::PRIME[19], real>(value);
    case 20: return math::radical_inverse<math::table::PRIME[20], real>(value);
    case 21: return math::radical_inverse<math::table::PRIME[21], real>(value);
    case 22: return math::radical_inverse<math::table::PRIME[22], real>(value);
    case 23: return math::radical_inverse<math::table::PRIME[23], real>(value);
    case 24: return math::radical_inverse<math::table::PRIME[24], real>(value);
    case 25: return math::radical_inverse<math::table::PRIME[25], real>(value);
    case 26: return math::radical_inverse<math::table::PRIME[26], real>(value);
    case 27: return math::radical_inverse<math::table::PRIME[27], real>(value);
    case 28: return math::radical_inverse<math::table::PRIME[28], real>(value);
    case 29: return math::radical_inverse<math::table::PRIME[29], real>(value);
    case 30: return math::radical_inverse<math::table::PRIME[30], real>(value);
    case 31: return math::radical_inverse<math::table::PRIME[31], real>(value);
    case 32: return math::radical_inverse<math::table::PRIME[32], real>(value);
    case 33: return math::radical_inverse<math::table::PRIME[33], real>(value);
    case 34: return math::radical_inverse<math::table::PRIME[34], real>(value);
    case 35: return math::radical_inverse<math::table::PRIME[35], real>(value);
    case 36: return math::radical_inverse<math::table::PRIME[36], real>(value);
    case 37: return math::radical_inverse<math::table::PRIME[37], real>(value);
    case 38: return math::radical_inverse<math::table::PRIME[38], real>(value);
    case 39: return math::radical_inverse<math::table::PRIME[39], real>(value);
    case 40: return math::radical_inverse<math::table::PRIME[40], real>(value);
    case 41: return math::radical_inverse<math::table::PRIME[41], real>(value);
    case 42: return math::radical_inverse<math::table::PRIME[42], real>(value);
    case 43: return math::radical_inverse<math::table::PRIME[43], real>(value);
    case 44: return math::radical_inverse<math::table::PRIME[44], real>(value);
    case 45: return math::radical_inverse<math::table::PRIME[45], real>(value);
    case 46: return math::radical_inverse<math::table::PRIME[46], real>(value);
    case 47: return math::radical_inverse<math::table::PRIME[47], real>(value);
    case 48: return math::radical_inverse<math::table::PRIME[48], real>(value);
    case 49: return math::radical_inverse<math::table::PRIME[49], real>(value);
    case 50: return math::radical_inverse<math::table::PRIME[50], real>(value);
    case 51: return math::radical_inverse<math::table::PRIME[51], real>(value);
    case 52: return math::radical_inverse<math::table::PRIME[52], real>(value);
    case 53: return math::radical_inverse<math::table::PRIME[53], real>(value);
    case 54: return math::radical_inverse<math::table::PRIME[54], real>(value);
    case 55: return math::radical_inverse<math::table::PRIME[55], real>(value);
    case 56: return math::radical_inverse<math::table::PRIME[56], real>(value);
    case 57: return math::radical_inverse<math::table::PRIME[57], real>(value);
    case 58: return math::radical_inverse<math::table::PRIME[58], real>(value);
    case 59: return math::radical_inverse<math::table::PRIME[59], real>(value);
    case 60: return math::radical_inverse<math::table::PRIME[60], real>(value);
    case 61: return math::radical_inverse<math::table::PRIME[61], real>(value);
    case 62: return math::radical_inverse<math::table::PRIME[62], real>(value);
    case 63: return math::radical_inverse<math::table::PRIME[63], real>(value);
    case 64: return math::radical_inverse<math::table::PRIME[64], real>(value);
    case 65: return math::radical_inverse<math::table::PRIME[65], real>(value);
    case 66: return math::radical_inverse<math::table::PRIME[66], real>(value);
    case 67: return math::radical_inverse<math::table::PRIME[67], real>(value);
    case 68: return math::radical_inverse<math::table::PRIME[68], real>(value);
    case 69: return math::radical_inverse<math::table::PRIME[69], real>(value);
    case 70: return math::radical_inverse<math::table::PRIME[70], real>(value);
    case 71: return math::radical_inverse<math::table::PRIME[71], real>(value);
    case 72: return math::radical_inverse<math::table::PRIME[72], real>(value);
    case 73: return math::radical_inverse<math::table::PRIME[73], real>(value);
    case 74: return math::radical_inverse<math::table::PRIME[74], real>(value);
    case 75: return math::radical_inverse<math::table::PRIME[75], real>(value);
    case 76: return math::radical_inverse<math::table::PRIME[76], real>(value);
    case 77: return math::radical_inverse<math::table::PRIME[77], real>(value);
    case 78: return math::radical_inverse<math::table::PRIME[78], real>(value);
    case 79: return math::radical_inverse<math::table::PRIME[79], real>(value);
    case 80: return math::radical_inverse<math::table::PRIME[80], real>(value);
    case 81: return math::radical_inverse<math::table::PRIME[81], real>(value);
    case 82: return math::radical_inverse<math::table::PRIME[82], real>(value);
    case 83: return math::radical_inverse<math::table::PRIME[83], real>(value);
    case 84: return math::radical_inverse<math::table::PRIME[84], real>(value);
    case 85: return math::radical_inverse<math::table::PRIME[85], real>(value);
    case 86: return math::radical_inverse<math::table::PRIME[86], real>(value);
    case 87: return math::radical_inverse<math::table::PRIME[87], real>(value);
    case 88: return math::radical_inverse<math::table::PRIME[88], real>(value);
    case 89: return math::radical_inverse<math::table::PRIME[89], real>(value);
    case 90: return math::radical_inverse<math::table::PRIME[90], real>(value);
    case 91: return math::radical_inverse<math::table::PRIME[91], real>(value);
    case 92: return math::radical_inverse<math::table::PRIME[92], real>(value);
    case 93: return math::radical_inverse<math::table::PRIME[93], real>(value);
    case 94: return math::radical_inverse<math::table::PRIME[94], real>(value);
    case 95: return math::radical_inverse<math::table::PRIME[95], real>(value);
    case 96: return math::radical_inverse<math::table::PRIME[96], real>(value);
    case 97: return math::radical_inverse<math::table::PRIME[97], real>(value);
    case 98: return math::radical_inverse<math::table::PRIME[98], real>(value);
    case 99: return math::radical_inverse<math::table::PRIME[99], real>(value);
    case 100: return math::radical_inverse<math::table::PRIME[100], real>(value);
    case 101: return math::radical_inverse<math::table::PRIME[101], real>(value);
    case 102: return math::radical_inverse<math::table::PRIME[102], real>(value);
    case 103: return math::radical_inverse<math::table::PRIME[103], real>(value);
    case 104: return math::radical_inverse<math::table::PRIME[104], real>(value);
    case 105: return math::radical_inverse<math::table::PRIME[105], real>(value);
    case 106: return math::radical_inverse<math::table::PRIME[106], real>(value);
    case 107: return math::radical_inverse<math::table::PRIME[107], real>(value);
    case 108: return math::radical_inverse<math::table::PRIME[108], real>(value);
    case 109: return math::radical_inverse<math::table::PRIME[109], real>(value);
    case 110: return math::radical_inverse<math::table::PRIME[110], real>(value);
    case 111: return math::radical_inverse<math::table::PRIME[111], real>(value);
    case 112: return math::radical_inverse<math::table::PRIME[112], real>(value);
    case 113: return math::radical_inverse<math::table::PRIME[113], real>(value);
    case 114: return math::radical_inverse<math::table::PRIME[114], real>(value);
    case 115: return math::radical_inverse<math::table::PRIME[115], real>(value);
    case 116: return math::radical_inverse<math::table::PRIME[116], real>(value);
    case 117: return math::radical_inverse<math::table::PRIME[117], real>(value);
    case 118: return math::radical_inverse<math::table::PRIME[118], real>(value);
    case 119: return math::radical_inverse<math::table::PRIME[119], real>(value);
    case 120: return math::radical_inverse<math::table::PRIME[120], real>(value);
    case 121: return math::radical_inverse<math::table::PRIME[121], real>(value);
    case 122: return math::radical_inverse<math::table::PRIME[122], real>(value);
    case 123: return math::radical_inverse<math::table::PRIME[123], real>(value);
    case 124: return math::radical_inverse<math::table::PRIME[124], real>(value);
    case 125: return math::radical_inverse<math::table::PRIME[125], real>(value);
    case 126: return math::radical_inverse<math::table::PRIME[126], real>(value);
    case 127: return math::radical_inverse<math::table::PRIME[127], real>(value);
    case 128: return math::radical_inverse<math::table::PRIME[128], real>(value);
    case 129: return math::radical_inverse<math::table::PRIME[129], real>(value);
    case 130: return math::radical_inverse<math::table::PRIME[130], real>(value);
    case 131: return math::radical_inverse<math::table::PRIME[131], real>(value);
    case 132: return math::radical_inverse<math::table::PRIME[132], real>(value);
    case 133: return math::radical_inverse<math::table::PRIME[133], real>(value);
    case 134: return math::radical_inverse<math::table::PRIME[134], real>(value);
    case 135: return math::radical_inverse<math::table::PRIME[135], real>(value);
    case 136: return math::radical_inverse<math::table::PRIME[136], real>(value);
    case 137: return math::radical_inverse<math::table::PRIME[137], real>(value);
    case 138: return math::radical_inverse<math::table::PRIME[138], real>(value);
    case 139: return math::radical_inverse<math::table::PRIME[139], real>(value);
    case 140: return math::radical_inverse<math::table::PRIME[140], real>(value);
    case 141: return math::radical_inverse<math::table::PRIME[141], real>(value);
    case 142: return math::radical_inverse<math::table::PRIME[142], real>(value);
    case 143: return math::radical_inverse<math::table::PRIME[143], real>(value);
    case 144: return math::radical_inverse<math::table::PRIME[144], real>(value);
    case 145: return math::radical_inverse<math::table::PRIME[145], real>(value);
    case 146: return math::radical_inverse<math::table::PRIME[146], real>(value);
    case 147: return math::radical_inverse<math::table::PRIME[147], real>(value);
    case 148: return math::radical_inverse<math::table::PRIME[148], real>(value);
    case 149: return math::radical_inverse<math::table::PRIME[149], real>(value);
    case 150: return math::radical_inverse<math::table::PRIME[150], real>(value);
    case 151: return math::radical_inverse<math::table::PRIME[151], real>(value);
    case 152: return math::radical_inverse<math::table::PRIME[152], real>(value);
    case 153: return math::radical_inverse<math::table::PRIME[153], real>(value);
    case 154: return math::radical_inverse<math::table::PRIME[154], real>(value);
    case 155: return math::radical_inverse<math::table::PRIME[155], real>(value);
    case 156: return math::radical_inverse<math::table::PRIME[156], real>(value);
    case 157: return math::radical_inverse<math::table::PRIME[157], real>(value);
    case 158: return math::radical_inverse<math::table::PRIME[158], real>(value);
    case 159: return math::radical_inverse<math::table::PRIME[159], real>(value);
    case 160: return math::radical_inverse<math::table::PRIME[160], real>(value);
    case 161: return math::radical_inverse<math::table::PRIME[161], real>(value);
    case 162: return math::radical_inverse<math::table::PRIME[162], real>(value);
    case 163: return math::radical_inverse<math::table::PRIME[163], real>(value);
    case 164: return math::radical_inverse<math::table::PRIME[164], real>(value);
    case 165: return math::radical_inverse<math::table::PRIME[165], real>(value);
    case 166: return math::radical_inverse<math::table::PRIME[166], real>(value);
    case 167: return math::radical_inverse<math::table::PRIME[167], real>(value);
    case 168: return math::radical_inverse<math::table::PRIME[168], real>(value);
    case 169: return math::radical_inverse<math::table::PRIME[169], real>(value);
    case 170: return math::radical_inverse<math::table::PRIME[170], real>(value);
    case 171: return math::radical_inverse<math::table::PRIME[171], real>(value);
    case 172: return math::radical_inverse<math::table::PRIME[172], real>(value);
    case 173: return math::radical_inverse<math::table::PRIME[173], real>(value);
    case 174: return math::radical_inverse<math::table::PRIME[174], real>(value);
    case 175: return math::radical_inverse<math::table::PRIME[175], real>(value);
    case 176: return math::radical_inverse<math::table::PRIME[176], real>(value);
    case 177: return math::radical_inverse<math::table::PRIME[177], real>(value);
    case 178: return math::radical_inverse<math::table::PRIME[178], real>(value);
    case 179: return math::radical_inverse<math::table::PRIME[179], real>(value);
    case 180: return math::radical_inverse<math::table::PRIME[180], real>(value);
    case 181: return math::radical_inverse<math::table::PRIME[181], real>(value);
    case 182: return math::radical_inverse<math::table::PRIME[182], real>(value);
    case 183: return math::radical_inverse<math::table::PRIME[183], real>(value);
    case 184: return math::radical_inverse<math::table::PRIME[184], real>(value);
    case 185: return math::radical_inverse<math::table::PRIME[185], real>(value);
    case 186: return math::radical_inverse<math::table::PRIME[186], real>(value);
    case 187: return math::radical_inverse<math::table::PRIME[187], real>(value);
    case 188: return math::radical_inverse<math::table::PRIME[188], real>(value);
    case 189: return math::radical_inverse<math::table::PRIME[189], real>(value);
    case 190: return math::radical_inverse<math::table::PRIME[190], real>(value);
    case 191: return math::radical_inverse<math::table::PRIME[191], real>(value);
    case 192: return math::radical_inverse<math::table::PRIME[192], real>(value);
    case 193: return math::radical_inverse<math::table::PRIME[193], real>(value);
    case 194: return math::radical_inverse<math::table::PRIME[194], real>(value);
    case 195: return math::radical_inverse<math::table::PRIME[195], real>(value);
    case 196: return math::radical_inverse<math::table::PRIME[196], real>(value);
    case 197: return math::radical_inverse<math::table::PRIME[197], real>(value);
    case 198: return math::radical_inverse<math::table::PRIME[198], real>(value);
    case 199: return math::radical_inverse<math::table::PRIME[199], real>(value);
    case 200: return math::radical_inverse<math::table::PRIME[200], real>(value);
    case 201: return math::radical_inverse<math::table::PRIME[201], real>(value);
    case 202: return math::radical_inverse<math::table::PRIME[202], real>(value);
    case 203: return math::radical_inverse<math::table::PRIME[203], real>(value);
    case 204: return math::radical_inverse<math::table::PRIME[204], real>(value);
    case 205: return math::radical_inverse<math::table::PRIME[205], real>(value);
    case 206: return math::radical_inverse<math::table::PRIME[206], real>(value);
    case 207: return math::radical_inverse<math::table::PRIME[207], real>(value);
    case 208: return math::radical_inverse<math::table::PRIME[208], real>(value);
    case 209: return math::radical_inverse<math::table::PRIME[209], real>(value);
    case 210: return math::radical_inverse<math::table::PRIME[210], real>(value);
    case 211: return math::radical_inverse<math::table::PRIME[211], real>(value);
    case 212: return math::radical_inverse<math::table::PRIME[212], real>(value);
    case 213: return math::radical_inverse<math::table::PRIME[213], real>(value);
    case 214: return math::radical_inverse<math::table::PRIME[214], real>(value);
    case 215: return math::radical_inverse<math::table::PRIME[215], real>(value);
    case 216: return math::radical_inverse<math::table::PRIME[216], real>(value);
    case 217: return math::radical_inverse<math::table::PRIME[217], real>(value);
    case 218: return math::radical_inverse<math::table::PRIME[218], real>(value);
    case 219: return math::radical_inverse<math::table::PRIME[219], real>(value);
    case 220: return math::radical_inverse<math::table::PRIME[220], real>(value);
    case 221: return math::radical_inverse<math::table::PRIME[221], real>(value);
    case 222: return math::radical_inverse<math::table::PRIME[222], real>(value);
    case 223: return math::radical_inverse<math::table::PRIME[223], real>(value);
    case 224: return math::radical_inverse<math::table::PRIME[224], real>(value);
    case 225: return math::radical_inverse<math::table::PRIME[225], real>(value);
    case 226: return math::radical_inverse<math::table::PRIME[226], real>(value);
    case 227: return math::radical_inverse<math::table::PRIME[227], real>(value);
    case 228: return math::radical_inverse<math::table::PRIME[228], real>(value);
    case 229: return math::radical_inverse<math::table::PRIME[229], real>(value);
    case 230: return math::radical_inverse<math::table::PRIME[230], real>(value);
    case 231: return math::radical_inverse<math::table::PRIME[231], real>(value);
    case 232: return math::radical_inverse<math::table::PRIME[232], real>(value);
    case 233: return math::radical_inverse<math::table::PRIME[233], real>(value);
    case 234: return math::radical_inverse<math::table::PRIME[234], real>(value);
    case 235: return math::radical_inverse<math::table::PRIME[235], real>(value);
    case 236: return math::radical_inverse<math::table::PRIME[236], real>(value);
    case 237: return math::radical_inverse<math::table::PRIME[237], real>(value);
    case 238: return math::radical_inverse<math::table::PRIME[238], real>(value);
    case 239: return math::radical_inverse<math::table::PRIME[239], real>(value);
    case 240: return math::radical_inverse<math::table::PRIME[240], real>(value);
    case 241: return math::radical_inverse<math::table::PRIME[241], real>(value);
    case 242: return math::radical_inverse<math::table::PRIME[242], real>(value);
    case 243: return math::radical_inverse<math::table::PRIME[243], real>(value);
    case 244: return math::radical_inverse<math::table::PRIME[244], real>(value);
    case 245: return math::radical_inverse<math::table::PRIME[245], real>(value);
    case 246: return math::radical_inverse<math::table::PRIME[246], real>(value);
    case 247: return math::radical_inverse<math::table::PRIME[247], real>(value);
    case 248: return math::radical_inverse<math::table::PRIME[248], real>(value);
    case 249: return math::radical_inverse<math::table::PRIME[249], real>(value);
    case 250: return math::radical_inverse<math::table::PRIME[250], real>(value);
    case 251: return math::radical_inverse<math::table::PRIME[251], real>(value);
    case 252: return math::radical_inverse<math::table::PRIME[252], real>(value);
    case 253: return math::radical_inverse<math::table::PRIME[253], real>(value);
    case 254: return math::radical_inverse<math::table::PRIME[254], real>(value);
    case 255: return math::radical_inverse<math::table::PRIME[255], real>(value);
    case 256: return math::radical_inverse<math::table::PRIME[256], real>(value);
    case 257: return math::radical_inverse<math::table::PRIME[257], real>(value);
    case 258: return math::radical_inverse<math::table::PRIME[258], real>(value);
    case 259: return math::radical_inverse<math::table::PRIME[259], real>(value);
    case 260: return math::radical_inverse<math::table::PRIME[260], real>(value);
    case 261: return math::radical_inverse<math::table::PRIME[261], real>(value);
    case 262: return math::radical_inverse<math::table::PRIME[262], real>(value);
    case 263: return math::radical_inverse<math::table::PRIME[263], real>(value);
    case 264: return math::radical_inverse<math::table::PRIME[264], real>(value);
    case 265: return math::radical_inverse<math::table::PRIME[265], real>(value);
    case 266: return math::radical_inverse<math::table::PRIME[266], real>(value);
    case 267: return math::radical_inverse<math::table::PRIME[267], real>(value);
    case 268: return math::radical_inverse<math::table::PRIME[268], real>(value);
    case 269: return math::radical_inverse<math::table::PRIME[269], real>(value);
    case 270: return math::radical_inverse<math::table::PRIME[270], real>(value);
    case 271: return math::radical_inverse<math::table::PRIME[271], real>(value);
    case 272: return math::radical_inverse<math::table::PRIME[272], real>(value);
    case 273: return math::radical_inverse<math::table::PRIME[273], real>(value);
    case 274: return math::radical_inverse<math::table::PRIME[274], real>(value);
    case 275: return math::radical_inverse<math::table::PRIME[275], real>(value);
    case 276: return math::radical_inverse<math::table::PRIME[276], real>(value);
    case 277: return math::radical_inverse<math::table::PRIME[277], real>(value);
    case 278: return math::radical_inverse<math::table::PRIME[278], real>(value);
    case 279: return math::radical_inverse<math::table::PRIME[279], real>(value);
    case 280: return math::radical_inverse<math::table::PRIME[280], real>(value);
    case 281: return math::radical_inverse<math::table::PRIME[281], real>(value);
    case 282: return math::radical_inverse<math::table::PRIME[282], real>(value);
    case 283: return math::radical_inverse<math::table::PRIME[283], real>(value);
    case 284: return math::radical_inverse<math::table::PRIME[284], real>(value);
    case 285: return math::radical_inverse<math::table::PRIME[285], real>(value);
    case 286: return math::radical_inverse<math::table::PRIME[286], real>(value);
    case 287: return math::radical_inverse<math::table::PRIME[287], real>(value);
    case 288: return math::radical_inverse<math::table::PRIME[288], real>(value);
    case 289: return math::radical_inverse<math::table::PRIME[289], real>(value);
    case 290: return math::radical_inverse<math::table::PRIME[290], real>(value);
    case 291: return math::radical_inverse<math::table::PRIME[291], real>(value);
    case 292: return math::radical_inverse<math::table::PRIME[292], real>(value);
    case 293: return math::radical_inverse<math::table::PRIME[293], real>(value);
    case 294: return math::radical_inverse<math::table::PRIME[294], real>(value);
    case 295: return math::radical_inverse<math::table::PRIME[295], real>(value);
    case 296: return math::radical_inverse<math::table::PRIME[296], real>(value);
    case 297: return math::radical_inverse<math::table::PRIME[297], real>(value);
    case 298: return math::radical_inverse<math::table::PRIME[298], real>(value);
    case 299: return math::radical_inverse<math::table::PRIME[299], real>(value);
    case 300: return math::radical_inverse<math::table::PRIME[300], real>(value);
    case 301: return math::radical_inverse<math::table::PRIME[301], real>(value);
    case 302: return math::radical_inverse<math::table::PRIME[302], real>(value);
    case 303: return math::radical_inverse<math::table::PRIME[303], real>(value);
    case 304: return math::radical_inverse<math::table::PRIME[304], real>(value);
    case 305: return math::radical_inverse<math::table::PRIME[305], real>(value);
    case 306: return math::radical_inverse<math::table::PRIME[306], real>(value);
    case 307: return math::radical_inverse<math::table::PRIME[307], real>(value);
    case 308: return math::radical_inverse<math::table::PRIME[308], real>(value);
    case 309: return math::radical_inverse<math::table::PRIME[309], real>(value);
    case 310: return math::radical_inverse<math::table::PRIME[310], real>(value);
    case 311: return math::radical_inverse<math::table::PRIME[311], real>(value);
    case 312: return math::radical_inverse<math::table::PRIME[312], real>(value);
    case 313: return math::radical_inverse<math::table::PRIME[313], real>(value);
    case 314: return math::radical_inverse<math::table::PRIME[314], real>(value);
    case 315: return math::radical_inverse<math::table::PRIME[315], real>(value);
    case 316: return math::radical_inverse<math::table::PRIME[316], real>(value);
    case 317: return math::radical_inverse<math::table::PRIME[317], real>(value);
    case 318: return math::radical_inverse<math::table::PRIME[318], real>(value);
    case 319: return math::radical_inverse<math::table::PRIME[319], real>(value);
    case 320: return math::radical_inverse<math::table::PRIME[320], real>(value);
    case 321: return math::radical_inverse<math::table::PRIME[321], real>(value);
    case 322: return math::radical_inverse<math::table::PRIME[322], real>(value);
    case 323: return math::radical_inverse<math::table::PRIME[323], real>(value);
    case 324: return math::radical_inverse<math::table::PRIME[324], real>(value);
    case 325: return math::radical_inverse<math::table::PRIME[325], real>(value);
    case 326: return math::radical_inverse<math::table::PRIME[326], real>(value);
    case 327: return math::radical_inverse<math::table::PRIME[327], real>(value);
    case 328: return math::radical_inverse<math::table::PRIME[328], real>(value);
    case 329: return math::radical_inverse<math::table::PRIME[329], real>(value);
    case 330: return math::radical_inverse<math::table::PRIME[330], real>(value);
    case 331: return math::radical_inverse<math::table::PRIME[331], real>(value);
    case 332: return math::radical_inverse<math::table::PRIME[332], real>(value);
    case 333: return math::radical_inverse<math::table::PRIME[333], real>(value);
    case 334: return math::radical_inverse<math::table::PRIME[334], real>(value);
    case 335: return math::radical_inverse<math::table::PRIME[335], real>(value);
    case 336: return math::radical_inverse<math::table::PRIME[336], real>(value);
    case 337: return math::radical_inverse<math::table::PRIME[337], real>(value);
    case 338: return math::radical_inverse<math::table::PRIME[338], real>(value);
    case 339: return math::radical_inverse<math::table::PRIME[339], real>(value);
    case 340: return math::radical_inverse<math::table::PRIME[340], real>(value);
    case 341: return math::radical_inverse<math::table::PRIME[341], real>(value);
    case 342: return math::radical_inverse<math::table::PRIME[342], real>(value);
    case 343: return math::radical_inverse<math::table::PRIME[343], real>(value);
    case 344: return math::radical_inverse<math::table::PRIME[344], real>(value);
    case 345: return math::radical_inverse<math::table::PRIME[345], real>(value);
    case 346: return math::radical_inverse<math::table::PRIME[346], real>(value);
    case 347: return math::radical_inverse<math::table::PRIME[347], real>(value);
    case 348: return math::radical_inverse<math::table::PRIME[348], real>(value);
    case 349: return math::radical_inverse<math::table::PRIME[349], real>(value);
    case 350: return math::radical_inverse<math::table::PRIME[350], real>(value);
    case 351: return math::radical_inverse<math::table::PRIME[351], real>(value);
    case 352: return math::radical_inverse<math::table::PRIME[352], real>(value);
    case 353: return math::radical_inverse<math::table::PRIME[353], real>(value);
    case 354: return math::radical_inverse<math::table::PRIME[354], real>(value);
    case 355: return math::radical_inverse<math::table::PRIME[355], real>(value);
    case 356: return math::radical_inverse<math::table::PRIME[356], real>(value);
    case 357: return math::radical_inverse<math::table::PRIME[357], real>(value);
    case 358: return math::radical_inverse<math::table::PRIME[358], real>(value);
    case 359: return math::radical_inverse<math::table::PRIME[359], real>(value);
    case 360: return math::radical_inverse<math::table::PRIME[360], real>(value);
    case 361: return math::radical_inverse<math::table::PRIME[361], real>(value);
    case 362: return math::radical_inverse<math::table::PRIME[362], real>(value);
    case 363: return math::radical_inverse<math::table::PRIME[363], real>(value);
    case 364: return math::radical_inverse<math::table::PRIME[364], real>(value);
    case 365: return math::radical_inverse<math::table::PRIME[365], real>(value);
    case 366: return math::radical_inverse<math::table::PRIME[366], real>(value);
    case 367: return math::radical_inverse<math::table::PRIME[367], real>(value);
    case 368: return math::radical_inverse<math::table::PRIME[368], real>(value);
    case 369: return math::radical_inverse<math::table::PRIME[369], real>(value);
    case 370: return math::radical_inverse<math::table::PRIME[370], real>(value);
    case 371: return math::radical_inverse<math::table::PRIME[371], real>(value);
    case 372: return math::radical_inverse<math::table::PRIME[372], real>(value);
    case 373: return math::radical_inverse<math::table::PRIME[373], real>(value);
    case 374: return math::radical_inverse<math::table::PRIME[374], real>(value);
    case 375: return math::radical_inverse<math::table::PRIME[375], real>(value);
    case 376: return math::radical_inverse<math::table::PRIME[376], real>(value);
    case 377: return math::radical_inverse<math::table::PRIME[377], real>(value);
    case 378: return math::radical_inverse<math::table::PRIME[378], real>(value);
    case 379: return math::radical_inverse<math::table::PRIME[379], real>(value);
    case 380: return math::radical_inverse<math::table::PRIME[380], real>(value);
    case 381: return math::radical_inverse<math::table::PRIME[381], real>(value);
    case 382: return math::radical_inverse<math::table::PRIME[382], real>(value);
    case 383: return math::radical_inverse<math::table::PRIME[383], real>(value);
    case 384: return math::radical_inverse<math::table::PRIME[384], real>(value);
    case 385: return math::radical_inverse<math::table::PRIME[385], real>(value);
    case 386: return math::radical_inverse<math::table::PRIME[386], real>(value);
    case 387: return math::radical_inverse<math::table::PRIME[387], real>(value);
    case 388: return math::radical_inverse<math::table::PRIME[388], real>(value);
    case 389: return math::radical_inverse<math::table::PRIME[389], real>(value);
    case 390: return math::radical_inverse<math::table::PRIME[390], real>(value);
    case 391: return math::radical_inverse<math::table::PRIME[391], real>(value);
    case 392: return math::radical_inverse<math::table::PRIME[392], real>(value);
    case 393: return math::radical_inverse<math::table::PRIME[393], real>(value);
    case 394: return math::radical_inverse<math::table::PRIME[394], real>(value);
    case 395: return math::radical_inverse<math::table::PRIME[395], real>(value);
    case 396: return math::radical_inverse<math::table::PRIME[396], real>(value);
    case 397: return math::radical_inverse<math::table::PRIME[397], real>(value);
    case 398: return math::radical_inverse<math::table::PRIME[398], real>(value);
    case 399: return math::radical_inverse<math::table::PRIME[399], real>(value);
    case 400: return math::radical_inverse<math::table::PRIME[400], real>(value);
    case 401: return math::radical_inverse<math::table::PRIME[401], real>(value);
    case 402: return math::radical_inverse<math::table::PRIME[402], real>(value);
    case 403: return math::radical_inverse<math::table::PRIME[403], real>(value);
    case 404: return math::radical_inverse<math::table::PRIME[404], real>(value);
    case 405: return math::radical_inverse<math::table::PRIME[405], real>(value);
    case 406: return math::radical_inverse<math::table::PRIME[406], real>(value);
    case 407: return math::radical_inverse<math::table::PRIME[407], real>(value);
    case 408: return math::radical_inverse<math::table::PRIME[408], real>(value);
    case 409: return math::radical_inverse<math::table::PRIME[409], real>(value);
    case 410: return math::radical_inverse<math::table::PRIME[410], real>(value);
    case 411: return math::radical_inverse<math::table::PRIME[411], real>(value);
    case 412: return math::radical_inverse<math::table::PRIME[412], real>(value);
    case 413: return math::radical_inverse<math::table::PRIME[413], real>(value);
    case 414: return math::radical_inverse<math::table::PRIME[414], real>(value);
    case 415: return math::radical_inverse<math::table::PRIME[415], real>(value);
    case 416: return math::radical_inverse<math::table::PRIME[416], real>(value);
    case 417: return math::radical_inverse<math::table::PRIME[417], real>(value);
    case 418: return math::radical_inverse<math::table::PRIME[418], real>(value);
    case 419: return math::radical_inverse<math::table::PRIME[419], real>(value);
    case 420: return math::radical_inverse<math::table::PRIME[420], real>(value);
    case 421: return math::radical_inverse<math::table::PRIME[421], real>(value);
    case 422: return math::radical_inverse<math::table::PRIME[422], real>(value);
    case 423: return math::radical_inverse<math::table::PRIME[423], real>(value);
    case 424: return math::radical_inverse<math::table::PRIME[424], real>(value);
    case 425: return math::radical_inverse<math::table::PRIME[425], real>(value);
    case 426: return math::radical_inverse<math::table::PRIME[426], real>(value);
    case 427: return math::radical_inverse<math::table::PRIME[427], real>(value);
    case 428: return math::radical_inverse<math::table::PRIME[428], real>(value);
    case 429: return math::radical_inverse<math::table::PRIME[429], real>(value);
    case 430: return math::radical_inverse<math::table::PRIME[430], real>(value);
    case 431: return math::radical_inverse<math::table::PRIME[431], real>(value);
    case 432: return math::radical_inverse<math::table::PRIME[432], real>(value);
    case 433: return math::radical_inverse<math::table::PRIME[433], real>(value);
    case 434: return math::radical_inverse<math::table::PRIME[434], real>(value);
    case 435: return math::radical_inverse<math::table::PRIME[435], real>(value);
    case 436: return math::radical_inverse<math::table::PRIME[436], real>(value);
    case 437: return math::radical_inverse<math::table::PRIME[437], real>(value);
    case 438: return math::radical_inverse<math::table::PRIME[438], real>(value);
    case 439: return math::radical_inverse<math::table::PRIME[439], real>(value);
    case 440: return math::radical_inverse<math::table::PRIME[440], real>(value);
    case 441: return math::radical_inverse<math::table::PRIME[441], real>(value);
    case 442: return math::radical_inverse<math::table::PRIME[442], real>(value);
    case 443: return math::radical_inverse<math::table::PRIME[443], real>(value);
    case 444: return math::radical_inverse<math::table::PRIME[444], real>(value);
    case 445: return math::radical_inverse<math::table::PRIME[445], real>(value);
    case 446: return math::radical_inverse<math::table::PRIME[446], real>(value);
    case 447: return math::radical_inverse<math::table::PRIME[447], real>(value);
    case 448: return math::radical_inverse<math::table::PRIME[448], real>(value);
    case 449: return math::radical_inverse<math::table::PRIME[449], real>(value);
    case 450: return math::radical_inverse<math::table::PRIME[450], real>(value);
    case 451: return math::radical_inverse<math::table::PRIME[451], real>(value);
    case 452: return math::radical_inverse<math::table::PRIME[452], real>(value);
    case 453: return math::radical_inverse<math::table::PRIME[453], real>(value);
    case 454: return math::radical_inverse<math::table::PRIME[454], real>(value);
    case 455: return math::radical_inverse<math::table::PRIME[455], real>(value);
    case 456: return math::radical_inverse<math::table::PRIME[456], real>(value);
    case 457: return math::radical_inverse<math::table::PRIME[457], real>(value);
    case 458: return math::radical_inverse<math::table::PRIME[458], real>(value);
    case 459: return math::radical_inverse<math::table::PRIME[459], real>(value);
    case 460: return math::radical_inverse<math::table::PRIME[460], real>(value);
    case 461: return math::radical_inverse<math::table::PRIME[461], real>(value);
    case 462: return math::radical_inverse<math::table::PRIME[462], real>(value);
    case 463: return math::radical_inverse<math::table::PRIME[463], real>(value);
    case 464: return math::radical_inverse<math::table::PRIME[464], real>(value);
    case 465: return math::radical_inverse<math::table::PRIME[465], real>(value);
    case 466: return math::radical_inverse<math::table::PRIME[466], real>(value);
    case 467: return math::radical_inverse<math::table::PRIME[467], real>(value);
    case 468: return math::radical_inverse<math::table::PRIME[468], real>(value);
    case 469: return math::radical_inverse<math::table::PRIME[469], real>(value);
    case 470: return math::radical_inverse<math::table::PRIME[470], real>(value);
    case 471: return math::radical_inverse<math::table::PRIME[471], real>(value);
    case 472: return math::radical_inverse<math::table::PRIME[472], real>(value);
    case 473: return math::radical_inverse<math::table::PRIME[473], real>(value);
    case 474: return math::radical_inverse<math::table::PRIME[474], real>(value);
    case 475: return math::radical_inverse<math::table::PRIME[475], real>(value);
    case 476: return math::radical_inverse<math::table::PRIME[476], real>(value);
    case 477: return math::radical_inverse<math::table::PRIME[477], real>(value);
    case 478: return math::radical_inverse<math::table::PRIME[478], real>(value);
    case 479: return math::radical_inverse<math::table::PRIME[479], real>(value);
    case 480: return math::radical_inverse<math::table::PRIME[480], real>(value);
    case 481: return math::radical_inverse<math::table::PRIME[481], real>(value);
    case 482: return math::radical_inverse<math::table::PRIME[482], real>(value);
    case 483: return math::radical_inverse<math::table::PRIME[483], real>(value);
    case 484: return math::radical_inverse<math::table::PRIME[484], real>(value);
    case 485: return math::radical_inverse<math::table::PRIME[485], real>(value);
    case 486: return math::radical_inverse<math::table::PRIME[486], real>(value);
    case 487: return math::radical_inverse<math::table::PRIME[487], real>(value);
    case 488: return math::radical_inverse<math::table::PRIME[488], real>(value);
    case 489: return math::radical_inverse<math::table::PRIME[489], real>(value);
    case 490: return math::radical_inverse<math::table::PRIME[490], real>(value);
    case 491: return math::radical_inverse<math::table::PRIME[491], real>(value);
    case 492: return math::radical_inverse<math::table::PRIME[492], real>(value);
    case 493: return math::radical_inverse<math::table::PRIME[493], real>(value);
    case 494: return math::radical_inverse<math::table::PRIME[494], real>(value);
    case 495: return math::radical_inverse<math::table::PRIME[495], real>(value);
    case 496: return math::radical_inverse<math::table::PRIME[496], real>(value);
    case 497: return math::radical_inverse<math::table::PRIME[497], real>(value);
    case 498: return math::radical_inverse<math::table::PRIME[498], real>(value);
    case 499: return math::radical_inverse<math::table::PRIME[499], real>(value);
    case 500: return math::radical_inverse<math::table::PRIME[500], real>(value);
    case 501: return math::radical_inverse<math::table::PRIME[501], real>(value);
    case 502: return math::radical_inverse<math::table::PRIME[502], real>(value);
    case 503: return math::radical_inverse<math::table::PRIME[503], real>(value);
    case 504: return math::radical_inverse<math::table::PRIME[504], real>(value);
    case 505: return math::radical_inverse<math::table::PRIME[505], real>(value);
    case 506: return math::radical_inverse<math::table::PRIME[506], real>(value);
    case 507: return math::radical_inverse<math::table::PRIME[507], real>(value);
    case 508: return math::radical_inverse<math::table::PRIME[508], real>(value);
    case 509: return math::radical_inverse<math::table::PRIME[509], real>(value);
    case 510: return math::radical_inverse<math::table::PRIME[510], real>(value);
    case 511: return math::radical_inverse<math::table::PRIME[511], real>(value);
    case 512: return math::radical_inverse<math::table::PRIME[512], real>(value);
    case 513: return math::radical_inverse<math::table::PRIME[513], real>(value);
    case 514: return math::radical_inverse<math::table::PRIME[514], real>(value);
    case 515: return math::radical_inverse<math::table::PRIME[515], real>(value);
    case 516: return math::radical_inverse<math::table::PRIME[516], real>(value);
    case 517: return math::radical_inverse<math::table::PRIME[517], real>(value);
    case 518: return math::radical_inverse<math::table::PRIME[518], real>(value);
    case 519: return math::radical_inverse<math::table::PRIME[519], real>(value);
    case 520: return math::radical_inverse<math::table::PRIME[520], real>(value);
    case 521: return math::radical_inverse<math::table::PRIME[521], real>(value);
    case 522: return math::radical_inverse<math::table::PRIME[522], real>(value);
    case 523: return math::radical_inverse<math::table::PRIME[523], real>(value);
    case 524: return math::radical_inverse<math::table::PRIME[524], real>(value);
    case 525: return math::radical_inverse<math::table::PRIME[525], real>(value);
    case 526: return math::radical_inverse<math::table::PRIME[526], real>(value);
    case 527: return math::radical_inverse<math::table::PRIME[527], real>(value);
    case 528: return math::radical_inverse<math::table::PRIME[528], real>(value);
    case 529: return math::radical_inverse<math::table::PRIME[529], real>(value);
    case 530: return math::radical_inverse<math::table::PRIME[530], real>(value);
    case 531: return math::radical_inverse<math::table::PRIME[531], real>(value);
    case 532: return math::radical_inverse<math::table::PRIME[532], real>(value);
    case 533: return math::radical_inverse<math::table::PRIME[533], real>(value);
    case 534: return math::radical_inverse<math::table::PRIME[534], real>(value);
    case 535: return math::radical_inverse<math::table::PRIME[535], real>(value);
    case 536: return math::radical_inverse<math::table::PRIME[536], real>(value);
    case 537: return math::radical_inverse<math::table::PRIME[537], real>(value);
    case 538: return math::radical_inverse<math::table::PRIME[538], real>(value);
    case 539: return math::radical_inverse<math::table::PRIME[539], real>(value);
    case 540: return math::radical_inverse<math::table::PRIME[540], real>(value);
    case 541: return math::radical_inverse<math::table::PRIME[541], real>(value);
    case 542: return math::radical_inverse<math::table::PRIME[542], real>(value);
    case 543: return math::radical_inverse<math::table::PRIME[543], real>(value);
    case 544: return math::radical_inverse<math::table::PRIME[544], real>(value);
    case 545: return math::radical_inverse<math::table::PRIME[545], real>(value);
    case 546: return math::radical_inverse<math::table::PRIME[546], real>(value);
    case 547: return math::radical_inverse<math::table::PRIME[547], real>(value);
    case 548: return math::radical_inverse<math::table::PRIME[548], real>(value);
    case 549: return math::radical_inverse<math::table::PRIME[549], real>(value);
    case 550: return math::radical_inverse<math::table::PRIME[550], real>(value);
    case 551: return math::radical_inverse<math::table::PRIME[551], real>(value);
    case 552: return math::radical_inverse<math::table::PRIME[552], real>(value);
    case 553: return math::radical_inverse<math::table::PRIME[553], real>(value);
    case 554: return math::radical_inverse<math::table::PRIME[554], real>(value);
    case 555: return math::radical_inverse<math::table::PRIME[555], real>(value);
    case 556: return math::radical_inverse<math::table::PRIME[556], real>(value);
    case 557: return math::radical_inverse<math::table::PRIME[557], real>(value);
    case 558: return math::radical_inverse<math::table::PRIME[558], real>(value);
    case 559: return math::radical_inverse<math::table::PRIME[559], real>(value);
    case 560: return math::radical_inverse<math::table::PRIME[560], real>(value);
    case 561: return math::radical_inverse<math::table::PRIME[561], real>(value);
    case 562: return math::radical_inverse<math::table::PRIME[562], real>(value);
    case 563: return math::radical_inverse<math::table::PRIME[563], real>(value);
    case 564: return math::radical_inverse<math::table::PRIME[564], real>(value);
    case 565: return math::radical_inverse<math::table::PRIME[565], real>(value);
    case 566: return math::radical_inverse<math::table::PRIME[566], real>(value);
    case 567: return math::radical_inverse<math::table::PRIME[567], real>(value);
    case 568: return math::radical_inverse<math::table::PRIME[568], real>(value);
    case 569: return math::radical_inverse<math::table::PRIME[569], real>(value);
    case 570: return math::radical_inverse<math::table::PRIME[570], real>(value);
    case 571: return math::radical_inverse<math::table::PRIME[571], real>(value);
    case 572: return math::radical_inverse<math::table::PRIME[572], real>(value);
    case 573: return math::radical_inverse<math::table::PRIME[573], real>(value);
    case 574: return math::radical_inverse<math::table::PRIME[574], real>(value);
    case 575: return math::radical_inverse<math::table::PRIME[575], real>(value);
    case 576: return math::radical_inverse<math::table::PRIME[576], real>(value);
    case 577: return math::radical_inverse<math::table::PRIME[577], real>(value);
    case 578: return math::radical_inverse<math::table::PRIME[578], real>(value);
    case 579: return math::radical_inverse<math::table::PRIME[579], real>(value);
    case 580: return math::radical_inverse<math::table::PRIME[580], real>(value);
    case 581: return math::radical_inverse<math::table::PRIME[581], real>(value);
    case 582: return math::radical_inverse<math::table::PRIME[582], real>(value);
    case 583: return math::radical_inverse<math::table::PRIME[583], real>(value);
    case 584: return math::radical_inverse<math::table::PRIME[584], real>(value);
    case 585: return math::radical_inverse<math::table::PRIME[585], real>(value);
    case 586: return math::radical_inverse<math::table::PRIME[586], real>(value);
    case 587: return math::radical_inverse<math::table::PRIME[587], real>(value);
    case 588: return math::radical_inverse<math::table::PRIME[588], real>(value);
    case 589: return math::radical_inverse<math::table::PRIME[589], real>(value);
    case 590: return math::radical_inverse<math::table::PRIME[590], real>(value);
    case 591: return math::radical_inverse<math::table::PRIME[591], real>(value);
    case 592: return math::radical_inverse<math::table::PRIME[592], real>(value);
    case 593: return math::radical_inverse<math::table::PRIME[593], real>(value);
    case 594: return math::radical_inverse<math::table::PRIME[594], real>(value);
    case 595: return math::radical_inverse<math::table::PRIME[595], real>(value);
    case 596: return math::radical_inverse<math::table::PRIME[596], real>(value);
    case 597: return math::radical_inverse<math::table::PRIME[597], real>(value);
    case 598: return math::radical_inverse<math::table::PRIME[598], real>(value);
    case 599: return math::radical_inverse<math::table::PRIME[599], real>(value);
    case 600: return math::radical_inverse<math::table::PRIME[600], real>(value);
    case 601: return math::radical_inverse<math::table::PRIME[601], real>(value);
    case 602: return math::radical_inverse<math::table::PRIME[602], real>(value);
    case 603: return math::radical_inverse<math::table::PRIME[603], real>(value);
    case 604: return math::radical_inverse<math::table::PRIME[604], real>(value);
    case 605: return math::radical_inverse<math::table::PRIME[605], real>(value);
    case 606: return math::radical_inverse<math::table::PRIME[606], real>(value);
    case 607: return math::radical_inverse<math::table::PRIME[607], real>(value);
    case 608: return math::radical_inverse<math::table::PRIME[608], real>(value);
    case 609: return math::radical_inverse<math::table::PRIME[609], real>(value);
    case 610: return math::radical_inverse<math::table::PRIME[610], real>(value);
    case 611: return math::radical_inverse<math::table::PRIME[611], real>(value);
    case 612: return math::radical_inverse<math::table::PRIME[612], real>(value);
    case 613: return math::radical_inverse<math::table::PRIME[613], real>(value);
    case 614: return math::radical_inverse<math::table::PRIME[614], real>(value);
    case 615: return math::radical_inverse<math::table::PRIME[615], real>(value);
    case 616: return math::radical_inverse<math::table::PRIME[616], real>(value);
    case 617: return math::radical_inverse<math::table::PRIME[617], real>(value);
    case 618: return math::radical_inverse<math::table::PRIME[618], real>(value);
    case 619: return math::radical_inverse<math::table::PRIME[619], real>(value);
    case 620: return math::radical_inverse<math::table::PRIME[620], real>(value);
    case 621: return math::radical_inverse<math::table::PRIME[621], real>(value);
    case 622: return math::radical_inverse<math::table::PRIME[622], real>(value);
    case 623: return math::radical_inverse<math::table::PRIME[623], real>(value);
    case 624: return math::radical_inverse<math::table::PRIME[624], real>(value);
    case 625: return math::radical_inverse<math::table::PRIME[625], real>(value);
    case 626: return math::radical_inverse<math::table::PRIME[626], real>(value);
    case 627: return math::radical_inverse<math::table::PRIME[627], real>(value);
    case 628: return math::radical_inverse<math::table::PRIME[628], real>(value);
    case 629: return math::radical_inverse<math::table::PRIME[629], real>(value);
    case 630: return math::radical_inverse<math::table::PRIME[630], real>(value);
    case 631: return math::radical_inverse<math::table::PRIME[631], real>(value);
    case 632: return math::radical_inverse<math::table::PRIME[632], real>(value);
    case 633: return math::radical_inverse<math::table::PRIME[633], real>(value);
    case 634: return math::radical_inverse<math::table::PRIME[634], real>(value);
    case 635: return math::radical_inverse<math::table::PRIME[635], real>(value);
    case 636: return math::radical_inverse<math::table::PRIME[636], real>(value);
    case 637: return math::radical_inverse<math::table::PRIME[637], real>(value);
    case 638: return math::radical_inverse<math::table::PRIME[638], real>(value);
    case 639: return math::radical_inverse<math::table::PRIME[639], real>(value);
    case 640: return math::radical_inverse<math::table::PRIME[640], real>(value);
    case 641: return math::radical_inverse<math::table::PRIME[641], real>(value);
    case 642: return math::radical_inverse<math::table::PRIME[642], real>(value);
    case 643: return math::radical_inverse<math::table::PRIME[643], real>(value);
    case 644: return math::radical_inverse<math::table::PRIME[644], real>(value);
    case 645: return math::radical_inverse<math::table::PRIME[645], real>(value);
    case 646: return math::radical_inverse<math::table::PRIME[646], real>(value);
    case 647: return math::radical_inverse<math::table::PRIME[647], real>(value);
    case 648: return math::radical_inverse<math::table::PRIME[648], real>(value);
    case 649: return math::radical_inverse<math::table::PRIME[649], real>(value);
    case 650: return math::radical_inverse<math::table::PRIME[650], real>(value);
    case 651: return math::radical_inverse<math::table::PRIME[651], real>(value);
    case 652: return math::radical_inverse<math::table::PRIME[652], real>(value);
    case 653: return math::radical_inverse<math::table::PRIME[653], real>(value);
    case 654: return math::radical_inverse<math::table::PRIME[654], real>(value);
    case 655: return math::radical_inverse<math::table::PRIME[655], real>(value);
    case 656: return math::radical_inverse<math::table::PRIME[656], real>(value);
    case 657: return math::radical_inverse<math::table::PRIME[657], real>(value);
    case 658: return math::radical_inverse<math::table::PRIME[658], real>(value);
    case 659: return math::radical_inverse<math::table::PRIME[659], real>(value);
    case 660: return math::radical_inverse<math::table::PRIME[660], real>(value);
    case 661: return math::radical_inverse<math::table::PRIME[661], real>(value);
    case 662: return math::radical_inverse<math::table::PRIME[662], real>(value);
    case 663: return math::radical_inverse<math::table::PRIME[663], real>(value);
    case 664: return math::radical_inverse<math::table::PRIME[664], real>(value);
    case 665: return math::radical_inverse<math::table::PRIME[665], real>(value);
    case 666: return math::radical_inverse<math::table::PRIME[666], real>(value);
    case 667: return math::radical_inverse<math::table::PRIME[667], real>(value);
    case 668: return math::radical_inverse<math::table::PRIME[668], real>(value);
    case 669: return math::radical_inverse<math::table::PRIME[669], real>(value);
    case 670: return math::radical_inverse<math::table::PRIME[670], real>(value);
    case 671: return math::radical_inverse<math::table::PRIME[671], real>(value);
    case 672: return math::radical_inverse<math::table::PRIME[672], real>(value);
    case 673: return math::radical_inverse<math::table::PRIME[673], real>(value);
    case 674: return math::radical_inverse<math::table::PRIME[674], real>(value);
    case 675: return math::radical_inverse<math::table::PRIME[675], real>(value);
    case 676: return math::radical_inverse<math::table::PRIME[676], real>(value);
    case 677: return math::radical_inverse<math::table::PRIME[677], real>(value);
    case 678: return math::radical_inverse<math::table::PRIME[678], real>(value);
    case 679: return math::radical_inverse<math::table::PRIME[679], real>(value);
    case 680: return math::radical_inverse<math::table::PRIME[680], real>(value);
    case 681: return math::radical_inverse<math::table::PRIME[681], real>(value);
    case 682: return math::radical_inverse<math::table::PRIME[682], real>(value);
    case 683: return math::radical_inverse<math::table::PRIME[683], real>(value);
    case 684: return math::radical_inverse<math::table::PRIME[684], real>(value);
    case 685: return math::radical_inverse<math::table::PRIME[685], real>(value);
    case 686: return math::radical_inverse<math::table::PRIME[686], real>(value);
    case 687: return math::radical_inverse<math::table::PRIME[687], real>(value);
    case 688: return math::radical_inverse<math::table::PRIME[688], real>(value);
    case 689: return math::radical_inverse<math::table::PRIME[689], real>(value);
    case 690: return math::radical_inverse<math::table::PRIME[690], real>(value);
    case 691: return math::radical_inverse<math::table::PRIME[691], real>(value);
    case 692: return math::radical_inverse<math::table::PRIME[692], real>(value);
    case 693: return math::radical_inverse<math::table::PRIME[693], real>(value);
    case 694: return math::radical_inverse<math::table::PRIME[694], real>(value);
    case 695: return math::radical_inverse<math::table::PRIME[695], real>(value);
    case 696: return math::radical_inverse<math::table::PRIME[696], real>(value);
    case 697: return math::radical_inverse<math::table::PRIME[697], real>(value);
    case 698: return math::radical_inverse<math::table::PRIME[698], real>(value);
    case 699: return math::radical_inverse<math::table::PRIME[699], real>(value);
    case 700: return math::radical_inverse<math::table::PRIME[700], real>(value);
    case 701: return math::radical_inverse<math::table::PRIME[701], real>(value);
    case 702: return math::radical_inverse<math::table::PRIME[702], real>(value);
    case 703: return math::radical_inverse<math::table::PRIME[703], real>(value);
    case 704: return math::radical_inverse<math::table::PRIME[704], real>(value);
    case 705: return math::radical_inverse<math::table::PRIME[705], real>(value);
    case 706: return math::radical_inverse<math::table::PRIME[706], real>(value);
    case 707: return math::radical_inverse<math::table::PRIME[707], real>(value);
    case 708: return math::radical_inverse<math::table::PRIME[708], real>(value);
    case 709: return math::radical_inverse<math::table::PRIME[709], real>(value);
    case 710: return math::radical_inverse<math::table::PRIME[710], real>(value);
    case 711: return math::radical_inverse<math::table::PRIME[711], real>(value);
    case 712: return math::radical_inverse<math::table::PRIME[712], real>(value);
    case 713: return math::radical_inverse<math::table::PRIME[713], real>(value);
    case 714: return math::radical_inverse<math::table::PRIME[714], real>(value);
    case 715: return math::radical_inverse<math::table::PRIME[715], real>(value);
    case 716: return math::radical_inverse<math::table::PRIME[716], real>(value);
    case 717: return math::radical_inverse<math::table::PRIME[717], real>(value);
    case 718: return math::radical_inverse<math::table::PRIME[718], real>(value);
    case 719: return math::radical_inverse<math::table::PRIME[719], real>(value);
    case 720: return math::radical_inverse<math::table::PRIME[720], real>(value);
    case 721: return math::radical_inverse<math::table::PRIME[721], real>(value);
    case 722: return math::radical_inverse<math::table::PRIME[722], real>(value);
    case 723: return math::radical_inverse<math::table::PRIME[723], real>(value);
    case 724: return math::radical_inverse<math::table::PRIME[724], real>(value);
    case 725: return math::radical_inverse<math::table::PRIME[725], real>(value);
    case 726: return math::radical_inverse<math::table::PRIME[726], real>(value);
    case 727: return math::radical_inverse<math::table::PRIME[727], real>(value);
    case 728: return math::radical_inverse<math::table::PRIME[728], real>(value);
    case 729: return math::radical_inverse<math::table::PRIME[729], real>(value);
    case 730: return math::radical_inverse<math::table::PRIME[730], real>(value);
    case 731: return math::radical_inverse<math::table::PRIME[731], real>(value);
    case 732: return math::radical_inverse<math::table::PRIME[732], real>(value);
    case 733: return math::radical_inverse<math::table::PRIME[733], real>(value);
    case 734: return math::radical_inverse<math::table::PRIME[734], real>(value);
    case 735: return math::radical_inverse<math::table::PRIME[735], real>(value);
    case 736: return math::radical_inverse<math::table::PRIME[736], real>(value);
    case 737: return math::radical_inverse<math::table::PRIME[737], real>(value);
    case 738: return math::radical_inverse<math::table::PRIME[738], real>(value);
    case 739: return math::radical_inverse<math::table::PRIME[739], real>(value);
    case 740: return math::radical_inverse<math::table::PRIME[740], real>(value);
    case 741: return math::radical_inverse<math::table::PRIME[741], real>(value);
    case 742: return math::radical_inverse<math::table::PRIME[742], real>(value);
    case 743: return math::radical_inverse<math::table::PRIME[743], real>(value);
    case 744: return math::radical_inverse<math::table::PRIME[744], real>(value);
    case 745: return math::radical_inverse<math::table::PRIME[745], real>(value);
    case 746: return math::radical_inverse<math::table::PRIME[746], real>(value);
    case 747: return math::radical_inverse<math::table::PRIME[747], real>(value);
    case 748: return math::radical_inverse<math::table::PRIME[748], real>(value);
    case 749: return math::radical_inverse<math::table::PRIME[749], real>(value);
    case 750: return math::radical_inverse<math::table::PRIME[750], real>(value);
    case 751: return math::radical_inverse<math::table::PRIME[751], real>(value);
    case 752: return math::radical_inverse<math::table::PRIME[752], real>(value);
    case 753: return math::radical_inverse<math::table::PRIME[753], real>(value);
    case 754: return math::radical_inverse<math::table::PRIME[754], real>(value);
    case 755: return math::radical_inverse<math::table::PRIME[755], real>(value);
    case 756: return math::radical_inverse<math::table::PRIME[756], real>(value);
    case 757: return math::radical_inverse<math::table::PRIME[757], real>(value);
    case 758: return math::radical_inverse<math::table::PRIME[758], real>(value);
    case 759: return math::radical_inverse<math::table::PRIME[759], real>(value);
    case 760: return math::radical_inverse<math::table::PRIME[760], real>(value);
    case 761: return math::radical_inverse<math::table::PRIME[761], real>(value);
    case 762: return math::radical_inverse<math::table::PRIME[762], real>(value);
    case 763: return math::radical_inverse<math::table::PRIME[763], real>(value);
    case 764: return math::radical_inverse<math::table::PRIME[764], real>(value);
    case 765: return math::radical_inverse<math::table::PRIME[765], real>(value);
    case 766: return math::radical_inverse<math::table::PRIME[766], real>(value);
    case 767: return math::radical_inverse<math::table::PRIME[767], real>(value);
    case 768: return math::radical_inverse<math::table::PRIME[768], real>(value);
    case 769: return math::radical_inverse<math::table::PRIME[769], real>(value);
    case 770: return math::radical_inverse<math::table::PRIME[770], real>(value);
    case 771: return math::radical_inverse<math::table::PRIME[771], real>(value);
    case 772: return math::radical_inverse<math::table::PRIME[772], real>(value);
    case 773: return math::radical_inverse<math::table::PRIME[773], real>(value);
    case 774: return math::radical_inverse<math::table::PRIME[774], real>(value);
    case 775: return math::radical_inverse<math::table::PRIME[775], real>(value);
    case 776: return math::radical_inverse<math::table::PRIME[776], real>(value);
    case 777: return math::radical_inverse<math::table::PRIME[777], real>(value);
    case 778: return math::radical_inverse<math::table::PRIME[778], real>(value);
    case 779: return math::radical_inverse<math::table::PRIME[779], real>(value);
    case 780: return math::radical_inverse<math::table::PRIME[780], real>(value);
    case 781: return math::radical_inverse<math::table::PRIME[781], real>(value);
    case 782: return math::radical_inverse<math::table::PRIME[782], real>(value);
    case 783: return math::radical_inverse<math::table::PRIME[783], real>(value);
    case 784: return math::radical_inverse<math::table::PRIME[784], real>(value);
    case 785: return math::radical_inverse<math::table::PRIME[785], real>(value);
    case 786: return math::radical_inverse<math::table::PRIME[786], real>(value);
    case 787: return math::radical_inverse<math::table::PRIME[787], real>(value);
    case 788: return math::radical_inverse<math::table::PRIME[788], real>(value);
    case 789: return math::radical_inverse<math::table::PRIME[789], real>(value);
    case 790: return math::radical_inverse<math::table::PRIME[790], real>(value);
    case 791: return math::radical_inverse<math::table::PRIME[791], real>(value);
    case 792: return math::radical_inverse<math::table::PRIME[792], real>(value);
    case 793: return math::radical_inverse<math::table::PRIME[793], real>(value);
    case 794: return math::radical_inverse<math::table::PRIME[794], real>(value);
    case 795: return math::radical_inverse<math::table::PRIME[795], real>(value);
    case 796: return math::radical_inverse<math::table::PRIME[796], real>(value);
    case 797: return math::radical_inverse<math::table::PRIME[797], real>(value);
    case 798: return math::radical_inverse<math::table::PRIME[798], real>(value);
    case 799: return math::radical_inverse<math::table::PRIME[799], real>(value);
    case 800: return math::radical_inverse<math::table::PRIME[800], real>(value);
    case 801: return math::radical_inverse<math::table::PRIME[801], real>(value);
    case 802: return math::radical_inverse<math::table::PRIME[802], real>(value);
    case 803: return math::radical_inverse<math::table::PRIME[803], real>(value);
    case 804: return math::radical_inverse<math::table::PRIME[804], real>(value);
    case 805: return math::radical_inverse<math::table::PRIME[805], real>(value);
    case 806: return math::radical_inverse<math::table::PRIME[806], real>(value);
    case 807: return math::radical_inverse<math::table::PRIME[807], real>(value);
    case 808: return math::radical_inverse<math::table::PRIME[808], real>(value);
    case 809: return math::radical_inverse<math::table::PRIME[809], real>(value);
    case 810: return math::radical_inverse<math::table::PRIME[810], real>(value);
    case 811: return math::radical_inverse<math::table::PRIME[811], real>(value);
    case 812: return math::radical_inverse<math::table::PRIME[812], real>(value);
    case 813: return math::radical_inverse<math::table::PRIME[813], real>(value);
    case 814: return math::radical_inverse<math::table::PRIME[814], real>(value);
    case 815: return math::radical_inverse<math::table::PRIME[815], real>(value);
    case 816: return math::radical_inverse<math::table::PRIME[816], real>(value);
    case 817: return math::radical_inverse<math::table::PRIME[817], real>(value);
    case 818: return math::radical_inverse<math::table::PRIME[818], real>(value);
    case 819: return math::radical_inverse<math::table::PRIME[819], real>(value);
    case 820: return math::radical_inverse<math::table::PRIME[820], real>(value);
    case 821: return math::radical_inverse<math::table::PRIME[821], real>(value);
    case 822: return math::radical_inverse<math::table::PRIME[822], real>(value);
    case 823: return math::radical_inverse<math::table::PRIME[823], real>(value);
    case 824: return math::radical_inverse<math::table::PRIME[824], real>(value);
    case 825: return math::radical_inverse<math::table::PRIME[825], real>(value);
    case 826: return math::radical_inverse<math::table::PRIME[826], real>(value);
    case 827: return math::radical_inverse<math::table::PRIME[827], real>(value);
    case 828: return math::radical_inverse<math::table::PRIME[828], real>(value);
    case 829: return math::radical_inverse<math::table::PRIME[829], real>(value);
    case 830: return math::radical_inverse<math::table::PRIME[830], real>(value);
    case 831: return math::radical_inverse<math::table::PRIME[831], real>(value);
    case 832: return math::radical_inverse<math::table::PRIME[832], real>(value);
    case 833: return math::radical_inverse<math::table::PRIME[833], real>(value);
    case 834: return math::radical_inverse<math::table::PRIME[834], real>(value);
    case 835: return math::radical_inverse<math::table::PRIME[835], real>(value);
    case 836: return math::radical_inverse<math::table::PRIME[836], real>(value);
    case 837: return math::radical_inverse<math::table::PRIME[837], real>(value);
    case 838: return math::radical_inverse<math::table::PRIME[838], real>(value);
    case 839: return math::radical_inverse<math::table::PRIME[839], real>(value);
    case 840: return math::radical_inverse<math::table::PRIME[840], real>(value);
    case 841: return math::radical_inverse<math::table::PRIME[841], real>(value);
    case 842: return math::radical_inverse<math::table::PRIME[842], real>(value);
    case 843: return math::radical_inverse<math::table::PRIME[843], real>(value);
    case 844: return math::radical_inverse<math::table::PRIME[844], real>(value);
    case 845: return math::radical_inverse<math::table::PRIME[845], real>(value);
    case 846: return math::radical_inverse<math::table::PRIME[846], real>(value);
    case 847: return math::radical_inverse<math::table::PRIME[847], real>(value);
    case 848: return math::radical_inverse<math::table::PRIME[848], real>(value);
    case 849: return math::radical_inverse<math::table::PRIME[849], real>(value);
    case 850: return math::radical_inverse<math::table::PRIME[850], real>(value);
    case 851: return math::radical_inverse<math::table::PRIME[851], real>(value);
    case 852: return math::radical_inverse<math::table::PRIME[852], real>(value);
    case 853: return math::radical_inverse<math::table::PRIME[853], real>(value);
    case 854: return math::radical_inverse<math::table::PRIME[854], real>(value);
    case 855: return math::radical_inverse<math::table::PRIME[855], real>(value);
    case 856: return math::radical_inverse<math::table::PRIME[856], real>(value);
    case 857: return math::radical_inverse<math::table::PRIME[857], real>(value);
    case 858: return math::radical_inverse<math::table::PRIME[858], real>(value);
    case 859: return math::radical_inverse<math::table::PRIME[859], real>(value);
    case 860: return math::radical_inverse<math::table::PRIME[860], real>(value);
    case 861: return math::radical_inverse<math::table::PRIME[861], real>(value);
    case 862: return math::radical_inverse<math::table::PRIME[862], real>(value);
    case 863: return math::radical_inverse<math::table::PRIME[863], real>(value);
    case 864: return math::radical_inverse<math::table::PRIME[864], real>(value);
    case 865: return math::radical_inverse<math::table::PRIME[865], real>(value);
    case 866: return math::radical_inverse<math::table::PRIME[866], real>(value);
    case 867: return math::radical_inverse<math::table::PRIME[867], real>(value);
    case 868: return math::radical_inverse<math::table::PRIME[868], real>(value);
    case 869: return math::radical_inverse<math::table::PRIME[869], real>(value);
    case 870: return math::radical_inverse<math::table::PRIME[870], real>(value);
    case 871: return math::radical_inverse<math::table::PRIME[871], real>(value);
    case 872: return math::radical_inverse<math::table::PRIME[872], real>(value);
    case 873: return math::radical_inverse<math::table::PRIME[873], real>(value);
    case 874: return math::radical_inverse<math::table::PRIME[874], real>(value);
    case 875: return math::radical_inverse<math::table::PRIME[875], real>(value);
    case 876: return math::radical_inverse<math::table::PRIME[876], real>(value);
    case 877: return math::radical_inverse<math::table::PRIME[877], real>(value);
    case 878: return math::radical_inverse<math::table::PRIME[878], real>(value);
    case 879: return math::radical_inverse<math::table::PRIME[879], real>(value);
    case 880: return math::radical_inverse<math::table::PRIME[880], real>(value);
    case 881: return math::radical_inverse<math::table::PRIME[881], real>(value);
    case 882: return math::radical_inverse<math::table::PRIME[882], real>(value);
    case 883: return math::radical_inverse<math::table::PRIME[883], real>(value);
    case 884: return math::radical_inverse<math::table::PRIME[884], real>(value);
    case 885: return math::radical_inverse<math::table::PRIME[885], real>(value);
    case 886: return math::radical_inverse<math::table::PRIME[886], real>(value);
    case 887: return math::radical_inverse<math::table::PRIME[887], real>(value);
    case 888: return math::radical_inverse<math::table::PRIME[888], real>(value);
    case 889: return math::radical_inverse<math::table::PRIME[889], real>(value);
    case 890: return math::radical_inverse<math::table::PRIME[890], real>(value);
    case 891: return math::radical_inverse<math::table::PRIME[891], real>(value);
    case 892: return math::radical_inverse<math::table::PRIME[892], real>(value);
    case 893: return math::radical_inverse<math::table::PRIME[893], real>(value);
    case 894: return math::radical_inverse<math::table::PRIME[894], real>(value);
    case 895: return math::radical_inverse<math::table::PRIME[895], real>(value);
    case 896: return math::radical_inverse<math::table::PRIME[896], real>(value);
    case 897: return math::radical_inverse<math::table::PRIME[897], real>(value);
    case 898: return math::radical_inverse<math::table::PRIME[898], real>(value);
    case 899: return math::radical_inverse<math::table::PRIME[899], real>(value);
    case 900: return math::radical_inverse<math::table::PRIME[900], real>(value);
    case 901: return math::radical_inverse<math::table::PRIME[901], real>(value);
    case 902: return math::radical_inverse<math::table::PRIME[902], real>(value);
    case 903: return math::radical_inverse<math::table::PRIME[903], real>(value);
    case 904: return math::radical_inverse<math::table::PRIME[904], real>(value);
    case 905: return math::radical_inverse<math::table::PRIME[905], real>(value);
    case 906: return math::radical_inverse<math::table::PRIME[906], real>(value);
    case 907: return math::radical_inverse<math::table::PRIME[907], real>(value);
    case 908: return math::radical_inverse<math::table::PRIME[908], real>(value);
    case 909: return math::radical_inverse<math::table::PRIME[909], real>(value);
    case 910: return math::radical_inverse<math::table::PRIME[910], real>(value);
    case 911: return math::radical_inverse<math::table::PRIME[911], real>(value);
    case 912: return math::radical_inverse<math::table::PRIME[912], real>(value);
    case 913: return math::radical_inverse<math::table::PRIME[913], real>(value);
    case 914: return math::radical_inverse<math::table::PRIME[914], real>(value);
    case 915: return math::radical_inverse<math::table::PRIME[915], real>(value);
    case 916: return math::radical_inverse<math::table::PRIME[916], real>(value);
    case 917: return math::radical_inverse<math::table::PRIME[917], real>(value);
    case 918: return math::radical_inverse<math::table::PRIME[918], real>(value);
    case 919: return math::radical_inverse<math::table::PRIME[919], real>(value);
    case 920: return math::radical_inverse<math::table::PRIME[920], real>(value);
    case 921: return math::radical_inverse<math::table::PRIME[921], real>(value);
    case 922: return math::radical_inverse<math::table::PRIME[922], real>(value);
    case 923: return math::radical_inverse<math::table::PRIME[923], real>(value);
    case 924: return math::radical_inverse<math::table::PRIME[924], real>(value);
    case 925: return math::radical_inverse<math::table::PRIME[925], real>(value);
    case 926: return math::radical_inverse<math::table::PRIME[926], real>(value);
    case 927: return math::radical_inverse<math::table::PRIME[927], real>(value);
    case 928: return math::radical_inverse<math::table::PRIME[928], real>(value);
    case 929: return math::radical_inverse<math::table::PRIME[929], real>(value);
    case 930: return math::radical_inverse<math::table::PRIME[930], real>(value);
    case 931: return math::radical_inverse<math::table::PRIME[931], real>(value);
    case 932: return math::radical_inverse<math::table::PRIME[932], real>(value);
    case 933: return math::radical_inverse<math::table::PRIME[933], real>(value);
    case 934: return math::radical_inverse<math::table::PRIME[934], real>(value);
    case 935: return math::radical_inverse<math::table::PRIME[935], real>(value);
    case 936: return math::radical_inverse<math::table::PRIME[936], real>(value);
    case 937: return math::radical_inverse<math::table::PRIME[937], real>(value);
    case 938: return math::radical_inverse<math::table::PRIME[938], real>(value);
    case 939: return math::radical_inverse<math::table::PRIME[939], real>(value);
    case 940: return math::radical_inverse<math::table::PRIME[940], real>(value);
    case 941: return math::radical_inverse<math::table::PRIME[941], real>(value);
    case 942: return math::radical_inverse<math::table::PRIME[942], real>(value);
    case 943: return math::radical_inverse<math::table::PRIME[943], real>(value);
    case 944: return math::radical_inverse<math::table::PRIME[944], real>(value);
    case 945: return math::radical_inverse<math::table::PRIME[945], real>(value);
    case 946: return math::radical_inverse<math::table::PRIME[946], real>(value);
    case 947: return math::radical_inverse<math::table::PRIME[947], real>(value);
    case 948: return math::radical_inverse<math::table::PRIME[948], real>(value);
    case 949: return math::radical_inverse<math::table::PRIME[949], real>(value);
    case 950: return math::radical_inverse<math::table::PRIME[950], real>(value);
    case 951: return math::radical_inverse<math::table::PRIME[951], real>(value);
    case 952: return math::radical_inverse<math::table::PRIME[952], real>(value);
    case 953: return math::radical_inverse<math::table::PRIME[953], real>(value);
    case 954: return math::radical_inverse<math::table::PRIME[954], real>(value);
    case 955: return math::radical_inverse<math::table::PRIME[955], real>(value);
    case 956: return math::radical_inverse<math::table::PRIME[956], real>(value);
    case 957: return math::radical_inverse<math::table::PRIME[957], real>(value);
    case 958: return math::radical_inverse<math::table::PRIME[958], real>(value);
    case 959: return math::radical_inverse<math::table::PRIME[959], real>(value);
    case 960: return math::radical_inverse<math::table::PRIME[960], real>(value);
    case 961: return math::radical_inverse<math::table::PRIME[961], real>(value);
    case 962: return math::radical_inverse<math::table::PRIME[962], real>(value);
    case 963: return math::radical_inverse<math::table::PRIME[963], real>(value);
    case 964: return math::radical_inverse<math::table::PRIME[964], real>(value);
    case 965: return math::radical_inverse<math::table::PRIME[965], real>(value);
    case 966: return math::radical_inverse<math::table::PRIME[966], real>(value);
    case 967: return math::radical_inverse<math::table::PRIME[967], real>(value);
    case 968: return math::radical_inverse<math::table::PRIME[968], real>(value);
    case 969: return math::radical_inverse<math::table::PRIME[969], real>(value);
    case 970: return math::radical_inverse<math::table::PRIME[970], real>(value);
    case 971: return math::radical_inverse<math::table::PRIME[971], real>(value);
    case 972: return math::radical_inverse<math::table::PRIME[972], real>(value);
    case 973: return math::radical_inverse<math::table::PRIME[973], real>(value);
    case 974: return math::radical_inverse<math::table::PRIME[974], real>(value);
    case 975: return math::radical_inverse<math::table::PRIME[975], real>(value);
    case 976: return math::radical_inverse<math::table::PRIME[976], real>(value);
    case 977: return math::radical_inverse<math::table::PRIME[977], real>(value);
    case 978: return math::radical_inverse<math::table::PRIME[978], real>(value);
    case 979: return math::radical_inverse<math::table::PRIME[979], real>(value);
    case 980: return math::radical_inverse<math::table::PRIME[980], real>(value);
    case 981: return math::radical_inverse<math::table::PRIME[981], real>(value);
    case 982: return math::radical_inverse<math::table::PRIME[982], real>(value);
    case 983: return math::radical_inverse<math::table::PRIME[983], real>(value);
    case 984: return math::radical_inverse<math::table::PRIME[984], real>(value);
    case 985: return math::radical_inverse<math::table::PRIME[985], real>(value);
    case 986: return math::radical_inverse<math::table::PRIME[986], real>(value);
    case 987: return math::radical_inverse<math::table::PRIME[987], real>(value);
    case 988: return math::radical_inverse<math::table::PRIME[988], real>(value);
    case 989: return math::radical_inverse<math::table::PRIME[989], real>(value);
    case 990: return math::radical_inverse<math::table::PRIME[990], real>(value);
    case 991: return math::radical_inverse<math::table::PRIME[991], real>(value);
    case 992: return math::radical_inverse<math::table::PRIME[992], real>(value);
    case 993: return math::radical_inverse<math::table::PRIME[993], real>(value);
    case 994: return math::radical_inverse<math::table::PRIME[994], real>(value);
    case 995: return math::radical_inverse<math::table::PRIME[995], real>(value);
    case 996: return math::radical_inverse<math::table::PRIME[996], real>(value);
    case 997: return math::radical_inverse<math::table::PRIME[997], real>(value);
    case 998: return math::radical_inverse<math::table::PRIME[998], real>(value);
    case 999: return math::radical_inverse<math::table::PRIME[999], real>(value);
    case 1000: return math::radical_inverse<math::table::PRIME[1000], real>(value);
    case 1001: return math::radical_inverse<math::table::PRIME[1001], real>(value);
    case 1002: return math::radical_inverse<math::table::PRIME[1002], real>(value);
    case 1003: return math::radical_inverse<math::table::PRIME[1003], real>(value);
    case 1004: return math::radical_inverse<math::table::PRIME[1004], real>(value);
    case 1005: return math::radical_inverse<math::table::PRIME[1005], real>(value);
    case 1006: return math::radical_inverse<math::table::PRIME[1006], real>(value);
    case 1007: return math::radical_inverse<math::table::PRIME[1007], real>(value);
    case 1008: return math::radical_inverse<math::table::PRIME[1008], real>(value);
    case 1009: return math::radical_inverse<math::table::PRIME[1009], real>(value);
    case 1010: return math::radical_inverse<math::table::PRIME[1010], real>(value);
    case 1011: return math::radical_inverse<math::table::PRIME[1011], real>(value);
    case 1012: return math::radical_inverse<math::table::PRIME[1012], real>(value);
    case 1013: return math::radical_inverse<math::table::PRIME[1013], real>(value);
    case 1014: return math::radical_inverse<math::table::PRIME[1014], real>(value);
    case 1015: return math::radical_inverse<math::table::PRIME[1015], real>(value);
    case 1016: return math::radical_inverse<math::table::PRIME[1016], real>(value);
    case 1017: return math::radical_inverse<math::table::PRIME[1017], real>(value);
    case 1018: return math::radical_inverse<math::table::PRIME[1018], real>(value);
    case 1019: return math::radical_inverse<math::table::PRIME[1019], real>(value);
    case 1020: return math::radical_inverse<math::table::PRIME[1020], real>(value);
    case 1021: return math::radical_inverse<math::table::PRIME[1021], real>(value);
    case 1022: return math::radical_inverse<math::table::PRIME[1022], real>(value);
    case 1023: return math::radical_inverse<math::table::PRIME[1023], real>(value);
    }
}
 
template<typename DigitPermuter>
inline real radical_inverse_permuted(
    const uint64 dimIndex, const uint64 value, DigitPermuter permuter)
{
    PH_ASSERT_LT(dimIndex, MAX_DIMENSIONS);
 
    switch(dimIndex)
    {
    default: PH_ASSERT_UNREACHABLE_SECTION(); return 0.0_r;
    case 0: return math::radical_inverse_permuted<math::table::PRIME[0], real>(dimIndex, value, permuter);
    case 1: return math::radical_inverse_permuted<math::table::PRIME[1], real>(dimIndex, value, permuter);
    case 2: return math::radical_inverse_permuted<math::table::PRIME[2], real>(dimIndex, value, permuter);
    case 3: return math::radical_inverse_permuted<math::table::PRIME[3], real>(dimIndex, value, permuter);
    case 4: return math::radical_inverse_permuted<math::table::PRIME[4], real>(dimIndex, value, permuter);
    case 5: return math::radical_inverse_permuted<math::table::PRIME[5], real>(dimIndex, value, permuter);
    case 6: return math::radical_inverse_permuted<math::table::PRIME[6], real>(dimIndex, value, permuter);
    case 7: return math::radical_inverse_permuted<math::table::PRIME[7], real>(dimIndex, value, permuter);
    case 8: return math::radical_inverse_permuted<math::table::PRIME[8], real>(dimIndex, value, permuter);
    case 9: return math::radical_inverse_permuted<math::table::PRIME[9], real>(dimIndex, value, permuter);
    case 10: return math::radical_inverse_permuted<math::table::PRIME[10], real>(dimIndex, value, permuter);
    case 11: return math::radical_inverse_permuted<math::table::PRIME[11], real>(dimIndex, value, permuter);
    case 12: return math::radical_inverse_permuted<math::table::PRIME[12], real>(dimIndex, value, permuter);
    case 13: return math::radical_inverse_permuted<math::table::PRIME[13], real>(dimIndex, value, permuter);
    case 14: return math::radical_inverse_permuted<math::table::PRIME[14], real>(dimIndex, value, permuter);
    case 15: return math::radical_inverse_permuted<math::table::PRIME[15], real>(dimIndex, value, permuter);
    case 16: return math::radical_inverse_permuted<math::table::PRIME[16], real>(dimIndex, value, permuter);
    case 17: return math::radical_inverse_permuted<math::table::PRIME[17], real>(dimIndex, value, permuter);
    case 18: return math::radical_inverse_permuted<math::table::PRIME[18], real>(dimIndex, value, permuter);
    case 19: return math::radical_inverse_permuted<math::table::PRIME[19], real>(dimIndex, value, permuter);
    case 20: return math::radical_inverse_permuted<math::table::PRIME[20], real>(dimIndex, value, permuter);
    case 21: return math::radical_inverse_permuted<math::table::PRIME[21], real>(dimIndex, value, permuter);
    case 22: return math::radical_inverse_permuted<math::table::PRIME[22], real>(dimIndex, value, permuter);
    case 23: return math::radical_inverse_permuted<math::table::PRIME[23], real>(dimIndex, value, permuter);
    case 24: return math::radical_inverse_permuted<math::table::PRIME[24], real>(dimIndex, value, permuter);
    case 25: return math::radical_inverse_permuted<math::table::PRIME[25], real>(dimIndex, value, permuter);
    case 26: return math::radical_inverse_permuted<math::table::PRIME[26], real>(dimIndex, value, permuter);
    case 27: return math::radical_inverse_permuted<math::table::PRIME[27], real>(dimIndex, value, permuter);
    case 28: return math::radical_inverse_permuted<math::table::PRIME[28], real>(dimIndex, value, permuter);
    case 29: return math::radical_inverse_permuted<math::table::PRIME[29], real>(dimIndex, value, permuter);
    case 30: return math::radical_inverse_permuted<math::table::PRIME[30], real>(dimIndex, value, permuter);
    case 31: return math::radical_inverse_permuted<math::table::PRIME[31], real>(dimIndex, value, permuter);
    case 32: return math::radical_inverse_permuted<math::table::PRIME[32], real>(dimIndex, value, permuter);
    case 33: return math::radical_inverse_permuted<math::table::PRIME[33], real>(dimIndex, value, permuter);
    case 34: return math::radical_inverse_permuted<math::table::PRIME[34], real>(dimIndex, value, permuter);
    case 35: return math::radical_inverse_permuted<math::table::PRIME[35], real>(dimIndex, value, permuter);
    case 36: return math::radical_inverse_permuted<math::table::PRIME[36], real>(dimIndex, value, permuter);
    case 37: return math::radical_inverse_permuted<math::table::PRIME[37], real>(dimIndex, value, permuter);
    case 38: return math::radical_inverse_permuted<math::table::PRIME[38], real>(dimIndex, value, permuter);
    case 39: return math::radical_inverse_permuted<math::table::PRIME[39], real>(dimIndex, value, permuter);
    case 40: return math::radical_inverse_permuted<math::table::PRIME[40], real>(dimIndex, value, permuter);
    case 41: return math::radical_inverse_permuted<math::table::PRIME[41], real>(dimIndex, value, permuter);
    case 42: return math::radical_inverse_permuted<math::table::PRIME[42], real>(dimIndex, value, permuter);
    case 43: return math::radical_inverse_permuted<math::table::PRIME[43], real>(dimIndex, value, permuter);
    case 44: return math::radical_inverse_permuted<math::table::PRIME[44], real>(dimIndex, value, permuter);
    case 45: return math::radical_inverse_permuted<math::table::PRIME[45], real>(dimIndex, value, permuter);
    case 46: return math::radical_inverse_permuted<math::table::PRIME[46], real>(dimIndex, value, permuter);
    case 47: return math::radical_inverse_permuted<math::table::PRIME[47], real>(dimIndex, value, permuter);
    case 48: return math::radical_inverse_permuted<math::table::PRIME[48], real>(dimIndex, value, permuter);
    case 49: return math::radical_inverse_permuted<math::table::PRIME[49], real>(dimIndex, value, permuter);
    case 50: return math::radical_inverse_permuted<math::table::PRIME[50], real>(dimIndex, value, permuter);
    case 51: return math::radical_inverse_permuted<math::table::PRIME[51], real>(dimIndex, value, permuter);
    case 52: return math::radical_inverse_permuted<math::table::PRIME[52], real>(dimIndex, value, permuter);
    case 53: return math::radical_inverse_permuted<math::table::PRIME[53], real>(dimIndex, value, permuter);
    case 54: return math::radical_inverse_permuted<math::table::PRIME[54], real>(dimIndex, value, permuter);
    case 55: return math::radical_inverse_permuted<math::table::PRIME[55], real>(dimIndex, value, permuter);
    case 56: return math::radical_inverse_permuted<math::table::PRIME[56], real>(dimIndex, value, permuter);
    case 57: return math::radical_inverse_permuted<math::table::PRIME[57], real>(dimIndex, value, permuter);
    case 58: return math::radical_inverse_permuted<math::table::PRIME[58], real>(dimIndex, value, permuter);
    case 59: return math::radical_inverse_permuted<math::table::PRIME[59], real>(dimIndex, value, permuter);
    case 60: return math::radical_inverse_permuted<math::table::PRIME[60], real>(dimIndex, value, permuter);
    case 61: return math::radical_inverse_permuted<math::table::PRIME[61], real>(dimIndex, value, permuter);
    case 62: return math::radical_inverse_permuted<math::table::PRIME[62], real>(dimIndex, value, permuter);
    case 63: return math::radical_inverse_permuted<math::table::PRIME[63], real>(dimIndex, value, permuter);
    case 64: return math::radical_inverse_permuted<math::table::PRIME[64], real>(dimIndex, value, permuter);
    case 65: return math::radical_inverse_permuted<math::table::PRIME[65], real>(dimIndex, value, permuter);
    case 66: return math::radical_inverse_permuted<math::table::PRIME[66], real>(dimIndex, value, permuter);
    case 67: return math::radical_inverse_permuted<math::table::PRIME[67], real>(dimIndex, value, permuter);
    case 68: return math::radical_inverse_permuted<math::table::PRIME[68], real>(dimIndex, value, permuter);
    case 69: return math::radical_inverse_permuted<math::table::PRIME[69], real>(dimIndex, value, permuter);
    case 70: return math::radical_inverse_permuted<math::table::PRIME[70], real>(dimIndex, value, permuter);
    case 71: return math::radical_inverse_permuted<math::table::PRIME[71], real>(dimIndex, value, permuter);
    case 72: return math::radical_inverse_permuted<math::table::PRIME[72], real>(dimIndex, value, permuter);
    case 73: return math::radical_inverse_permuted<math::table::PRIME[73], real>(dimIndex, value, permuter);
    case 74: return math::radical_inverse_permuted<math::table::PRIME[74], real>(dimIndex, value, permuter);
    case 75: return math::radical_inverse_permuted<math::table::PRIME[75], real>(dimIndex, value, permuter);
    case 76: return math::radical_inverse_permuted<math::table::PRIME[76], real>(dimIndex, value, permuter);
    case 77: return math::radical_inverse_permuted<math::table::PRIME[77], real>(dimIndex, value, permuter);
    case 78: return math::radical_inverse_permuted<math::table::PRIME[78], real>(dimIndex, value, permuter);
    case 79: return math::radical_inverse_permuted<math::table::PRIME[79], real>(dimIndex, value, permuter);
    case 80: return math::radical_inverse_permuted<math::table::PRIME[80], real>(dimIndex, value, permuter);
    case 81: return math::radical_inverse_permuted<math::table::PRIME[81], real>(dimIndex, value, permuter);
    case 82: return math::radical_inverse_permuted<math::table::PRIME[82], real>(dimIndex, value, permuter);
    case 83: return math::radical_inverse_permuted<math::table::PRIME[83], real>(dimIndex, value, permuter);
    case 84: return math::radical_inverse_permuted<math::table::PRIME[84], real>(dimIndex, value, permuter);
    case 85: return math::radical_inverse_permuted<math::table::PRIME[85], real>(dimIndex, value, permuter);
    case 86: return math::radical_inverse_permuted<math::table::PRIME[86], real>(dimIndex, value, permuter);
    case 87: return math::radical_inverse_permuted<math::table::PRIME[87], real>(dimIndex, value, permuter);
    case 88: return math::radical_inverse_permuted<math::table::PRIME[88], real>(dimIndex, value, permuter);
    case 89: return math::radical_inverse_permuted<math::table::PRIME[89], real>(dimIndex, value, permuter);
    case 90: return math::radical_inverse_permuted<math::table::PRIME[90], real>(dimIndex, value, permuter);
    case 91: return math::radical_inverse_permuted<math::table::PRIME[91], real>(dimIndex, value, permuter);
    case 92: return math::radical_inverse_permuted<math::table::PRIME[92], real>(dimIndex, value, permuter);
    case 93: return math::radical_inverse_permuted<math::table::PRIME[93], real>(dimIndex, value, permuter);
    case 94: return math::radical_inverse_permuted<math::table::PRIME[94], real>(dimIndex, value, permuter);
    case 95: return math::radical_inverse_permuted<math::table::PRIME[95], real>(dimIndex, value, permuter);
    case 96: return math::radical_inverse_permuted<math::table::PRIME[96], real>(dimIndex, value, permuter);
    case 97: return math::radical_inverse_permuted<math::table::PRIME[97], real>(dimIndex, value, permuter);
    case 98: return math::radical_inverse_permuted<math::table::PRIME[98], real>(dimIndex, value, permuter);
    case 99: return math::radical_inverse_permuted<math::table::PRIME[99], real>(dimIndex, value, permuter);
    case 100: return math::radical_inverse_permuted<math::table::PRIME[100], real>(dimIndex, value, permuter);
    case 101: return math::radical_inverse_permuted<math::table::PRIME[101], real>(dimIndex, value, permuter);
    case 102: return math::radical_inverse_permuted<math::table::PRIME[102], real>(dimIndex, value, permuter);
    case 103: return math::radical_inverse_permuted<math::table::PRIME[103], real>(dimIndex, value, permuter);
    case 104: return math::radical_inverse_permuted<math::table::PRIME[104], real>(dimIndex, value, permuter);
    case 105: return math::radical_inverse_permuted<math::table::PRIME[105], real>(dimIndex, value, permuter);
    case 106: return math::radical_inverse_permuted<math::table::PRIME[106], real>(dimIndex, value, permuter);
    case 107: return math::radical_inverse_permuted<math::table::PRIME[107], real>(dimIndex, value, permuter);
    case 108: return math::radical_inverse_permuted<math::table::PRIME[108], real>(dimIndex, value, permuter);
    case 109: return math::radical_inverse_permuted<math::table::PRIME[109], real>(dimIndex, value, permuter);
    case 110: return math::radical_inverse_permuted<math::table::PRIME[110], real>(dimIndex, value, permuter);
    case 111: return math::radical_inverse_permuted<math::table::PRIME[111], real>(dimIndex, value, permuter);
    case 112: return math::radical_inverse_permuted<math::table::PRIME[112], real>(dimIndex, value, permuter);
    case 113: return math::radical_inverse_permuted<math::table::PRIME[113], real>(dimIndex, value, permuter);
    case 114: return math::radical_inverse_permuted<math::table::PRIME[114], real>(dimIndex, value, permuter);
    case 115: return math::radical_inverse_permuted<math::table::PRIME[115], real>(dimIndex, value, permuter);
    case 116: return math::radical_inverse_permuted<math::table::PRIME[116], real>(dimIndex, value, permuter);
    case 117: return math::radical_inverse_permuted<math::table::PRIME[117], real>(dimIndex, value, permuter);
    case 118: return math::radical_inverse_permuted<math::table::PRIME[118], real>(dimIndex, value, permuter);
    case 119: return math::radical_inverse_permuted<math::table::PRIME[119], real>(dimIndex, value, permuter);
    case 120: return math::radical_inverse_permuted<math::table::PRIME[120], real>(dimIndex, value, permuter);
    case 121: return math::radical_inverse_permuted<math::table::PRIME[121], real>(dimIndex, value, permuter);
    case 122: return math::radical_inverse_permuted<math::table::PRIME[122], real>(dimIndex, value, permuter);
    case 123: return math::radical_inverse_permuted<math::table::PRIME[123], real>(dimIndex, value, permuter);
    case 124: return math::radical_inverse_permuted<math::table::PRIME[124], real>(dimIndex, value, permuter);
    case 125: return math::radical_inverse_permuted<math::table::PRIME[125], real>(dimIndex, value, permuter);
    case 126: return math::radical_inverse_permuted<math::table::PRIME[126], real>(dimIndex, value, permuter);
    case 127: return math::radical_inverse_permuted<math::table::PRIME[127], real>(dimIndex, value, permuter);
    case 128: return math::radical_inverse_permuted<math::table::PRIME[128], real>(dimIndex, value, permuter);
    case 129: return math::radical_inverse_permuted<math::table::PRIME[129], real>(dimIndex, value, permuter);
    case 130: return math::radical_inverse_permuted<math::table::PRIME[130], real>(dimIndex, value, permuter);
    case 131: return math::radical_inverse_permuted<math::table::PRIME[131], real>(dimIndex, value, permuter);
    case 132: return math::radical_inverse_permuted<math::table::PRIME[132], real>(dimIndex, value, permuter);
    case 133: return math::radical_inverse_permuted<math::table::PRIME[133], real>(dimIndex, value, permuter);
    case 134: return math::radical_inverse_permuted<math::table::PRIME[134], real>(dimIndex, value, permuter);
    case 135: return math::radical_inverse_permuted<math::table::PRIME[135], real>(dimIndex, value, permuter);
    case 136: return math::radical_inverse_permuted<math::table::PRIME[136], real>(dimIndex, value, permuter);
    case 137: return math::radical_inverse_permuted<math::table::PRIME[137], real>(dimIndex, value, permuter);
    case 138: return math::radical_inverse_permuted<math::table::PRIME[138], real>(dimIndex, value, permuter);
    case 139: return math::radical_inverse_permuted<math::table::PRIME[139], real>(dimIndex, value, permuter);
    case 140: return math::radical_inverse_permuted<math::table::PRIME[140], real>(dimIndex, value, permuter);
    case 141: return math::radical_inverse_permuted<math::table::PRIME[141], real>(dimIndex, value, permuter);
    case 142: return math::radical_inverse_permuted<math::table::PRIME[142], real>(dimIndex, value, permuter);
    case 143: return math::radical_inverse_permuted<math::table::PRIME[143], real>(dimIndex, value, permuter);
    case 144: return math::radical_inverse_permuted<math::table::PRIME[144], real>(dimIndex, value, permuter);
    case 145: return math::radical_inverse_permuted<math::table::PRIME[145], real>(dimIndex, value, permuter);
    case 146: return math::radical_inverse_permuted<math::table::PRIME[146], real>(dimIndex, value, permuter);
    case 147: return math::radical_inverse_permuted<math::table::PRIME[147], real>(dimIndex, value, permuter);
    case 148: return math::radical_inverse_permuted<math::table::PRIME[148], real>(dimIndex, value, permuter);
    case 149: return math::radical_inverse_permuted<math::table::PRIME[149], real>(dimIndex, value, permuter);
    case 150: return math::radical_inverse_permuted<math::table::PRIME[150], real>(dimIndex, value, permuter);
    case 151: return math::radical_inverse_permuted<math::table::PRIME[151], real>(dimIndex, value, permuter);
    case 152: return math::radical_inverse_permuted<math::table::PRIME[152], real>(dimIndex, value, permuter);
    case 153: return math::radical_inverse_permuted<math::table::PRIME[153], real>(dimIndex, value, permuter);
    case 154: return math::radical_inverse_permuted<math::table::PRIME[154], real>(dimIndex, value, permuter);
    case 155: return math::radical_inverse_permuted<math::table::PRIME[155], real>(dimIndex, value, permuter);
    case 156: return math::radical_inverse_permuted<math::table::PRIME[156], real>(dimIndex, value, permuter);
    case 157: return math::radical_inverse_permuted<math::table::PRIME[157], real>(dimIndex, value, permuter);
    case 158: return math::radical_inverse_permuted<math::table::PRIME[158], real>(dimIndex, value, permuter);
    case 159: return math::radical_inverse_permuted<math::table::PRIME[159], real>(dimIndex, value, permuter);
    case 160: return math::radical_inverse_permuted<math::table::PRIME[160], real>(dimIndex, value, permuter);
    case 161: return math::radical_inverse_permuted<math::table::PRIME[161], real>(dimIndex, value, permuter);
    case 162: return math::radical_inverse_permuted<math::table::PRIME[162], real>(dimIndex, value, permuter);
    case 163: return math::radical_inverse_permuted<math::table::PRIME[163], real>(dimIndex, value, permuter);
    case 164: return math::radical_inverse_permuted<math::table::PRIME[164], real>(dimIndex, value, permuter);
    case 165: return math::radical_inverse_permuted<math::table::PRIME[165], real>(dimIndex, value, permuter);
    case 166: return math::radical_inverse_permuted<math::table::PRIME[166], real>(dimIndex, value, permuter);
    case 167: return math::radical_inverse_permuted<math::table::PRIME[167], real>(dimIndex, value, permuter);
    case 168: return math::radical_inverse_permuted<math::table::PRIME[168], real>(dimIndex, value, permuter);
    case 169: return math::radical_inverse_permuted<math::table::PRIME[169], real>(dimIndex, value, permuter);
    case 170: return math::radical_inverse_permuted<math::table::PRIME[170], real>(dimIndex, value, permuter);
    case 171: return math::radical_inverse_permuted<math::table::PRIME[171], real>(dimIndex, value, permuter);
    case 172: return math::radical_inverse_permuted<math::table::PRIME[172], real>(dimIndex, value, permuter);
    case 173: return math::radical_inverse_permuted<math::table::PRIME[173], real>(dimIndex, value, permuter);
    case 174: return math::radical_inverse_permuted<math::table::PRIME[174], real>(dimIndex, value, permuter);
    case 175: return math::radical_inverse_permuted<math::table::PRIME[175], real>(dimIndex, value, permuter);
    case 176: return math::radical_inverse_permuted<math::table::PRIME[176], real>(dimIndex, value, permuter);
    case 177: return math::radical_inverse_permuted<math::table::PRIME[177], real>(dimIndex, value, permuter);
    case 178: return math::radical_inverse_permuted<math::table::PRIME[178], real>(dimIndex, value, permuter);
    case 179: return math::radical_inverse_permuted<math::table::PRIME[179], real>(dimIndex, value, permuter);
    case 180: return math::radical_inverse_permuted<math::table::PRIME[180], real>(dimIndex, value, permuter);
    case 181: return math::radical_inverse_permuted<math::table::PRIME[181], real>(dimIndex, value, permuter);
    case 182: return math::radical_inverse_permuted<math::table::PRIME[182], real>(dimIndex, value, permuter);
    case 183: return math::radical_inverse_permuted<math::table::PRIME[183], real>(dimIndex, value, permuter);
    case 184: return math::radical_inverse_permuted<math::table::PRIME[184], real>(dimIndex, value, permuter);
    case 185: return math::radical_inverse_permuted<math::table::PRIME[185], real>(dimIndex, value, permuter);
    case 186: return math::radical_inverse_permuted<math::table::PRIME[186], real>(dimIndex, value, permuter);
    case 187: return math::radical_inverse_permuted<math::table::PRIME[187], real>(dimIndex, value, permuter);
    case 188: return math::radical_inverse_permuted<math::table::PRIME[188], real>(dimIndex, value, permuter);
    case 189: return math::radical_inverse_permuted<math::table::PRIME[189], real>(dimIndex, value, permuter);
    case 190: return math::radical_inverse_permuted<math::table::PRIME[190], real>(dimIndex, value, permuter);
    case 191: return math::radical_inverse_permuted<math::table::PRIME[191], real>(dimIndex, value, permuter);
    case 192: return math::radical_inverse_permuted<math::table::PRIME[192], real>(dimIndex, value, permuter);
    case 193: return math::radical_inverse_permuted<math::table::PRIME[193], real>(dimIndex, value, permuter);
    case 194: return math::radical_inverse_permuted<math::table::PRIME[194], real>(dimIndex, value, permuter);
    case 195: return math::radical_inverse_permuted<math::table::PRIME[195], real>(dimIndex, value, permuter);
    case 196: return math::radical_inverse_permuted<math::table::PRIME[196], real>(dimIndex, value, permuter);
    case 197: return math::radical_inverse_permuted<math::table::PRIME[197], real>(dimIndex, value, permuter);
    case 198: return math::radical_inverse_permuted<math::table::PRIME[198], real>(dimIndex, value, permuter);
    case 199: return math::radical_inverse_permuted<math::table::PRIME[199], real>(dimIndex, value, permuter);
    case 200: return math::radical_inverse_permuted<math::table::PRIME[200], real>(dimIndex, value, permuter);
    case 201: return math::radical_inverse_permuted<math::table::PRIME[201], real>(dimIndex, value, permuter);
    case 202: return math::radical_inverse_permuted<math::table::PRIME[202], real>(dimIndex, value, permuter);
    case 203: return math::radical_inverse_permuted<math::table::PRIME[203], real>(dimIndex, value, permuter);
    case 204: return math::radical_inverse_permuted<math::table::PRIME[204], real>(dimIndex, value, permuter);
    case 205: return math::radical_inverse_permuted<math::table::PRIME[205], real>(dimIndex, value, permuter);
    case 206: return math::radical_inverse_permuted<math::table::PRIME[206], real>(dimIndex, value, permuter);
    case 207: return math::radical_inverse_permuted<math::table::PRIME[207], real>(dimIndex, value, permuter);
    case 208: return math::radical_inverse_permuted<math::table::PRIME[208], real>(dimIndex, value, permuter);
    case 209: return math::radical_inverse_permuted<math::table::PRIME[209], real>(dimIndex, value, permuter);
    case 210: return math::radical_inverse_permuted<math::table::PRIME[210], real>(dimIndex, value, permuter);
    case 211: return math::radical_inverse_permuted<math::table::PRIME[211], real>(dimIndex, value, permuter);
    case 212: return math::radical_inverse_permuted<math::table::PRIME[212], real>(dimIndex, value, permuter);
    case 213: return math::radical_inverse_permuted<math::table::PRIME[213], real>(dimIndex, value, permuter);
    case 214: return math::radical_inverse_permuted<math::table::PRIME[214], real>(dimIndex, value, permuter);
    case 215: return math::radical_inverse_permuted<math::table::PRIME[215], real>(dimIndex, value, permuter);
    case 216: return math::radical_inverse_permuted<math::table::PRIME[216], real>(dimIndex, value, permuter);
    case 217: return math::radical_inverse_permuted<math::table::PRIME[217], real>(dimIndex, value, permuter);
    case 218: return math::radical_inverse_permuted<math::table::PRIME[218], real>(dimIndex, value, permuter);
    case 219: return math::radical_inverse_permuted<math::table::PRIME[219], real>(dimIndex, value, permuter);
    case 220: return math::radical_inverse_permuted<math::table::PRIME[220], real>(dimIndex, value, permuter);
    case 221: return math::radical_inverse_permuted<math::table::PRIME[221], real>(dimIndex, value, permuter);
    case 222: return math::radical_inverse_permuted<math::table::PRIME[222], real>(dimIndex, value, permuter);
    case 223: return math::radical_inverse_permuted<math::table::PRIME[223], real>(dimIndex, value, permuter);
    case 224: return math::radical_inverse_permuted<math::table::PRIME[224], real>(dimIndex, value, permuter);
    case 225: return math::radical_inverse_permuted<math::table::PRIME[225], real>(dimIndex, value, permuter);
    case 226: return math::radical_inverse_permuted<math::table::PRIME[226], real>(dimIndex, value, permuter);
    case 227: return math::radical_inverse_permuted<math::table::PRIME[227], real>(dimIndex, value, permuter);
    case 228: return math::radical_inverse_permuted<math::table::PRIME[228], real>(dimIndex, value, permuter);
    case 229: return math::radical_inverse_permuted<math::table::PRIME[229], real>(dimIndex, value, permuter);
    case 230: return math::radical_inverse_permuted<math::table::PRIME[230], real>(dimIndex, value, permuter);
    case 231: return math::radical_inverse_permuted<math::table::PRIME[231], real>(dimIndex, value, permuter);
    case 232: return math::radical_inverse_permuted<math::table::PRIME[232], real>(dimIndex, value, permuter);
    case 233: return math::radical_inverse_permuted<math::table::PRIME[233], real>(dimIndex, value, permuter);
    case 234: return math::radical_inverse_permuted<math::table::PRIME[234], real>(dimIndex, value, permuter);
    case 235: return math::radical_inverse_permuted<math::table::PRIME[235], real>(dimIndex, value, permuter);
    case 236: return math::radical_inverse_permuted<math::table::PRIME[236], real>(dimIndex, value, permuter);
    case 237: return math::radical_inverse_permuted<math::table::PRIME[237], real>(dimIndex, value, permuter);
    case 238: return math::radical_inverse_permuted<math::table::PRIME[238], real>(dimIndex, value, permuter);
    case 239: return math::radical_inverse_permuted<math::table::PRIME[239], real>(dimIndex, value, permuter);
    case 240: return math::radical_inverse_permuted<math::table::PRIME[240], real>(dimIndex, value, permuter);
    case 241: return math::radical_inverse_permuted<math::table::PRIME[241], real>(dimIndex, value, permuter);
    case 242: return math::radical_inverse_permuted<math::table::PRIME[242], real>(dimIndex, value, permuter);
    case 243: return math::radical_inverse_permuted<math::table::PRIME[243], real>(dimIndex, value, permuter);
    case 244: return math::radical_inverse_permuted<math::table::PRIME[244], real>(dimIndex, value, permuter);
    case 245: return math::radical_inverse_permuted<math::table::PRIME[245], real>(dimIndex, value, permuter);
    case 246: return math::radical_inverse_permuted<math::table::PRIME[246], real>(dimIndex, value, permuter);
    case 247: return math::radical_inverse_permuted<math::table::PRIME[247], real>(dimIndex, value, permuter);
    case 248: return math::radical_inverse_permuted<math::table::PRIME[248], real>(dimIndex, value, permuter);
    case 249: return math::radical_inverse_permuted<math::table::PRIME[249], real>(dimIndex, value, permuter);
    case 250: return math::radical_inverse_permuted<math::table::PRIME[250], real>(dimIndex, value, permuter);
    case 251: return math::radical_inverse_permuted<math::table::PRIME[251], real>(dimIndex, value, permuter);
    case 252: return math::radical_inverse_permuted<math::table::PRIME[252], real>(dimIndex, value, permuter);
    case 253: return math::radical_inverse_permuted<math::table::PRIME[253], real>(dimIndex, value, permuter);
    case 254: return math::radical_inverse_permuted<math::table::PRIME[254], real>(dimIndex, value, permuter);
    case 255: return math::radical_inverse_permuted<math::table::PRIME[255], real>(dimIndex, value, permuter);
    case 256: return math::radical_inverse_permuted<math::table::PRIME[256], real>(dimIndex, value, permuter);
    case 257: return math::radical_inverse_permuted<math::table::PRIME[257], real>(dimIndex, value, permuter);
    case 258: return math::radical_inverse_permuted<math::table::PRIME[258], real>(dimIndex, value, permuter);
    case 259: return math::radical_inverse_permuted<math::table::PRIME[259], real>(dimIndex, value, permuter);
    case 260: return math::radical_inverse_permuted<math::table::PRIME[260], real>(dimIndex, value, permuter);
    case 261: return math::radical_inverse_permuted<math::table::PRIME[261], real>(dimIndex, value, permuter);
    case 262: return math::radical_inverse_permuted<math::table::PRIME[262], real>(dimIndex, value, permuter);
    case 263: return math::radical_inverse_permuted<math::table::PRIME[263], real>(dimIndex, value, permuter);
    case 264: return math::radical_inverse_permuted<math::table::PRIME[264], real>(dimIndex, value, permuter);
    case 265: return math::radical_inverse_permuted<math::table::PRIME[265], real>(dimIndex, value, permuter);
    case 266: return math::radical_inverse_permuted<math::table::PRIME[266], real>(dimIndex, value, permuter);
    case 267: return math::radical_inverse_permuted<math::table::PRIME[267], real>(dimIndex, value, permuter);
    case 268: return math::radical_inverse_permuted<math::table::PRIME[268], real>(dimIndex, value, permuter);
    case 269: return math::radical_inverse_permuted<math::table::PRIME[269], real>(dimIndex, value, permuter);
    case 270: return math::radical_inverse_permuted<math::table::PRIME[270], real>(dimIndex, value, permuter);
    case 271: return math::radical_inverse_permuted<math::table::PRIME[271], real>(dimIndex, value, permuter);
    case 272: return math::radical_inverse_permuted<math::table::PRIME[272], real>(dimIndex, value, permuter);
    case 273: return math::radical_inverse_permuted<math::table::PRIME[273], real>(dimIndex, value, permuter);
    case 274: return math::radical_inverse_permuted<math::table::PRIME[274], real>(dimIndex, value, permuter);
    case 275: return math::radical_inverse_permuted<math::table::PRIME[275], real>(dimIndex, value, permuter);
    case 276: return math::radical_inverse_permuted<math::table::PRIME[276], real>(dimIndex, value, permuter);
    case 277: return math::radical_inverse_permuted<math::table::PRIME[277], real>(dimIndex, value, permuter);
    case 278: return math::radical_inverse_permuted<math::table::PRIME[278], real>(dimIndex, value, permuter);
    case 279: return math::radical_inverse_permuted<math::table::PRIME[279], real>(dimIndex, value, permuter);
    case 280: return math::radical_inverse_permuted<math::table::PRIME[280], real>(dimIndex, value, permuter);
    case 281: return math::radical_inverse_permuted<math::table::PRIME[281], real>(dimIndex, value, permuter);
    case 282: return math::radical_inverse_permuted<math::table::PRIME[282], real>(dimIndex, value, permuter);
    case 283: return math::radical_inverse_permuted<math::table::PRIME[283], real>(dimIndex, value, permuter);
    case 284: return math::radical_inverse_permuted<math::table::PRIME[284], real>(dimIndex, value, permuter);
    case 285: return math::radical_inverse_permuted<math::table::PRIME[285], real>(dimIndex, value, permuter);
    case 286: return math::radical_inverse_permuted<math::table::PRIME[286], real>(dimIndex, value, permuter);
    case 287: return math::radical_inverse_permuted<math::table::PRIME[287], real>(dimIndex, value, permuter);
    case 288: return math::radical_inverse_permuted<math::table::PRIME[288], real>(dimIndex, value, permuter);
    case 289: return math::radical_inverse_permuted<math::table::PRIME[289], real>(dimIndex, value, permuter);
    case 290: return math::radical_inverse_permuted<math::table::PRIME[290], real>(dimIndex, value, permuter);
    case 291: return math::radical_inverse_permuted<math::table::PRIME[291], real>(dimIndex, value, permuter);
    case 292: return math::radical_inverse_permuted<math::table::PRIME[292], real>(dimIndex, value, permuter);
    case 293: return math::radical_inverse_permuted<math::table::PRIME[293], real>(dimIndex, value, permuter);
    case 294: return math::radical_inverse_permuted<math::table::PRIME[294], real>(dimIndex, value, permuter);
    case 295: return math::radical_inverse_permuted<math::table::PRIME[295], real>(dimIndex, value, permuter);
    case 296: return math::radical_inverse_permuted<math::table::PRIME[296], real>(dimIndex, value, permuter);
    case 297: return math::radical_inverse_permuted<math::table::PRIME[297], real>(dimIndex, value, permuter);
    case 298: return math::radical_inverse_permuted<math::table::PRIME[298], real>(dimIndex, value, permuter);
    case 299: return math::radical_inverse_permuted<math::table::PRIME[299], real>(dimIndex, value, permuter);
    case 300: return math::radical_inverse_permuted<math::table::PRIME[300], real>(dimIndex, value, permuter);
    case 301: return math::radical_inverse_permuted<math::table::PRIME[301], real>(dimIndex, value, permuter);
    case 302: return math::radical_inverse_permuted<math::table::PRIME[302], real>(dimIndex, value, permuter);
    case 303: return math::radical_inverse_permuted<math::table::PRIME[303], real>(dimIndex, value, permuter);
    case 304: return math::radical_inverse_permuted<math::table::PRIME[304], real>(dimIndex, value, permuter);
    case 305: return math::radical_inverse_permuted<math::table::PRIME[305], real>(dimIndex, value, permuter);
    case 306: return math::radical_inverse_permuted<math::table::PRIME[306], real>(dimIndex, value, permuter);
    case 307: return math::radical_inverse_permuted<math::table::PRIME[307], real>(dimIndex, value, permuter);
    case 308: return math::radical_inverse_permuted<math::table::PRIME[308], real>(dimIndex, value, permuter);
    case 309: return math::radical_inverse_permuted<math::table::PRIME[309], real>(dimIndex, value, permuter);
    case 310: return math::radical_inverse_permuted<math::table::PRIME[310], real>(dimIndex, value, permuter);
    case 311: return math::radical_inverse_permuted<math::table::PRIME[311], real>(dimIndex, value, permuter);
    case 312: return math::radical_inverse_permuted<math::table::PRIME[312], real>(dimIndex, value, permuter);
    case 313: return math::radical_inverse_permuted<math::table::PRIME[313], real>(dimIndex, value, permuter);
    case 314: return math::radical_inverse_permuted<math::table::PRIME[314], real>(dimIndex, value, permuter);
    case 315: return math::radical_inverse_permuted<math::table::PRIME[315], real>(dimIndex, value, permuter);
    case 316: return math::radical_inverse_permuted<math::table::PRIME[316], real>(dimIndex, value, permuter);
    case 317: return math::radical_inverse_permuted<math::table::PRIME[317], real>(dimIndex, value, permuter);
    case 318: return math::radical_inverse_permuted<math::table::PRIME[318], real>(dimIndex, value, permuter);
    case 319: return math::radical_inverse_permuted<math::table::PRIME[319], real>(dimIndex, value, permuter);
    case 320: return math::radical_inverse_permuted<math::table::PRIME[320], real>(dimIndex, value, permuter);
    case 321: return math::radical_inverse_permuted<math::table::PRIME[321], real>(dimIndex, value, permuter);
    case 322: return math::radical_inverse_permuted<math::table::PRIME[322], real>(dimIndex, value, permuter);
    case 323: return math::radical_inverse_permuted<math::table::PRIME[323], real>(dimIndex, value, permuter);
    case 324: return math::radical_inverse_permuted<math::table::PRIME[324], real>(dimIndex, value, permuter);
    case 325: return math::radical_inverse_permuted<math::table::PRIME[325], real>(dimIndex, value, permuter);
    case 326: return math::radical_inverse_permuted<math::table::PRIME[326], real>(dimIndex, value, permuter);
    case 327: return math::radical_inverse_permuted<math::table::PRIME[327], real>(dimIndex, value, permuter);
    case 328: return math::radical_inverse_permuted<math::table::PRIME[328], real>(dimIndex, value, permuter);
    case 329: return math::radical_inverse_permuted<math::table::PRIME[329], real>(dimIndex, value, permuter);
    case 330: return math::radical_inverse_permuted<math::table::PRIME[330], real>(dimIndex, value, permuter);
    case 331: return math::radical_inverse_permuted<math::table::PRIME[331], real>(dimIndex, value, permuter);
    case 332: return math::radical_inverse_permuted<math::table::PRIME[332], real>(dimIndex, value, permuter);
    case 333: return math::radical_inverse_permuted<math::table::PRIME[333], real>(dimIndex, value, permuter);
    case 334: return math::radical_inverse_permuted<math::table::PRIME[334], real>(dimIndex, value, permuter);
    case 335: return math::radical_inverse_permuted<math::table::PRIME[335], real>(dimIndex, value, permuter);
    case 336: return math::radical_inverse_permuted<math::table::PRIME[336], real>(dimIndex, value, permuter);
    case 337: return math::radical_inverse_permuted<math::table::PRIME[337], real>(dimIndex, value, permuter);
    case 338: return math::radical_inverse_permuted<math::table::PRIME[338], real>(dimIndex, value, permuter);
    case 339: return math::radical_inverse_permuted<math::table::PRIME[339], real>(dimIndex, value, permuter);
    case 340: return math::radical_inverse_permuted<math::table::PRIME[340], real>(dimIndex, value, permuter);
    case 341: return math::radical_inverse_permuted<math::table::PRIME[341], real>(dimIndex, value, permuter);
    case 342: return math::radical_inverse_permuted<math::table::PRIME[342], real>(dimIndex, value, permuter);
    case 343: return math::radical_inverse_permuted<math::table::PRIME[343], real>(dimIndex, value, permuter);
    case 344: return math::radical_inverse_permuted<math::table::PRIME[344], real>(dimIndex, value, permuter);
    case 345: return math::radical_inverse_permuted<math::table::PRIME[345], real>(dimIndex, value, permuter);
    case 346: return math::radical_inverse_permuted<math::table::PRIME[346], real>(dimIndex, value, permuter);
    case 347: return math::radical_inverse_permuted<math::table::PRIME[347], real>(dimIndex, value, permuter);
    case 348: return math::radical_inverse_permuted<math::table::PRIME[348], real>(dimIndex, value, permuter);
    case 349: return math::radical_inverse_permuted<math::table::PRIME[349], real>(dimIndex, value, permuter);
    case 350: return math::radical_inverse_permuted<math::table::PRIME[350], real>(dimIndex, value, permuter);
    case 351: return math::radical_inverse_permuted<math::table::PRIME[351], real>(dimIndex, value, permuter);
    case 352: return math::radical_inverse_permuted<math::table::PRIME[352], real>(dimIndex, value, permuter);
    case 353: return math::radical_inverse_permuted<math::table::PRIME[353], real>(dimIndex, value, permuter);
    case 354: return math::radical_inverse_permuted<math::table::PRIME[354], real>(dimIndex, value, permuter);
    case 355: return math::radical_inverse_permuted<math::table::PRIME[355], real>(dimIndex, value, permuter);
    case 356: return math::radical_inverse_permuted<math::table::PRIME[356], real>(dimIndex, value, permuter);
    case 357: return math::radical_inverse_permuted<math::table::PRIME[357], real>(dimIndex, value, permuter);
    case 358: return math::radical_inverse_permuted<math::table::PRIME[358], real>(dimIndex, value, permuter);
    case 359: return math::radical_inverse_permuted<math::table::PRIME[359], real>(dimIndex, value, permuter);
    case 360: return math::radical_inverse_permuted<math::table::PRIME[360], real>(dimIndex, value, permuter);
    case 361: return math::radical_inverse_permuted<math::table::PRIME[361], real>(dimIndex, value, permuter);
    case 362: return math::radical_inverse_permuted<math::table::PRIME[362], real>(dimIndex, value, permuter);
    case 363: return math::radical_inverse_permuted<math::table::PRIME[363], real>(dimIndex, value, permuter);
    case 364: return math::radical_inverse_permuted<math::table::PRIME[364], real>(dimIndex, value, permuter);
    case 365: return math::radical_inverse_permuted<math::table::PRIME[365], real>(dimIndex, value, permuter);
    case 366: return math::radical_inverse_permuted<math::table::PRIME[366], real>(dimIndex, value, permuter);
    case 367: return math::radical_inverse_permuted<math::table::PRIME[367], real>(dimIndex, value, permuter);
    case 368: return math::radical_inverse_permuted<math::table::PRIME[368], real>(dimIndex, value, permuter);
    case 369: return math::radical_inverse_permuted<math::table::PRIME[369], real>(dimIndex, value, permuter);
    case 370: return math::radical_inverse_permuted<math::table::PRIME[370], real>(dimIndex, value, permuter);
    case 371: return math::radical_inverse_permuted<math::table::PRIME[371], real>(dimIndex, value, permuter);
    case 372: return math::radical_inverse_permuted<math::table::PRIME[372], real>(dimIndex, value, permuter);
    case 373: return math::radical_inverse_permuted<math::table::PRIME[373], real>(dimIndex, value, permuter);
    case 374: return math::radical_inverse_permuted<math::table::PRIME[374], real>(dimIndex, value, permuter);
    case 375: return math::radical_inverse_permuted<math::table::PRIME[375], real>(dimIndex, value, permuter);
    case 376: return math::radical_inverse_permuted<math::table::PRIME[376], real>(dimIndex, value, permuter);
    case 377: return math::radical_inverse_permuted<math::table::PRIME[377], real>(dimIndex, value, permuter);
    case 378: return math::radical_inverse_permuted<math::table::PRIME[378], real>(dimIndex, value, permuter);
    case 379: return math::radical_inverse_permuted<math::table::PRIME[379], real>(dimIndex, value, permuter);
    case 380: return math::radical_inverse_permuted<math::table::PRIME[380], real>(dimIndex, value, permuter);
    case 381: return math::radical_inverse_permuted<math::table::PRIME[381], real>(dimIndex, value, permuter);
    case 382: return math::radical_inverse_permuted<math::table::PRIME[382], real>(dimIndex, value, permuter);
    case 383: return math::radical_inverse_permuted<math::table::PRIME[383], real>(dimIndex, value, permuter);
    case 384: return math::radical_inverse_permuted<math::table::PRIME[384], real>(dimIndex, value, permuter);
    case 385: return math::radical_inverse_permuted<math::table::PRIME[385], real>(dimIndex, value, permuter);
    case 386: return math::radical_inverse_permuted<math::table::PRIME[386], real>(dimIndex, value, permuter);
    case 387: return math::radical_inverse_permuted<math::table::PRIME[387], real>(dimIndex, value, permuter);
    case 388: return math::radical_inverse_permuted<math::table::PRIME[388], real>(dimIndex, value, permuter);
    case 389: return math::radical_inverse_permuted<math::table::PRIME[389], real>(dimIndex, value, permuter);
    case 390: return math::radical_inverse_permuted<math::table::PRIME[390], real>(dimIndex, value, permuter);
    case 391: return math::radical_inverse_permuted<math::table::PRIME[391], real>(dimIndex, value, permuter);
    case 392: return math::radical_inverse_permuted<math::table::PRIME[392], real>(dimIndex, value, permuter);
    case 393: return math::radical_inverse_permuted<math::table::PRIME[393], real>(dimIndex, value, permuter);
    case 394: return math::radical_inverse_permuted<math::table::PRIME[394], real>(dimIndex, value, permuter);
    case 395: return math::radical_inverse_permuted<math::table::PRIME[395], real>(dimIndex, value, permuter);
    case 396: return math::radical_inverse_permuted<math::table::PRIME[396], real>(dimIndex, value, permuter);
    case 397: return math::radical_inverse_permuted<math::table::PRIME[397], real>(dimIndex, value, permuter);
    case 398: return math::radical_inverse_permuted<math::table::PRIME[398], real>(dimIndex, value, permuter);
    case 399: return math::radical_inverse_permuted<math::table::PRIME[399], real>(dimIndex, value, permuter);
    case 400: return math::radical_inverse_permuted<math::table::PRIME[400], real>(dimIndex, value, permuter);
    case 401: return math::radical_inverse_permuted<math::table::PRIME[401], real>(dimIndex, value, permuter);
    case 402: return math::radical_inverse_permuted<math::table::PRIME[402], real>(dimIndex, value, permuter);
    case 403: return math::radical_inverse_permuted<math::table::PRIME[403], real>(dimIndex, value, permuter);
    case 404: return math::radical_inverse_permuted<math::table::PRIME[404], real>(dimIndex, value, permuter);
    case 405: return math::radical_inverse_permuted<math::table::PRIME[405], real>(dimIndex, value, permuter);
    case 406: return math::radical_inverse_permuted<math::table::PRIME[406], real>(dimIndex, value, permuter);
    case 407: return math::radical_inverse_permuted<math::table::PRIME[407], real>(dimIndex, value, permuter);
    case 408: return math::radical_inverse_permuted<math::table::PRIME[408], real>(dimIndex, value, permuter);
    case 409: return math::radical_inverse_permuted<math::table::PRIME[409], real>(dimIndex, value, permuter);
    case 410: return math::radical_inverse_permuted<math::table::PRIME[410], real>(dimIndex, value, permuter);
    case 411: return math::radical_inverse_permuted<math::table::PRIME[411], real>(dimIndex, value, permuter);
    case 412: return math::radical_inverse_permuted<math::table::PRIME[412], real>(dimIndex, value, permuter);
    case 413: return math::radical_inverse_permuted<math::table::PRIME[413], real>(dimIndex, value, permuter);
    case 414: return math::radical_inverse_permuted<math::table::PRIME[414], real>(dimIndex, value, permuter);
    case 415: return math::radical_inverse_permuted<math::table::PRIME[415], real>(dimIndex, value, permuter);
    case 416: return math::radical_inverse_permuted<math::table::PRIME[416], real>(dimIndex, value, permuter);
    case 417: return math::radical_inverse_permuted<math::table::PRIME[417], real>(dimIndex, value, permuter);
    case 418: return math::radical_inverse_permuted<math::table::PRIME[418], real>(dimIndex, value, permuter);
    case 419: return math::radical_inverse_permuted<math::table::PRIME[419], real>(dimIndex, value, permuter);
    case 420: return math::radical_inverse_permuted<math::table::PRIME[420], real>(dimIndex, value, permuter);
    case 421: return math::radical_inverse_permuted<math::table::PRIME[421], real>(dimIndex, value, permuter);
    case 422: return math::radical_inverse_permuted<math::table::PRIME[422], real>(dimIndex, value, permuter);
    case 423: return math::radical_inverse_permuted<math::table::PRIME[423], real>(dimIndex, value, permuter);
    case 424: return math::radical_inverse_permuted<math::table::PRIME[424], real>(dimIndex, value, permuter);
    case 425: return math::radical_inverse_permuted<math::table::PRIME[425], real>(dimIndex, value, permuter);
    case 426: return math::radical_inverse_permuted<math::table::PRIME[426], real>(dimIndex, value, permuter);
    case 427: return math::radical_inverse_permuted<math::table::PRIME[427], real>(dimIndex, value, permuter);
    case 428: return math::radical_inverse_permuted<math::table::PRIME[428], real>(dimIndex, value, permuter);
    case 429: return math::radical_inverse_permuted<math::table::PRIME[429], real>(dimIndex, value, permuter);
    case 430: return math::radical_inverse_permuted<math::table::PRIME[430], real>(dimIndex, value, permuter);
    case 431: return math::radical_inverse_permuted<math::table::PRIME[431], real>(dimIndex, value, permuter);
    case 432: return math::radical_inverse_permuted<math::table::PRIME[432], real>(dimIndex, value, permuter);
    case 433: return math::radical_inverse_permuted<math::table::PRIME[433], real>(dimIndex, value, permuter);
    case 434: return math::radical_inverse_permuted<math::table::PRIME[434], real>(dimIndex, value, permuter);
    case 435: return math::radical_inverse_permuted<math::table::PRIME[435], real>(dimIndex, value, permuter);
    case 436: return math::radical_inverse_permuted<math::table::PRIME[436], real>(dimIndex, value, permuter);
    case 437: return math::radical_inverse_permuted<math::table::PRIME[437], real>(dimIndex, value, permuter);
    case 438: return math::radical_inverse_permuted<math::table::PRIME[438], real>(dimIndex, value, permuter);
    case 439: return math::radical_inverse_permuted<math::table::PRIME[439], real>(dimIndex, value, permuter);
    case 440: return math::radical_inverse_permuted<math::table::PRIME[440], real>(dimIndex, value, permuter);
    case 441: return math::radical_inverse_permuted<math::table::PRIME[441], real>(dimIndex, value, permuter);
    case 442: return math::radical_inverse_permuted<math::table::PRIME[442], real>(dimIndex, value, permuter);
    case 443: return math::radical_inverse_permuted<math::table::PRIME[443], real>(dimIndex, value, permuter);
    case 444: return math::radical_inverse_permuted<math::table::PRIME[444], real>(dimIndex, value, permuter);
    case 445: return math::radical_inverse_permuted<math::table::PRIME[445], real>(dimIndex, value, permuter);
    case 446: return math::radical_inverse_permuted<math::table::PRIME[446], real>(dimIndex, value, permuter);
    case 447: return math::radical_inverse_permuted<math::table::PRIME[447], real>(dimIndex, value, permuter);
    case 448: return math::radical_inverse_permuted<math::table::PRIME[448], real>(dimIndex, value, permuter);
    case 449: return math::radical_inverse_permuted<math::table::PRIME[449], real>(dimIndex, value, permuter);
    case 450: return math::radical_inverse_permuted<math::table::PRIME[450], real>(dimIndex, value, permuter);
    case 451: return math::radical_inverse_permuted<math::table::PRIME[451], real>(dimIndex, value, permuter);
    case 452: return math::radical_inverse_permuted<math::table::PRIME[452], real>(dimIndex, value, permuter);
    case 453: return math::radical_inverse_permuted<math::table::PRIME[453], real>(dimIndex, value, permuter);
    case 454: return math::radical_inverse_permuted<math::table::PRIME[454], real>(dimIndex, value, permuter);
    case 455: return math::radical_inverse_permuted<math::table::PRIME[455], real>(dimIndex, value, permuter);
    case 456: return math::radical_inverse_permuted<math::table::PRIME[456], real>(dimIndex, value, permuter);
    case 457: return math::radical_inverse_permuted<math::table::PRIME[457], real>(dimIndex, value, permuter);
    case 458: return math::radical_inverse_permuted<math::table::PRIME[458], real>(dimIndex, value, permuter);
    case 459: return math::radical_inverse_permuted<math::table::PRIME[459], real>(dimIndex, value, permuter);
    case 460: return math::radical_inverse_permuted<math::table::PRIME[460], real>(dimIndex, value, permuter);
    case 461: return math::radical_inverse_permuted<math::table::PRIME[461], real>(dimIndex, value, permuter);
    case 462: return math::radical_inverse_permuted<math::table::PRIME[462], real>(dimIndex, value, permuter);
    case 463: return math::radical_inverse_permuted<math::table::PRIME[463], real>(dimIndex, value, permuter);
    case 464: return math::radical_inverse_permuted<math::table::PRIME[464], real>(dimIndex, value, permuter);
    case 465: return math::radical_inverse_permuted<math::table::PRIME[465], real>(dimIndex, value, permuter);
    case 466: return math::radical_inverse_permuted<math::table::PRIME[466], real>(dimIndex, value, permuter);
    case 467: return math::radical_inverse_permuted<math::table::PRIME[467], real>(dimIndex, value, permuter);
    case 468: return math::radical_inverse_permuted<math::table::PRIME[468], real>(dimIndex, value, permuter);
    case 469: return math::radical_inverse_permuted<math::table::PRIME[469], real>(dimIndex, value, permuter);
    case 470: return math::radical_inverse_permuted<math::table::PRIME[470], real>(dimIndex, value, permuter);
    case 471: return math::radical_inverse_permuted<math::table::PRIME[471], real>(dimIndex, value, permuter);
    case 472: return math::radical_inverse_permuted<math::table::PRIME[472], real>(dimIndex, value, permuter);
    case 473: return math::radical_inverse_permuted<math::table::PRIME[473], real>(dimIndex, value, permuter);
    case 474: return math::radical_inverse_permuted<math::table::PRIME[474], real>(dimIndex, value, permuter);
    case 475: return math::radical_inverse_permuted<math::table::PRIME[475], real>(dimIndex, value, permuter);
    case 476: return math::radical_inverse_permuted<math::table::PRIME[476], real>(dimIndex, value, permuter);
    case 477: return math::radical_inverse_permuted<math::table::PRIME[477], real>(dimIndex, value, permuter);
    case 478: return math::radical_inverse_permuted<math::table::PRIME[478], real>(dimIndex, value, permuter);
    case 479: return math::radical_inverse_permuted<math::table::PRIME[479], real>(dimIndex, value, permuter);
    case 480: return math::radical_inverse_permuted<math::table::PRIME[480], real>(dimIndex, value, permuter);
    case 481: return math::radical_inverse_permuted<math::table::PRIME[481], real>(dimIndex, value, permuter);
    case 482: return math::radical_inverse_permuted<math::table::PRIME[482], real>(dimIndex, value, permuter);
    case 483: return math::radical_inverse_permuted<math::table::PRIME[483], real>(dimIndex, value, permuter);
    case 484: return math::radical_inverse_permuted<math::table::PRIME[484], real>(dimIndex, value, permuter);
    case 485: return math::radical_inverse_permuted<math::table::PRIME[485], real>(dimIndex, value, permuter);
    case 486: return math::radical_inverse_permuted<math::table::PRIME[486], real>(dimIndex, value, permuter);
    case 487: return math::radical_inverse_permuted<math::table::PRIME[487], real>(dimIndex, value, permuter);
    case 488: return math::radical_inverse_permuted<math::table::PRIME[488], real>(dimIndex, value, permuter);
    case 489: return math::radical_inverse_permuted<math::table::PRIME[489], real>(dimIndex, value, permuter);
    case 490: return math::radical_inverse_permuted<math::table::PRIME[490], real>(dimIndex, value, permuter);
    case 491: return math::radical_inverse_permuted<math::table::PRIME[491], real>(dimIndex, value, permuter);
    case 492: return math::radical_inverse_permuted<math::table::PRIME[492], real>(dimIndex, value, permuter);
    case 493: return math::radical_inverse_permuted<math::table::PRIME[493], real>(dimIndex, value, permuter);
    case 494: return math::radical_inverse_permuted<math::table::PRIME[494], real>(dimIndex, value, permuter);
    case 495: return math::radical_inverse_permuted<math::table::PRIME[495], real>(dimIndex, value, permuter);
    case 496: return math::radical_inverse_permuted<math::table::PRIME[496], real>(dimIndex, value, permuter);
    case 497: return math::radical_inverse_permuted<math::table::PRIME[497], real>(dimIndex, value, permuter);
    case 498: return math::radical_inverse_permuted<math::table::PRIME[498], real>(dimIndex, value, permuter);
    case 499: return math::radical_inverse_permuted<math::table::PRIME[499], real>(dimIndex, value, permuter);
    case 500: return math::radical_inverse_permuted<math::table::PRIME[500], real>(dimIndex, value, permuter);
    case 501: return math::radical_inverse_permuted<math::table::PRIME[501], real>(dimIndex, value, permuter);
    case 502: return math::radical_inverse_permuted<math::table::PRIME[502], real>(dimIndex, value, permuter);
    case 503: return math::radical_inverse_permuted<math::table::PRIME[503], real>(dimIndex, value, permuter);
    case 504: return math::radical_inverse_permuted<math::table::PRIME[504], real>(dimIndex, value, permuter);
    case 505: return math::radical_inverse_permuted<math::table::PRIME[505], real>(dimIndex, value, permuter);
    case 506: return math::radical_inverse_permuted<math::table::PRIME[506], real>(dimIndex, value, permuter);
    case 507: return math::radical_inverse_permuted<math::table::PRIME[507], real>(dimIndex, value, permuter);
    case 508: return math::radical_inverse_permuted<math::table::PRIME[508], real>(dimIndex, value, permuter);
    case 509: return math::radical_inverse_permuted<math::table::PRIME[509], real>(dimIndex, value, permuter);
    case 510: return math::radical_inverse_permuted<math::table::PRIME[510], real>(dimIndex, value, permuter);
    case 511: return math::radical_inverse_permuted<math::table::PRIME[511], real>(dimIndex, value, permuter);
    case 512: return math::radical_inverse_permuted<math::table::PRIME[512], real>(dimIndex, value, permuter);
    case 513: return math::radical_inverse_permuted<math::table::PRIME[513], real>(dimIndex, value, permuter);
    case 514: return math::radical_inverse_permuted<math::table::PRIME[514], real>(dimIndex, value, permuter);
    case 515: return math::radical_inverse_permuted<math::table::PRIME[515], real>(dimIndex, value, permuter);
    case 516: return math::radical_inverse_permuted<math::table::PRIME[516], real>(dimIndex, value, permuter);
    case 517: return math::radical_inverse_permuted<math::table::PRIME[517], real>(dimIndex, value, permuter);
    case 518: return math::radical_inverse_permuted<math::table::PRIME[518], real>(dimIndex, value, permuter);
    case 519: return math::radical_inverse_permuted<math::table::PRIME[519], real>(dimIndex, value, permuter);
    case 520: return math::radical_inverse_permuted<math::table::PRIME[520], real>(dimIndex, value, permuter);
    case 521: return math::radical_inverse_permuted<math::table::PRIME[521], real>(dimIndex, value, permuter);
    case 522: return math::radical_inverse_permuted<math::table::PRIME[522], real>(dimIndex, value, permuter);
    case 523: return math::radical_inverse_permuted<math::table::PRIME[523], real>(dimIndex, value, permuter);
    case 524: return math::radical_inverse_permuted<math::table::PRIME[524], real>(dimIndex, value, permuter);
    case 525: return math::radical_inverse_permuted<math::table::PRIME[525], real>(dimIndex, value, permuter);
    case 526: return math::radical_inverse_permuted<math::table::PRIME[526], real>(dimIndex, value, permuter);
    case 527: return math::radical_inverse_permuted<math::table::PRIME[527], real>(dimIndex, value, permuter);
    case 528: return math::radical_inverse_permuted<math::table::PRIME[528], real>(dimIndex, value, permuter);
    case 529: return math::radical_inverse_permuted<math::table::PRIME[529], real>(dimIndex, value, permuter);
    case 530: return math::radical_inverse_permuted<math::table::PRIME[530], real>(dimIndex, value, permuter);
    case 531: return math::radical_inverse_permuted<math::table::PRIME[531], real>(dimIndex, value, permuter);
    case 532: return math::radical_inverse_permuted<math::table::PRIME[532], real>(dimIndex, value, permuter);
    case 533: return math::radical_inverse_permuted<math::table::PRIME[533], real>(dimIndex, value, permuter);
    case 534: return math::radical_inverse_permuted<math::table::PRIME[534], real>(dimIndex, value, permuter);
    case 535: return math::radical_inverse_permuted<math::table::PRIME[535], real>(dimIndex, value, permuter);
    case 536: return math::radical_inverse_permuted<math::table::PRIME[536], real>(dimIndex, value, permuter);
    case 537: return math::radical_inverse_permuted<math::table::PRIME[537], real>(dimIndex, value, permuter);
    case 538: return math::radical_inverse_permuted<math::table::PRIME[538], real>(dimIndex, value, permuter);
    case 539: return math::radical_inverse_permuted<math::table::PRIME[539], real>(dimIndex, value, permuter);
    case 540: return math::radical_inverse_permuted<math::table::PRIME[540], real>(dimIndex, value, permuter);
    case 541: return math::radical_inverse_permuted<math::table::PRIME[541], real>(dimIndex, value, permuter);
    case 542: return math::radical_inverse_permuted<math::table::PRIME[542], real>(dimIndex, value, permuter);
    case 543: return math::radical_inverse_permuted<math::table::PRIME[543], real>(dimIndex, value, permuter);
    case 544: return math::radical_inverse_permuted<math::table::PRIME[544], real>(dimIndex, value, permuter);
    case 545: return math::radical_inverse_permuted<math::table::PRIME[545], real>(dimIndex, value, permuter);
    case 546: return math::radical_inverse_permuted<math::table::PRIME[546], real>(dimIndex, value, permuter);
    case 547: return math::radical_inverse_permuted<math::table::PRIME[547], real>(dimIndex, value, permuter);
    case 548: return math::radical_inverse_permuted<math::table::PRIME[548], real>(dimIndex, value, permuter);
    case 549: return math::radical_inverse_permuted<math::table::PRIME[549], real>(dimIndex, value, permuter);
    case 550: return math::radical_inverse_permuted<math::table::PRIME[550], real>(dimIndex, value, permuter);
    case 551: return math::radical_inverse_permuted<math::table::PRIME[551], real>(dimIndex, value, permuter);
    case 552: return math::radical_inverse_permuted<math::table::PRIME[552], real>(dimIndex, value, permuter);
    case 553: return math::radical_inverse_permuted<math::table::PRIME[553], real>(dimIndex, value, permuter);
    case 554: return math::radical_inverse_permuted<math::table::PRIME[554], real>(dimIndex, value, permuter);
    case 555: return math::radical_inverse_permuted<math::table::PRIME[555], real>(dimIndex, value, permuter);
    case 556: return math::radical_inverse_permuted<math::table::PRIME[556], real>(dimIndex, value, permuter);
    case 557: return math::radical_inverse_permuted<math::table::PRIME[557], real>(dimIndex, value, permuter);
    case 558: return math::radical_inverse_permuted<math::table::PRIME[558], real>(dimIndex, value, permuter);
    case 559: return math::radical_inverse_permuted<math::table::PRIME[559], real>(dimIndex, value, permuter);
    case 560: return math::radical_inverse_permuted<math::table::PRIME[560], real>(dimIndex, value, permuter);
    case 561: return math::radical_inverse_permuted<math::table::PRIME[561], real>(dimIndex, value, permuter);
    case 562: return math::radical_inverse_permuted<math::table::PRIME[562], real>(dimIndex, value, permuter);
    case 563: return math::radical_inverse_permuted<math::table::PRIME[563], real>(dimIndex, value, permuter);
    case 564: return math::radical_inverse_permuted<math::table::PRIME[564], real>(dimIndex, value, permuter);
    case 565: return math::radical_inverse_permuted<math::table::PRIME[565], real>(dimIndex, value, permuter);
    case 566: return math::radical_inverse_permuted<math::table::PRIME[566], real>(dimIndex, value, permuter);
    case 567: return math::radical_inverse_permuted<math::table::PRIME[567], real>(dimIndex, value, permuter);
    case 568: return math::radical_inverse_permuted<math::table::PRIME[568], real>(dimIndex, value, permuter);
    case 569: return math::radical_inverse_permuted<math::table::PRIME[569], real>(dimIndex, value, permuter);
    case 570: return math::radical_inverse_permuted<math::table::PRIME[570], real>(dimIndex, value, permuter);
    case 571: return math::radical_inverse_permuted<math::table::PRIME[571], real>(dimIndex, value, permuter);
    case 572: return math::radical_inverse_permuted<math::table::PRIME[572], real>(dimIndex, value, permuter);
    case 573: return math::radical_inverse_permuted<math::table::PRIME[573], real>(dimIndex, value, permuter);
    case 574: return math::radical_inverse_permuted<math::table::PRIME[574], real>(dimIndex, value, permuter);
    case 575: return math::radical_inverse_permuted<math::table::PRIME[575], real>(dimIndex, value, permuter);
    case 576: return math::radical_inverse_permuted<math::table::PRIME[576], real>(dimIndex, value, permuter);
    case 577: return math::radical_inverse_permuted<math::table::PRIME[577], real>(dimIndex, value, permuter);
    case 578: return math::radical_inverse_permuted<math::table::PRIME[578], real>(dimIndex, value, permuter);
    case 579: return math::radical_inverse_permuted<math::table::PRIME[579], real>(dimIndex, value, permuter);
    case 580: return math::radical_inverse_permuted<math::table::PRIME[580], real>(dimIndex, value, permuter);
    case 581: return math::radical_inverse_permuted<math::table::PRIME[581], real>(dimIndex, value, permuter);
    case 582: return math::radical_inverse_permuted<math::table::PRIME[582], real>(dimIndex, value, permuter);
    case 583: return math::radical_inverse_permuted<math::table::PRIME[583], real>(dimIndex, value, permuter);
    case 584: return math::radical_inverse_permuted<math::table::PRIME[584], real>(dimIndex, value, permuter);
    case 585: return math::radical_inverse_permuted<math::table::PRIME[585], real>(dimIndex, value, permuter);
    case 586: return math::radical_inverse_permuted<math::table::PRIME[586], real>(dimIndex, value, permuter);
    case 587: return math::radical_inverse_permuted<math::table::PRIME[587], real>(dimIndex, value, permuter);
    case 588: return math::radical_inverse_permuted<math::table::PRIME[588], real>(dimIndex, value, permuter);
    case 589: return math::radical_inverse_permuted<math::table::PRIME[589], real>(dimIndex, value, permuter);
    case 590: return math::radical_inverse_permuted<math::table::PRIME[590], real>(dimIndex, value, permuter);
    case 591: return math::radical_inverse_permuted<math::table::PRIME[591], real>(dimIndex, value, permuter);
    case 592: return math::radical_inverse_permuted<math::table::PRIME[592], real>(dimIndex, value, permuter);
    case 593: return math::radical_inverse_permuted<math::table::PRIME[593], real>(dimIndex, value, permuter);
    case 594: return math::radical_inverse_permuted<math::table::PRIME[594], real>(dimIndex, value, permuter);
    case 595: return math::radical_inverse_permuted<math::table::PRIME[595], real>(dimIndex, value, permuter);
    case 596: return math::radical_inverse_permuted<math::table::PRIME[596], real>(dimIndex, value, permuter);
    case 597: return math::radical_inverse_permuted<math::table::PRIME[597], real>(dimIndex, value, permuter);
    case 598: return math::radical_inverse_permuted<math::table::PRIME[598], real>(dimIndex, value, permuter);
    case 599: return math::radical_inverse_permuted<math::table::PRIME[599], real>(dimIndex, value, permuter);
    case 600: return math::radical_inverse_permuted<math::table::PRIME[600], real>(dimIndex, value, permuter);
    case 601: return math::radical_inverse_permuted<math::table::PRIME[601], real>(dimIndex, value, permuter);
    case 602: return math::radical_inverse_permuted<math::table::PRIME[602], real>(dimIndex, value, permuter);
    case 603: return math::radical_inverse_permuted<math::table::PRIME[603], real>(dimIndex, value, permuter);
    case 604: return math::radical_inverse_permuted<math::table::PRIME[604], real>(dimIndex, value, permuter);
    case 605: return math::radical_inverse_permuted<math::table::PRIME[605], real>(dimIndex, value, permuter);
    case 606: return math::radical_inverse_permuted<math::table::PRIME[606], real>(dimIndex, value, permuter);
    case 607: return math::radical_inverse_permuted<math::table::PRIME[607], real>(dimIndex, value, permuter);
    case 608: return math::radical_inverse_permuted<math::table::PRIME[608], real>(dimIndex, value, permuter);
    case 609: return math::radical_inverse_permuted<math::table::PRIME[609], real>(dimIndex, value, permuter);
    case 610: return math::radical_inverse_permuted<math::table::PRIME[610], real>(dimIndex, value, permuter);
    case 611: return math::radical_inverse_permuted<math::table::PRIME[611], real>(dimIndex, value, permuter);
    case 612: return math::radical_inverse_permuted<math::table::PRIME[612], real>(dimIndex, value, permuter);
    case 613: return math::radical_inverse_permuted<math::table::PRIME[613], real>(dimIndex, value, permuter);
    case 614: return math::radical_inverse_permuted<math::table::PRIME[614], real>(dimIndex, value, permuter);
    case 615: return math::radical_inverse_permuted<math::table::PRIME[615], real>(dimIndex, value, permuter);
    case 616: return math::radical_inverse_permuted<math::table::PRIME[616], real>(dimIndex, value, permuter);
    case 617: return math::radical_inverse_permuted<math::table::PRIME[617], real>(dimIndex, value, permuter);
    case 618: return math::radical_inverse_permuted<math::table::PRIME[618], real>(dimIndex, value, permuter);
    case 619: return math::radical_inverse_permuted<math::table::PRIME[619], real>(dimIndex, value, permuter);
    case 620: return math::radical_inverse_permuted<math::table::PRIME[620], real>(dimIndex, value, permuter);
    case 621: return math::radical_inverse_permuted<math::table::PRIME[621], real>(dimIndex, value, permuter);
    case 622: return math::radical_inverse_permuted<math::table::PRIME[622], real>(dimIndex, value, permuter);
    case 623: return math::radical_inverse_permuted<math::table::PRIME[623], real>(dimIndex, value, permuter);
    case 624: return math::radical_inverse_permuted<math::table::PRIME[624], real>(dimIndex, value, permuter);
    case 625: return math::radical_inverse_permuted<math::table::PRIME[625], real>(dimIndex, value, permuter);
    case 626: return math::radical_inverse_permuted<math::table::PRIME[626], real>(dimIndex, value, permuter);
    case 627: return math::radical_inverse_permuted<math::table::PRIME[627], real>(dimIndex, value, permuter);
    case 628: return math::radical_inverse_permuted<math::table::PRIME[628], real>(dimIndex, value, permuter);
    case 629: return math::radical_inverse_permuted<math::table::PRIME[629], real>(dimIndex, value, permuter);
    case 630: return math::radical_inverse_permuted<math::table::PRIME[630], real>(dimIndex, value, permuter);
    case 631: return math::radical_inverse_permuted<math::table::PRIME[631], real>(dimIndex, value, permuter);
    case 632: return math::radical_inverse_permuted<math::table::PRIME[632], real>(dimIndex, value, permuter);
    case 633: return math::radical_inverse_permuted<math::table::PRIME[633], real>(dimIndex, value, permuter);
    case 634: return math::radical_inverse_permuted<math::table::PRIME[634], real>(dimIndex, value, permuter);
    case 635: return math::radical_inverse_permuted<math::table::PRIME[635], real>(dimIndex, value, permuter);
    case 636: return math::radical_inverse_permuted<math::table::PRIME[636], real>(dimIndex, value, permuter);
    case 637: return math::radical_inverse_permuted<math::table::PRIME[637], real>(dimIndex, value, permuter);
    case 638: return math::radical_inverse_permuted<math::table::PRIME[638], real>(dimIndex, value, permuter);
    case 639: return math::radical_inverse_permuted<math::table::PRIME[639], real>(dimIndex, value, permuter);
    case 640: return math::radical_inverse_permuted<math::table::PRIME[640], real>(dimIndex, value, permuter);
    case 641: return math::radical_inverse_permuted<math::table::PRIME[641], real>(dimIndex, value, permuter);
    case 642: return math::radical_inverse_permuted<math::table::PRIME[642], real>(dimIndex, value, permuter);
    case 643: return math::radical_inverse_permuted<math::table::PRIME[643], real>(dimIndex, value, permuter);
    case 644: return math::radical_inverse_permuted<math::table::PRIME[644], real>(dimIndex, value, permuter);
    case 645: return math::radical_inverse_permuted<math::table::PRIME[645], real>(dimIndex, value, permuter);
    case 646: return math::radical_inverse_permuted<math::table::PRIME[646], real>(dimIndex, value, permuter);
    case 647: return math::radical_inverse_permuted<math::table::PRIME[647], real>(dimIndex, value, permuter);
    case 648: return math::radical_inverse_permuted<math::table::PRIME[648], real>(dimIndex, value, permuter);
    case 649: return math::radical_inverse_permuted<math::table::PRIME[649], real>(dimIndex, value, permuter);
    case 650: return math::radical_inverse_permuted<math::table::PRIME[650], real>(dimIndex, value, permuter);
    case 651: return math::radical_inverse_permuted<math::table::PRIME[651], real>(dimIndex, value, permuter);
    case 652: return math::radical_inverse_permuted<math::table::PRIME[652], real>(dimIndex, value, permuter);
    case 653: return math::radical_inverse_permuted<math::table::PRIME[653], real>(dimIndex, value, permuter);
    case 654: return math::radical_inverse_permuted<math::table::PRIME[654], real>(dimIndex, value, permuter);
    case 655: return math::radical_inverse_permuted<math::table::PRIME[655], real>(dimIndex, value, permuter);
    case 656: return math::radical_inverse_permuted<math::table::PRIME[656], real>(dimIndex, value, permuter);
    case 657: return math::radical_inverse_permuted<math::table::PRIME[657], real>(dimIndex, value, permuter);
    case 658: return math::radical_inverse_permuted<math::table::PRIME[658], real>(dimIndex, value, permuter);
    case 659: return math::radical_inverse_permuted<math::table::PRIME[659], real>(dimIndex, value, permuter);
    case 660: return math::radical_inverse_permuted<math::table::PRIME[660], real>(dimIndex, value, permuter);
    case 661: return math::radical_inverse_permuted<math::table::PRIME[661], real>(dimIndex, value, permuter);
    case 662: return math::radical_inverse_permuted<math::table::PRIME[662], real>(dimIndex, value, permuter);
    case 663: return math::radical_inverse_permuted<math::table::PRIME[663], real>(dimIndex, value, permuter);
    case 664: return math::radical_inverse_permuted<math::table::PRIME[664], real>(dimIndex, value, permuter);
    case 665: return math::radical_inverse_permuted<math::table::PRIME[665], real>(dimIndex, value, permuter);
    case 666: return math::radical_inverse_permuted<math::table::PRIME[666], real>(dimIndex, value, permuter);
    case 667: return math::radical_inverse_permuted<math::table::PRIME[667], real>(dimIndex, value, permuter);
    case 668: return math::radical_inverse_permuted<math::table::PRIME[668], real>(dimIndex, value, permuter);
    case 669: return math::radical_inverse_permuted<math::table::PRIME[669], real>(dimIndex, value, permuter);
    case 670: return math::radical_inverse_permuted<math::table::PRIME[670], real>(dimIndex, value, permuter);
    case 671: return math::radical_inverse_permuted<math::table::PRIME[671], real>(dimIndex, value, permuter);
    case 672: return math::radical_inverse_permuted<math::table::PRIME[672], real>(dimIndex, value, permuter);
    case 673: return math::radical_inverse_permuted<math::table::PRIME[673], real>(dimIndex, value, permuter);
    case 674: return math::radical_inverse_permuted<math::table::PRIME[674], real>(dimIndex, value, permuter);
    case 675: return math::radical_inverse_permuted<math::table::PRIME[675], real>(dimIndex, value, permuter);
    case 676: return math::radical_inverse_permuted<math::table::PRIME[676], real>(dimIndex, value, permuter);
    case 677: return math::radical_inverse_permuted<math::table::PRIME[677], real>(dimIndex, value, permuter);
    case 678: return math::radical_inverse_permuted<math::table::PRIME[678], real>(dimIndex, value, permuter);
    case 679: return math::radical_inverse_permuted<math::table::PRIME[679], real>(dimIndex, value, permuter);
    case 680: return math::radical_inverse_permuted<math::table::PRIME[680], real>(dimIndex, value, permuter);
    case 681: return math::radical_inverse_permuted<math::table::PRIME[681], real>(dimIndex, value, permuter);
    case 682: return math::radical_inverse_permuted<math::table::PRIME[682], real>(dimIndex, value, permuter);
    case 683: return math::radical_inverse_permuted<math::table::PRIME[683], real>(dimIndex, value, permuter);
    case 684: return math::radical_inverse_permuted<math::table::PRIME[684], real>(dimIndex, value, permuter);
    case 685: return math::radical_inverse_permuted<math::table::PRIME[685], real>(dimIndex, value, permuter);
    case 686: return math::radical_inverse_permuted<math::table::PRIME[686], real>(dimIndex, value, permuter);
    case 687: return math::radical_inverse_permuted<math::table::PRIME[687], real>(dimIndex, value, permuter);
    case 688: return math::radical_inverse_permuted<math::table::PRIME[688], real>(dimIndex, value, permuter);
    case 689: return math::radical_inverse_permuted<math::table::PRIME[689], real>(dimIndex, value, permuter);
    case 690: return math::radical_inverse_permuted<math::table::PRIME[690], real>(dimIndex, value, permuter);
    case 691: return math::radical_inverse_permuted<math::table::PRIME[691], real>(dimIndex, value, permuter);
    case 692: return math::radical_inverse_permuted<math::table::PRIME[692], real>(dimIndex, value, permuter);
    case 693: return math::radical_inverse_permuted<math::table::PRIME[693], real>(dimIndex, value, permuter);
    case 694: return math::radical_inverse_permuted<math::table::PRIME[694], real>(dimIndex, value, permuter);
    case 695: return math::radical_inverse_permuted<math::table::PRIME[695], real>(dimIndex, value, permuter);
    case 696: return math::radical_inverse_permuted<math::table::PRIME[696], real>(dimIndex, value, permuter);
    case 697: return math::radical_inverse_permuted<math::table::PRIME[697], real>(dimIndex, value, permuter);
    case 698: return math::radical_inverse_permuted<math::table::PRIME[698], real>(dimIndex, value, permuter);
    case 699: return math::radical_inverse_permuted<math::table::PRIME[699], real>(dimIndex, value, permuter);
    case 700: return math::radical_inverse_permuted<math::table::PRIME[700], real>(dimIndex, value, permuter);
    case 701: return math::radical_inverse_permuted<math::table::PRIME[701], real>(dimIndex, value, permuter);
    case 702: return math::radical_inverse_permuted<math::table::PRIME[702], real>(dimIndex, value, permuter);
    case 703: return math::radical_inverse_permuted<math::table::PRIME[703], real>(dimIndex, value, permuter);
    case 704: return math::radical_inverse_permuted<math::table::PRIME[704], real>(dimIndex, value, permuter);
    case 705: return math::radical_inverse_permuted<math::table::PRIME[705], real>(dimIndex, value, permuter);
    case 706: return math::radical_inverse_permuted<math::table::PRIME[706], real>(dimIndex, value, permuter);
    case 707: return math::radical_inverse_permuted<math::table::PRIME[707], real>(dimIndex, value, permuter);
    case 708: return math::radical_inverse_permuted<math::table::PRIME[708], real>(dimIndex, value, permuter);
    case 709: return math::radical_inverse_permuted<math::table::PRIME[709], real>(dimIndex, value, permuter);
    case 710: return math::radical_inverse_permuted<math::table::PRIME[710], real>(dimIndex, value, permuter);
    case 711: return math::radical_inverse_permuted<math::table::PRIME[711], real>(dimIndex, value, permuter);
    case 712: return math::radical_inverse_permuted<math::table::PRIME[712], real>(dimIndex, value, permuter);
    case 713: return math::radical_inverse_permuted<math::table::PRIME[713], real>(dimIndex, value, permuter);
    case 714: return math::radical_inverse_permuted<math::table::PRIME[714], real>(dimIndex, value, permuter);
    case 715: return math::radical_inverse_permuted<math::table::PRIME[715], real>(dimIndex, value, permuter);
    case 716: return math::radical_inverse_permuted<math::table::PRIME[716], real>(dimIndex, value, permuter);
    case 717: return math::radical_inverse_permuted<math::table::PRIME[717], real>(dimIndex, value, permuter);
    case 718: return math::radical_inverse_permuted<math::table::PRIME[718], real>(dimIndex, value, permuter);
    case 719: return math::radical_inverse_permuted<math::table::PRIME[719], real>(dimIndex, value, permuter);
    case 720: return math::radical_inverse_permuted<math::table::PRIME[720], real>(dimIndex, value, permuter);
    case 721: return math::radical_inverse_permuted<math::table::PRIME[721], real>(dimIndex, value, permuter);
    case 722: return math::radical_inverse_permuted<math::table::PRIME[722], real>(dimIndex, value, permuter);
    case 723: return math::radical_inverse_permuted<math::table::PRIME[723], real>(dimIndex, value, permuter);
    case 724: return math::radical_inverse_permuted<math::table::PRIME[724], real>(dimIndex, value, permuter);
    case 725: return math::radical_inverse_permuted<math::table::PRIME[725], real>(dimIndex, value, permuter);
    case 726: return math::radical_inverse_permuted<math::table::PRIME[726], real>(dimIndex, value, permuter);
    case 727: return math::radical_inverse_permuted<math::table::PRIME[727], real>(dimIndex, value, permuter);
    case 728: return math::radical_inverse_permuted<math::table::PRIME[728], real>(dimIndex, value, permuter);
    case 729: return math::radical_inverse_permuted<math::table::PRIME[729], real>(dimIndex, value, permuter);
    case 730: return math::radical_inverse_permuted<math::table::PRIME[730], real>(dimIndex, value, permuter);
    case 731: return math::radical_inverse_permuted<math::table::PRIME[731], real>(dimIndex, value, permuter);
    case 732: return math::radical_inverse_permuted<math::table::PRIME[732], real>(dimIndex, value, permuter);
    case 733: return math::radical_inverse_permuted<math::table::PRIME[733], real>(dimIndex, value, permuter);
    case 734: return math::radical_inverse_permuted<math::table::PRIME[734], real>(dimIndex, value, permuter);
    case 735: return math::radical_inverse_permuted<math::table::PRIME[735], real>(dimIndex, value, permuter);
    case 736: return math::radical_inverse_permuted<math::table::PRIME[736], real>(dimIndex, value, permuter);
    case 737: return math::radical_inverse_permuted<math::table::PRIME[737], real>(dimIndex, value, permuter);
    case 738: return math::radical_inverse_permuted<math::table::PRIME[738], real>(dimIndex, value, permuter);
    case 739: return math::radical_inverse_permuted<math::table::PRIME[739], real>(dimIndex, value, permuter);
    case 740: return math::radical_inverse_permuted<math::table::PRIME[740], real>(dimIndex, value, permuter);
    case 741: return math::radical_inverse_permuted<math::table::PRIME[741], real>(dimIndex, value, permuter);
    case 742: return math::radical_inverse_permuted<math::table::PRIME[742], real>(dimIndex, value, permuter);
    case 743: return math::radical_inverse_permuted<math::table::PRIME[743], real>(dimIndex, value, permuter);
    case 744: return math::radical_inverse_permuted<math::table::PRIME[744], real>(dimIndex, value, permuter);
    case 745: return math::radical_inverse_permuted<math::table::PRIME[745], real>(dimIndex, value, permuter);
    case 746: return math::radical_inverse_permuted<math::table::PRIME[746], real>(dimIndex, value, permuter);
    case 747: return math::radical_inverse_permuted<math::table::PRIME[747], real>(dimIndex, value, permuter);
    case 748: return math::radical_inverse_permuted<math::table::PRIME[748], real>(dimIndex, value, permuter);
    case 749: return math::radical_inverse_permuted<math::table::PRIME[749], real>(dimIndex, value, permuter);
    case 750: return math::radical_inverse_permuted<math::table::PRIME[750], real>(dimIndex, value, permuter);
    case 751: return math::radical_inverse_permuted<math::table::PRIME[751], real>(dimIndex, value, permuter);
    case 752: return math::radical_inverse_permuted<math::table::PRIME[752], real>(dimIndex, value, permuter);
    case 753: return math::radical_inverse_permuted<math::table::PRIME[753], real>(dimIndex, value, permuter);
    case 754: return math::radical_inverse_permuted<math::table::PRIME[754], real>(dimIndex, value, permuter);
    case 755: return math::radical_inverse_permuted<math::table::PRIME[755], real>(dimIndex, value, permuter);
    case 756: return math::radical_inverse_permuted<math::table::PRIME[756], real>(dimIndex, value, permuter);
    case 757: return math::radical_inverse_permuted<math::table::PRIME[757], real>(dimIndex, value, permuter);
    case 758: return math::radical_inverse_permuted<math::table::PRIME[758], real>(dimIndex, value, permuter);
    case 759: return math::radical_inverse_permuted<math::table::PRIME[759], real>(dimIndex, value, permuter);
    case 760: return math::radical_inverse_permuted<math::table::PRIME[760], real>(dimIndex, value, permuter);
    case 761: return math::radical_inverse_permuted<math::table::PRIME[761], real>(dimIndex, value, permuter);
    case 762: return math::radical_inverse_permuted<math::table::PRIME[762], real>(dimIndex, value, permuter);
    case 763: return math::radical_inverse_permuted<math::table::PRIME[763], real>(dimIndex, value, permuter);
    case 764: return math::radical_inverse_permuted<math::table::PRIME[764], real>(dimIndex, value, permuter);
    case 765: return math::radical_inverse_permuted<math::table::PRIME[765], real>(dimIndex, value, permuter);
    case 766: return math::radical_inverse_permuted<math::table::PRIME[766], real>(dimIndex, value, permuter);
    case 767: return math::radical_inverse_permuted<math::table::PRIME[767], real>(dimIndex, value, permuter);
    case 768: return math::radical_inverse_permuted<math::table::PRIME[768], real>(dimIndex, value, permuter);
    case 769: return math::radical_inverse_permuted<math::table::PRIME[769], real>(dimIndex, value, permuter);
    case 770: return math::radical_inverse_permuted<math::table::PRIME[770], real>(dimIndex, value, permuter);
    case 771: return math::radical_inverse_permuted<math::table::PRIME[771], real>(dimIndex, value, permuter);
    case 772: return math::radical_inverse_permuted<math::table::PRIME[772], real>(dimIndex, value, permuter);
    case 773: return math::radical_inverse_permuted<math::table::PRIME[773], real>(dimIndex, value, permuter);
    case 774: return math::radical_inverse_permuted<math::table::PRIME[774], real>(dimIndex, value, permuter);
    case 775: return math::radical_inverse_permuted<math::table::PRIME[775], real>(dimIndex, value, permuter);
    case 776: return math::radical_inverse_permuted<math::table::PRIME[776], real>(dimIndex, value, permuter);
    case 777: return math::radical_inverse_permuted<math::table::PRIME[777], real>(dimIndex, value, permuter);
    case 778: return math::radical_inverse_permuted<math::table::PRIME[778], real>(dimIndex, value, permuter);
    case 779: return math::radical_inverse_permuted<math::table::PRIME[779], real>(dimIndex, value, permuter);
    case 780: return math::radical_inverse_permuted<math::table::PRIME[780], real>(dimIndex, value, permuter);
    case 781: return math::radical_inverse_permuted<math::table::PRIME[781], real>(dimIndex, value, permuter);
    case 782: return math::radical_inverse_permuted<math::table::PRIME[782], real>(dimIndex, value, permuter);
    case 783: return math::radical_inverse_permuted<math::table::PRIME[783], real>(dimIndex, value, permuter);
    case 784: return math::radical_inverse_permuted<math::table::PRIME[784], real>(dimIndex, value, permuter);
    case 785: return math::radical_inverse_permuted<math::table::PRIME[785], real>(dimIndex, value, permuter);
    case 786: return math::radical_inverse_permuted<math::table::PRIME[786], real>(dimIndex, value, permuter);
    case 787: return math::radical_inverse_permuted<math::table::PRIME[787], real>(dimIndex, value, permuter);
    case 788: return math::radical_inverse_permuted<math::table::PRIME[788], real>(dimIndex, value, permuter);
    case 789: return math::radical_inverse_permuted<math::table::PRIME[789], real>(dimIndex, value, permuter);
    case 790: return math::radical_inverse_permuted<math::table::PRIME[790], real>(dimIndex, value, permuter);
    case 791: return math::radical_inverse_permuted<math::table::PRIME[791], real>(dimIndex, value, permuter);
    case 792: return math::radical_inverse_permuted<math::table::PRIME[792], real>(dimIndex, value, permuter);
    case 793: return math::radical_inverse_permuted<math::table::PRIME[793], real>(dimIndex, value, permuter);
    case 794: return math::radical_inverse_permuted<math::table::PRIME[794], real>(dimIndex, value, permuter);
    case 795: return math::radical_inverse_permuted<math::table::PRIME[795], real>(dimIndex, value, permuter);
    case 796: return math::radical_inverse_permuted<math::table::PRIME[796], real>(dimIndex, value, permuter);
    case 797: return math::radical_inverse_permuted<math::table::PRIME[797], real>(dimIndex, value, permuter);
    case 798: return math::radical_inverse_permuted<math::table::PRIME[798], real>(dimIndex, value, permuter);
    case 799: return math::radical_inverse_permuted<math::table::PRIME[799], real>(dimIndex, value, permuter);
    case 800: return math::radical_inverse_permuted<math::table::PRIME[800], real>(dimIndex, value, permuter);
    case 801: return math::radical_inverse_permuted<math::table::PRIME[801], real>(dimIndex, value, permuter);
    case 802: return math::radical_inverse_permuted<math::table::PRIME[802], real>(dimIndex, value, permuter);
    case 803: return math::radical_inverse_permuted<math::table::PRIME[803], real>(dimIndex, value, permuter);
    case 804: return math::radical_inverse_permuted<math::table::PRIME[804], real>(dimIndex, value, permuter);
    case 805: return math::radical_inverse_permuted<math::table::PRIME[805], real>(dimIndex, value, permuter);
    case 806: return math::radical_inverse_permuted<math::table::PRIME[806], real>(dimIndex, value, permuter);
    case 807: return math::radical_inverse_permuted<math::table::PRIME[807], real>(dimIndex, value, permuter);
    case 808: return math::radical_inverse_permuted<math::table::PRIME[808], real>(dimIndex, value, permuter);
    case 809: return math::radical_inverse_permuted<math::table::PRIME[809], real>(dimIndex, value, permuter);
    case 810: return math::radical_inverse_permuted<math::table::PRIME[810], real>(dimIndex, value, permuter);
    case 811: return math::radical_inverse_permuted<math::table::PRIME[811], real>(dimIndex, value, permuter);
    case 812: return math::radical_inverse_permuted<math::table::PRIME[812], real>(dimIndex, value, permuter);
    case 813: return math::radical_inverse_permuted<math::table::PRIME[813], real>(dimIndex, value, permuter);
    case 814: return math::radical_inverse_permuted<math::table::PRIME[814], real>(dimIndex, value, permuter);
    case 815: return math::radical_inverse_permuted<math::table::PRIME[815], real>(dimIndex, value, permuter);
    case 816: return math::radical_inverse_permuted<math::table::PRIME[816], real>(dimIndex, value, permuter);
    case 817: return math::radical_inverse_permuted<math::table::PRIME[817], real>(dimIndex, value, permuter);
    case 818: return math::radical_inverse_permuted<math::table::PRIME[818], real>(dimIndex, value, permuter);
    case 819: return math::radical_inverse_permuted<math::table::PRIME[819], real>(dimIndex, value, permuter);
    case 820: return math::radical_inverse_permuted<math::table::PRIME[820], real>(dimIndex, value, permuter);
    case 821: return math::radical_inverse_permuted<math::table::PRIME[821], real>(dimIndex, value, permuter);
    case 822: return math::radical_inverse_permuted<math::table::PRIME[822], real>(dimIndex, value, permuter);
    case 823: return math::radical_inverse_permuted<math::table::PRIME[823], real>(dimIndex, value, permuter);
    case 824: return math::radical_inverse_permuted<math::table::PRIME[824], real>(dimIndex, value, permuter);
    case 825: return math::radical_inverse_permuted<math::table::PRIME[825], real>(dimIndex, value, permuter);
    case 826: return math::radical_inverse_permuted<math::table::PRIME[826], real>(dimIndex, value, permuter);
    case 827: return math::radical_inverse_permuted<math::table::PRIME[827], real>(dimIndex, value, permuter);
    case 828: return math::radical_inverse_permuted<math::table::PRIME[828], real>(dimIndex, value, permuter);
    case 829: return math::radical_inverse_permuted<math::table::PRIME[829], real>(dimIndex, value, permuter);
    case 830: return math::radical_inverse_permuted<math::table::PRIME[830], real>(dimIndex, value, permuter);
    case 831: return math::radical_inverse_permuted<math::table::PRIME[831], real>(dimIndex, value, permuter);
    case 832: return math::radical_inverse_permuted<math::table::PRIME[832], real>(dimIndex, value, permuter);
    case 833: return math::radical_inverse_permuted<math::table::PRIME[833], real>(dimIndex, value, permuter);
    case 834: return math::radical_inverse_permuted<math::table::PRIME[834], real>(dimIndex, value, permuter);
    case 835: return math::radical_inverse_permuted<math::table::PRIME[835], real>(dimIndex, value, permuter);
    case 836: return math::radical_inverse_permuted<math::table::PRIME[836], real>(dimIndex, value, permuter);
    case 837: return math::radical_inverse_permuted<math::table::PRIME[837], real>(dimIndex, value, permuter);
    case 838: return math::radical_inverse_permuted<math::table::PRIME[838], real>(dimIndex, value, permuter);
    case 839: return math::radical_inverse_permuted<math::table::PRIME[839], real>(dimIndex, value, permuter);
    case 840: return math::radical_inverse_permuted<math::table::PRIME[840], real>(dimIndex, value, permuter);
    case 841: return math::radical_inverse_permuted<math::table::PRIME[841], real>(dimIndex, value, permuter);
    case 842: return math::radical_inverse_permuted<math::table::PRIME[842], real>(dimIndex, value, permuter);
    case 843: return math::radical_inverse_permuted<math::table::PRIME[843], real>(dimIndex, value, permuter);
    case 844: return math::radical_inverse_permuted<math::table::PRIME[844], real>(dimIndex, value, permuter);
    case 845: return math::radical_inverse_permuted<math::table::PRIME[845], real>(dimIndex, value, permuter);
    case 846: return math::radical_inverse_permuted<math::table::PRIME[846], real>(dimIndex, value, permuter);
    case 847: return math::radical_inverse_permuted<math::table::PRIME[847], real>(dimIndex, value, permuter);
    case 848: return math::radical_inverse_permuted<math::table::PRIME[848], real>(dimIndex, value, permuter);
    case 849: return math::radical_inverse_permuted<math::table::PRIME[849], real>(dimIndex, value, permuter);
    case 850: return math::radical_inverse_permuted<math::table::PRIME[850], real>(dimIndex, value, permuter);
    case 851: return math::radical_inverse_permuted<math::table::PRIME[851], real>(dimIndex, value, permuter);
    case 852: return math::radical_inverse_permuted<math::table::PRIME[852], real>(dimIndex, value, permuter);
    case 853: return math::radical_inverse_permuted<math::table::PRIME[853], real>(dimIndex, value, permuter);
    case 854: return math::radical_inverse_permuted<math::table::PRIME[854], real>(dimIndex, value, permuter);
    case 855: return math::radical_inverse_permuted<math::table::PRIME[855], real>(dimIndex, value, permuter);
    case 856: return math::radical_inverse_permuted<math::table::PRIME[856], real>(dimIndex, value, permuter);
    case 857: return math::radical_inverse_permuted<math::table::PRIME[857], real>(dimIndex, value, permuter);
    case 858: return math::radical_inverse_permuted<math::table::PRIME[858], real>(dimIndex, value, permuter);
    case 859: return math::radical_inverse_permuted<math::table::PRIME[859], real>(dimIndex, value, permuter);
    case 860: return math::radical_inverse_permuted<math::table::PRIME[860], real>(dimIndex, value, permuter);
    case 861: return math::radical_inverse_permuted<math::table::PRIME[861], real>(dimIndex, value, permuter);
    case 862: return math::radical_inverse_permuted<math::table::PRIME[862], real>(dimIndex, value, permuter);
    case 863: return math::radical_inverse_permuted<math::table::PRIME[863], real>(dimIndex, value, permuter);
    case 864: return math::radical_inverse_permuted<math::table::PRIME[864], real>(dimIndex, value, permuter);
    case 865: return math::radical_inverse_permuted<math::table::PRIME[865], real>(dimIndex, value, permuter);
    case 866: return math::radical_inverse_permuted<math::table::PRIME[866], real>(dimIndex, value, permuter);
    case 867: return math::radical_inverse_permuted<math::table::PRIME[867], real>(dimIndex, value, permuter);
    case 868: return math::radical_inverse_permuted<math::table::PRIME[868], real>(dimIndex, value, permuter);
    case 869: return math::radical_inverse_permuted<math::table::PRIME[869], real>(dimIndex, value, permuter);
    case 870: return math::radical_inverse_permuted<math::table::PRIME[870], real>(dimIndex, value, permuter);
    case 871: return math::radical_inverse_permuted<math::table::PRIME[871], real>(dimIndex, value, permuter);
    case 872: return math::radical_inverse_permuted<math::table::PRIME[872], real>(dimIndex, value, permuter);
    case 873: return math::radical_inverse_permuted<math::table::PRIME[873], real>(dimIndex, value, permuter);
    case 874: return math::radical_inverse_permuted<math::table::PRIME[874], real>(dimIndex, value, permuter);
    case 875: return math::radical_inverse_permuted<math::table::PRIME[875], real>(dimIndex, value, permuter);
    case 876: return math::radical_inverse_permuted<math::table::PRIME[876], real>(dimIndex, value, permuter);
    case 877: return math::radical_inverse_permuted<math::table::PRIME[877], real>(dimIndex, value, permuter);
    case 878: return math::radical_inverse_permuted<math::table::PRIME[878], real>(dimIndex, value, permuter);
    case 879: return math::radical_inverse_permuted<math::table::PRIME[879], real>(dimIndex, value, permuter);
    case 880: return math::radical_inverse_permuted<math::table::PRIME[880], real>(dimIndex, value, permuter);
    case 881: return math::radical_inverse_permuted<math::table::PRIME[881], real>(dimIndex, value, permuter);
    case 882: return math::radical_inverse_permuted<math::table::PRIME[882], real>(dimIndex, value, permuter);
    case 883: return math::radical_inverse_permuted<math::table::PRIME[883], real>(dimIndex, value, permuter);
    case 884: return math::radical_inverse_permuted<math::table::PRIME[884], real>(dimIndex, value, permuter);
    case 885: return math::radical_inverse_permuted<math::table::PRIME[885], real>(dimIndex, value, permuter);
    case 886: return math::radical_inverse_permuted<math::table::PRIME[886], real>(dimIndex, value, permuter);
    case 887: return math::radical_inverse_permuted<math::table::PRIME[887], real>(dimIndex, value, permuter);
    case 888: return math::radical_inverse_permuted<math::table::PRIME[888], real>(dimIndex, value, permuter);
    case 889: return math::radical_inverse_permuted<math::table::PRIME[889], real>(dimIndex, value, permuter);
    case 890: return math::radical_inverse_permuted<math::table::PRIME[890], real>(dimIndex, value, permuter);
    case 891: return math::radical_inverse_permuted<math::table::PRIME[891], real>(dimIndex, value, permuter);
    case 892: return math::radical_inverse_permuted<math::table::PRIME[892], real>(dimIndex, value, permuter);
    case 893: return math::radical_inverse_permuted<math::table::PRIME[893], real>(dimIndex, value, permuter);
    case 894: return math::radical_inverse_permuted<math::table::PRIME[894], real>(dimIndex, value, permuter);
    case 895: return math::radical_inverse_permuted<math::table::PRIME[895], real>(dimIndex, value, permuter);
    case 896: return math::radical_inverse_permuted<math::table::PRIME[896], real>(dimIndex, value, permuter);
    case 897: return math::radical_inverse_permuted<math::table::PRIME[897], real>(dimIndex, value, permuter);
    case 898: return math::radical_inverse_permuted<math::table::PRIME[898], real>(dimIndex, value, permuter);
    case 899: return math::radical_inverse_permuted<math::table::PRIME[899], real>(dimIndex, value, permuter);
    case 900: return math::radical_inverse_permuted<math::table::PRIME[900], real>(dimIndex, value, permuter);
    case 901: return math::radical_inverse_permuted<math::table::PRIME[901], real>(dimIndex, value, permuter);
    case 902: return math::radical_inverse_permuted<math::table::PRIME[902], real>(dimIndex, value, permuter);
    case 903: return math::radical_inverse_permuted<math::table::PRIME[903], real>(dimIndex, value, permuter);
    case 904: return math::radical_inverse_permuted<math::table::PRIME[904], real>(dimIndex, value, permuter);
    case 905: return math::radical_inverse_permuted<math::table::PRIME[905], real>(dimIndex, value, permuter);
    case 906: return math::radical_inverse_permuted<math::table::PRIME[906], real>(dimIndex, value, permuter);
    case 907: return math::radical_inverse_permuted<math::table::PRIME[907], real>(dimIndex, value, permuter);
    case 908: return math::radical_inverse_permuted<math::table::PRIME[908], real>(dimIndex, value, permuter);
    case 909: return math::radical_inverse_permuted<math::table::PRIME[909], real>(dimIndex, value, permuter);
    case 910: return math::radical_inverse_permuted<math::table::PRIME[910], real>(dimIndex, value, permuter);
    case 911: return math::radical_inverse_permuted<math::table::PRIME[911], real>(dimIndex, value, permuter);
    case 912: return math::radical_inverse_permuted<math::table::PRIME[912], real>(dimIndex, value, permuter);
    case 913: return math::radical_inverse_permuted<math::table::PRIME[913], real>(dimIndex, value, permuter);
    case 914: return math::radical_inverse_permuted<math::table::PRIME[914], real>(dimIndex, value, permuter);
    case 915: return math::radical_inverse_permuted<math::table::PRIME[915], real>(dimIndex, value, permuter);
    case 916: return math::radical_inverse_permuted<math::table::PRIME[916], real>(dimIndex, value, permuter);
    case 917: return math::radical_inverse_permuted<math::table::PRIME[917], real>(dimIndex, value, permuter);
    case 918: return math::radical_inverse_permuted<math::table::PRIME[918], real>(dimIndex, value, permuter);
    case 919: return math::radical_inverse_permuted<math::table::PRIME[919], real>(dimIndex, value, permuter);
    case 920: return math::radical_inverse_permuted<math::table::PRIME[920], real>(dimIndex, value, permuter);
    case 921: return math::radical_inverse_permuted<math::table::PRIME[921], real>(dimIndex, value, permuter);
    case 922: return math::radical_inverse_permuted<math::table::PRIME[922], real>(dimIndex, value, permuter);
    case 923: return math::radical_inverse_permuted<math::table::PRIME[923], real>(dimIndex, value, permuter);
    case 924: return math::radical_inverse_permuted<math::table::PRIME[924], real>(dimIndex, value, permuter);
    case 925: return math::radical_inverse_permuted<math::table::PRIME[925], real>(dimIndex, value, permuter);
    case 926: return math::radical_inverse_permuted<math::table::PRIME[926], real>(dimIndex, value, permuter);
    case 927: return math::radical_inverse_permuted<math::table::PRIME[927], real>(dimIndex, value, permuter);
    case 928: return math::radical_inverse_permuted<math::table::PRIME[928], real>(dimIndex, value, permuter);
    case 929: return math::radical_inverse_permuted<math::table::PRIME[929], real>(dimIndex, value, permuter);
    case 930: return math::radical_inverse_permuted<math::table::PRIME[930], real>(dimIndex, value, permuter);
    case 931: return math::radical_inverse_permuted<math::table::PRIME[931], real>(dimIndex, value, permuter);
    case 932: return math::radical_inverse_permuted<math::table::PRIME[932], real>(dimIndex, value, permuter);
    case 933: return math::radical_inverse_permuted<math::table::PRIME[933], real>(dimIndex, value, permuter);
    case 934: return math::radical_inverse_permuted<math::table::PRIME[934], real>(dimIndex, value, permuter);
    case 935: return math::radical_inverse_permuted<math::table::PRIME[935], real>(dimIndex, value, permuter);
    case 936: return math::radical_inverse_permuted<math::table::PRIME[936], real>(dimIndex, value, permuter);
    case 937: return math::radical_inverse_permuted<math::table::PRIME[937], real>(dimIndex, value, permuter);
    case 938: return math::radical_inverse_permuted<math::table::PRIME[938], real>(dimIndex, value, permuter);
    case 939: return math::radical_inverse_permuted<math::table::PRIME[939], real>(dimIndex, value, permuter);
    case 940: return math::radical_inverse_permuted<math::table::PRIME[940], real>(dimIndex, value, permuter);
    case 941: return math::radical_inverse_permuted<math::table::PRIME[941], real>(dimIndex, value, permuter);
    case 942: return math::radical_inverse_permuted<math::table::PRIME[942], real>(dimIndex, value, permuter);
    case 943: return math::radical_inverse_permuted<math::table::PRIME[943], real>(dimIndex, value, permuter);
    case 944: return math::radical_inverse_permuted<math::table::PRIME[944], real>(dimIndex, value, permuter);
    case 945: return math::radical_inverse_permuted<math::table::PRIME[945], real>(dimIndex, value, permuter);
    case 946: return math::radical_inverse_permuted<math::table::PRIME[946], real>(dimIndex, value, permuter);
    case 947: return math::radical_inverse_permuted<math::table::PRIME[947], real>(dimIndex, value, permuter);
    case 948: return math::radical_inverse_permuted<math::table::PRIME[948], real>(dimIndex, value, permuter);
    case 949: return math::radical_inverse_permuted<math::table::PRIME[949], real>(dimIndex, value, permuter);
    case 950: return math::radical_inverse_permuted<math::table::PRIME[950], real>(dimIndex, value, permuter);
    case 951: return math::radical_inverse_permuted<math::table::PRIME[951], real>(dimIndex, value, permuter);
    case 952: return math::radical_inverse_permuted<math::table::PRIME[952], real>(dimIndex, value, permuter);
    case 953: return math::radical_inverse_permuted<math::table::PRIME[953], real>(dimIndex, value, permuter);
    case 954: return math::radical_inverse_permuted<math::table::PRIME[954], real>(dimIndex, value, permuter);
    case 955: return math::radical_inverse_permuted<math::table::PRIME[955], real>(dimIndex, value, permuter);
    case 956: return math::radical_inverse_permuted<math::table::PRIME[956], real>(dimIndex, value, permuter);
    case 957: return math::radical_inverse_permuted<math::table::PRIME[957], real>(dimIndex, value, permuter);
    case 958: return math::radical_inverse_permuted<math::table::PRIME[958], real>(dimIndex, value, permuter);
    case 959: return math::radical_inverse_permuted<math::table::PRIME[959], real>(dimIndex, value, permuter);
    case 960: return math::radical_inverse_permuted<math::table::PRIME[960], real>(dimIndex, value, permuter);
    case 961: return math::radical_inverse_permuted<math::table::PRIME[961], real>(dimIndex, value, permuter);
    case 962: return math::radical_inverse_permuted<math::table::PRIME[962], real>(dimIndex, value, permuter);
    case 963: return math::radical_inverse_permuted<math::table::PRIME[963], real>(dimIndex, value, permuter);
    case 964: return math::radical_inverse_permuted<math::table::PRIME[964], real>(dimIndex, value, permuter);
    case 965: return math::radical_inverse_permuted<math::table::PRIME[965], real>(dimIndex, value, permuter);
    case 966: return math::radical_inverse_permuted<math::table::PRIME[966], real>(dimIndex, value, permuter);
    case 967: return math::radical_inverse_permuted<math::table::PRIME[967], real>(dimIndex, value, permuter);
    case 968: return math::radical_inverse_permuted<math::table::PRIME[968], real>(dimIndex, value, permuter);
    case 969: return math::radical_inverse_permuted<math::table::PRIME[969], real>(dimIndex, value, permuter);
    case 970: return math::radical_inverse_permuted<math::table::PRIME[970], real>(dimIndex, value, permuter);
    case 971: return math::radical_inverse_permuted<math::table::PRIME[971], real>(dimIndex, value, permuter);
    case 972: return math::radical_inverse_permuted<math::table::PRIME[972], real>(dimIndex, value, permuter);
    case 973: return math::radical_inverse_permuted<math::table::PRIME[973], real>(dimIndex, value, permuter);
    case 974: return math::radical_inverse_permuted<math::table::PRIME[974], real>(dimIndex, value, permuter);
    case 975: return math::radical_inverse_permuted<math::table::PRIME[975], real>(dimIndex, value, permuter);
    case 976: return math::radical_inverse_permuted<math::table::PRIME[976], real>(dimIndex, value, permuter);
    case 977: return math::radical_inverse_permuted<math::table::PRIME[977], real>(dimIndex, value, permuter);
    case 978: return math::radical_inverse_permuted<math::table::PRIME[978], real>(dimIndex, value, permuter);
    case 979: return math::radical_inverse_permuted<math::table::PRIME[979], real>(dimIndex, value, permuter);
    case 980: return math::radical_inverse_permuted<math::table::PRIME[980], real>(dimIndex, value, permuter);
    case 981: return math::radical_inverse_permuted<math::table::PRIME[981], real>(dimIndex, value, permuter);
    case 982: return math::radical_inverse_permuted<math::table::PRIME[982], real>(dimIndex, value, permuter);
    case 983: return math::radical_inverse_permuted<math::table::PRIME[983], real>(dimIndex, value, permuter);
    case 984: return math::radical_inverse_permuted<math::table::PRIME[984], real>(dimIndex, value, permuter);
    case 985: return math::radical_inverse_permuted<math::table::PRIME[985], real>(dimIndex, value, permuter);
    case 986: return math::radical_inverse_permuted<math::table::PRIME[986], real>(dimIndex, value, permuter);
    case 987: return math::radical_inverse_permuted<math::table::PRIME[987], real>(dimIndex, value, permuter);
    case 988: return math::radical_inverse_permuted<math::table::PRIME[988], real>(dimIndex, value, permuter);
    case 989: return math::radical_inverse_permuted<math::table::PRIME[989], real>(dimIndex, value, permuter);
    case 990: return math::radical_inverse_permuted<math::table::PRIME[990], real>(dimIndex, value, permuter);
    case 991: return math::radical_inverse_permuted<math::table::PRIME[991], real>(dimIndex, value, permuter);
    case 992: return math::radical_inverse_permuted<math::table::PRIME[992], real>(dimIndex, value, permuter);
    case 993: return math::radical_inverse_permuted<math::table::PRIME[993], real>(dimIndex, value, permuter);
    case 994: return math::radical_inverse_permuted<math::table::PRIME[994], real>(dimIndex, value, permuter);
    case 995: return math::radical_inverse_permuted<math::table::PRIME[995], real>(dimIndex, value, permuter);
    case 996: return math::radical_inverse_permuted<math::table::PRIME[996], real>(dimIndex, value, permuter);
    case 997: return math::radical_inverse_permuted<math::table::PRIME[997], real>(dimIndex, value, permuter);
    case 998: return math::radical_inverse_permuted<math::table::PRIME[998], real>(dimIndex, value, permuter);
    case 999: return math::radical_inverse_permuted<math::table::PRIME[999], real>(dimIndex, value, permuter);
    case 1000: return math::radical_inverse_permuted<math::table::PRIME[1000], real>(dimIndex, value, permuter);
    case 1001: return math::radical_inverse_permuted<math::table::PRIME[1001], real>(dimIndex, value, permuter);
    case 1002: return math::radical_inverse_permuted<math::table::PRIME[1002], real>(dimIndex, value, permuter);
    case 1003: return math::radical_inverse_permuted<math::table::PRIME[1003], real>(dimIndex, value, permuter);
    case 1004: return math::radical_inverse_permuted<math::table::PRIME[1004], real>(dimIndex, value, permuter);
    case 1005: return math::radical_inverse_permuted<math::table::PRIME[1005], real>(dimIndex, value, permuter);
    case 1006: return math::radical_inverse_permuted<math::table::PRIME[1006], real>(dimIndex, value, permuter);
    case 1007: return math::radical_inverse_permuted<math::table::PRIME[1007], real>(dimIndex, value, permuter);
    case 1008: return math::radical_inverse_permuted<math::table::PRIME[1008], real>(dimIndex, value, permuter);
    case 1009: return math::radical_inverse_permuted<math::table::PRIME[1009], real>(dimIndex, value, permuter);
    case 1010: return math::radical_inverse_permuted<math::table::PRIME[1010], real>(dimIndex, value, permuter);
    case 1011: return math::radical_inverse_permuted<math::table::PRIME[1011], real>(dimIndex, value, permuter);
    case 1012: return math::radical_inverse_permuted<math::table::PRIME[1012], real>(dimIndex, value, permuter);
    case 1013: return math::radical_inverse_permuted<math::table::PRIME[1013], real>(dimIndex, value, permuter);
    case 1014: return math::radical_inverse_permuted<math::table::PRIME[1014], real>(dimIndex, value, permuter);
    case 1015: return math::radical_inverse_permuted<math::table::PRIME[1015], real>(dimIndex, value, permuter);
    case 1016: return math::radical_inverse_permuted<math::table::PRIME[1016], real>(dimIndex, value, permuter);
    case 1017: return math::radical_inverse_permuted<math::table::PRIME[1017], real>(dimIndex, value, permuter);
    case 1018: return math::radical_inverse_permuted<math::table::PRIME[1018], real>(dimIndex, value, permuter);
    case 1019: return math::radical_inverse_permuted<math::table::PRIME[1019], real>(dimIndex, value, permuter);
    case 1020: return math::radical_inverse_permuted<math::table::PRIME[1020], real>(dimIndex, value, permuter);
    case 1021: return math::radical_inverse_permuted<math::table::PRIME[1021], real>(dimIndex, value, permuter);
    case 1022: return math::radical_inverse_permuted<math::table::PRIME[1022], real>(dimIndex, value, permuter);
    case 1023: return math::radical_inverse_permuted<math::table::PRIME[1023], real>(dimIndex, value, permuter);
    }
}
 
}// end namespace ph::halton_detail