My god

from copy import deepcopy, copy
from time import perf_counter

generator_size = 5 #X*2-1 x X*2-1
LWH = generator_size*2-1
gs = generator_size - 1

start_variant = 0
possible_variants = 2**(gs*gs*generator_size)
best_variant = 0

real_map = []
group_map = []

dmodcoords = [ [1, 1, -1], [1, -1, 1], [1, -1, -1], [-1, 1, 1], [-1, 1, -1], [-1, -1, 1], [-1, -1, -1]]

def generate_maps():
    map_x = []
    map_y = []
    for x in range(LWH):
        map_x.append(0)
    for y in range(LWH):
        map_y.append(deepcopy(map_x))
    for z in range(LWH):
        real_map.append(deepcopy(map_y))
        group_map.append(deepcopy(map_y))

def odd_mirroring():
    for z in range(generator_size):
        for y in range(generator_size):
            for x in range(generator_size):
                for mods in dmodcoords:
                    value = real_map[z][y][x]
                    lx = gs - x
                    ly = gs - y
                    lz = gs - z
                    nx = gs - lx * mods[2]
                    ny = gs - ly * mods[1]
                    nz = gs - lz * mods[0]
                    real_map[nz][ny][nx] = value

def purge_maps():
    for z in range(LWH):
        for y in range(LWH):
            for x in range(LWH):
                real_map[z][y][x] = 0
                group_map[z][y][x] = 0

sx = gs**0
sy = gs**1
sz = gs**2
half_map = gs

def generate_the_cross():
    for x in range(LWH):
        real_map[half_map][half_map][x] = 1
    for y in range(LWH):
        real_map[half_map][y][half_map] = 1
    for z in range(LWH):
        real_map[z][half_map][half_map] = 1

def generate_variant(variant):
    for z in range(generator_size):
        for y in range(generator_size-1):
            for x in range(generator_size-1):
                value = min(variant & 2**(sx*x+sy*y+sz*z), 1)
                real_map[z][y][x] = value

    odd_mirroring()

def show_map():
    for z in range(LWH):
        print(str(z+1) + ':', end='\n')
        for y in range(LWH):
            for x in range(LWH):
                print(real_map[z][y][x], end=' ')
            print()
        print(end='\n\n')

def show_virtual_map():
    for z in range(LWH):
        print(str(z+1) + ':', end='\n')
        for y in range(LWH):
            for x in range(LWH):
                print(group_map[z][y][x], end=' ')
            print()
        print(end='\n\n')

def count_blocks():
    amount = 0
    for z in range(LWH):
        for y in range(LWH):
            for x in range(LWH):
                if (real_map[z][y][x]):
                    amount += 1
    return amount

def bound_check(x, y, z):
    return (0<=x<LWH) and (0<=y<LWH) and (0<=z<LWH)

def make_group_map():
    group_id = 1
    dcoords = [ [1, 0, 0], [0, 1, 0], [-1, 0, 0], [0, -1, 0], [0, 0, 1], [0, 0, -1] ]
    whitelist = []
    blacklist = []
    coordinate = [0, 0, 0]
    new_coord = [0, 0, 0]
    local_whitelist = []

    for z in range(LWH):
        for y in range(LWH):
            for x in range(LWH):
                if (real_map[z][y][x]):
                    coordinate[0] = x
                    coordinate[1] = y
                    coordinate[2] = z
                    whitelist.append(copy(coordinate))
    while(len(whitelist)):
        sx = whitelist[0][0]
        sy = whitelist[0][1]
        sz = whitelist[0][2]
        coordinate[0] = sx
        coordinate[1] = sy
        coordinate[2] = sz
        local_whitelist.append(copy(coordinate))
        group_map[sz][sy][sx] = group_id
        whitelist.remove(coordinate)
        while(True):
            lsx = local_whitelist[0][0]
            lsy = local_whitelist[0][1]
            lsz = local_whitelist[0][2]
            coordinate[0] = lsx
            coordinate[1] = lsy
            coordinate[2] = lsz
            for dp in dcoords:
                nx = lsx + dp[0]
                ny = lsy + dp[1]
                nz = lsz + dp[2]
                new_coord[0] = nx
                new_coord[1] = ny
                new_coord[2] = nz
                if (not bound_check(nx, ny, nz)): continue
                if (real_map[nz][ny][nx]):
                    if (new_coord not in blacklist):
                        if (not group_map[nz][ny][nx]):
                            local_whitelist.append(copy(new_coord))
                            group_map[nz][ny][nx] = group_id
                            whitelist.remove(new_coord)
                            blacklist.append(copy(new_coord))
            local_whitelist.remove(coordinate)
            blacklist.append(copy(coordinate))
            if (not len(local_whitelist)):
                break
        group_id += 1

def count_groups():
    groups_found = 0
    current_group_id = 0
    groups_info = []
    group_id = 0
    length = 0
    width = 0
    height = 0
    size_sum = 0
    minx = LWH+1
    miny = LWH+1
    minz = LWH+1
    maxx = 0
    maxy = 0
    maxz = 0

    blank = [0, minx, miny, minz, maxx, maxy, maxz]
    first = perf_counter()
    for z in range(LWH):
        for y in range(LWH):
            for x in range(LWH):
                groups_found = max(groups_found, group_map[z][y][x])

    second = perf_counter()
    for group_id in range(groups_found+1):
        groups_info.append(deepcopy(blank))

    third = perf_counter()
    for z in range(LWH):
        for y in range(LWH):
            for x in range(LWH):
                if (group_map[z][y][x]):
                    group_id = group_map[z][y][x]-1
                    groups_info[group_id][1] = min(groups_info[group_id][1], x)
                    groups_info[group_id][2] = min(groups_info[group_id][2], y)
                    groups_info[group_id][3] = min(groups_info[group_id][3], z)
                    groups_info[group_id][4] = max(groups_info[group_id][4], x)
                    groups_info[group_id][5] = max(groups_info[group_id][5], y)
                    groups_info[group_id][6] = max(groups_info[group_id][6], z)
    fourth = perf_counter()
    for current_group_id in range(1, groups_found+1):
        length = groups_info[current_group_id-1][4] - groups_info[current_group_id-1][1]
        width = groups_info[current_group_id-1][5] - groups_info[current_group_id-1][2]
        height = groups_info[current_group_id-1][6] - groups_info[current_group_id-1][3]

        size_sum = length + width + height
        groups_info[current_group_id-1][0] = size_sum
    fivth = perf_counter()
    second -= first
    third -= second
    fourth -= third
    fivth -= fourth
    print (second, third, fourth, fivth, sep = ' : ')
    return groups_info

def count_power():
    #Build group-map
    make_group_map()

    total_blocks = count_blocks()
    groups_info = count_groups()
    sum_power = 0
    for group_sum in groups_info:
        sum_power += (group_sum[0]/3)**1.7
    block_power = 25 * total_blocks
    full_power = 2000000 / (1 + 1.00696**(-sum_power/3)) - 1000000 + block_power
    return full_power

generate_maps()
generate_the_cross()
best_power = 0

first = perf_counter()
generate_variant(1034013)
dt = perf_counter() - first
print('Generate Variant: ', dt)
first = perf_counter()
make_group_map()
dt = perf_counter() - first
print('Make group map: ', dt)
first = perf_counter()
count_blocks()
dt = perf_counter() - first
print('Count blocks: ', dt)
first = perf_counter()
x = count_groups()
dt = perf_counter() - first
print('Count groups: ', dt)
"""
for variant in range(possible_variants):
    generate_variant(variant)
    variant_power = count_power()
    if (best_power < variant_power):
        best_power = variant_power
        best_variant = variant
        print(best_variant, best_power, sep=' -- ')
    purge_maps()"""