import numpy as np

def solve_for_x(a, b, c):
    a = np.int64(a)
    b = np.int64(b)
    c = np.int64(c)
    
    loga = np.log([a])
    logbmodc = np.log([b % c])
    
    return logbmodc/loga

x = solve_for_x(34091202317940, 46461034929471, 61704897745301)


Out[25]: array([ 1.00993498])

def rank(hand):
    handVals, handSuits, counts, straight, flush, i, j  = [], [], [], 0, 0, 0, 0
    values = map(str, range(2, 10)) + ['T', 'J', 'Q', 'K', 'A']
    handcodeRank = {11:'Straight flush', 42:'Four of a kind', 32:'Full house',
                             10:'Flush', 01:'Straight', 33:'Three of a kind',
                             23:'Two pair', 24:'One pair', 15:'High card'}
    for h in hand: #split hand into values and suit
        handVals += (values.index(h[0]), )
        handSuits += (h[1], )
    handVals.sort()
    while i < len(handVals): #count occurrences of values in hand
        counts += [handVals.count(handVals[i]), ]
        i += counts[j]
        j += 1
    flush = + len(set(handSuits)) == 1
    straight = + max(handVals) - min(handVals) == 4 and max(counts) == 1
    straight += + (handVals == [0, 1, 2, 3, 12])
    handcode = abs(max(straight, flush) - 1)*(10*max(counts) + len(counts))
    handcode += 10*flush + straight
    return handcodeRank[handcode]

flush = + len(set(handSuits)) == 1

if len(set(handSuits)) == 1:
    flush = 1

def rank(hand):
    # Do you know about doc strings?  A big improvement would be to tell
    # me what a hand is supposed to look like.  Or if you don't care about
    # me, your future self might like to know after not using this for a month.
    
    handVals, handSuits, counts, straight, flush, i, j  = [], [], [], 0, 0, 0, 0
    
    # 'values' and 'handcodeRank' appear to be constant lookup tables so
    # you can put them outside the function for efficiency if you want.
    # This code will rebuild them every time the function is called.
    # 'values' should also be a dictionary, based on the way you use it below.
    values = map(str, range(2, 10)) + ['T', 'J', 'Q', 'K', 'A']
    handcodeRank = {11:'Straight flush', 42:'Four of a kind', 32:'Full house',
                             10:'Flush', 01:'Straight', 33:'Three of a kind',
                             23:'Two pair', 24:'One pair', 15:'High card'}

    for h in hand: #split hand into values and suit
        handVals += (values.index(h[0]), )
        handSuits += (h[1], )
        # I'm surprised this even works, as you are concatenating tuple to list.
        # So you definitely should write handVals += [values.index(h[0])].
        # But better still would be handVals.append(values.index(h[0])) as
        # the += operator is building a whole new list.
        # Better still is for values to be a dictionary.  Now you've got a direct lookup
        # rather than a search across a list, and the code is simpler:
        # handVales.append(values[h[0]])
        # Finally and least importantly, most Pythonic would be to unpack h in
        # the for loop with...
        # for h, s in hand:
        #     handVals.append(values[h])
        #     handSuits.append(s)

    handVals.sort()
    while i < len(handVals): #count occurrences of values in hand
        # You're adding a list to a list this time, yay.  Again you can use
        # counts.append(...).  A one item list doesn't need the final comma.
        counts += [handVals.count(handVals[i]), ]
        i += counts[j]
        j += 1

    # what are all those +'s about?  You know all the values are positive.
    # You don't need them and they are confusing.
    flush = + len(set(handSuits)) == 1

    # This scares me, I would use more parenthesis.
    straight = + max(handVals) - min(handVals) == 4 and max(counts) == 1

    straight += + (handVals == [0, 1, 2, 3, 12])
    handcode = abs(max(straight, flush) - 1)*(10*max(counts) + len(counts))
    handcode += 10*flush + straight
    return handcodeRank[handcode]

>>> flush = 2 + 2 == 4
>>> flush
True
>>> flush = + (2 + 2 == 4)
>>> flush
1

>>> 10*True + True
11
>>> 10*False + True
1

def rank(hand):
    """Assumes hand is a list of format ['Tc', '2h', 'As', '2c', 'Qd']
       Returns string describing rank of hand, e.g., 'One pair'"""

flush = 0
if len(set(s)) == 1:
    flush == 1

flush = len(set(s)) == 1

>>> flush = len(set(s)) == 1
True
>>> True + 0
1
>>> flush = 0 + len(set(s)) == 1
1
>>> flush = + len(set(s)) == 1
1

flush = len(set(handSuits)) == 1
straight = ((max(handVals) - min(handVals) == 4) and max(counts) == 1)
straight += (handVals == [0, 1, 2, 3, 12])
handcode = abs(max(straight, flush) - 1)*(10*max(counts) + len(counts))
handcode += 10*flush + straight

flush = len(set(s)) == 1

flush += (len(set(s)) == 1)

if not x:
    ...

abs(max(straight, flush) - 1)

(not straight and not flush)

class makeClass(int i, int k)
{
class temp;
temp.j = i;
temp.h = k;
return temp;
}

...

and in main()
{
class newClass = makeClass(3, 4);
}

flush = False
if len(set(s)) == 1:
    flush = True

len(s) == 5

def is_flush (s):
    do some test:
    return True

flush = is_flush(c)