Configuration: 3 with 2 MVars and 1 uses with shortoutput: True
> testing translation candidate 0 :
([putCh^1,putCh^2,putS],[takeS,takeCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 1 :
([putCh^1,putCh^2,putS],[takeS,takeCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 2 :
([putCh^1,putCh^2,putS],[takeCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 3 :
([putCh^1,putCh^2,putS],[takeCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 4 :
([putCh^1,putCh^2,putS],[takeCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 5 :
([putCh^1,putCh^2,putS],[takeCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 6 :
([putCh^1,putCh^2,putS,takeCh^2],[takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 7 :
([putCh^1,putCh^2,putS,takeCh^2],[takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 8 :
([putCh^1,putCh^2,putS,takeCh^2,takeCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 9 :
([putCh^1,putCh^2,putS,takeCh^1],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 10 :
([putCh^1,putCh^2,putS,takeCh^1],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 11 :
([putCh^1,putCh^2,putS,takeCh^1,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 12 :
([putCh^1,putCh^2,takeCh^2,putS],[takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 13 :
([putCh^1,putCh^2,takeCh^2,putS],[takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 14 :
([putCh^1,putCh^2,takeCh^2,putS,takeCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 15 :
([putCh^1,putCh^2,takeCh^2,takeCh^1,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 16 :
([putCh^1,putCh^2,takeCh^1,putS],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 17 :
([putCh^1,putCh^2,takeCh^1,putS],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 18 :
([putCh^1,putCh^2,takeCh^1,putS,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 19 :
([putCh^1,putCh^2,takeCh^1,takeCh^2,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 20 :
([putCh^1,putS],[putCh^2,takeS,takeCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 21 :
([putCh^1,putS],[putCh^2,takeS,takeCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 22 :
([putCh^1,putS],[putCh^2,takeCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 23 :
([putCh^1,putS],[putCh^2,takeCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 24 :
([putCh^1,putS],[putCh^2,takeCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 25 :
([putCh^1,putS],[putCh^2,takeCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 26 :
([putCh^1,putS],[takeS,putCh^2,takeCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 27 :
([putCh^1,putS],[takeS,putCh^2,takeCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 28 :
([putCh^1,putS],[takeS,takeCh^2,putCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 29 :
([putCh^1,putS],[takeS,takeCh^2,takeCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 30 :
([putCh^1,putS],[takeS,takeCh^1,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 31 :
([putCh^1,putS],[takeS,takeCh^1,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 32 :
([putCh^1,putS],[takeCh^2,putCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 33 :
([putCh^1,putS],[takeCh^2,putCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 34 :
([putCh^1,putS],[takeCh^2,takeS,putCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 35 :
([putCh^1,putS],[takeCh^2,takeS,takeCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 36 :
([putCh^1,putS],[takeCh^2,takeCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 37 :
([putCh^1,putS],[takeCh^2,takeCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 38 :
([putCh^1,putS],[takeCh^1,putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 39 :
([putCh^1,putS],[takeCh^1,putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 40 :
([putCh^1,putS],[takeCh^1,takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 41 :
([putCh^1,putS],[takeCh^1,takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 42 :
([putCh^1,putS],[takeCh^1,takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 43 :
([putCh^1,putS],[takeCh^1,takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 44 :
([putCh^1,putS,putCh^2],[takeS,takeCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 45 :
([putCh^1,putS,putCh^2],[takeS,takeCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 46 :
([putCh^1,putS,putCh^2],[takeCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 47 :
([putCh^1,putS,putCh^2],[takeCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 48 :
([putCh^1,putS,putCh^2],[takeCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 49 :
([putCh^1,putS,putCh^2],[takeCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 50 :
([putCh^1,putS,putCh^2,takeCh^2],[takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 51 :
([putCh^1,putS,putCh^2,takeCh^2],[takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 52 :
([putCh^1,putS,putCh^2,takeCh^2,takeCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 53 :
([putCh^1,putS,putCh^2,takeCh^1],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 54 :
([putCh^1,putS,putCh^2,takeCh^1],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 55 :
([putCh^1,putS,putCh^2,takeCh^1,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 56 :
([putCh^1,putS,takeCh^2],[putCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 57 :
([putCh^1,putS,takeCh^2],[putCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 58 :
([putCh^1,putS,takeCh^2],[takeS,putCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 59 :
([putCh^1,putS,takeCh^2],[takeS,takeCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 60 :
([putCh^1,putS,takeCh^2],[takeCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 61 :
([putCh^1,putS,takeCh^2],[takeCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 62 :
([putCh^1,putS,takeCh^2,putCh^2],[takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 63 :
([putCh^1,putS,takeCh^2,putCh^2],[takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 64 :
([putCh^1,putS,takeCh^2,putCh^2,takeCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 65 :
([putCh^1,putS,takeCh^2,takeCh^1],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 66 :
([putCh^1,putS,takeCh^2,takeCh^1],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
>>> testing pi program 12
([[Output "x" "z",Output "z" "a"],[Input "x" "w" 0,Input "w" "b" 0,Stop],[Input "x" "y" 0,Output "x" "y"]],True,True)
>>> testing pi program 13
([[Input "x" "z" 0,Input "z" "a" 0,Stop],[Input "x" "w" 0,Input "w" "a" 0,Stop],[Output "x" "y",Output "y" "u"]],True,True)
>>> testing pi program 14
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Output "x" "y"]],True,True)
>>> testing pi program 15
([[Output "x" "y",Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Output "x" "y"]],True,True)
>>> testing pi program 16
([[Output "x" "y"],[Input "x" "y" 0],[Output "x" "y",Stop]],True,False)
>>> testing pi program 17
([[Output "x" "y",Output "x" "z",Output "z" "u",Stop],[Input "x" "w" 0],[Input "x" "ww" 0],[Output "x" "u"]],False,False)
>>> testing pi program 18
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Input "x" "u" 0]],False,False)
>>> testing pi program 19
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Input "x" "u" 0],[Input "x" "u" 0]],False,False)
>>> testing pi program 20
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "x" "u"]],False,False)
>>> testing pi program 21
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "w" "u"]],True,False)
>>> testing pi program 22
([[Input "x" "y" 0,Input "y" "z" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "w" "u"],[Output "ww" "u"]],True,True)
>>> testing pi program 23
([[Output "x" "y",Input "y" "z" 0,Stop],[Input "x" "w" 0,Output "w" "u"]],True,True)
>>> testing pi program 24
([[Output "x" "y",Input "y" "z" 0,Input "z" "zz" 0],[Input "x" "w" 0,Output "w" "u"],[Output "u" "uu",Stop]],True,True)
>>> testing pi program 25
([[Output "x" "y",Input "y" "z" 0,Input "z" "zz" 0],[Input "x" "w" 0],[Input "x" "w" 0,Output "w" "u"],[Output "u" "uu",Stop]],True,False)
>>> testing pi program 26
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 27
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 28
([[Output "x" "y"],[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 29
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0],[Input "x" "y" 0]],True,True)
>>> testing pi program 30
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 31
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 32
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 33
([[Output "x" "w",Input "x" "y" 0,Output "y" "q"],[Input "x" "z" 0],[Output "x" "z"],[Input "w" "p" 0,Stop]],False,False)
>>> testing pi program 34
([[Output "x" "y",Input "x" "z" 0,Output "z" "q"],[Input "x" "z" 0],[Input "x" "z" 0],[Output "x" "z"],[Input "y" "u" 0,Stop]],False,False)
>>> testing pi program 35
([[Input "x" "w" 0,Output "x" "y",Input "y" "q" 0],[Input "x" "z" 0],[Output "x" "z"],[Output "w" "p",Stop]],False,False)
>>> testing pi program 36
([[Output "x" "z",Output "z" "a",Output "p" "q",Stop],[Output "x" "w",Output "w" "a",Input "p" "r" 0,Stop],[Input "x" "y" 0,Input "y" "u" 0],[Input "x" "l" 0,Input "l" "u" 0]],True,True)
>>> failed!
> testing translation candidate 67 :
([putCh^1,putS,takeCh^2,takeCh^1,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 68 :
([putCh^1,putS,takeCh^1],[putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 69 :
([putCh^1,putS,takeCh^1],[putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 70 :
([putCh^1,putS,takeCh^1],[takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 71 :
([putCh^1,putS,takeCh^1],[takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 72 :
([putCh^1,putS,takeCh^1],[takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 73 :
([putCh^1,putS,takeCh^1],[takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 74 :
([putCh^1,putS,takeCh^1,putCh^2],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 75 :
([putCh^1,putS,takeCh^1,putCh^2],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 76 :
([putCh^1,putS,takeCh^1,putCh^2,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 77 :
([putCh^1,putS,takeCh^1,takeCh^2],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 78 :
([putCh^1,putS,takeCh^1,takeCh^2],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 79 :
([putCh^1,putS,takeCh^1,takeCh^2,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 80 :
([putCh^1,takeCh^2,putCh^2,putS],[takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 81 :
([putCh^1,takeCh^2,putCh^2,putS],[takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 82 :
([putCh^1,takeCh^2,putCh^2,putS,takeCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 83 :
([putCh^1,takeCh^2,putCh^2,takeCh^1,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 84 :
([putCh^1,takeCh^2,putS],[putCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 85 :
([putCh^1,takeCh^2,putS],[putCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 86 :
([putCh^1,takeCh^2,putS],[takeS,putCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 87 :
([putCh^1,takeCh^2,putS],[takeS,takeCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 88 :
([putCh^1,takeCh^2,putS],[takeCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
>>> testing pi program 12
([[Output "x" "z",Output "z" "a"],[Input "x" "w" 0,Input "w" "b" 0,Stop],[Input "x" "y" 0,Output "x" "y"]],True,True)
>>> testing pi program 13
([[Input "x" "z" 0,Input "z" "a" 0,Stop],[Input "x" "w" 0,Input "w" "a" 0,Stop],[Output "x" "y",Output "y" "u"]],True,True)
>>> testing pi program 14
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Output "x" "y"]],True,True)
>>> testing pi program 15
([[Output "x" "y",Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Output "x" "y"]],True,True)
>>> testing pi program 16
([[Output "x" "y"],[Input "x" "y" 0],[Output "x" "y",Stop]],True,False)
>>> testing pi program 17
([[Output "x" "y",Output "x" "z",Output "z" "u",Stop],[Input "x" "w" 0],[Input "x" "ww" 0],[Output "x" "u"]],False,False)
>>> testing pi program 18
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Input "x" "u" 0]],False,False)
>>> testing pi program 19
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Input "x" "u" 0],[Input "x" "u" 0]],False,False)
>>> testing pi program 20
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "x" "u"]],False,False)
>>> testing pi program 21
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "w" "u"]],True,False)
>>> testing pi program 22
([[Input "x" "y" 0,Input "y" "z" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "w" "u"],[Output "ww" "u"]],True,True)
>>> testing pi program 23
([[Output "x" "y",Input "y" "z" 0,Stop],[Input "x" "w" 0,Output "w" "u"]],True,True)
>>> testing pi program 24
([[Output "x" "y",Input "y" "z" 0,Input "z" "zz" 0],[Input "x" "w" 0,Output "w" "u"],[Output "u" "uu",Stop]],True,True)
>>> testing pi program 25
([[Output "x" "y",Input "y" "z" 0,Input "z" "zz" 0],[Input "x" "w" 0],[Input "x" "w" 0,Output "w" "u"],[Output "u" "uu",Stop]],True,False)
>>> testing pi program 26
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 27
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 28
([[Output "x" "y"],[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 29
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0],[Input "x" "y" 0]],True,True)
>>> testing pi program 30
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 31
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 32
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 33
([[Output "x" "w",Input "x" "y" 0,Output "y" "q"],[Input "x" "z" 0],[Output "x" "z"],[Input "w" "p" 0,Stop]],False,False)
ok
> testing translation candidate 89 :
([putCh^1,takeCh^2,putS],[takeCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 90 :
([putCh^1,takeCh^2,putS,putCh^2],[takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 91 :
([putCh^1,takeCh^2,putS,putCh^2],[takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 92 :
([putCh^1,takeCh^2,putS,putCh^2,takeCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 93 :
([putCh^1,takeCh^2,putS,takeCh^1],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 94 :
([putCh^1,takeCh^2,putS,takeCh^1],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 95 :
([putCh^1,takeCh^2,putS,takeCh^1,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 96 :
([putCh^1,takeCh^2,takeCh^1,putCh^2,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 97 :
([putCh^1,takeCh^2,takeCh^1,putS],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 98 :
([putCh^1,takeCh^2,takeCh^1,putS],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 99 :
([putCh^1,takeCh^2,takeCh^1,putS,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 100 :
([putCh^1,takeCh^1,putCh^2,putS],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 101 :
([putCh^1,takeCh^1,putCh^2,putS],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 102 :
([putCh^1,takeCh^1,putCh^2,putS,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 103 :
([putCh^1,takeCh^1,putCh^2,takeCh^2,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 104 :
([putCh^1,takeCh^1,putS],[putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 105 :
([putCh^1,takeCh^1,putS],[putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 106 :
([putCh^1,takeCh^1,putS],[takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 107 :
([putCh^1,takeCh^1,putS],[takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 108 :
([putCh^1,takeCh^1,putS],[takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 109 :
([putCh^1,takeCh^1,putS],[takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 110 :
([putCh^1,takeCh^1,putS,putCh^2],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 111 :
([putCh^1,takeCh^1,putS,putCh^2],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 112 :
([putCh^1,takeCh^1,putS,putCh^2,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 113 :
([putCh^1,takeCh^1,putS,takeCh^2],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 114 :
([putCh^1,takeCh^1,putS,takeCh^2],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 115 :
([putCh^1,takeCh^1,putS,takeCh^2,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 116 :
([putCh^1,takeCh^1,takeCh^2,putCh^2,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 117 :
([putCh^1,takeCh^1,takeCh^2,putS],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 118 :
([putCh^1,takeCh^1,takeCh^2,putS],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 119 :
([putCh^1,takeCh^1,takeCh^2,putS,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 120 :
([putS],[putCh^1,putCh^2,takeS,takeCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 121 :
([putS],[putCh^1,putCh^2,takeS,takeCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 122 :
([putS],[putCh^1,putCh^2,takeCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 123 :
([putS],[putCh^1,putCh^2,takeCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 124 :
([putS],[putCh^1,putCh^2,takeCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 125 :
([putS],[putCh^1,putCh^2,takeCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 126 :
([putS],[putCh^1,takeS,putCh^2,takeCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 127 :
([putS],[putCh^1,takeS,putCh^2,takeCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 128 :
([putS],[putCh^1,takeS,takeCh^2,putCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 129 :
([putS],[putCh^1,takeS,takeCh^2,takeCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 130 :
([putS],[putCh^1,takeS,takeCh^1,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 131 :
([putS],[putCh^1,takeS,takeCh^1,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 132 :
([putS],[putCh^1,takeCh^2,putCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 133 :
([putS],[putCh^1,takeCh^2,putCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 134 :
([putS],[putCh^1,takeCh^2,takeS,putCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 135 :
([putS],[putCh^1,takeCh^2,takeS,takeCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 136 :
([putS],[putCh^1,takeCh^2,takeCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 137 :
([putS],[putCh^1,takeCh^2,takeCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 138 :
([putS],[putCh^1,takeCh^1,putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 139 :
([putS],[putCh^1,takeCh^1,putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 140 :
([putS],[putCh^1,takeCh^1,takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 141 :
([putS],[putCh^1,takeCh^1,takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 142 :
([putS],[putCh^1,takeCh^1,takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 143 :
([putS],[putCh^1,takeCh^1,takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 144 :
([putS],[takeS,putCh^1,putCh^2,takeCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 145 :
([putS],[takeS,putCh^1,putCh^2,takeCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 146 :
([putS],[takeS,putCh^1,takeCh^2,putCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 147 :
([putS],[takeS,putCh^1,takeCh^2,takeCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 148 :
([putS],[takeS,putCh^1,takeCh^1,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 149 :
([putS],[takeS,putCh^1,takeCh^1,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 150 :
([putS],[takeS,takeCh^1,putCh^2,putCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 151 :
([putS],[takeS,takeCh^1,putCh^2,takeCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 152 :
([putS],[takeS,takeCh^1,putCh^1,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 153 :
([putS],[takeS,takeCh^1,putCh^1,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 154 :
([putS],[takeS,takeCh^1,takeCh^2,putCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 155 :
([putS],[takeS,takeCh^1,takeCh^2,putCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 156 :
([putS],[takeCh^1,putCh^2,putCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 157 :
([putS],[takeCh^1,putCh^2,putCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 158 :
([putS],[takeCh^1,putCh^2,takeS,putCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 159 :
([putS],[takeCh^1,putCh^2,takeS,takeCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 160 :
([putS],[takeCh^1,putCh^2,takeCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 161 :
([putS],[takeCh^1,putCh^2,takeCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 162 :
([putS],[takeCh^1,putCh^1,putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 163 :
([putS],[takeCh^1,putCh^1,putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 164 :
([putS],[takeCh^1,putCh^1,takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 165 :
([putS],[takeCh^1,putCh^1,takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 166 :
([putS],[takeCh^1,putCh^1,takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 167 :
([putS],[takeCh^1,putCh^1,takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 168 :
([putS],[takeCh^1,takeS,putCh^2,putCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 169 :
([putS],[takeCh^1,takeS,putCh^2,takeCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 170 :
([putS],[takeCh^1,takeS,putCh^1,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 171 :
([putS],[takeCh^1,takeS,putCh^1,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 172 :
([putS],[takeCh^1,takeS,takeCh^2,putCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 173 :
([putS],[takeCh^1,takeS,takeCh^2,putCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 174 :
([putS],[takeCh^1,takeCh^2,putCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 175 :
([putS],[takeCh^1,takeCh^2,putCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 176 :
([putS],[takeCh^1,takeCh^2,putCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 177 :
([putS],[takeCh^1,takeCh^2,putCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 178 :
([putS],[takeCh^1,takeCh^2,takeS,putCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 179 :
([putS],[takeCh^1,takeCh^2,takeS,putCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 180 :
([putS,putCh^1],[putCh^2,takeS,takeCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 181 :
([putS,putCh^1],[putCh^2,takeS,takeCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 182 :
([putS,putCh^1],[putCh^2,takeCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 183 :
([putS,putCh^1],[putCh^2,takeCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 184 :
([putS,putCh^1],[putCh^2,takeCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 185 :
([putS,putCh^1],[putCh^2,takeCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 186 :
([putS,putCh^1],[takeS,putCh^2,takeCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 187 :
([putS,putCh^1],[takeS,putCh^2,takeCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 188 :
([putS,putCh^1],[takeS,takeCh^2,putCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 189 :
([putS,putCh^1],[takeS,takeCh^2,takeCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 190 :
([putS,putCh^1],[takeS,takeCh^1,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 191 :
([putS,putCh^1],[takeS,takeCh^1,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 192 :
([putS,putCh^1],[takeCh^2,putCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 193 :
([putS,putCh^1],[takeCh^2,putCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 194 :
([putS,putCh^1],[takeCh^2,takeS,putCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 195 :
([putS,putCh^1],[takeCh^2,takeS,takeCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 196 :
([putS,putCh^1],[takeCh^2,takeCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 197 :
([putS,putCh^1],[takeCh^2,takeCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 198 :
([putS,putCh^1],[takeCh^1,putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 199 :
([putS,putCh^1],[takeCh^1,putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 200 :
([putS,putCh^1],[takeCh^1,takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 201 :
([putS,putCh^1],[takeCh^1,takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 202 :
([putS,putCh^1],[takeCh^1,takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 203 :
([putS,putCh^1],[takeCh^1,takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 204 :
([putS,putCh^1,putCh^2],[takeS,takeCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 205 :
([putS,putCh^1,putCh^2],[takeS,takeCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 206 :
([putS,putCh^1,putCh^2],[takeCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 207 :
([putS,putCh^1,putCh^2],[takeCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 208 :
([putS,putCh^1,putCh^2],[takeCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 209 :
([putS,putCh^1,putCh^2],[takeCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 210 :
([putS,putCh^1,putCh^2,takeCh^2],[takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 211 :
([putS,putCh^1,putCh^2,takeCh^2],[takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 212 :
([putS,putCh^1,putCh^2,takeCh^2,takeCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 213 :
([putS,putCh^1,putCh^2,takeCh^1],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 214 :
([putS,putCh^1,putCh^2,takeCh^1],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 215 :
([putS,putCh^1,putCh^2,takeCh^1,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 216 :
([putS,putCh^1,takeCh^2],[putCh^2,takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 217 :
([putS,putCh^1,takeCh^2],[putCh^2,takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 218 :
([putS,putCh^1,takeCh^2],[takeS,putCh^2,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 219 :
([putS,putCh^1,takeCh^2],[takeS,takeCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 220 :
([putS,putCh^1,takeCh^2],[takeCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 221 :
([putS,putCh^1,takeCh^2],[takeCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 222 :
([putS,putCh^1,takeCh^2,putCh^2],[takeS,takeCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 223 :
([putS,putCh^1,takeCh^2,putCh^2],[takeCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 224 :
([putS,putCh^1,takeCh^2,putCh^2,takeCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 225 :
([putS,putCh^1,takeCh^2,takeCh^1],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 226 :
([putS,putCh^1,takeCh^2,takeCh^1],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 227 :
([putS,putCh^1,takeCh^2,takeCh^1,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 228 :
([putS,putCh^1,takeCh^1],[putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 229 :
([putS,putCh^1,takeCh^1],[putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 230 :
([putS,putCh^1,takeCh^1],[takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 231 :
([putS,putCh^1,takeCh^1],[takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 232 :
([putS,putCh^1,takeCh^1],[takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 233 :
([putS,putCh^1,takeCh^1],[takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 234 :
([putS,putCh^1,takeCh^1,putCh^2],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 235 :
([putS,putCh^1,takeCh^1,putCh^2],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 236 :
([putS,putCh^1,takeCh^1,putCh^2,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
ok
> testing translation candidate 237 :
([putS,putCh^1,takeCh^1,takeCh^2],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 238 :
([putS,putCh^1,takeCh^1,takeCh^2],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 239 :
([putS,putCh^1,takeCh^1,takeCh^2,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 240 :
([putS,takeCh^1],[putCh^2,putCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 241 :
([putS,takeCh^1],[putCh^2,putCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 242 :
([putS,takeCh^1],[putCh^2,takeS,putCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 243 :
([putS,takeCh^1],[putCh^2,takeS,takeCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 244 :
([putS,takeCh^1],[putCh^2,takeCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 245 :
([putS,takeCh^1],[putCh^2,takeCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 246 :
([putS,takeCh^1],[putCh^1,putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 247 :
([putS,takeCh^1],[putCh^1,putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 248 :
([putS,takeCh^1],[putCh^1,takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 249 :
([putS,takeCh^1],[putCh^1,takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 250 :
([putS,takeCh^1],[putCh^1,takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 251 :
([putS,takeCh^1],[putCh^1,takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 252 :
([putS,takeCh^1],[takeS,putCh^2,putCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 253 :
([putS,takeCh^1],[takeS,putCh^2,takeCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 254 :
([putS,takeCh^1],[takeS,putCh^1,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 255 :
([putS,takeCh^1],[takeS,putCh^1,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 256 :
([putS,takeCh^1],[takeS,takeCh^2,putCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 257 :
([putS,takeCh^1],[takeS,takeCh^2,putCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 258 :
([putS,takeCh^1],[takeCh^2,putCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 259 :
([putS,takeCh^1],[takeCh^2,putCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 260 :
([putS,takeCh^1],[takeCh^2,putCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 261 :
([putS,takeCh^1],[takeCh^2,putCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 262 :
([putS,takeCh^1],[takeCh^2,takeS,putCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 263 :
([putS,takeCh^1],[takeCh^2,takeS,putCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 264 :
([putS,takeCh^1,putCh^2],[putCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 265 :
([putS,takeCh^1,putCh^2],[putCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 266 :
([putS,takeCh^1,putCh^2],[takeS,putCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 267 :
([putS,takeCh^1,putCh^2],[takeS,takeCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 268 :
([putS,takeCh^1,putCh^2],[takeCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 269 :
([putS,takeCh^1,putCh^2],[takeCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 270 :
([putS,takeCh^1,putCh^2,putCh^1],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 271 :
([putS,takeCh^1,putCh^2,putCh^1],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 272 :
([putS,takeCh^1,putCh^2,putCh^1,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 273 :
([putS,takeCh^1,putCh^2,takeCh^2],[putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 274 :
([putS,takeCh^1,putCh^2,takeCh^2],[takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 275 :
([putS,takeCh^1,putCh^2,takeCh^2,putCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 276 :
([putS,takeCh^1,putCh^1],[putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 277 :
([putS,takeCh^1,putCh^1],[putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 278 :
([putS,takeCh^1,putCh^1],[takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 279 :
([putS,takeCh^1,putCh^1],[takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 280 :
([putS,takeCh^1,putCh^1],[takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 281 :
([putS,takeCh^1,putCh^1],[takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 282 :
([putS,takeCh^1,putCh^1,putCh^2],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 283 :
([putS,takeCh^1,putCh^1,putCh^2],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 284 :
([putS,takeCh^1,putCh^1,putCh^2,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 285 :
([putS,takeCh^1,putCh^1,takeCh^2],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 286 :
([putS,takeCh^1,putCh^1,takeCh^2],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 287 :
([putS,takeCh^1,putCh^1,takeCh^2,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 288 :
([putS,takeCh^1,takeCh^2],[putCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 289 :
([putS,takeCh^1,takeCh^2],[putCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 290 :
([putS,takeCh^1,takeCh^2],[putCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 291 :
([putS,takeCh^1,takeCh^2],[putCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 292 :
([putS,takeCh^1,takeCh^2],[takeS,putCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 293 :
([putS,takeCh^1,takeCh^2],[takeS,putCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
ok
> testing translation candidate 294 :
([putS,takeCh^1,takeCh^2,putCh^2],[putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 295 :
([putS,takeCh^1,takeCh^2,putCh^2],[takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 296 :
([putS,takeCh^1,takeCh^2,putCh^2,putCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 297 :
([putS,takeCh^1,takeCh^2,putCh^1],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 298 :
([putS,takeCh^1,takeCh^2,putCh^1],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 299 :
([putS,takeCh^1,takeCh^2,putCh^1,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 300 :
([takeCh^1,putCh^2,putCh^1,putS],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 301 :
([takeCh^1,putCh^2,putCh^1,putS],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 302 :
([takeCh^1,putCh^2,putCh^1,putS,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 303 :
([takeCh^1,putCh^2,putCh^1,takeCh^2,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 304 :
([takeCh^1,putCh^2,putS],[putCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 305 :
([takeCh^1,putCh^2,putS],[putCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 306 :
([takeCh^1,putCh^2,putS],[takeS,putCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 307 :
([takeCh^1,putCh^2,putS],[takeS,takeCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 308 :
([takeCh^1,putCh^2,putS],[takeCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 309 :
([takeCh^1,putCh^2,putS],[takeCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 310 :
([takeCh^1,putCh^2,putS,putCh^1],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 311 :
([takeCh^1,putCh^2,putS,putCh^1],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 312 :
([takeCh^1,putCh^2,putS,putCh^1,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 313 :
([takeCh^1,putCh^2,putS,takeCh^2],[putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 314 :
([takeCh^1,putCh^2,putS,takeCh^2],[takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 315 :
([takeCh^1,putCh^2,putS,takeCh^2,putCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 316 :
([takeCh^1,putCh^2,takeCh^2,putCh^1,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 317 :
([takeCh^1,putCh^2,takeCh^2,putS],[putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 318 :
([takeCh^1,putCh^2,takeCh^2,putS],[takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 319 :
([takeCh^1,putCh^2,takeCh^2,putS,putCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 320 :
([takeCh^1,putCh^1,putCh^2,putS],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 321 :
([takeCh^1,putCh^1,putCh^2,putS],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 322 :
([takeCh^1,putCh^1,putCh^2,putS,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 323 :
([takeCh^1,putCh^1,putCh^2,takeCh^2,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 324 :
([takeCh^1,putCh^1,putS],[putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 325 :
([takeCh^1,putCh^1,putS],[putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 326 :
([takeCh^1,putCh^1,putS],[takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 327 :
([takeCh^1,putCh^1,putS],[takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 328 :
([takeCh^1,putCh^1,putS],[takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 329 :
([takeCh^1,putCh^1,putS],[takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 330 :
([takeCh^1,putCh^1,putS,putCh^2],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 331 :
([takeCh^1,putCh^1,putS,putCh^2],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 332 :
([takeCh^1,putCh^1,putS,putCh^2,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 333 :
([takeCh^1,putCh^1,putS,takeCh^2],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 334 :
([takeCh^1,putCh^1,putS,takeCh^2],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 335 :
([takeCh^1,putCh^1,putS,takeCh^2,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 336 :
([takeCh^1,putCh^1,takeCh^2,putCh^2,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 337 :
([takeCh^1,putCh^1,takeCh^2,putS],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 338 :
([takeCh^1,putCh^1,takeCh^2,putS],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 339 :
([takeCh^1,putCh^1,takeCh^2,putS,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 340 :
([takeCh^1,putS],[putCh^2,putCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
>>> testing pi program 12
([[Output "x" "z",Output "z" "a"],[Input "x" "w" 0,Input "w" "b" 0,Stop],[Input "x" "y" 0,Output "x" "y"]],True,True)
>>> testing pi program 13
([[Input "x" "z" 0,Input "z" "a" 0,Stop],[Input "x" "w" 0,Input "w" "a" 0,Stop],[Output "x" "y",Output "y" "u"]],True,True)
>>> testing pi program 14
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Output "x" "y"]],True,True)
>>> testing pi program 15
([[Output "x" "y",Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Output "x" "y"]],True,True)
>>> testing pi program 16
([[Output "x" "y"],[Input "x" "y" 0],[Output "x" "y",Stop]],True,False)
>>> testing pi program 17
([[Output "x" "y",Output "x" "z",Output "z" "u",Stop],[Input "x" "w" 0],[Input "x" "ww" 0],[Output "x" "u"]],False,False)
>>> testing pi program 18
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Input "x" "u" 0]],False,False)
>>> testing pi program 19
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Input "x" "u" 0],[Input "x" "u" 0]],False,False)
>>> testing pi program 20
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "x" "u"]],False,False)
>>> testing pi program 21
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "w" "u"]],True,False)
>>> testing pi program 22
([[Input "x" "y" 0,Input "y" "z" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "w" "u"],[Output "ww" "u"]],True,True)
>>> testing pi program 23
([[Output "x" "y",Input "y" "z" 0,Stop],[Input "x" "w" 0,Output "w" "u"]],True,True)
>>> testing pi program 24
([[Output "x" "y",Input "y" "z" 0,Input "z" "zz" 0],[Input "x" "w" 0,Output "w" "u"],[Output "u" "uu",Stop]],True,True)
>>> testing pi program 25
([[Output "x" "y",Input "y" "z" 0,Input "z" "zz" 0],[Input "x" "w" 0],[Input "x" "w" 0,Output "w" "u"],[Output "u" "uu",Stop]],True,False)
>>> testing pi program 26
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 27
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 28
([[Output "x" "y"],[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 29
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0],[Input "x" "y" 0]],True,True)
>>> testing pi program 30
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 31
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 32
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 33
([[Output "x" "w",Input "x" "y" 0,Output "y" "q"],[Input "x" "z" 0],[Output "x" "z"],[Input "w" "p" 0,Stop]],False,False)
>>> testing pi program 34
([[Output "x" "y",Input "x" "z" 0,Output "z" "q"],[Input "x" "z" 0],[Input "x" "z" 0],[Output "x" "z"],[Input "y" "u" 0,Stop]],False,False)
>>> testing pi program 35
([[Input "x" "w" 0,Output "x" "y",Input "y" "q" 0],[Input "x" "z" 0],[Output "x" "z"],[Output "w" "p",Stop]],False,False)
>>> testing pi program 36
([[Output "x" "z",Output "z" "a",Output "p" "q",Stop],[Output "x" "w",Output "w" "a",Input "p" "r" 0,Stop],[Input "x" "y" 0,Input "y" "u" 0],[Input "x" "l" 0,Input "l" "u" 0]],True,True)
timeout (skipped)
>>> failed!
> testing translation candidate 341 :
([takeCh^1,putS],[putCh^2,putCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 342 :
([takeCh^1,putS],[putCh^2,takeS,putCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 343 :
([takeCh^1,putS],[putCh^2,takeS,takeCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 344 :
([takeCh^1,putS],[putCh^2,takeCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 345 :
([takeCh^1,putS],[putCh^2,takeCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 346 :
([takeCh^1,putS],[putCh^1,putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 347 :
([takeCh^1,putS],[putCh^1,putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 348 :
([takeCh^1,putS],[putCh^1,takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 349 :
([takeCh^1,putS],[putCh^1,takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 350 :
([takeCh^1,putS],[putCh^1,takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 351 :
([takeCh^1,putS],[putCh^1,takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
ok
> testing translation candidate 352 :
([takeCh^1,putS],[takeS,putCh^2,putCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 353 :
([takeCh^1,putS],[takeS,putCh^2,takeCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 354 :
([takeCh^1,putS],[takeS,putCh^1,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 355 :
([takeCh^1,putS],[takeS,putCh^1,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 356 :
([takeCh^1,putS],[takeS,takeCh^2,putCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 357 :
([takeCh^1,putS],[takeS,takeCh^2,putCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 358 :
([takeCh^1,putS],[takeCh^2,putCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 359 :
([takeCh^1,putS],[takeCh^2,putCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 360 :
([takeCh^1,putS],[takeCh^2,putCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 361 :
([takeCh^1,putS],[takeCh^2,putCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 362 :
([takeCh^1,putS],[takeCh^2,takeS,putCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 363 :
([takeCh^1,putS],[takeCh^2,takeS,putCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 364 :
([takeCh^1,putS,putCh^2],[putCh^1,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 365 :
([takeCh^1,putS,putCh^2],[putCh^1,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 366 :
([takeCh^1,putS,putCh^2],[takeS,putCh^1,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 367 :
([takeCh^1,putS,putCh^2],[takeS,takeCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 368 :
([takeCh^1,putS,putCh^2],[takeCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 369 :
([takeCh^1,putS,putCh^2],[takeCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 370 :
([takeCh^1,putS,putCh^2,putCh^1],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 371 :
([takeCh^1,putS,putCh^2,putCh^1],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 372 :
([takeCh^1,putS,putCh^2,putCh^1,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 373 :
([takeCh^1,putS,putCh^2,takeCh^2],[putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 374 :
([takeCh^1,putS,putCh^2,takeCh^2],[takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 375 :
([takeCh^1,putS,putCh^2,takeCh^2,putCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 376 :
([takeCh^1,putS,putCh^1],[putCh^2,takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 377 :
([takeCh^1,putS,putCh^1],[putCh^2,takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 378 :
([takeCh^1,putS,putCh^1],[takeS,putCh^2,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 379 :
([takeCh^1,putS,putCh^1],[takeS,takeCh^2,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 380 :
([takeCh^1,putS,putCh^1],[takeCh^2,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 381 :
([takeCh^1,putS,putCh^1],[takeCh^2,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 382 :
([takeCh^1,putS,putCh^1,putCh^2],[takeS,takeCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 383 :
([takeCh^1,putS,putCh^1,putCh^2],[takeCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 384 :
([takeCh^1,putS,putCh^1,putCh^2,takeCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 385 :
([takeCh^1,putS,putCh^1,takeCh^2],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 386 :
([takeCh^1,putS,putCh^1,takeCh^2],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 387 :
([takeCh^1,putS,putCh^1,takeCh^2,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 388 :
([takeCh^1,putS,takeCh^2],[putCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 389 :
([takeCh^1,putS,takeCh^2],[putCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 390 :
([takeCh^1,putS,takeCh^2],[putCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 391 :
([takeCh^1,putS,takeCh^2],[putCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 9
([[Output "x" "y",Output "x" "z",Stop],[Input "x" "w" 0]],False,False)
>>> testing pi program 10
([[Input "x" "y" 0,Input "x" "z" 0,Stop],[Output "x" "w",Input "w" "z" 0]],False,False)
>>> testing pi program 11
([[Output "x" "z",Output "z" "a",Stop],[Output "x" "w",Output "w" "a",Stop],[Input "x" "y" 0,Input "y" "u" 0]],True,True)
>>> testing pi program 12
([[Output "x" "z",Output "z" "a"],[Input "x" "w" 0,Input "w" "b" 0,Stop],[Input "x" "y" 0,Output "x" "y"]],True,True)
>>> testing pi program 13
([[Input "x" "z" 0,Input "z" "a" 0,Stop],[Input "x" "w" 0,Input "w" "a" 0,Stop],[Output "x" "y",Output "y" "u"]],True,True)
>>> testing pi program 14
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Output "x" "y"]],True,True)
>>> testing pi program 15
([[Output "x" "y",Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Output "x" "y"]],True,True)
>>> testing pi program 16
([[Output "x" "y"],[Input "x" "y" 0],[Output "x" "y",Stop]],True,False)
>>> testing pi program 17
([[Output "x" "y",Output "x" "z",Output "z" "u",Stop],[Input "x" "w" 0],[Input "x" "ww" 0],[Output "x" "u"]],False,False)
>>> testing pi program 18
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Input "x" "u" 0]],False,False)
>>> testing pi program 19
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Input "x" "u" 0],[Input "x" "u" 0]],False,False)
>>> testing pi program 20
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "x" "u"]],False,False)
>>> testing pi program 21
([[Input "x" "y" 0,Input "x" "z" 0,Input "z" "u" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "w" "u"]],True,False)
>>> testing pi program 22
([[Input "x" "y" 0,Input "y" "z" 0,Stop],[Output "x" "w"],[Output "x" "ww"],[Output "w" "u"],[Output "ww" "u"]],True,True)
>>> testing pi program 23
([[Output "x" "y",Input "y" "z" 0,Stop],[Input "x" "w" 0,Output "w" "u"]],True,True)
>>> testing pi program 24
([[Output "x" "y",Input "y" "z" 0,Input "z" "zz" 0],[Input "x" "w" 0,Output "w" "u"],[Output "u" "uu",Stop]],True,True)
>>> testing pi program 25
([[Output "x" "y",Input "y" "z" 0,Input "z" "zz" 0],[Input "x" "w" 0],[Input "x" "w" 0,Output "w" "u"],[Output "u" "uu",Stop]],True,False)
>>> testing pi program 26
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 27
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 28
([[Output "x" "y"],[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 29
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0],[Input "x" "y" 0]],True,True)
>>> testing pi program 30
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 31
([[Output "x" "y"],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 32
([[Output "x" "y",Stop],[Output "x" "y",Stop],[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 33
([[Output "x" "w",Input "x" "y" 0,Output "y" "q"],[Input "x" "z" 0],[Output "x" "z"],[Input "w" "p" 0,Stop]],False,False)
>>> testing pi program 34
([[Output "x" "y",Input "x" "z" 0,Output "z" "q"],[Input "x" "z" 0],[Input "x" "z" 0],[Output "x" "z"],[Input "y" "u" 0,Stop]],False,False)
ok
> testing translation candidate 392 :
([takeCh^1,putS,takeCh^2],[takeS,putCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 393 :
([takeCh^1,putS,takeCh^2],[takeS,putCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 394 :
([takeCh^1,putS,takeCh^2,putCh^2],[putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 395 :
([takeCh^1,putS,takeCh^2,putCh^2],[takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 396 :
([takeCh^1,putS,takeCh^2,putCh^2,putCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 397 :
([takeCh^1,putS,takeCh^2,putCh^1],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 398 :
([takeCh^1,putS,takeCh^2,putCh^1],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 399 :
([takeCh^1,putS,takeCh^2,putCh^1,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 400 :
([takeCh^1,takeCh^2,putCh^2,putCh^1,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 401 :
([takeCh^1,takeCh^2,putCh^2,putS],[putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 402 :
([takeCh^1,takeCh^2,putCh^2,putS],[takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 403 :
([takeCh^1,takeCh^2,putCh^2,putS,putCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 404 :
([takeCh^1,takeCh^2,putCh^1,putCh^2,putS],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 405 :
([takeCh^1,takeCh^2,putCh^1,putS],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 406 :
([takeCh^1,takeCh^2,putCh^1,putS],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 407 :
([takeCh^1,takeCh^2,putCh^1,putS,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 408 :
([takeCh^1,takeCh^2,putS],[putCh^2,putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 409 :
([takeCh^1,takeCh^2,putS],[putCh^2,takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 410 :
([takeCh^1,takeCh^2,putS],[putCh^1,putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
>>> testing pi program 2
([[Output "x" "y"],[Input "x" "y" 0,Stop]],True,True)
>>> testing pi program 3
([[Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 4
([[Output "x" "y",Stop]],False,False)
>>> testing pi program 5
([[Output "x" "y",Stop],[Output "xx" "yy"],[Input "x" "y" 0]],True,True)
>>> testing pi program 6
([[Output "x" "y"],[Output "xx" "yy",Stop],[Input "x" "y" 0]],False,False)
>>> testing pi program 7
([[Output "x" "y",Stop],[Input "x" "y" 0],[Input "xxx" "yyyy" 0]],True,True)
>>> testing pi program 8
([[Output "x" "y",Input "x" "z" 0,Stop],[Input "x" "w" 0]],False,False)
ok
> testing translation candidate 411 :
([takeCh^1,takeCh^2,putS],[putCh^1,takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 412 :
([takeCh^1,takeCh^2,putS],[takeS,putCh^2,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 413 :
([takeCh^1,takeCh^2,putS],[takeS,putCh^1,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 414 :
([takeCh^1,takeCh^2,putS,putCh^2],[putCh^1,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 415 :
([takeCh^1,takeCh^2,putS,putCh^2],[takeS,putCh^1])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 416 :
([takeCh^1,takeCh^2,putS,putCh^2,putCh^1],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 417 :
([takeCh^1,takeCh^2,putS,putCh^1],[putCh^2,takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 418 :
([takeCh^1,takeCh^2,putS,putCh^1],[takeS,putCh^2])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> testing translation candidate 419 :
([takeCh^1,takeCh^2,putS,putCh^1,putCh^2],[takeS])
>>> testing pi program 0
([[Output "x" "y",Input "x" "y" 0,Stop]],False,False)
>>> testing pi program 1
([[Output "x" "y",Stop],[Input "x" "y" 0]],True,True)
ok
> done!
==================================================================
  Summary
==================================================================

Used counterexamples: [0,1,2,8,11,33,34]

Skipped translations (by timeout): [66,340]
66: ([putCh^1,putS,takeCh^2,takeCh^1],[takeS,putCh^2])
340: ([takeCh^1,putS],[putCh^2,putCh^1,takeS,takeCh^2])

Number of candidates: 420