from bitcoin import *
import threading
import time
import math
import sys

pub = "bc1qq2rnv02hjzv5h0lwa03um43afwcfcpf0qg56ca"
randprv = "LP5U3KWRLvPwDefz4FVMrAJVFtU4u8pj15w8VSpZF2aaPeY5QIx8"
_1M=1024**2
nthreads = 48

def index2permarray(k, size):
  if size <= 1:
    return [0]
  arr = []
  while size > 1:
    multiplier = math.factorial(size-1)
    digit = math.floor(k/multiplier)
    arr += [digit]
    k = k % multiplier
    size = size-1
  return arr

fact52array = []
for i in range(0,53):
  fact52array += [math.factorial(i)]

def index2permutation(i,n,p):
  arr=""
  for k in range(1, n + 1): # k goes from 1 to n
    f = fact52array[n - k]  # compute factorial once per iteration
    d = i // f            # use integer division (like division + floor)
    arr = arr + str(p[d])          # print permuted number with trailing space
    p = p[:d] + p[d+1:]        # delete p[d] from p
    i = i % f             # reduce i to its remainder
  return arr

class checkKey (threading.Thread):
   def __init__(self, threadID, low, high):
      threading.Thread.__init__(self)
      self.threadID = threadID
      self.low = low
      self.high = high
   def run(self):
     for i in range(self.low, self.high+1):
        if (self.high-self.low+1 - i) % 100 == 0:
          print("Thread {}: {}%".format(self.threadID, i/(self.high-self.low+1)))
        prv = index2permutation(i,52,randprv)
        try:
          testpub = prvtopub(prv)
          if testpub == pub:
             printf("Match: " + prv)
             sys.exit(0)
        except Exception as s:
          pass

fact52 = math.factorial(52)
def main():
  threadcount=0
  k=0
  while _1M*k<fact52:
    while (threading.activeCount() <= nthreads):
      checkKey(threading.activeCount(), _1M*k, _1M*(k+1)).start()
      threadcount += 1
      k += 1
    time.sleep(0.01)
    #print(str(_1M*k/fact52*100) + "% ", end="", flush=True)

main()

# Python 3 implementation of the approach

# Given the array arr[] of N elements and a permutation array P[], the task is to permute the given array arr[] based on the permutation array P[].
# Function to permute the the given
# array based on the given conditions
def permute(A, P, n):
     
    # For each element of P
    for i in range(n):
        next = i
 
        # Check if it is already
        # considered in cycle
        while (P[next] >= 0):
             
            # Swap the current element according
            # to the permutation in P
            t = A[i]
            A[i] = A[P[next]]
            A[P[next]] = t
             
            temp = P[next]
 
            # Subtract n from an entry in P
            # to make it negative which indicates
            # the corresponding move
            # has been performed
            P[next] -= n
            next = temp

def int_from_code(code):
    """
    :type code: list
    :rtype: int
    """
    num = 0
    for i, v in enumerate(reversed(code), 1):
        num *= i
        num += v

    return num

def code_from_int(size, num):
    """
    :type size: int
    :type num: int
    :rtype: list
    """
    code = []
    for i in range(size):
        num, j = divmod(num, size - i)
        code.append(j)

    return code


def perm_from_code(base, code, pick=None):
    """
    :type base: list
    :type code: list
    :rtype: list
    """
    if pick:
        return _perm_from_code_pick(base, code)

    perm = base.copy()
    for i in range(len(base) - 1):
        j = code[i]
        perm[i], perm[i+j] = perm[i+j], perm[i]

    return perm

def perm_from_int(base, num, pick=None):
    """
    :type base: list
    :type num: int
    :rtype: list
    """
    code = code_from_int(len(base), num)
    return perm_from_code(base, code, pick=pick)

def code_from_perm(base, perm, pick=None):
    """
    :type base: list
    :type perm: list
    :rtype: list
    """
    if pick:
        _code_from_perm_pick(base, perm)

    p = base.copy()
    n = len(base)
    pos_map = {v: i for i, v in enumerate(base)}

    w = []
    for i in range(n):
        print(pos_map, perm)
        d = pos_map[perm[i]] - i
        w.append(d)

        if not d:
            continue
        t = pos_map[perm[i]]
        pos_map[p[i]], pos_map[p[t]] = pos_map[p[t]], pos_map[p[i]]
        p[i], p[t] = p[t], p[i]

    return w

def int_from_perm(base, perm, pick=None):
    """
    :type base: list
    :type perm: list
    :rtype: int
    """
    code = code_from_perm(base, perm, pick=pick)
    return int_from_code(code)