Pseudo algorithm to code

[Slavi]

Hey guys,
It's not exactly trouble with coding that I am facing more like trouble with understanding what I have to implement ..

Quick background .. I am trying to implement statistical-saturation attack on block ciphers. The piper that describes the attack has the following algorithm that is used against the block cipher PRESENT(that's what about the paper is)

input: a 8-bit subkey guess sk and the 8-bit input distribution distrib_in[256]
output: the 8-bit output distribution distrib_out[256]

initialize distrib_out[256] to the all-zero state
for each 8-bit values text do
        for each 8-bit values rand do
                fix the 8-bit trial to text and xor with sk
                fix the 8-bit non trial to rand
                apply the sboxes
                apply the permutation
                evaluate the value of the 8 bit trial out
                update distrib_out[out]=distrib_out[out]+distrib_in[text]/256
        end for
end for

So I tried implementing that in python and I get the following:

================= Python code implementing it =====================
===== Fixed bits for simplicity now are 1234????

def algorithm1(sk4bit):
        text = ["".join(seq) for seq in itertools.product("01", repeat=4)] # generate all possible fixed inputs
        rand = ["".join(seq) for seq in itertools.product("01", repeat=4)] # generate all possible rand inputs
        sk4bit = getHexFromBinaryNibble(sk4bit)

        #fixed bits the ****????       
        for t in text:
                for r in rand:
                        # fix and xor text with sk
                        left = xor_strings(getHexFromBinaryNibble(t),sk4bit)
                        #fix rand -> don't need to as nothing is changed to other positions

                        #apply sboxes
                        left = sBox(left)
                        right = sBox(getHexFromBinaryNibble(r))

                        #permutation , 4th bit of left is going to 1st bit of right, and 1st bit of right to 4th bit of left
                        permuted1, permuted2 = permute(left,right)

                        # Algorithm ends here ---

                        #xor with sk
                        permuted1XOR = xor_strings(permuted1,sk4bit)

                        #apply sboxes
                        permuted1XOR = sBox(permuted1XOR)
                        permuted2 = sBox(permuted2)

                        #or last time
                        permuted1XOR2 = xor_strings(permuted1XOR,sk4bit)

                        #print the outcome
                        print 'Input: %s%s Output: %s%s Key: %s' % (t,r,bin(int(permuted1XOR2, 16))[2:].zfill(4),bin(int(permuted2, 16))[2:].zfill(4),sk4bit)

I tried following the algorithm step by step but something is dodgy and the results are not as expected
The part after ==algorithm ends here== is because the block cipher that I am making it for is so simple that it doesn't require additional methods to add the rest of the encryption which is another xor, through xbox and xor again, basically this:

             | | | |    | | | |
             | | | |    | | | |  
             ^ ^ ^ ^    ^ ^ ^ ^  K(i)
             |_|_|_|    |_|_|_|
             |     |    |     |
             |  S  |    |  S  |
             |_ _ _|    |_ _ _|
             | | | |    | | | |
              ____Round 1_____
             | | | \    / | | |
             | | |   --   | | |
             | | | /    \ | | |
             | | | |    | | | |
             ^ ^ ^ ^    ^ ^ ^ ^  K(i+1)
             |_|_|_|    |_|_|_|
             |     |    |     |
             |  S  |    |  S  |
             |_ _ _|    |_ _ _|
             | | | |    | | | |
              ____Round 2_____
             | | | |    | | | |
             ^ ^ ^ ^    ^ ^ ^ ^  K(i+2)
             | | | |    | | | |
             | | | |    | | | |

Any help appreciated ..