diff options
Diffstat (limited to 'src/systemc/tests/systemc/datatypes/misc/concat/test07/golden/test07.log')
| -rw-r--r-- | src/systemc/tests/systemc/datatypes/misc/concat/test07/golden/test07.log | 36866 |
1 files changed, 36866 insertions, 0 deletions
diff --git a/src/systemc/tests/systemc/datatypes/misc/concat/test07/golden/test07.log b/src/systemc/tests/systemc/datatypes/misc/concat/test07/golden/test07.log new file mode 100644 index 000000000..17d6ba2fb --- /dev/null +++ b/src/systemc/tests/systemc/datatypes/misc/concat/test07/golden/test07.log @@ -0,0 +1,36866 @@ +SystemC Simulation + +[64,64]: + int 0fedcba9876543210aaaaaaaa55555555 <- ( fedcba9876543210 , aaaaaaaa55555555 ) + +[64,63]: + int 7f6e5d4c3b2a19082aaaaaaa55555555 <- ( fedcba9876543210 , 2aaaaaaa55555555 ) + +[64,62]: + int 3fb72ea61d950c842aaaaaaa55555555 <- ( fedcba9876543210 , eaaaaaaa55555555 ) + +[64,61]: + int 1fdb97530eca86420aaaaaaa55555555 <- ( fedcba9876543210 , 0aaaaaaa55555555 ) + +[64,60]: + int 0fedcba9876543210aaaaaaa55555555 <- ( fedcba9876543210 , aaaaaaa55555555 ) + +[64,59]: + int 7f6e5d4c3b2a19082aaaaaa55555555 <- ( fedcba9876543210 , 2aaaaaa55555555 ) + +[64,58]: + int 3fb72ea61d950c842aaaaaa55555555 <- ( fedcba9876543210 , eaaaaaa55555555 ) + +[64,57]: + int 1fdb97530eca86420aaaaaa55555555 <- ( fedcba9876543210 , 0aaaaaa55555555 ) + +[64,56]: + int 0fedcba9876543210aaaaaa55555555 <- ( fedcba9876543210 , aaaaaa55555555 ) + +[64,55]: + int 7f6e5d4c3b2a19082aaaaa55555555 <- ( fedcba9876543210 , 2aaaaa55555555 ) + +[64,54]: + int 3fb72ea61d950c842aaaaa55555555 <- ( fedcba9876543210 , eaaaaa55555555 ) + +[64,53]: + int 1fdb97530eca86420aaaaa55555555 <- ( fedcba9876543210 , 0aaaaa55555555 ) + +[64,52]: + int 0fedcba9876543210aaaaa55555555 <- ( fedcba9876543210 , aaaaa55555555 ) + +[64,51]: + int 7f6e5d4c3b2a19082aaaa55555555 <- ( fedcba9876543210 , 2aaaa55555555 ) + +[64,50]: + int 3fb72ea61d950c842aaaa55555555 <- ( fedcba9876543210 , eaaaa55555555 ) + +[64,49]: + int 1fdb97530eca86420aaaa55555555 <- ( fedcba9876543210 , 0aaaa55555555 ) + +[64,48]: + int 0fedcba9876543210aaaa55555555 <- ( fedcba9876543210 , aaaa55555555 ) + +[64,47]: + int 7f6e5d4c3b2a19082aaa55555555 <- ( fedcba9876543210 , 2aaa55555555 ) + +[64,46]: + int 3fb72ea61d950c842aaa55555555 <- ( fedcba9876543210 , eaaa55555555 ) + +[64,45]: + int 1fdb97530eca86420aaa55555555 <- ( fedcba9876543210 , 0aaa55555555 ) + +[64,44]: + int 0fedcba9876543210aaa55555555 <- ( fedcba9876543210 , aaa55555555 ) + +[64,43]: + int 7f6e5d4c3b2a19082aa55555555 <- ( fedcba9876543210 , 2aa55555555 ) + +[64,42]: + int 3fb72ea61d950c842aa55555555 <- ( fedcba9876543210 , eaa55555555 ) + +[64,41]: + int 1fdb97530eca86420aa55555555 <- ( fedcba9876543210 , 0aa55555555 ) + +[64,40]: + int 0fedcba9876543210aa55555555 <- ( fedcba9876543210 , aa55555555 ) + +[64,39]: + int 7f6e5d4c3b2a19082a55555555 <- ( fedcba9876543210 , 2a55555555 ) + +[64,38]: + int 3fb72ea61d950c842a55555555 <- ( fedcba9876543210 , ea55555555 ) + +[64,37]: + int 1fdb97530eca86420a55555555 <- ( fedcba9876543210 , 0a55555555 ) + +[64,36]: + int 0fedcba9876543210a55555555 <- ( fedcba9876543210 , a55555555 ) + +[64,35]: + int 7f6e5d4c3b2a1908255555555 <- ( fedcba9876543210 , 255555555 ) + +[64,34]: + int 3fb72ea61d950c84255555555 <- ( fedcba9876543210 , e55555555 ) + +[64,33]: + int 1fdb97530eca8642055555555 <- ( fedcba9876543210 , 055555555 ) + +[64,32]: + int 0fedcba987654321055555555 <- ( fedcba9876543210 , 55555555 ) + +[64,31]: + int 7f6e5d4c3b2a190855555555 <- ( fedcba9876543210 , d5555555 ) + +[64,30]: + int 3fb72ea61d950c8415555555 <- ( fedcba9876543210 , 15555555 ) + +[64,29]: + int 1fdb97530eca864215555555 <- ( fedcba9876543210 , f5555555 ) + +[64,28]: + int 0fedcba98765432105555555 <- ( fedcba9876543210 , 5555555 ) + +[64,27]: + int 7f6e5d4c3b2a19085555555 <- ( fedcba9876543210 , d555555 ) + +[64,26]: + int 3fb72ea61d950c841555555 <- ( fedcba9876543210 , 1555555 ) + +[64,25]: + int 1fdb97530eca86421555555 <- ( fedcba9876543210 , f555555 ) + +[64,24]: + int 0fedcba9876543210555555 <- ( fedcba9876543210 , 555555 ) + +[64,23]: + int 7f6e5d4c3b2a1908555555 <- ( fedcba9876543210 , d55555 ) + +[64,22]: + int 3fb72ea61d950c84155555 <- ( fedcba9876543210 , 155555 ) + +[64,21]: + int 1fdb97530eca8642155555 <- ( fedcba9876543210 , f55555 ) + +[64,20]: + int 0fedcba987654321055555 <- ( fedcba9876543210 , 55555 ) + +[64,19]: + int 7f6e5d4c3b2a190855555 <- ( fedcba9876543210 , d5555 ) + +[64,18]: + int 3fb72ea61d950c8415555 <- ( fedcba9876543210 , 15555 ) + +[64,17]: + int 1fdb97530eca864215555 <- ( fedcba9876543210 , f5555 ) + +[64,16]: + int 0fedcba98765432105555 <- ( fedcba9876543210 , 5555 ) + +[64,15]: + int 7f6e5d4c3b2a19085555 <- ( fedcba9876543210 , d555 ) + +[64,14]: + int 3fb72ea61d950c841555 <- ( fedcba9876543210 , 1555 ) + +[64,13]: + int 1fdb97530eca86421555 <- ( fedcba9876543210 , f555 ) + +[64,12]: + int 0fedcba9876543210555 <- ( fedcba9876543210 , 555 ) + +[64,11]: + int 7f6e5d4c3b2a1908555 <- ( fedcba9876543210 , d55 ) + +[64,10]: + int 3fb72ea61d950c84155 <- ( fedcba9876543210 , 155 ) + +[64,9]: + int 1fdb97530eca8642155 <- ( fedcba9876543210 , f55 ) + +[64,8]: + int 0fedcba987654321055 <- ( fedcba9876543210 , 55 ) + +[64,7]: + int 7f6e5d4c3b2a190855 <- ( fedcba9876543210 , d5 ) + +[64,6]: + int 3fb72ea61d950c8415 <- ( fedcba9876543210 , 15 ) + +[64,5]: + int 1fdb97530eca864215 <- ( fedcba9876543210 , f5 ) + +[64,4]: + int 0fedcba98765432105 <- ( fedcba9876543210 , 5 ) + +[64,3]: + int 7f6e5d4c3b2a19085 <- ( fedcba9876543210 , d ) + +[64,2]: + int 3fb72ea61d950c841 <- ( fedcba9876543210 , 1 ) + +[64,1]: + int 1fdb97530eca86421 <- ( fedcba9876543210 , f ) + +[63,64]: + int 7edcba9876543210aaaaaaaa55555555 <- ( fedcba9876543210 , aaaaaaaa55555555 ) + +[63,63]: + int 3f6e5d4c3b2a19082aaaaaaa55555555 <- ( fedcba9876543210 , 2aaaaaaa55555555 ) + +[63,62]: + int 1fb72ea61d950c842aaaaaaa55555555 <- ( fedcba9876543210 , eaaaaaaa55555555 ) + +[63,61]: + int 0fdb97530eca86420aaaaaaa55555555 <- ( fedcba9876543210 , 0aaaaaaa55555555 ) + +[63,60]: + int 7edcba9876543210aaaaaaa55555555 <- ( fedcba9876543210 , aaaaaaa55555555 ) + +[63,59]: + int 3f6e5d4c3b2a19082aaaaaa55555555 <- ( fedcba9876543210 , 2aaaaaa55555555 ) + +[63,58]: + int 1fb72ea61d950c842aaaaaa55555555 <- ( fedcba9876543210 , eaaaaaa55555555 ) + +[63,57]: + int 0fdb97530eca86420aaaaaa55555555 <- ( fedcba9876543210 , 0aaaaaa55555555 ) + +[63,56]: + int 7edcba9876543210aaaaaa55555555 <- ( fedcba9876543210 , aaaaaa55555555 ) + +[63,55]: + int 3f6e5d4c3b2a19082aaaaa55555555 <- ( fedcba9876543210 , 2aaaaa55555555 ) + +[63,54]: + int 1fb72ea61d950c842aaaaa55555555 <- ( fedcba9876543210 , eaaaaa55555555 ) + +[63,53]: + int 0fdb97530eca86420aaaaa55555555 <- ( fedcba9876543210 , 0aaaaa55555555 ) + +[63,52]: + int 7edcba9876543210aaaaa55555555 <- ( fedcba9876543210 , aaaaa55555555 ) + +[63,51]: + int 3f6e5d4c3b2a19082aaaa55555555 <- ( fedcba9876543210 , 2aaaa55555555 ) + +[63,50]: + int 1fb72ea61d950c842aaaa55555555 <- ( fedcba9876543210 , eaaaa55555555 ) + +[63,49]: + int 0fdb97530eca86420aaaa55555555 <- ( fedcba9876543210 , 0aaaa55555555 ) + +[63,48]: + int 7edcba9876543210aaaa55555555 <- ( fedcba9876543210 , aaaa55555555 ) + +[63,47]: + int 3f6e5d4c3b2a19082aaa55555555 <- ( fedcba9876543210 , 2aaa55555555 ) + +[63,46]: + int 1fb72ea61d950c842aaa55555555 <- ( fedcba9876543210 , eaaa55555555 ) + +[63,45]: + int 0fdb97530eca86420aaa55555555 <- ( fedcba9876543210 , 0aaa55555555 ) + +[63,44]: + int 7edcba9876543210aaa55555555 <- ( fedcba9876543210 , aaa55555555 ) + +[63,43]: + int 3f6e5d4c3b2a19082aa55555555 <- ( fedcba9876543210 , 2aa55555555 ) + +[63,42]: + int 1fb72ea61d950c842aa55555555 <- ( fedcba9876543210 , eaa55555555 ) + +[63,41]: + int 0fdb97530eca86420aa55555555 <- ( fedcba9876543210 , 0aa55555555 ) + +[63,40]: + int 7edcba9876543210aa55555555 <- ( fedcba9876543210 , aa55555555 ) + +[63,39]: + int 3f6e5d4c3b2a19082a55555555 <- ( fedcba9876543210 , 2a55555555 ) + +[63,38]: + int 1fb72ea61d950c842a55555555 <- ( fedcba9876543210 , ea55555555 ) + +[63,37]: + int 0fdb97530eca86420a55555555 <- ( fedcba9876543210 , 0a55555555 ) + +[63,36]: + int 7edcba9876543210a55555555 <- ( fedcba9876543210 , a55555555 ) + +[63,35]: + int 3f6e5d4c3b2a1908255555555 <- ( fedcba9876543210 , 255555555 ) + +[63,34]: + int 1fb72ea61d950c84255555555 <- ( fedcba9876543210 , e55555555 ) + +[63,33]: + int 0fdb97530eca8642055555555 <- ( fedcba9876543210 , 055555555 ) + +[63,32]: + int 7edcba987654321055555555 <- ( fedcba9876543210 , 55555555 ) + +[63,31]: + int 3f6e5d4c3b2a190855555555 <- ( fedcba9876543210 , d5555555 ) + +[63,30]: + int 1fb72ea61d950c8415555555 <- ( fedcba9876543210 , 15555555 ) + +[63,29]: + int 0fdb97530eca864215555555 <- ( fedcba9876543210 , f5555555 ) + +[63,28]: + int 7edcba98765432105555555 <- ( fedcba9876543210 , 5555555 ) + +[63,27]: + int 3f6e5d4c3b2a19085555555 <- ( fedcba9876543210 , d555555 ) + +[63,26]: + int 1fb72ea61d950c841555555 <- ( fedcba9876543210 , 1555555 ) + +[63,25]: + int 0fdb97530eca86421555555 <- ( fedcba9876543210 , f555555 ) + +[63,24]: + int 7edcba9876543210555555 <- ( fedcba9876543210 , 555555 ) + +[63,23]: + int 3f6e5d4c3b2a1908555555 <- ( fedcba9876543210 , d55555 ) + +[63,22]: + int 1fb72ea61d950c84155555 <- ( fedcba9876543210 , 155555 ) + +[63,21]: + int 0fdb97530eca8642155555 <- ( fedcba9876543210 , f55555 ) + +[63,20]: + int 7edcba987654321055555 <- ( fedcba9876543210 , 55555 ) + +[63,19]: + int 3f6e5d4c3b2a190855555 <- ( fedcba9876543210 , d5555 ) + +[63,18]: + int 1fb72ea61d950c8415555 <- ( fedcba9876543210 , 15555 ) + +[63,17]: + int 0fdb97530eca864215555 <- ( fedcba9876543210 , f5555 ) + +[63,16]: + int 7edcba98765432105555 <- ( fedcba9876543210 , 5555 ) + +[63,15]: + int 3f6e5d4c3b2a19085555 <- ( fedcba9876543210 , d555 ) + +[63,14]: + int 1fb72ea61d950c841555 <- ( fedcba9876543210 , 1555 ) + +[63,13]: + int 0fdb97530eca86421555 <- ( fedcba9876543210 , f555 ) + +[63,12]: + int 7edcba9876543210555 <- ( fedcba9876543210 , 555 ) + +[63,11]: + int 3f6e5d4c3b2a1908555 <- ( fedcba9876543210 , d55 ) + +[63,10]: + int 1fb72ea61d950c84155 <- ( fedcba9876543210 , 155 ) + +[63,9]: + int 0fdb97530eca8642155 <- ( fedcba9876543210 , f55 ) + +[63,8]: + int 7edcba987654321055 <- ( fedcba9876543210 , 55 ) + +[63,7]: + int 3f6e5d4c3b2a190855 <- ( fedcba9876543210 , d5 ) + +[63,6]: + int 1fb72ea61d950c8415 <- ( fedcba9876543210 , 15 ) + +[63,5]: + int 0fdb97530eca864215 <- ( fedcba9876543210 , f5 ) + +[63,4]: + int 7edcba98765432105 <- ( fedcba9876543210 , 5 ) + +[63,3]: + int 3f6e5d4c3b2a19085 <- ( fedcba9876543210 , d ) + +[63,2]: + int 1fb72ea61d950c841 <- ( fedcba9876543210 , 1 ) + +[63,1]: + int 0fdb97530eca86421 <- ( fedcba9876543210 , f ) + +[62,64]: + int 3edcba9876543210aaaaaaaa55555555 <- ( fedcba9876543210 , aaaaaaaa55555555 ) + +[62,63]: + int 1f6e5d4c3b2a19082aaaaaaa55555555 <- ( fedcba9876543210 , 2aaaaaaa55555555 ) + +[62,62]: + int 0fb72ea61d950c842aaaaaaa55555555 <- ( fedcba9876543210 , eaaaaaaa55555555 ) + +[62,61]: + int 7db97530eca86420aaaaaaa55555555 <- ( fedcba9876543210 , 0aaaaaaa55555555 ) + +[62,60]: + int 3edcba9876543210aaaaaaa55555555 <- ( fedcba9876543210 , aaaaaaa55555555 ) + +[62,59]: + int 1f6e5d4c3b2a19082aaaaaa55555555 <- ( fedcba9876543210 , 2aaaaaa55555555 ) + +[62,58]: + int 0fb72ea61d950c842aaaaaa55555555 <- ( fedcba9876543210 , eaaaaaa55555555 ) + +[62,57]: + int 7db97530eca86420aaaaaa55555555 <- ( fedcba9876543210 , 0aaaaaa55555555 ) + +[62,56]: + int 3edcba9876543210aaaaaa55555555 <- ( fedcba9876543210 , aaaaaa55555555 ) + +[62,55]: + int 1f6e5d4c3b2a19082aaaaa55555555 <- ( fedcba9876543210 , 2aaaaa55555555 ) + +[62,54]: + int 0fb72ea61d950c842aaaaa55555555 <- ( fedcba9876543210 , eaaaaa55555555 ) + +[62,53]: + int 7db97530eca86420aaaaa55555555 <- ( fedcba9876543210 , 0aaaaa55555555 ) + +[62,52]: + int 3edcba9876543210aaaaa55555555 <- ( fedcba9876543210 , aaaaa55555555 ) + +[62,51]: + int 1f6e5d4c3b2a19082aaaa55555555 <- ( fedcba9876543210 , 2aaaa55555555 ) + +[62,50]: + int 0fb72ea61d950c842aaaa55555555 <- ( fedcba9876543210 , eaaaa55555555 ) + +[62,49]: + int 7db97530eca86420aaaa55555555 <- ( fedcba9876543210 , 0aaaa55555555 ) + +[62,48]: + int 3edcba9876543210aaaa55555555 <- ( fedcba9876543210 , aaaa55555555 ) + +[62,47]: + int 1f6e5d4c3b2a19082aaa55555555 <- ( fedcba9876543210 , 2aaa55555555 ) + +[62,46]: + int 0fb72ea61d950c842aaa55555555 <- ( fedcba9876543210 , eaaa55555555 ) + +[62,45]: + int 7db97530eca86420aaa55555555 <- ( fedcba9876543210 , 0aaa55555555 ) + +[62,44]: + int 3edcba9876543210aaa55555555 <- ( fedcba9876543210 , aaa55555555 ) + +[62,43]: + int 1f6e5d4c3b2a19082aa55555555 <- ( fedcba9876543210 , 2aa55555555 ) + +[62,42]: + int 0fb72ea61d950c842aa55555555 <- ( fedcba9876543210 , eaa55555555 ) + +[62,41]: + int 7db97530eca86420aa55555555 <- ( fedcba9876543210 , 0aa55555555 ) + +[62,40]: + int 3edcba9876543210aa55555555 <- ( fedcba9876543210 , aa55555555 ) + +[62,39]: + int 1f6e5d4c3b2a19082a55555555 <- ( fedcba9876543210 , 2a55555555 ) + +[62,38]: + int 0fb72ea61d950c842a55555555 <- ( fedcba9876543210 , ea55555555 ) + +[62,37]: + int 7db97530eca86420a55555555 <- ( fedcba9876543210 , 0a55555555 ) + +[62,36]: + int 3edcba9876543210a55555555 <- ( fedcba9876543210 , a55555555 ) + +[62,35]: + int 1f6e5d4c3b2a1908255555555 <- ( fedcba9876543210 , 255555555 ) + +[62,34]: + int 0fb72ea61d950c84255555555 <- ( fedcba9876543210 , e55555555 ) + +[62,33]: + int 7db97530eca8642055555555 <- ( fedcba9876543210 , 055555555 ) + +[62,32]: + int 3edcba987654321055555555 <- ( fedcba9876543210 , 55555555 ) + +[62,31]: + int 1f6e5d4c3b2a190855555555 <- ( fedcba9876543210 , d5555555 ) + +[62,30]: + int 0fb72ea61d950c8415555555 <- ( fedcba9876543210 , 15555555 ) + +[62,29]: + int 7db97530eca864215555555 <- ( fedcba9876543210 , f5555555 ) + +[62,28]: + int 3edcba98765432105555555 <- ( fedcba9876543210 , 5555555 ) + +[62,27]: + int 1f6e5d4c3b2a19085555555 <- ( fedcba9876543210 , d555555 ) + +[62,26]: + int 0fb72ea61d950c841555555 <- ( fedcba9876543210 , 1555555 ) + +[62,25]: + int 7db97530eca86421555555 <- ( fedcba9876543210 , f555555 ) + +[62,24]: + int 3edcba9876543210555555 <- ( fedcba9876543210 , 555555 ) + +[62,23]: + int 1f6e5d4c3b2a1908555555 <- ( fedcba9876543210 , d55555 ) + +[62,22]: + int 0fb72ea61d950c84155555 <- ( fedcba9876543210 , 155555 ) + +[62,21]: + int 7db97530eca8642155555 <- ( fedcba9876543210 , f55555 ) + +[62,20]: + int 3edcba987654321055555 <- ( fedcba9876543210 , 55555 ) + +[62,19]: + int 1f6e5d4c3b2a190855555 <- ( fedcba9876543210 , d5555 ) + +[62,18]: + int 0fb72ea61d950c8415555 <- ( fedcba9876543210 , 15555 ) + +[62,17]: + int 7db97530eca864215555 <- ( fedcba9876543210 , f5555 ) + +[62,16]: + int 3edcba98765432105555 <- ( fedcba9876543210 , 5555 ) + +[62,15]: + int 1f6e5d4c3b2a19085555 <- ( fedcba9876543210 , d555 ) + +[62,14]: + int 0fb72ea61d950c841555 <- ( fedcba9876543210 , 1555 ) + +[62,13]: + int 7db97530eca86421555 <- ( fedcba9876543210 , f555 ) + +[62,12]: + int 3edcba9876543210555 <- ( fedcba9876543210 , 555 ) + +[62,11]: + int 1f6e5d4c3b2a1908555 <- ( fedcba9876543210 , d55 ) + +[62,10]: + int 0fb72ea61d950c84155 <- ( fedcba9876543210 , 155 ) + +[62,9]: + int 7db97530eca8642155 <- ( fedcba9876543210 , f55 ) + +[62,8]: + int 3edcba987654321055 <- ( fedcba9876543210 , 55 ) + +[62,7]: + int 1f6e5d4c3b2a190855 <- ( fedcba9876543210 , d5 ) + +[62,6]: + int 0fb72ea61d950c8415 <- ( fedcba9876543210 , 15 ) + +[62,5]: + int 7db97530eca864215 <- ( fedcba9876543210 , f5 ) + +[62,4]: + int 3edcba98765432105 <- ( fedcba9876543210 , 5 ) + +[62,3]: + int 1f6e5d4c3b2a19085 <- ( fedcba9876543210 , d ) + +[62,2]: + int 0fb72ea61d950c841 <- ( fedcba9876543210 , 1 ) + +[62,1]: + int 7db97530eca86421 <- ( fedcba9876543210 , f ) + +[61,64]: + int 1edcba9876543210aaaaaaaa55555555 <- ( fedcba9876543210 , aaaaaaaa55555555 ) + +[61,63]: + int 0f6e5d4c3b2a19082aaaaaaa55555555 <- ( fedcba9876543210 , 2aaaaaaa55555555 ) + +[61,62]: + int 7b72ea61d950c842aaaaaaa55555555 <- ( fedcba9876543210 , eaaaaaaa55555555 ) + +[61,61]: + int 3db97530eca86420aaaaaaa55555555 <- ( fedcba9876543210 , 0aaaaaaa55555555 ) + +[61,60]: + int 1edcba9876543210aaaaaaa55555555 <- ( fedcba9876543210 , aaaaaaa55555555 ) + +[61,59]: + int 0f6e5d4c3b2a19082aaaaaa55555555 <- ( fedcba9876543210 , 2aaaaaa55555555 ) + +[61,58]: + int 7b72ea61d950c842aaaaaa55555555 <- ( fedcba9876543210 , eaaaaaa55555555 ) + +[61,57]: + int 3db97530eca86420aaaaaa55555555 <- ( fedcba9876543210 , 0aaaaaa55555555 ) + +[61,56]: + int 1edcba9876543210aaaaaa55555555 <- ( fedcba9876543210 , aaaaaa55555555 ) + +[61,55]: + int 0f6e5d4c3b2a19082aaaaa55555555 <- ( fedcba9876543210 , 2aaaaa55555555 ) + +[61,54]: + int 7b72ea61d950c842aaaaa55555555 <- ( fedcba9876543210 , eaaaaa55555555 ) + +[61,53]: + int 3db97530eca86420aaaaa55555555 <- ( fedcba9876543210 , 0aaaaa55555555 ) + +[61,52]: + int 1edcba9876543210aaaaa55555555 <- ( fedcba9876543210 , aaaaa55555555 ) + +[61,51]: + int 0f6e5d4c3b2a19082aaaa55555555 <- ( fedcba9876543210 , 2aaaa55555555 ) + +[61,50]: + int 7b72ea61d950c842aaaa55555555 <- ( fedcba9876543210 , eaaaa55555555 ) + +[61,49]: + int 3db97530eca86420aaaa55555555 <- ( fedcba9876543210 , 0aaaa55555555 ) + +[61,48]: + int 1edcba9876543210aaaa55555555 <- ( fedcba9876543210 , aaaa55555555 ) + +[61,47]: + int 0f6e5d4c3b2a19082aaa55555555 <- ( fedcba9876543210 , 2aaa55555555 ) + +[61,46]: + int 7b72ea61d950c842aaa55555555 <- ( fedcba9876543210 , eaaa55555555 ) + +[61,45]: + int 3db97530eca86420aaa55555555 <- ( fedcba9876543210 , 0aaa55555555 ) + +[61,44]: + int 1edcba9876543210aaa55555555 <- ( fedcba9876543210 , aaa55555555 ) + +[61,43]: + int 0f6e5d4c3b2a19082aa55555555 <- ( fedcba9876543210 , 2aa55555555 ) + +[61,42]: + int 7b72ea61d950c842aa55555555 <- ( fedcba9876543210 , eaa55555555 ) + +[61,41]: + int 3db97530eca86420aa55555555 <- ( fedcba9876543210 , 0aa55555555 ) + +[61,40]: + int 1edcba9876543210aa55555555 <- ( fedcba9876543210 , aa55555555 ) + +[61,39]: + int 0f6e5d4c3b2a19082a55555555 <- ( fedcba9876543210 , 2a55555555 ) + +[61,38]: + int 7b72ea61d950c842a55555555 <- ( fedcba9876543210 , ea55555555 ) + +[61,37]: + int 3db97530eca86420a55555555 <- ( fedcba9876543210 , 0a55555555 ) + +[61,36]: + int 1edcba9876543210a55555555 <- ( fedcba9876543210 , a55555555 ) + +[61,35]: + int 0f6e5d4c3b2a1908255555555 <- ( fedcba9876543210 , 255555555 ) + +[61,34]: + int 7b72ea61d950c84255555555 <- ( fedcba9876543210 , e55555555 ) + +[61,33]: + int 3db97530eca8642055555555 <- ( fedcba9876543210 , 055555555 ) + +[61,32]: + int 1edcba987654321055555555 <- ( fedcba9876543210 , 55555555 ) + +[61,31]: + int 0f6e5d4c3b2a190855555555 <- ( fedcba9876543210 , d5555555 ) + +[61,30]: + int 7b72ea61d950c8415555555 <- ( fedcba9876543210 , 15555555 ) + +[61,29]: + int 3db97530eca864215555555 <- ( fedcba9876543210 , f5555555 ) + +[61,28]: + int 1edcba98765432105555555 <- ( fedcba9876543210 , 5555555 ) + +[61,27]: + int 0f6e5d4c3b2a19085555555 <- ( fedcba9876543210 , d555555 ) + +[61,26]: + int 7b72ea61d950c841555555 <- ( fedcba9876543210 , 1555555 ) + +[61,25]: + int 3db97530eca86421555555 <- ( fedcba9876543210 , f555555 ) + +[61,24]: + int 1edcba9876543210555555 <- ( fedcba9876543210 , 555555 ) + +[61,23]: + int 0f6e5d4c3b2a1908555555 <- ( fedcba9876543210 , d55555 ) + +[61,22]: + int 7b72ea61d950c84155555 <- ( fedcba9876543210 , 155555 ) + +[61,21]: + int 3db97530eca8642155555 <- ( fedcba9876543210 , f55555 ) + +[61,20]: + int 1edcba987654321055555 <- ( fedcba9876543210 , 55555 ) + +[61,19]: + int 0f6e5d4c3b2a190855555 <- ( fedcba9876543210 , d5555 ) + +[61,18]: + int 7b72ea61d950c8415555 <- ( fedcba9876543210 , 15555 ) + +[61,17]: + int 3db97530eca864215555 <- ( fedcba9876543210 , f5555 ) + +[61,16]: + int 1edcba98765432105555 <- ( fedcba9876543210 , 5555 ) + +[61,15]: + int 0f6e5d4c3b2a19085555 <- ( fedcba9876543210 , d555 ) + +[61,14]: + int 7b72ea61d950c841555 <- ( fedcba9876543210 , 1555 ) + +[61,13]: + int 3db97530eca86421555 <- ( fedcba9876543210 , f555 ) + +[61,12]: + int 1edcba9876543210555 <- ( fedcba9876543210 , 555 ) + +[61,11]: + int 0f6e5d4c3b2a1908555 <- ( fedcba9876543210 , d55 ) + +[61,10]: + int 7b72ea61d950c84155 <- ( fedcba9876543210 , 155 ) + +[61,9]: + int 3db97530eca8642155 <- ( fedcba9876543210 , f55 ) + +[61,8]: + int 1edcba987654321055 <- ( fedcba9876543210 , 55 ) + +[61,7]: + int 0f6e5d4c3b2a190855 <- ( fedcba9876543210 , d5 ) + +[61,6]: + int 7b72ea61d950c8415 <- ( fedcba9876543210 , 15 ) + +[61,5]: + int 3db97530eca864215 <- ( fedcba9876543210 , f5 ) + +[61,4]: + int 1edcba98765432105 <- ( fedcba9876543210 , 5 ) + +[61,3]: + int 0f6e5d4c3b2a19085 <- ( fedcba9876543210 , d ) + +[61,2]: + int 7b72ea61d950c841 <- ( fedcba9876543210 , 1 ) + +[61,1]: + int 3db97530eca86421 <- ( fedcba9876543210 , f ) + +[60,64]: + int 0edcba9876543210aaaaaaaa55555555 <- ( edcba9876543210 , aaaaaaaa55555555 ) + +[60,63]: + int 76e5d4c3b2a19082aaaaaaa55555555 <- ( edcba9876543210 , 2aaaaaaa55555555 ) + +[60,62]: + int 3b72ea61d950c842aaaaaaa55555555 <- ( edcba9876543210 , eaaaaaaa55555555 ) + +[60,61]: + int 1db97530eca86420aaaaaaa55555555 <- ( edcba9876543210 , 0aaaaaaa55555555 ) + +[60,60]: + int 0edcba9876543210aaaaaaa55555555 <- ( edcba9876543210 , aaaaaaa55555555 ) + +[60,59]: + int 76e5d4c3b2a19082aaaaaa55555555 <- ( edcba9876543210 , 2aaaaaa55555555 ) + +[60,58]: + int 3b72ea61d950c842aaaaaa55555555 <- ( edcba9876543210 , eaaaaaa55555555 ) + +[60,57]: + int 1db97530eca86420aaaaaa55555555 <- ( edcba9876543210 , 0aaaaaa55555555 ) + +[60,56]: + int 0edcba9876543210aaaaaa55555555 <- ( edcba9876543210 , aaaaaa55555555 ) + +[60,55]: + int 76e5d4c3b2a19082aaaaa55555555 <- ( edcba9876543210 , 2aaaaa55555555 ) + +[60,54]: + int 3b72ea61d950c842aaaaa55555555 <- ( edcba9876543210 , eaaaaa55555555 ) + +[60,53]: + int 1db97530eca86420aaaaa55555555 <- ( edcba9876543210 , 0aaaaa55555555 ) + +[60,52]: + int 0edcba9876543210aaaaa55555555 <- ( edcba9876543210 , aaaaa55555555 ) + +[60,51]: + int 76e5d4c3b2a19082aaaa55555555 <- ( edcba9876543210 , 2aaaa55555555 ) + +[60,50]: + int 3b72ea61d950c842aaaa55555555 <- ( edcba9876543210 , eaaaa55555555 ) + +[60,49]: + int 1db97530eca86420aaaa55555555 <- ( edcba9876543210 , 0aaaa55555555 ) + +[60,48]: + int 0edcba9876543210aaaa55555555 <- ( edcba9876543210 , aaaa55555555 ) + +[60,47]: + int 76e5d4c3b2a19082aaa55555555 <- ( edcba9876543210 , 2aaa55555555 ) + +[60,46]: + int 3b72ea61d950c842aaa55555555 <- ( edcba9876543210 , eaaa55555555 ) + +[60,45]: + int 1db97530eca86420aaa55555555 <- ( edcba9876543210 , 0aaa55555555 ) + +[60,44]: + int 0edcba9876543210aaa55555555 <- ( edcba9876543210 , aaa55555555 ) + +[60,43]: + int 76e5d4c3b2a19082aa55555555 <- ( edcba9876543210 , 2aa55555555 ) + +[60,42]: + int 3b72ea61d950c842aa55555555 <- ( edcba9876543210 , eaa55555555 ) + +[60,41]: + int 1db97530eca86420aa55555555 <- ( edcba9876543210 , 0aa55555555 ) + +[60,40]: + int 0edcba9876543210aa55555555 <- ( edcba9876543210 , aa55555555 ) + +[60,39]: + int 76e5d4c3b2a19082a55555555 <- ( edcba9876543210 , 2a55555555 ) + +[60,38]: + int 3b72ea61d950c842a55555555 <- ( edcba9876543210 , ea55555555 ) + +[60,37]: + int 1db97530eca86420a55555555 <- ( edcba9876543210 , 0a55555555 ) + +[60,36]: + int 0edcba9876543210a55555555 <- ( edcba9876543210 , a55555555 ) + +[60,35]: + int 76e5d4c3b2a1908255555555 <- ( edcba9876543210 , 255555555 ) + +[60,34]: + int 3b72ea61d950c84255555555 <- ( edcba9876543210 , e55555555 ) + +[60,33]: + int 1db97530eca8642055555555 <- ( edcba9876543210 , 055555555 ) + +[60,32]: + int 0edcba987654321055555555 <- ( edcba9876543210 , 55555555 ) + +[60,31]: + int 76e5d4c3b2a190855555555 <- ( edcba9876543210 , d5555555 ) + +[60,30]: + int 3b72ea61d950c8415555555 <- ( edcba9876543210 , 15555555 ) + +[60,29]: + int 1db97530eca864215555555 <- ( edcba9876543210 , f5555555 ) + +[60,28]: + int 0edcba98765432105555555 <- ( edcba9876543210 , 5555555 ) + +[60,27]: + int 76e5d4c3b2a19085555555 <- ( edcba9876543210 , d555555 ) + +[60,26]: + int 3b72ea61d950c841555555 <- ( edcba9876543210 , 1555555 ) + +[60,25]: + int 1db97530eca86421555555 <- ( edcba9876543210 , f555555 ) + +[60,24]: + int 0edcba9876543210555555 <- ( edcba9876543210 , 555555 ) + +[60,23]: + int 76e5d4c3b2a1908555555 <- ( edcba9876543210 , d55555 ) + +[60,22]: + int 3b72ea61d950c84155555 <- ( edcba9876543210 , 155555 ) + +[60,21]: + int 1db97530eca8642155555 <- ( edcba9876543210 , f55555 ) + +[60,20]: + int 0edcba987654321055555 <- ( edcba9876543210 , 55555 ) + +[60,19]: + int 76e5d4c3b2a190855555 <- ( edcba9876543210 , d5555 ) + +[60,18]: + int 3b72ea61d950c8415555 <- ( edcba9876543210 , 15555 ) + +[60,17]: + int 1db97530eca864215555 <- ( edcba9876543210 , f5555 ) + +[60,16]: + int 0edcba98765432105555 <- ( edcba9876543210 , 5555 ) + +[60,15]: + int 76e5d4c3b2a19085555 <- ( edcba9876543210 , d555 ) + +[60,14]: + int 3b72ea61d950c841555 <- ( edcba9876543210 , 1555 ) + +[60,13]: + int 1db97530eca86421555 <- ( edcba9876543210 , f555 ) + +[60,12]: + int 0edcba9876543210555 <- ( edcba9876543210 , 555 ) + +[60,11]: + int 76e5d4c3b2a1908555 <- ( edcba9876543210 , d55 ) + +[60,10]: + int 3b72ea61d950c84155 <- ( edcba9876543210 , 155 ) + +[60,9]: + int 1db97530eca8642155 <- ( edcba9876543210 , f55 ) + +[60,8]: + int 0edcba987654321055 <- ( edcba9876543210 , 55 ) + +[60,7]: + int 76e5d4c3b2a190855 <- ( edcba9876543210 , d5 ) + +[60,6]: + int 3b72ea61d950c8415 <- ( edcba9876543210 , 15 ) + +[60,5]: + int 1db97530eca864215 <- ( edcba9876543210 , f5 ) + +[60,4]: + int 0edcba98765432105 <- ( edcba9876543210 , 5 ) + +[60,3]: + int 76e5d4c3b2a19085 <- ( edcba9876543210 , d ) + +[60,2]: + int 3b72ea61d950c841 <- ( edcba9876543210 , 1 ) + +[60,1]: + int 1db97530eca86421 <- ( edcba9876543210 , f ) + +[59,64]: + int 6dcba9876543210aaaaaaaa55555555 <- ( edcba9876543210 , aaaaaaaa55555555 ) + +[59,63]: + int 36e5d4c3b2a19082aaaaaaa55555555 <- ( edcba9876543210 , 2aaaaaaa55555555 ) + +[59,62]: + int 1b72ea61d950c842aaaaaaa55555555 <- ( edcba9876543210 , eaaaaaaa55555555 ) + +[59,61]: + int 0db97530eca86420aaaaaaa55555555 <- ( edcba9876543210 , 0aaaaaaa55555555 ) + +[59,60]: + int 6dcba9876543210aaaaaaa55555555 <- ( edcba9876543210 , aaaaaaa55555555 ) + +[59,59]: + int 36e5d4c3b2a19082aaaaaa55555555 <- ( edcba9876543210 , 2aaaaaa55555555 ) + +[59,58]: + int 1b72ea61d950c842aaaaaa55555555 <- ( edcba9876543210 , eaaaaaa55555555 ) + +[59,57]: + int 0db97530eca86420aaaaaa55555555 <- ( edcba9876543210 , 0aaaaaa55555555 ) + +[59,56]: + int 6dcba9876543210aaaaaa55555555 <- ( edcba9876543210 , aaaaaa55555555 ) + +[59,55]: + int 36e5d4c3b2a19082aaaaa55555555 <- ( edcba9876543210 , 2aaaaa55555555 ) + +[59,54]: + int 1b72ea61d950c842aaaaa55555555 <- ( edcba9876543210 , eaaaaa55555555 ) + +[59,53]: + int 0db97530eca86420aaaaa55555555 <- ( edcba9876543210 , 0aaaaa55555555 ) + +[59,52]: + int 6dcba9876543210aaaaa55555555 <- ( edcba9876543210 , aaaaa55555555 ) + +[59,51]: + int 36e5d4c3b2a19082aaaa55555555 <- ( edcba9876543210 , 2aaaa55555555 ) + +[59,50]: + int 1b72ea61d950c842aaaa55555555 <- ( edcba9876543210 , eaaaa55555555 ) + +[59,49]: + int 0db97530eca86420aaaa55555555 <- ( edcba9876543210 , 0aaaa55555555 ) + +[59,48]: + int 6dcba9876543210aaaa55555555 <- ( edcba9876543210 , aaaa55555555 ) + +[59,47]: + int 36e5d4c3b2a19082aaa55555555 <- ( edcba9876543210 , 2aaa55555555 ) + +[59,46]: + int 1b72ea61d950c842aaa55555555 <- ( edcba9876543210 , eaaa55555555 ) + +[59,45]: + int 0db97530eca86420aaa55555555 <- ( edcba9876543210 , 0aaa55555555 ) + +[59,44]: + int 6dcba9876543210aaa55555555 <- ( edcba9876543210 , aaa55555555 ) + +[59,43]: + int 36e5d4c3b2a19082aa55555555 <- ( edcba9876543210 , 2aa55555555 ) + +[59,42]: + int 1b72ea61d950c842aa55555555 <- ( edcba9876543210 , eaa55555555 ) + +[59,41]: + int 0db97530eca86420aa55555555 <- ( edcba9876543210 , 0aa55555555 ) + +[59,40]: + int 6dcba9876543210aa55555555 <- ( edcba9876543210 , aa55555555 ) + +[59,39]: + int 36e5d4c3b2a19082a55555555 <- ( edcba9876543210 , 2a55555555 ) + +[59,38]: + int 1b72ea61d950c842a55555555 <- ( edcba9876543210 , ea55555555 ) + +[59,37]: + int 0db97530eca86420a55555555 <- ( edcba9876543210 , 0a55555555 ) + +[59,36]: + int 6dcba9876543210a55555555 <- ( edcba9876543210 , a55555555 ) + +[59,35]: + int 36e5d4c3b2a1908255555555 <- ( edcba9876543210 , 255555555 ) + +[59,34]: + int 1b72ea61d950c84255555555 <- ( edcba9876543210 , e55555555 ) + +[59,33]: + int 0db97530eca8642055555555 <- ( edcba9876543210 , 055555555 ) + +[59,32]: + int 6dcba987654321055555555 <- ( edcba9876543210 , 55555555 ) + +[59,31]: + int 36e5d4c3b2a190855555555 <- ( edcba9876543210 , d5555555 ) + +[59,30]: + int 1b72ea61d950c8415555555 <- ( edcba9876543210 , 15555555 ) + +[59,29]: + int 0db97530eca864215555555 <- ( edcba9876543210 , f5555555 ) + +[59,28]: + int 6dcba98765432105555555 <- ( edcba9876543210 , 5555555 ) + +[59,27]: + int 36e5d4c3b2a19085555555 <- ( edcba9876543210 , d555555 ) + +[59,26]: + int 1b72ea61d950c841555555 <- ( edcba9876543210 , 1555555 ) + +[59,25]: + int 0db97530eca86421555555 <- ( edcba9876543210 , f555555 ) + +[59,24]: + int 6dcba9876543210555555 <- ( edcba9876543210 , 555555 ) + +[59,23]: + int 36e5d4c3b2a1908555555 <- ( edcba9876543210 , d55555 ) + +[59,22]: + int 1b72ea61d950c84155555 <- ( edcba9876543210 , 155555 ) + +[59,21]: + int 0db97530eca8642155555 <- ( edcba9876543210 , f55555 ) + +[59,20]: + int 6dcba987654321055555 <- ( edcba9876543210 , 55555 ) + +[59,19]: + int 36e5d4c3b2a190855555 <- ( edcba9876543210 , d5555 ) + +[59,18]: + int 1b72ea61d950c8415555 <- ( edcba9876543210 , 15555 ) + +[59,17]: + int 0db97530eca864215555 <- ( edcba9876543210 , f5555 ) + +[59,16]: + int 6dcba98765432105555 <- ( edcba9876543210 , 5555 ) + +[59,15]: + int 36e5d4c3b2a19085555 <- ( edcba9876543210 , d555 ) + +[59,14]: + int 1b72ea61d950c841555 <- ( edcba9876543210 , 1555 ) + +[59,13]: + int 0db97530eca86421555 <- ( edcba9876543210 , f555 ) + +[59,12]: + int 6dcba9876543210555 <- ( edcba9876543210 , 555 ) + +[59,11]: + int 36e5d4c3b2a1908555 <- ( edcba9876543210 , d55 ) + +[59,10]: + int 1b72ea61d950c84155 <- ( edcba9876543210 , 155 ) + +[59,9]: + int 0db97530eca8642155 <- ( edcba9876543210 , f55 ) + +[59,8]: + int 6dcba987654321055 <- ( edcba9876543210 , 55 ) + +[59,7]: + int 36e5d4c3b2a190855 <- ( edcba9876543210 , d5 ) + +[59,6]: + int 1b72ea61d950c8415 <- ( edcba9876543210 , 15 ) + +[59,5]: + int 0db97530eca864215 <- ( edcba9876543210 , f5 ) + +[59,4]: + int 6dcba98765432105 <- ( edcba9876543210 , 5 ) + +[59,3]: + int 36e5d4c3b2a19085 <- ( edcba9876543210 , d ) + +[59,2]: + int 1b72ea61d950c841 <- ( edcba9876543210 , 1 ) + +[59,1]: + int 0db97530eca86421 <- ( edcba9876543210 , f ) + +[58,64]: + int 2dcba9876543210aaaaaaaa55555555 <- ( edcba9876543210 , aaaaaaaa55555555 ) + +[58,63]: + int 16e5d4c3b2a19082aaaaaaa55555555 <- ( edcba9876543210 , 2aaaaaaa55555555 ) + +[58,62]: + int 0b72ea61d950c842aaaaaaa55555555 <- ( edcba9876543210 , eaaaaaaa55555555 ) + +[58,61]: + int 5b97530eca86420aaaaaaa55555555 <- ( edcba9876543210 , 0aaaaaaa55555555 ) + +[58,60]: + int 2dcba9876543210aaaaaaa55555555 <- ( edcba9876543210 , aaaaaaa55555555 ) + +[58,59]: + int 16e5d4c3b2a19082aaaaaa55555555 <- ( edcba9876543210 , 2aaaaaa55555555 ) + +[58,58]: + int 0b72ea61d950c842aaaaaa55555555 <- ( edcba9876543210 , eaaaaaa55555555 ) + +[58,57]: + int 5b97530eca86420aaaaaa55555555 <- ( edcba9876543210 , 0aaaaaa55555555 ) + +[58,56]: + int 2dcba9876543210aaaaaa55555555 <- ( edcba9876543210 , aaaaaa55555555 ) + +[58,55]: + int 16e5d4c3b2a19082aaaaa55555555 <- ( edcba9876543210 , 2aaaaa55555555 ) + +[58,54]: + int 0b72ea61d950c842aaaaa55555555 <- ( edcba9876543210 , eaaaaa55555555 ) + +[58,53]: + int 5b97530eca86420aaaaa55555555 <- ( edcba9876543210 , 0aaaaa55555555 ) + +[58,52]: + int 2dcba9876543210aaaaa55555555 <- ( edcba9876543210 , aaaaa55555555 ) + +[58,51]: + int 16e5d4c3b2a19082aaaa55555555 <- ( edcba9876543210 , 2aaaa55555555 ) + +[58,50]: + int 0b72ea61d950c842aaaa55555555 <- ( edcba9876543210 , eaaaa55555555 ) + +[58,49]: + int 5b97530eca86420aaaa55555555 <- ( edcba9876543210 , 0aaaa55555555 ) + +[58,48]: + int 2dcba9876543210aaaa55555555 <- ( edcba9876543210 , aaaa55555555 ) + +[58,47]: + int 16e5d4c3b2a19082aaa55555555 <- ( edcba9876543210 , 2aaa55555555 ) + +[58,46]: + int 0b72ea61d950c842aaa55555555 <- ( edcba9876543210 , eaaa55555555 ) + +[58,45]: + int 5b97530eca86420aaa55555555 <- ( edcba9876543210 , 0aaa55555555 ) + +[58,44]: + int 2dcba9876543210aaa55555555 <- ( edcba9876543210 , aaa55555555 ) + +[58,43]: + int 16e5d4c3b2a19082aa55555555 <- ( edcba9876543210 , 2aa55555555 ) + +[58,42]: + int 0b72ea61d950c842aa55555555 <- ( edcba9876543210 , eaa55555555 ) + +[58,41]: + int 5b97530eca86420aa55555555 <- ( edcba9876543210 , 0aa55555555 ) + +[58,40]: + int 2dcba9876543210aa55555555 <- ( edcba9876543210 , aa55555555 ) + +[58,39]: + int 16e5d4c3b2a19082a55555555 <- ( edcba9876543210 , 2a55555555 ) + +[58,38]: + int 0b72ea61d950c842a55555555 <- ( edcba9876543210 , ea55555555 ) + +[58,37]: + int 5b97530eca86420a55555555 <- ( edcba9876543210 , 0a55555555 ) + +[58,36]: + int 2dcba9876543210a55555555 <- ( edcba9876543210 , a55555555 ) + +[58,35]: + int 16e5d4c3b2a1908255555555 <- ( edcba9876543210 , 255555555 ) + +[58,34]: + int 0b72ea61d950c84255555555 <- ( edcba9876543210 , e55555555 ) + +[58,33]: + int 5b97530eca8642055555555 <- ( edcba9876543210 , 055555555 ) + +[58,32]: + int 2dcba987654321055555555 <- ( edcba9876543210 , 55555555 ) + +[58,31]: + int 16e5d4c3b2a190855555555 <- ( edcba9876543210 , d5555555 ) + +[58,30]: + int 0b72ea61d950c8415555555 <- ( edcba9876543210 , 15555555 ) + +[58,29]: + int 5b97530eca864215555555 <- ( edcba9876543210 , f5555555 ) + +[58,28]: + int 2dcba98765432105555555 <- ( edcba9876543210 , 5555555 ) + +[58,27]: + int 16e5d4c3b2a19085555555 <- ( edcba9876543210 , d555555 ) + +[58,26]: + int 0b72ea61d950c841555555 <- ( edcba9876543210 , 1555555 ) + +[58,25]: + int 5b97530eca86421555555 <- ( edcba9876543210 , f555555 ) + +[58,24]: + int 2dcba9876543210555555 <- ( edcba9876543210 , 555555 ) + +[58,23]: + int 16e5d4c3b2a1908555555 <- ( edcba9876543210 , d55555 ) + +[58,22]: + int 0b72ea61d950c84155555 <- ( edcba9876543210 , 155555 ) + +[58,21]: + int 5b97530eca8642155555 <- ( edcba9876543210 , f55555 ) + +[58,20]: + int 2dcba987654321055555 <- ( edcba9876543210 , 55555 ) + +[58,19]: + int 16e5d4c3b2a190855555 <- ( edcba9876543210 , d5555 ) + +[58,18]: + int 0b72ea61d950c8415555 <- ( edcba9876543210 , 15555 ) + +[58,17]: + int 5b97530eca864215555 <- ( edcba9876543210 , f5555 ) + +[58,16]: + int 2dcba98765432105555 <- ( edcba9876543210 , 5555 ) + +[58,15]: + int 16e5d4c3b2a19085555 <- ( edcba9876543210 , d555 ) + +[58,14]: + int 0b72ea61d950c841555 <- ( edcba9876543210 , 1555 ) + +[58,13]: + int 5b97530eca86421555 <- ( edcba9876543210 , f555 ) + +[58,12]: + int 2dcba9876543210555 <- ( edcba9876543210 , 555 ) + +[58,11]: + int 16e5d4c3b2a1908555 <- ( edcba9876543210 , d55 ) + +[58,10]: + int 0b72ea61d950c84155 <- ( edcba9876543210 , 155 ) + +[58,9]: + int 5b97530eca8642155 <- ( edcba9876543210 , f55 ) + +[58,8]: + int 2dcba987654321055 <- ( edcba9876543210 , 55 ) + +[58,7]: + int 16e5d4c3b2a190855 <- ( edcba9876543210 , d5 ) + +[58,6]: + int 0b72ea61d950c8415 <- ( edcba9876543210 , 15 ) + +[58,5]: + int 5b97530eca864215 <- ( edcba9876543210 , f5 ) + +[58,4]: + int 2dcba98765432105 <- ( edcba9876543210 , 5 ) + +[58,3]: + int 16e5d4c3b2a19085 <- ( edcba9876543210 , d ) + +[58,2]: + int 0b72ea61d950c841 <- ( edcba9876543210 , 1 ) + +[58,1]: + int 5b97530eca86421 <- ( edcba9876543210 , f ) + +[57,64]: + int 0dcba9876543210aaaaaaaa55555555 <- ( 0dcba9876543210 , aaaaaaaa55555555 ) + +[57,63]: + int 06e5d4c3b2a19082aaaaaaa55555555 <- ( 0dcba9876543210 , 2aaaaaaa55555555 ) + +[57,62]: + int 372ea61d950c842aaaaaaa55555555 <- ( 0dcba9876543210 , eaaaaaaa55555555 ) + +[57,61]: + int 1b97530eca86420aaaaaaa55555555 <- ( 0dcba9876543210 , 0aaaaaaa55555555 ) + +[57,60]: + int 0dcba9876543210aaaaaaa55555555 <- ( 0dcba9876543210 , aaaaaaa55555555 ) + +[57,59]: + int 06e5d4c3b2a19082aaaaaa55555555 <- ( 0dcba9876543210 , 2aaaaaa55555555 ) + +[57,58]: + int 372ea61d950c842aaaaaa55555555 <- ( 0dcba9876543210 , eaaaaaa55555555 ) + +[57,57]: + int 1b97530eca86420aaaaaa55555555 <- ( 0dcba9876543210 , 0aaaaaa55555555 ) + +[57,56]: + int 0dcba9876543210aaaaaa55555555 <- ( 0dcba9876543210 , aaaaaa55555555 ) + +[57,55]: + int 06e5d4c3b2a19082aaaaa55555555 <- ( 0dcba9876543210 , 2aaaaa55555555 ) + +[57,54]: + int 372ea61d950c842aaaaa55555555 <- ( 0dcba9876543210 , eaaaaa55555555 ) + +[57,53]: + int 1b97530eca86420aaaaa55555555 <- ( 0dcba9876543210 , 0aaaaa55555555 ) + +[57,52]: + int 0dcba9876543210aaaaa55555555 <- ( 0dcba9876543210 , aaaaa55555555 ) + +[57,51]: + int 06e5d4c3b2a19082aaaa55555555 <- ( 0dcba9876543210 , 2aaaa55555555 ) + +[57,50]: + int 372ea61d950c842aaaa55555555 <- ( 0dcba9876543210 , eaaaa55555555 ) + +[57,49]: + int 1b97530eca86420aaaa55555555 <- ( 0dcba9876543210 , 0aaaa55555555 ) + +[57,48]: + int 0dcba9876543210aaaa55555555 <- ( 0dcba9876543210 , aaaa55555555 ) + +[57,47]: + int 06e5d4c3b2a19082aaa55555555 <- ( 0dcba9876543210 , 2aaa55555555 ) + +[57,46]: + int 372ea61d950c842aaa55555555 <- ( 0dcba9876543210 , eaaa55555555 ) + +[57,45]: + int 1b97530eca86420aaa55555555 <- ( 0dcba9876543210 , 0aaa55555555 ) + +[57,44]: + int 0dcba9876543210aaa55555555 <- ( 0dcba9876543210 , aaa55555555 ) + +[57,43]: + int 06e5d4c3b2a19082aa55555555 <- ( 0dcba9876543210 , 2aa55555555 ) + +[57,42]: + int 372ea61d950c842aa55555555 <- ( 0dcba9876543210 , eaa55555555 ) + +[57,41]: + int 1b97530eca86420aa55555555 <- ( 0dcba9876543210 , 0aa55555555 ) + +[57,40]: + int 0dcba9876543210aa55555555 <- ( 0dcba9876543210 , aa55555555 ) + +[57,39]: + int 06e5d4c3b2a19082a55555555 <- ( 0dcba9876543210 , 2a55555555 ) + +[57,38]: + int 372ea61d950c842a55555555 <- ( 0dcba9876543210 , ea55555555 ) + +[57,37]: + int 1b97530eca86420a55555555 <- ( 0dcba9876543210 , 0a55555555 ) + +[57,36]: + int 0dcba9876543210a55555555 <- ( 0dcba9876543210 , a55555555 ) + +[57,35]: + int 06e5d4c3b2a1908255555555 <- ( 0dcba9876543210 , 255555555 ) + +[57,34]: + int 372ea61d950c84255555555 <- ( 0dcba9876543210 , e55555555 ) + +[57,33]: + int 1b97530eca8642055555555 <- ( 0dcba9876543210 , 055555555 ) + +[57,32]: + int 0dcba987654321055555555 <- ( 0dcba9876543210 , 55555555 ) + +[57,31]: + int 06e5d4c3b2a190855555555 <- ( 0dcba9876543210 , d5555555 ) + +[57,30]: + int 372ea61d950c8415555555 <- ( 0dcba9876543210 , 15555555 ) + +[57,29]: + int 1b97530eca864215555555 <- ( 0dcba9876543210 , f5555555 ) + +[57,28]: + int 0dcba98765432105555555 <- ( 0dcba9876543210 , 5555555 ) + +[57,27]: + int 06e5d4c3b2a19085555555 <- ( 0dcba9876543210 , d555555 ) + +[57,26]: + int 372ea61d950c841555555 <- ( 0dcba9876543210 , 1555555 ) + +[57,25]: + int 1b97530eca86421555555 <- ( 0dcba9876543210 , f555555 ) + +[57,24]: + int 0dcba9876543210555555 <- ( 0dcba9876543210 , 555555 ) + +[57,23]: + int 06e5d4c3b2a1908555555 <- ( 0dcba9876543210 , d55555 ) + +[57,22]: + int 372ea61d950c84155555 <- ( 0dcba9876543210 , 155555 ) + +[57,21]: + int 1b97530eca8642155555 <- ( 0dcba9876543210 , f55555 ) + +[57,20]: + int 0dcba987654321055555 <- ( 0dcba9876543210 , 55555 ) + +[57,19]: + int 06e5d4c3b2a190855555 <- ( 0dcba9876543210 , d5555 ) + +[57,18]: + int 372ea61d950c8415555 <- ( 0dcba9876543210 , 15555 ) + +[57,17]: + int 1b97530eca864215555 <- ( 0dcba9876543210 , f5555 ) + +[57,16]: + int 0dcba98765432105555 <- ( 0dcba9876543210 , 5555 ) + +[57,15]: + int 06e5d4c3b2a19085555 <- ( 0dcba9876543210 , d555 ) + +[57,14]: + int 372ea61d950c841555 <- ( 0dcba9876543210 , 1555 ) + +[57,13]: + int 1b97530eca86421555 <- ( 0dcba9876543210 , f555 ) + +[57,12]: + int 0dcba9876543210555 <- ( 0dcba9876543210 , 555 ) + +[57,11]: + int 06e5d4c3b2a1908555 <- ( 0dcba9876543210 , d55 ) + +[57,10]: + int 372ea61d950c84155 <- ( 0dcba9876543210 , 155 ) + +[57,9]: + int 1b97530eca8642155 <- ( 0dcba9876543210 , f55 ) + +[57,8]: + int 0dcba987654321055 <- ( 0dcba9876543210 , 55 ) + +[57,7]: + int 06e5d4c3b2a190855 <- ( 0dcba9876543210 , d5 ) + +[57,6]: + int 372ea61d950c8415 <- ( 0dcba9876543210 , 15 ) + +[57,5]: + int 1b97530eca864215 <- ( 0dcba9876543210 , f5 ) + +[57,4]: + int 0dcba98765432105 <- ( 0dcba9876543210 , 5 ) + +[57,3]: + int 06e5d4c3b2a19085 <- ( 0dcba9876543210 , d ) + +[57,2]: + int 372ea61d950c841 <- ( 0dcba9876543210 , 1 ) + +[57,1]: + int 1b97530eca86421 <- ( 0dcba9876543210 , f ) + +[56,64]: + int 0dcba9876543210aaaaaaaa55555555 <- ( dcba9876543210 , aaaaaaaa55555555 ) + +[56,63]: + int 6e5d4c3b2a19082aaaaaaa55555555 <- ( dcba9876543210 , 2aaaaaaa55555555 ) + +[56,62]: + int 372ea61d950c842aaaaaaa55555555 <- ( dcba9876543210 , eaaaaaaa55555555 ) + +[56,61]: + int 1b97530eca86420aaaaaaa55555555 <- ( dcba9876543210 , 0aaaaaaa55555555 ) + +[56,60]: + int 0dcba9876543210aaaaaaa55555555 <- ( dcba9876543210 , aaaaaaa55555555 ) + +[56,59]: + int 6e5d4c3b2a19082aaaaaa55555555 <- ( dcba9876543210 , 2aaaaaa55555555 ) + +[56,58]: + int 372ea61d950c842aaaaaa55555555 <- ( dcba9876543210 , eaaaaaa55555555 ) + +[56,57]: + int 1b97530eca86420aaaaaa55555555 <- ( dcba9876543210 , 0aaaaaa55555555 ) + +[56,56]: + int 0dcba9876543210aaaaaa55555555 <- ( dcba9876543210 , aaaaaa55555555 ) + +[56,55]: + int 6e5d4c3b2a19082aaaaa55555555 <- ( dcba9876543210 , 2aaaaa55555555 ) + +[56,54]: + int 372ea61d950c842aaaaa55555555 <- ( dcba9876543210 , eaaaaa55555555 ) + +[56,53]: + int 1b97530eca86420aaaaa55555555 <- ( dcba9876543210 , 0aaaaa55555555 ) + +[56,52]: + int 0dcba9876543210aaaaa55555555 <- ( dcba9876543210 , aaaaa55555555 ) + +[56,51]: + int 6e5d4c3b2a19082aaaa55555555 <- ( dcba9876543210 , 2aaaa55555555 ) + +[56,50]: + int 372ea61d950c842aaaa55555555 <- ( dcba9876543210 , eaaaa55555555 ) + +[56,49]: + int 1b97530eca86420aaaa55555555 <- ( dcba9876543210 , 0aaaa55555555 ) + +[56,48]: + int 0dcba9876543210aaaa55555555 <- ( dcba9876543210 , aaaa55555555 ) + +[56,47]: + int 6e5d4c3b2a19082aaa55555555 <- ( dcba9876543210 , 2aaa55555555 ) + +[56,46]: + int 372ea61d950c842aaa55555555 <- ( dcba9876543210 , eaaa55555555 ) + +[56,45]: + int 1b97530eca86420aaa55555555 <- ( dcba9876543210 , 0aaa55555555 ) + +[56,44]: + int 0dcba9876543210aaa55555555 <- ( dcba9876543210 , aaa55555555 ) + +[56,43]: + int 6e5d4c3b2a19082aa55555555 <- ( dcba9876543210 , 2aa55555555 ) + +[56,42]: + int 372ea61d950c842aa55555555 <- ( dcba9876543210 , eaa55555555 ) + +[56,41]: + int 1b97530eca86420aa55555555 <- ( dcba9876543210 , 0aa55555555 ) + +[56,40]: + int 0dcba9876543210aa55555555 <- ( dcba9876543210 , aa55555555 ) + +[56,39]: + int 6e5d4c3b2a19082a55555555 <- ( dcba9876543210 , 2a55555555 ) + +[56,38]: + int 372ea61d950c842a55555555 <- ( dcba9876543210 , ea55555555 ) + +[56,37]: + int 1b97530eca86420a55555555 <- ( dcba9876543210 , 0a55555555 ) + +[56,36]: + int 0dcba9876543210a55555555 <- ( dcba9876543210 , a55555555 ) + +[56,35]: + int 6e5d4c3b2a1908255555555 <- ( dcba9876543210 , 255555555 ) + +[56,34]: + int 372ea61d950c84255555555 <- ( dcba9876543210 , e55555555 ) + +[56,33]: + int 1b97530eca8642055555555 <- ( dcba9876543210 , 055555555 ) + +[56,32]: + int 0dcba987654321055555555 <- ( dcba9876543210 , 55555555 ) + +[56,31]: + int 6e5d4c3b2a190855555555 <- ( dcba9876543210 , d5555555 ) + +[56,30]: + int 372ea61d950c8415555555 <- ( dcba9876543210 , 15555555 ) + +[56,29]: + int 1b97530eca864215555555 <- ( dcba9876543210 , f5555555 ) + +[56,28]: + int 0dcba98765432105555555 <- ( dcba9876543210 , 5555555 ) + +[56,27]: + int 6e5d4c3b2a19085555555 <- ( dcba9876543210 , d555555 ) + +[56,26]: + int 372ea61d950c841555555 <- ( dcba9876543210 , 1555555 ) + +[56,25]: + int 1b97530eca86421555555 <- ( dcba9876543210 , f555555 ) + +[56,24]: + int 0dcba9876543210555555 <- ( dcba9876543210 , 555555 ) + +[56,23]: + int 6e5d4c3b2a1908555555 <- ( dcba9876543210 , d55555 ) + +[56,22]: + int 372ea61d950c84155555 <- ( dcba9876543210 , 155555 ) + +[56,21]: + int 1b97530eca8642155555 <- ( dcba9876543210 , f55555 ) + +[56,20]: + int 0dcba987654321055555 <- ( dcba9876543210 , 55555 ) + +[56,19]: + int 6e5d4c3b2a190855555 <- ( dcba9876543210 , d5555 ) + +[56,18]: + int 372ea61d950c8415555 <- ( dcba9876543210 , 15555 ) + +[56,17]: + int 1b97530eca864215555 <- ( dcba9876543210 , f5555 ) + +[56,16]: + int 0dcba98765432105555 <- ( dcba9876543210 , 5555 ) + +[56,15]: + int 6e5d4c3b2a19085555 <- ( dcba9876543210 , d555 ) + +[56,14]: + int 372ea61d950c841555 <- ( dcba9876543210 , 1555 ) + +[56,13]: + int 1b97530eca86421555 <- ( dcba9876543210 , f555 ) + +[56,12]: + int 0dcba9876543210555 <- ( dcba9876543210 , 555 ) + +[56,11]: + int 6e5d4c3b2a1908555 <- ( dcba9876543210 , d55 ) + +[56,10]: + int 372ea61d950c84155 <- ( dcba9876543210 , 155 ) + +[56,9]: + int 1b97530eca8642155 <- ( dcba9876543210 , f55 ) + +[56,8]: + int 0dcba987654321055 <- ( dcba9876543210 , 55 ) + +[56,7]: + int 6e5d4c3b2a190855 <- ( dcba9876543210 , d5 ) + +[56,6]: + int 372ea61d950c8415 <- ( dcba9876543210 , 15 ) + +[56,5]: + int 1b97530eca864215 <- ( dcba9876543210 , f5 ) + +[56,4]: + int 0dcba98765432105 <- ( dcba9876543210 , 5 ) + +[56,3]: + int 6e5d4c3b2a19085 <- ( dcba9876543210 , d ) + +[56,2]: + int 372ea61d950c841 <- ( dcba9876543210 , 1 ) + +[56,1]: + int 1b97530eca86421 <- ( dcba9876543210 , f ) + +[55,64]: + int 5cba9876543210aaaaaaaa55555555 <- ( dcba9876543210 , aaaaaaaa55555555 ) + +[55,63]: + int 2e5d4c3b2a19082aaaaaaa55555555 <- ( dcba9876543210 , 2aaaaaaa55555555 ) + +[55,62]: + int 172ea61d950c842aaaaaaa55555555 <- ( dcba9876543210 , eaaaaaaa55555555 ) + +[55,61]: + int 0b97530eca86420aaaaaaa55555555 <- ( dcba9876543210 , 0aaaaaaa55555555 ) + +[55,60]: + int 5cba9876543210aaaaaaa55555555 <- ( dcba9876543210 , aaaaaaa55555555 ) + +[55,59]: + int 2e5d4c3b2a19082aaaaaa55555555 <- ( dcba9876543210 , 2aaaaaa55555555 ) + +[55,58]: + int 172ea61d950c842aaaaaa55555555 <- ( dcba9876543210 , eaaaaaa55555555 ) + +[55,57]: + int 0b97530eca86420aaaaaa55555555 <- ( dcba9876543210 , 0aaaaaa55555555 ) + +[55,56]: + int 5cba9876543210aaaaaa55555555 <- ( dcba9876543210 , aaaaaa55555555 ) + +[55,55]: + int 2e5d4c3b2a19082aaaaa55555555 <- ( dcba9876543210 , 2aaaaa55555555 ) + +[55,54]: + int 172ea61d950c842aaaaa55555555 <- ( dcba9876543210 , eaaaaa55555555 ) + +[55,53]: + int 0b97530eca86420aaaaa55555555 <- ( dcba9876543210 , 0aaaaa55555555 ) + +[55,52]: + int 5cba9876543210aaaaa55555555 <- ( dcba9876543210 , aaaaa55555555 ) + +[55,51]: + int 2e5d4c3b2a19082aaaa55555555 <- ( dcba9876543210 , 2aaaa55555555 ) + +[55,50]: + int 172ea61d950c842aaaa55555555 <- ( dcba9876543210 , eaaaa55555555 ) + +[55,49]: + int 0b97530eca86420aaaa55555555 <- ( dcba9876543210 , 0aaaa55555555 ) + +[55,48]: + int 5cba9876543210aaaa55555555 <- ( dcba9876543210 , aaaa55555555 ) + +[55,47]: + int 2e5d4c3b2a19082aaa55555555 <- ( dcba9876543210 , 2aaa55555555 ) + +[55,46]: + int 172ea61d950c842aaa55555555 <- ( dcba9876543210 , eaaa55555555 ) + +[55,45]: + int 0b97530eca86420aaa55555555 <- ( dcba9876543210 , 0aaa55555555 ) + +[55,44]: + int 5cba9876543210aaa55555555 <- ( dcba9876543210 , aaa55555555 ) + +[55,43]: + int 2e5d4c3b2a19082aa55555555 <- ( dcba9876543210 , 2aa55555555 ) + +[55,42]: + int 172ea61d950c842aa55555555 <- ( dcba9876543210 , eaa55555555 ) + +[55,41]: + int 0b97530eca86420aa55555555 <- ( dcba9876543210 , 0aa55555555 ) + +[55,40]: + int 5cba9876543210aa55555555 <- ( dcba9876543210 , aa55555555 ) + +[55,39]: + int 2e5d4c3b2a19082a55555555 <- ( dcba9876543210 , 2a55555555 ) + +[55,38]: + int 172ea61d950c842a55555555 <- ( dcba9876543210 , ea55555555 ) + +[55,37]: + int 0b97530eca86420a55555555 <- ( dcba9876543210 , 0a55555555 ) + +[55,36]: + int 5cba9876543210a55555555 <- ( dcba9876543210 , a55555555 ) + +[55,35]: + int 2e5d4c3b2a1908255555555 <- ( dcba9876543210 , 255555555 ) + +[55,34]: + int 172ea61d950c84255555555 <- ( dcba9876543210 , e55555555 ) + +[55,33]: + int 0b97530eca8642055555555 <- ( dcba9876543210 , 055555555 ) + +[55,32]: + int 5cba987654321055555555 <- ( dcba9876543210 , 55555555 ) + +[55,31]: + int 2e5d4c3b2a190855555555 <- ( dcba9876543210 , d5555555 ) + +[55,30]: + int 172ea61d950c8415555555 <- ( dcba9876543210 , 15555555 ) + +[55,29]: + int 0b97530eca864215555555 <- ( dcba9876543210 , f5555555 ) + +[55,28]: + int 5cba98765432105555555 <- ( dcba9876543210 , 5555555 ) + +[55,27]: + int 2e5d4c3b2a19085555555 <- ( dcba9876543210 , d555555 ) + +[55,26]: + int 172ea61d950c841555555 <- ( dcba9876543210 , 1555555 ) + +[55,25]: + int 0b97530eca86421555555 <- ( dcba9876543210 , f555555 ) + +[55,24]: + int 5cba9876543210555555 <- ( dcba9876543210 , 555555 ) + +[55,23]: + int 2e5d4c3b2a1908555555 <- ( dcba9876543210 , d55555 ) + +[55,22]: + int 172ea61d950c84155555 <- ( dcba9876543210 , 155555 ) + +[55,21]: + int 0b97530eca8642155555 <- ( dcba9876543210 , f55555 ) + +[55,20]: + int 5cba987654321055555 <- ( dcba9876543210 , 55555 ) + +[55,19]: + int 2e5d4c3b2a190855555 <- ( dcba9876543210 , d5555 ) + +[55,18]: + int 172ea61d950c8415555 <- ( dcba9876543210 , 15555 ) + +[55,17]: + int 0b97530eca864215555 <- ( dcba9876543210 , f5555 ) + +[55,16]: + int 5cba98765432105555 <- ( dcba9876543210 , 5555 ) + +[55,15]: + int 2e5d4c3b2a19085555 <- ( dcba9876543210 , d555 ) + +[55,14]: + int 172ea61d950c841555 <- ( dcba9876543210 , 1555 ) + +[55,13]: + int 0b97530eca86421555 <- ( dcba9876543210 , f555 ) + +[55,12]: + int 5cba9876543210555 <- ( dcba9876543210 , 555 ) + +[55,11]: + int 2e5d4c3b2a1908555 <- ( dcba9876543210 , d55 ) + +[55,10]: + int 172ea61d950c84155 <- ( dcba9876543210 , 155 ) + +[55,9]: + int 0b97530eca8642155 <- ( dcba9876543210 , f55 ) + +[55,8]: + int 5cba987654321055 <- ( dcba9876543210 , 55 ) + +[55,7]: + int 2e5d4c3b2a190855 <- ( dcba9876543210 , d5 ) + +[55,6]: + int 172ea61d950c8415 <- ( dcba9876543210 , 15 ) + +[55,5]: + int 0b97530eca864215 <- ( dcba9876543210 , f5 ) + +[55,4]: + int 5cba98765432105 <- ( dcba9876543210 , 5 ) + +[55,3]: + int 2e5d4c3b2a19085 <- ( dcba9876543210 , d ) + +[55,2]: + int 172ea61d950c841 <- ( dcba9876543210 , 1 ) + +[55,1]: + int 0b97530eca86421 <- ( dcba9876543210 , f ) + +[54,64]: + int 1cba9876543210aaaaaaaa55555555 <- ( 1cba9876543210 , aaaaaaaa55555555 ) + +[54,63]: + int 0e5d4c3b2a19082aaaaaaa55555555 <- ( 1cba9876543210 , 2aaaaaaa55555555 ) + +[54,62]: + int 072ea61d950c842aaaaaaa55555555 <- ( 1cba9876543210 , eaaaaaaa55555555 ) + +[54,61]: + int 397530eca86420aaaaaaa55555555 <- ( 1cba9876543210 , 0aaaaaaa55555555 ) + +[54,60]: + int 1cba9876543210aaaaaaa55555555 <- ( 1cba9876543210 , aaaaaaa55555555 ) + +[54,59]: + int 0e5d4c3b2a19082aaaaaa55555555 <- ( 1cba9876543210 , 2aaaaaa55555555 ) + +[54,58]: + int 072ea61d950c842aaaaaa55555555 <- ( 1cba9876543210 , eaaaaaa55555555 ) + +[54,57]: + int 397530eca86420aaaaaa55555555 <- ( 1cba9876543210 , 0aaaaaa55555555 ) + +[54,56]: + int 1cba9876543210aaaaaa55555555 <- ( 1cba9876543210 , aaaaaa55555555 ) + +[54,55]: + int 0e5d4c3b2a19082aaaaa55555555 <- ( 1cba9876543210 , 2aaaaa55555555 ) + +[54,54]: + int 072ea61d950c842aaaaa55555555 <- ( 1cba9876543210 , eaaaaa55555555 ) + +[54,53]: + int 397530eca86420aaaaa55555555 <- ( 1cba9876543210 , 0aaaaa55555555 ) + +[54,52]: + int 1cba9876543210aaaaa55555555 <- ( 1cba9876543210 , aaaaa55555555 ) + +[54,51]: + int 0e5d4c3b2a19082aaaa55555555 <- ( 1cba9876543210 , 2aaaa55555555 ) + +[54,50]: + int 072ea61d950c842aaaa55555555 <- ( 1cba9876543210 , eaaaa55555555 ) + +[54,49]: + int 397530eca86420aaaa55555555 <- ( 1cba9876543210 , 0aaaa55555555 ) + +[54,48]: + int 1cba9876543210aaaa55555555 <- ( 1cba9876543210 , aaaa55555555 ) + +[54,47]: + int 0e5d4c3b2a19082aaa55555555 <- ( 1cba9876543210 , 2aaa55555555 ) + +[54,46]: + int 072ea61d950c842aaa55555555 <- ( 1cba9876543210 , eaaa55555555 ) + +[54,45]: + int 397530eca86420aaa55555555 <- ( 1cba9876543210 , 0aaa55555555 ) + +[54,44]: + int 1cba9876543210aaa55555555 <- ( 1cba9876543210 , aaa55555555 ) + +[54,43]: + int 0e5d4c3b2a19082aa55555555 <- ( 1cba9876543210 , 2aa55555555 ) + +[54,42]: + int 072ea61d950c842aa55555555 <- ( 1cba9876543210 , eaa55555555 ) + +[54,41]: + int 397530eca86420aa55555555 <- ( 1cba9876543210 , 0aa55555555 ) + +[54,40]: + int 1cba9876543210aa55555555 <- ( 1cba9876543210 , aa55555555 ) + +[54,39]: + int 0e5d4c3b2a19082a55555555 <- ( 1cba9876543210 , 2a55555555 ) + +[54,38]: + int 072ea61d950c842a55555555 <- ( 1cba9876543210 , ea55555555 ) + +[54,37]: + int 397530eca86420a55555555 <- ( 1cba9876543210 , 0a55555555 ) + +[54,36]: + int 1cba9876543210a55555555 <- ( 1cba9876543210 , a55555555 ) + +[54,35]: + int 0e5d4c3b2a1908255555555 <- ( 1cba9876543210 , 255555555 ) + +[54,34]: + int 072ea61d950c84255555555 <- ( 1cba9876543210 , e55555555 ) + +[54,33]: + int 397530eca8642055555555 <- ( 1cba9876543210 , 055555555 ) + +[54,32]: + int 1cba987654321055555555 <- ( 1cba9876543210 , 55555555 ) + +[54,31]: + int 0e5d4c3b2a190855555555 <- ( 1cba9876543210 , d5555555 ) + +[54,30]: + int 072ea61d950c8415555555 <- ( 1cba9876543210 , 15555555 ) + +[54,29]: + int 397530eca864215555555 <- ( 1cba9876543210 , f5555555 ) + +[54,28]: + int 1cba98765432105555555 <- ( 1cba9876543210 , 5555555 ) + +[54,27]: + int 0e5d4c3b2a19085555555 <- ( 1cba9876543210 , d555555 ) + +[54,26]: + int 072ea61d950c841555555 <- ( 1cba9876543210 , 1555555 ) + +[54,25]: + int 397530eca86421555555 <- ( 1cba9876543210 , f555555 ) + +[54,24]: + int 1cba9876543210555555 <- ( 1cba9876543210 , 555555 ) + +[54,23]: + int 0e5d4c3b2a1908555555 <- ( 1cba9876543210 , d55555 ) + +[54,22]: + int 072ea61d950c84155555 <- ( 1cba9876543210 , 155555 ) + +[54,21]: + int 397530eca8642155555 <- ( 1cba9876543210 , f55555 ) + +[54,20]: + int 1cba987654321055555 <- ( 1cba9876543210 , 55555 ) + +[54,19]: + int 0e5d4c3b2a190855555 <- ( 1cba9876543210 , d5555 ) + +[54,18]: + int 072ea61d950c8415555 <- ( 1cba9876543210 , 15555 ) + +[54,17]: + int 397530eca864215555 <- ( 1cba9876543210 , f5555 ) + +[54,16]: + int 1cba98765432105555 <- ( 1cba9876543210 , 5555 ) + +[54,15]: + int 0e5d4c3b2a19085555 <- ( 1cba9876543210 , d555 ) + +[54,14]: + int 072ea61d950c841555 <- ( 1cba9876543210 , 1555 ) + +[54,13]: + int 397530eca86421555 <- ( 1cba9876543210 , f555 ) + +[54,12]: + int 1cba9876543210555 <- ( 1cba9876543210 , 555 ) + +[54,11]: + int 0e5d4c3b2a1908555 <- ( 1cba9876543210 , d55 ) + +[54,10]: + int 072ea61d950c84155 <- ( 1cba9876543210 , 155 ) + +[54,9]: + int 397530eca8642155 <- ( 1cba9876543210 , f55 ) + +[54,8]: + int 1cba987654321055 <- ( 1cba9876543210 , 55 ) + +[54,7]: + int 0e5d4c3b2a190855 <- ( 1cba9876543210 , d5 ) + +[54,6]: + int 072ea61d950c8415 <- ( 1cba9876543210 , 15 ) + +[54,5]: + int 397530eca864215 <- ( 1cba9876543210 , f5 ) + +[54,4]: + int 1cba98765432105 <- ( 1cba9876543210 , 5 ) + +[54,3]: + int 0e5d4c3b2a19085 <- ( 1cba9876543210 , d ) + +[54,2]: + int 072ea61d950c841 <- ( 1cba9876543210 , 1 ) + +[54,1]: + int 397530eca86421 <- ( 1cba9876543210 , f ) + +[53,64]: + int 1cba9876543210aaaaaaaa55555555 <- ( fcba9876543210 , aaaaaaaa55555555 ) + +[53,63]: + int 0e5d4c3b2a19082aaaaaaa55555555 <- ( fcba9876543210 , 2aaaaaaa55555555 ) + +[53,62]: + int 72ea61d950c842aaaaaaa55555555 <- ( fcba9876543210 , eaaaaaaa55555555 ) + +[53,61]: + int 397530eca86420aaaaaaa55555555 <- ( fcba9876543210 , 0aaaaaaa55555555 ) + +[53,60]: + int 1cba9876543210aaaaaaa55555555 <- ( fcba9876543210 , aaaaaaa55555555 ) + +[53,59]: + int 0e5d4c3b2a19082aaaaaa55555555 <- ( fcba9876543210 , 2aaaaaa55555555 ) + +[53,58]: + int 72ea61d950c842aaaaaa55555555 <- ( fcba9876543210 , eaaaaaa55555555 ) + +[53,57]: + int 397530eca86420aaaaaa55555555 <- ( fcba9876543210 , 0aaaaaa55555555 ) + +[53,56]: + int 1cba9876543210aaaaaa55555555 <- ( fcba9876543210 , aaaaaa55555555 ) + +[53,55]: + int 0e5d4c3b2a19082aaaaa55555555 <- ( fcba9876543210 , 2aaaaa55555555 ) + +[53,54]: + int 72ea61d950c842aaaaa55555555 <- ( fcba9876543210 , eaaaaa55555555 ) + +[53,53]: + int 397530eca86420aaaaa55555555 <- ( fcba9876543210 , 0aaaaa55555555 ) + +[53,52]: + int 1cba9876543210aaaaa55555555 <- ( fcba9876543210 , aaaaa55555555 ) + +[53,51]: + int 0e5d4c3b2a19082aaaa55555555 <- ( fcba9876543210 , 2aaaa55555555 ) + +[53,50]: + int 72ea61d950c842aaaa55555555 <- ( fcba9876543210 , eaaaa55555555 ) + +[53,49]: + int 397530eca86420aaaa55555555 <- ( fcba9876543210 , 0aaaa55555555 ) + +[53,48]: + int 1cba9876543210aaaa55555555 <- ( fcba9876543210 , aaaa55555555 ) + +[53,47]: + int 0e5d4c3b2a19082aaa55555555 <- ( fcba9876543210 , 2aaa55555555 ) + +[53,46]: + int 72ea61d950c842aaa55555555 <- ( fcba9876543210 , eaaa55555555 ) + +[53,45]: + int 397530eca86420aaa55555555 <- ( fcba9876543210 , 0aaa55555555 ) + +[53,44]: + int 1cba9876543210aaa55555555 <- ( fcba9876543210 , aaa55555555 ) + +[53,43]: + int 0e5d4c3b2a19082aa55555555 <- ( fcba9876543210 , 2aa55555555 ) + +[53,42]: + int 72ea61d950c842aa55555555 <- ( fcba9876543210 , eaa55555555 ) + +[53,41]: + int 397530eca86420aa55555555 <- ( fcba9876543210 , 0aa55555555 ) + +[53,40]: + int 1cba9876543210aa55555555 <- ( fcba9876543210 , aa55555555 ) + +[53,39]: + int 0e5d4c3b2a19082a55555555 <- ( fcba9876543210 , 2a55555555 ) + +[53,38]: + int 72ea61d950c842a55555555 <- ( fcba9876543210 , ea55555555 ) + +[53,37]: + int 397530eca86420a55555555 <- ( fcba9876543210 , 0a55555555 ) + +[53,36]: + int 1cba9876543210a55555555 <- ( fcba9876543210 , a55555555 ) + +[53,35]: + int 0e5d4c3b2a1908255555555 <- ( fcba9876543210 , 255555555 ) + +[53,34]: + int 72ea61d950c84255555555 <- ( fcba9876543210 , e55555555 ) + +[53,33]: + int 397530eca8642055555555 <- ( fcba9876543210 , 055555555 ) + +[53,32]: + int 1cba987654321055555555 <- ( fcba9876543210 , 55555555 ) + +[53,31]: + int 0e5d4c3b2a190855555555 <- ( fcba9876543210 , d5555555 ) + +[53,30]: + int 72ea61d950c8415555555 <- ( fcba9876543210 , 15555555 ) + +[53,29]: + int 397530eca864215555555 <- ( fcba9876543210 , f5555555 ) + +[53,28]: + int 1cba98765432105555555 <- ( fcba9876543210 , 5555555 ) + +[53,27]: + int 0e5d4c3b2a19085555555 <- ( fcba9876543210 , d555555 ) + +[53,26]: + int 72ea61d950c841555555 <- ( fcba9876543210 , 1555555 ) + +[53,25]: + int 397530eca86421555555 <- ( fcba9876543210 , f555555 ) + +[53,24]: + int 1cba9876543210555555 <- ( fcba9876543210 , 555555 ) + +[53,23]: + int 0e5d4c3b2a1908555555 <- ( fcba9876543210 , d55555 ) + +[53,22]: + int 72ea61d950c84155555 <- ( fcba9876543210 , 155555 ) + +[53,21]: + int 397530eca8642155555 <- ( fcba9876543210 , f55555 ) + +[53,20]: + int 1cba987654321055555 <- ( fcba9876543210 , 55555 ) + +[53,19]: + int 0e5d4c3b2a190855555 <- ( fcba9876543210 , d5555 ) + +[53,18]: + int 72ea61d950c8415555 <- ( fcba9876543210 , 15555 ) + +[53,17]: + int 397530eca864215555 <- ( fcba9876543210 , f5555 ) + +[53,16]: + int 1cba98765432105555 <- ( fcba9876543210 , 5555 ) + +[53,15]: + int 0e5d4c3b2a19085555 <- ( fcba9876543210 , d555 ) + +[53,14]: + int 72ea61d950c841555 <- ( fcba9876543210 , 1555 ) + +[53,13]: + int 397530eca86421555 <- ( fcba9876543210 , f555 ) + +[53,12]: + int 1cba9876543210555 <- ( fcba9876543210 , 555 ) + +[53,11]: + int 0e5d4c3b2a1908555 <- ( fcba9876543210 , d55 ) + +[53,10]: + int 72ea61d950c84155 <- ( fcba9876543210 , 155 ) + +[53,9]: + int 397530eca8642155 <- ( fcba9876543210 , f55 ) + +[53,8]: + int 1cba987654321055 <- ( fcba9876543210 , 55 ) + +[53,7]: + int 0e5d4c3b2a190855 <- ( fcba9876543210 , d5 ) + +[53,6]: + int 72ea61d950c8415 <- ( fcba9876543210 , 15 ) + +[53,5]: + int 397530eca864215 <- ( fcba9876543210 , f5 ) + +[53,4]: + int 1cba98765432105 <- ( fcba9876543210 , 5 ) + +[53,3]: + int 0e5d4c3b2a19085 <- ( fcba9876543210 , d ) + +[53,2]: + int 72ea61d950c841 <- ( fcba9876543210 , 1 ) + +[53,1]: + int 397530eca86421 <- ( fcba9876543210 , f ) + +[52,64]: + int 0cba9876543210aaaaaaaa55555555 <- ( cba9876543210 , aaaaaaaa55555555 ) + +[52,63]: + int 65d4c3b2a19082aaaaaaa55555555 <- ( cba9876543210 , 2aaaaaaa55555555 ) + +[52,62]: + int 32ea61d950c842aaaaaaa55555555 <- ( cba9876543210 , eaaaaaaa55555555 ) + +[52,61]: + int 197530eca86420aaaaaaa55555555 <- ( cba9876543210 , 0aaaaaaa55555555 ) + +[52,60]: + int 0cba9876543210aaaaaaa55555555 <- ( cba9876543210 , aaaaaaa55555555 ) + +[52,59]: + int 65d4c3b2a19082aaaaaa55555555 <- ( cba9876543210 , 2aaaaaa55555555 ) + +[52,58]: + int 32ea61d950c842aaaaaa55555555 <- ( cba9876543210 , eaaaaaa55555555 ) + +[52,57]: + int 197530eca86420aaaaaa55555555 <- ( cba9876543210 , 0aaaaaa55555555 ) + +[52,56]: + int 0cba9876543210aaaaaa55555555 <- ( cba9876543210 , aaaaaa55555555 ) + +[52,55]: + int 65d4c3b2a19082aaaaa55555555 <- ( cba9876543210 , 2aaaaa55555555 ) + +[52,54]: + int 32ea61d950c842aaaaa55555555 <- ( cba9876543210 , eaaaaa55555555 ) + +[52,53]: + int 197530eca86420aaaaa55555555 <- ( cba9876543210 , 0aaaaa55555555 ) + +[52,52]: + int 0cba9876543210aaaaa55555555 <- ( cba9876543210 , aaaaa55555555 ) + +[52,51]: + int 65d4c3b2a19082aaaa55555555 <- ( cba9876543210 , 2aaaa55555555 ) + +[52,50]: + int 32ea61d950c842aaaa55555555 <- ( cba9876543210 , eaaaa55555555 ) + +[52,49]: + int 197530eca86420aaaa55555555 <- ( cba9876543210 , 0aaaa55555555 ) + +[52,48]: + int 0cba9876543210aaaa55555555 <- ( cba9876543210 , aaaa55555555 ) + +[52,47]: + int 65d4c3b2a19082aaa55555555 <- ( cba9876543210 , 2aaa55555555 ) + +[52,46]: + int 32ea61d950c842aaa55555555 <- ( cba9876543210 , eaaa55555555 ) + +[52,45]: + int 197530eca86420aaa55555555 <- ( cba9876543210 , 0aaa55555555 ) + +[52,44]: + int 0cba9876543210aaa55555555 <- ( cba9876543210 , aaa55555555 ) + +[52,43]: + int 65d4c3b2a19082aa55555555 <- ( cba9876543210 , 2aa55555555 ) + +[52,42]: + int 32ea61d950c842aa55555555 <- ( cba9876543210 , eaa55555555 ) + +[52,41]: + int 197530eca86420aa55555555 <- ( cba9876543210 , 0aa55555555 ) + +[52,40]: + int 0cba9876543210aa55555555 <- ( cba9876543210 , aa55555555 ) + +[52,39]: + int 65d4c3b2a19082a55555555 <- ( cba9876543210 , 2a55555555 ) + +[52,38]: + int 32ea61d950c842a55555555 <- ( cba9876543210 , ea55555555 ) + +[52,37]: + int 197530eca86420a55555555 <- ( cba9876543210 , 0a55555555 ) + +[52,36]: + int 0cba9876543210a55555555 <- ( cba9876543210 , a55555555 ) + +[52,35]: + int 65d4c3b2a1908255555555 <- ( cba9876543210 , 255555555 ) + +[52,34]: + int 32ea61d950c84255555555 <- ( cba9876543210 , e55555555 ) + +[52,33]: + int 197530eca8642055555555 <- ( cba9876543210 , 055555555 ) + +[52,32]: + int 0cba987654321055555555 <- ( cba9876543210 , 55555555 ) + +[52,31]: + int 65d4c3b2a190855555555 <- ( cba9876543210 , d5555555 ) + +[52,30]: + int 32ea61d950c8415555555 <- ( cba9876543210 , 15555555 ) + +[52,29]: + int 197530eca864215555555 <- ( cba9876543210 , f5555555 ) + +[52,28]: + int 0cba98765432105555555 <- ( cba9876543210 , 5555555 ) + +[52,27]: + int 65d4c3b2a19085555555 <- ( cba9876543210 , d555555 ) + +[52,26]: + int 32ea61d950c841555555 <- ( cba9876543210 , 1555555 ) + +[52,25]: + int 197530eca86421555555 <- ( cba9876543210 , f555555 ) + +[52,24]: + int 0cba9876543210555555 <- ( cba9876543210 , 555555 ) + +[52,23]: + int 65d4c3b2a1908555555 <- ( cba9876543210 , d55555 ) + +[52,22]: + int 32ea61d950c84155555 <- ( cba9876543210 , 155555 ) + +[52,21]: + int 197530eca8642155555 <- ( cba9876543210 , f55555 ) + +[52,20]: + int 0cba987654321055555 <- ( cba9876543210 , 55555 ) + +[52,19]: + int 65d4c3b2a190855555 <- ( cba9876543210 , d5555 ) + +[52,18]: + int 32ea61d950c8415555 <- ( cba9876543210 , 15555 ) + +[52,17]: + int 197530eca864215555 <- ( cba9876543210 , f5555 ) + +[52,16]: + int 0cba98765432105555 <- ( cba9876543210 , 5555 ) + +[52,15]: + int 65d4c3b2a19085555 <- ( cba9876543210 , d555 ) + +[52,14]: + int 32ea61d950c841555 <- ( cba9876543210 , 1555 ) + +[52,13]: + int 197530eca86421555 <- ( cba9876543210 , f555 ) + +[52,12]: + int 0cba9876543210555 <- ( cba9876543210 , 555 ) + +[52,11]: + int 65d4c3b2a1908555 <- ( cba9876543210 , d55 ) + +[52,10]: + int 32ea61d950c84155 <- ( cba9876543210 , 155 ) + +[52,9]: + int 197530eca8642155 <- ( cba9876543210 , f55 ) + +[52,8]: + int 0cba987654321055 <- ( cba9876543210 , 55 ) + +[52,7]: + int 65d4c3b2a190855 <- ( cba9876543210 , d5 ) + +[52,6]: + int 32ea61d950c8415 <- ( cba9876543210 , 15 ) + +[52,5]: + int 197530eca864215 <- ( cba9876543210 , f5 ) + +[52,4]: + int 0cba98765432105 <- ( cba9876543210 , 5 ) + +[52,3]: + int 65d4c3b2a19085 <- ( cba9876543210 , d ) + +[52,2]: + int 32ea61d950c841 <- ( cba9876543210 , 1 ) + +[52,1]: + int 197530eca86421 <- ( cba9876543210 , f ) + +[51,64]: + int 4ba9876543210aaaaaaaa55555555 <- ( cba9876543210 , aaaaaaaa55555555 ) + +[51,63]: + int 25d4c3b2a19082aaaaaaa55555555 <- ( cba9876543210 , 2aaaaaaa55555555 ) + +[51,62]: + int 12ea61d950c842aaaaaaa55555555 <- ( cba9876543210 , eaaaaaaa55555555 ) + +[51,61]: + int 097530eca86420aaaaaaa55555555 <- ( cba9876543210 , 0aaaaaaa55555555 ) + +[51,60]: + int 4ba9876543210aaaaaaa55555555 <- ( cba9876543210 , aaaaaaa55555555 ) + +[51,59]: + int 25d4c3b2a19082aaaaaa55555555 <- ( cba9876543210 , 2aaaaaa55555555 ) + +[51,58]: + int 12ea61d950c842aaaaaa55555555 <- ( cba9876543210 , eaaaaaa55555555 ) + +[51,57]: + int 097530eca86420aaaaaa55555555 <- ( cba9876543210 , 0aaaaaa55555555 ) + +[51,56]: + int 4ba9876543210aaaaaa55555555 <- ( cba9876543210 , aaaaaa55555555 ) + +[51,55]: + int 25d4c3b2a19082aaaaa55555555 <- ( cba9876543210 , 2aaaaa55555555 ) + +[51,54]: + int 12ea61d950c842aaaaa55555555 <- ( cba9876543210 , eaaaaa55555555 ) + +[51,53]: + int 097530eca86420aaaaa55555555 <- ( cba9876543210 , 0aaaaa55555555 ) + +[51,52]: + int 4ba9876543210aaaaa55555555 <- ( cba9876543210 , aaaaa55555555 ) + +[51,51]: + int 25d4c3b2a19082aaaa55555555 <- ( cba9876543210 , 2aaaa55555555 ) + +[51,50]: + int 12ea61d950c842aaaa55555555 <- ( cba9876543210 , eaaaa55555555 ) + +[51,49]: + int 097530eca86420aaaa55555555 <- ( cba9876543210 , 0aaaa55555555 ) + +[51,48]: + int 4ba9876543210aaaa55555555 <- ( cba9876543210 , aaaa55555555 ) + +[51,47]: + int 25d4c3b2a19082aaa55555555 <- ( cba9876543210 , 2aaa55555555 ) + +[51,46]: + int 12ea61d950c842aaa55555555 <- ( cba9876543210 , eaaa55555555 ) + +[51,45]: + int 097530eca86420aaa55555555 <- ( cba9876543210 , 0aaa55555555 ) + +[51,44]: + int 4ba9876543210aaa55555555 <- ( cba9876543210 , aaa55555555 ) + +[51,43]: + int 25d4c3b2a19082aa55555555 <- ( cba9876543210 , 2aa55555555 ) + +[51,42]: + int 12ea61d950c842aa55555555 <- ( cba9876543210 , eaa55555555 ) + +[51,41]: + int 097530eca86420aa55555555 <- ( cba9876543210 , 0aa55555555 ) + +[51,40]: + int 4ba9876543210aa55555555 <- ( cba9876543210 , aa55555555 ) + +[51,39]: + int 25d4c3b2a19082a55555555 <- ( cba9876543210 , 2a55555555 ) + +[51,38]: + int 12ea61d950c842a55555555 <- ( cba9876543210 , ea55555555 ) + +[51,37]: + int 097530eca86420a55555555 <- ( cba9876543210 , 0a55555555 ) + +[51,36]: + int 4ba9876543210a55555555 <- ( cba9876543210 , a55555555 ) + +[51,35]: + int 25d4c3b2a1908255555555 <- ( cba9876543210 , 255555555 ) + +[51,34]: + int 12ea61d950c84255555555 <- ( cba9876543210 , e55555555 ) + +[51,33]: + int 097530eca8642055555555 <- ( cba9876543210 , 055555555 ) + +[51,32]: + int 4ba987654321055555555 <- ( cba9876543210 , 55555555 ) + +[51,31]: + int 25d4c3b2a190855555555 <- ( cba9876543210 , d5555555 ) + +[51,30]: + int 12ea61d950c8415555555 <- ( cba9876543210 , 15555555 ) + +[51,29]: + int 097530eca864215555555 <- ( cba9876543210 , f5555555 ) + +[51,28]: + int 4ba98765432105555555 <- ( cba9876543210 , 5555555 ) + +[51,27]: + int 25d4c3b2a19085555555 <- ( cba9876543210 , d555555 ) + +[51,26]: + int 12ea61d950c841555555 <- ( cba9876543210 , 1555555 ) + +[51,25]: + int 097530eca86421555555 <- ( cba9876543210 , f555555 ) + +[51,24]: + int 4ba9876543210555555 <- ( cba9876543210 , 555555 ) + +[51,23]: + int 25d4c3b2a1908555555 <- ( cba9876543210 , d55555 ) + +[51,22]: + int 12ea61d950c84155555 <- ( cba9876543210 , 155555 ) + +[51,21]: + int 097530eca8642155555 <- ( cba9876543210 , f55555 ) + +[51,20]: + int 4ba987654321055555 <- ( cba9876543210 , 55555 ) + +[51,19]: + int 25d4c3b2a190855555 <- ( cba9876543210 , d5555 ) + +[51,18]: + int 12ea61d950c8415555 <- ( cba9876543210 , 15555 ) + +[51,17]: + int 097530eca864215555 <- ( cba9876543210 , f5555 ) + +[51,16]: + int 4ba98765432105555 <- ( cba9876543210 , 5555 ) + +[51,15]: + int 25d4c3b2a19085555 <- ( cba9876543210 , d555 ) + +[51,14]: + int 12ea61d950c841555 <- ( cba9876543210 , 1555 ) + +[51,13]: + int 097530eca86421555 <- ( cba9876543210 , f555 ) + +[51,12]: + int 4ba9876543210555 <- ( cba9876543210 , 555 ) + +[51,11]: + int 25d4c3b2a1908555 <- ( cba9876543210 , d55 ) + +[51,10]: + int 12ea61d950c84155 <- ( cba9876543210 , 155 ) + +[51,9]: + int 097530eca8642155 <- ( cba9876543210 , f55 ) + +[51,8]: + int 4ba987654321055 <- ( cba9876543210 , 55 ) + +[51,7]: + int 25d4c3b2a190855 <- ( cba9876543210 , d5 ) + +[51,6]: + int 12ea61d950c8415 <- ( cba9876543210 , 15 ) + +[51,5]: + int 097530eca864215 <- ( cba9876543210 , f5 ) + +[51,4]: + int 4ba98765432105 <- ( cba9876543210 , 5 ) + +[51,3]: + int 25d4c3b2a19085 <- ( cba9876543210 , d ) + +[51,2]: + int 12ea61d950c841 <- ( cba9876543210 , 1 ) + +[51,1]: + int 097530eca86421 <- ( cba9876543210 , f ) + +[50,64]: + int 0ba9876543210aaaaaaaa55555555 <- ( 0ba9876543210 , aaaaaaaa55555555 ) + +[50,63]: + int 05d4c3b2a19082aaaaaaa55555555 <- ( 0ba9876543210 , 2aaaaaaa55555555 ) + +[50,62]: + int 02ea61d950c842aaaaaaa55555555 <- ( 0ba9876543210 , eaaaaaaa55555555 ) + +[50,61]: + int 17530eca86420aaaaaaa55555555 <- ( 0ba9876543210 , 0aaaaaaa55555555 ) + +[50,60]: + int 0ba9876543210aaaaaaa55555555 <- ( 0ba9876543210 , aaaaaaa55555555 ) + +[50,59]: + int 05d4c3b2a19082aaaaaa55555555 <- ( 0ba9876543210 , 2aaaaaa55555555 ) + +[50,58]: + int 02ea61d950c842aaaaaa55555555 <- ( 0ba9876543210 , eaaaaaa55555555 ) + +[50,57]: + int 17530eca86420aaaaaa55555555 <- ( 0ba9876543210 , 0aaaaaa55555555 ) + +[50,56]: + int 0ba9876543210aaaaaa55555555 <- ( 0ba9876543210 , aaaaaa55555555 ) + +[50,55]: + int 05d4c3b2a19082aaaaa55555555 <- ( 0ba9876543210 , 2aaaaa55555555 ) + +[50,54]: + int 02ea61d950c842aaaaa55555555 <- ( 0ba9876543210 , eaaaaa55555555 ) + +[50,53]: + int 17530eca86420aaaaa55555555 <- ( 0ba9876543210 , 0aaaaa55555555 ) + +[50,52]: + int 0ba9876543210aaaaa55555555 <- ( 0ba9876543210 , aaaaa55555555 ) + +[50,51]: + int 05d4c3b2a19082aaaa55555555 <- ( 0ba9876543210 , 2aaaa55555555 ) + +[50,50]: + int 02ea61d950c842aaaa55555555 <- ( 0ba9876543210 , eaaaa55555555 ) + +[50,49]: + int 17530eca86420aaaa55555555 <- ( 0ba9876543210 , 0aaaa55555555 ) + +[50,48]: + int 0ba9876543210aaaa55555555 <- ( 0ba9876543210 , aaaa55555555 ) + +[50,47]: + int 05d4c3b2a19082aaa55555555 <- ( 0ba9876543210 , 2aaa55555555 ) + +[50,46]: + int 02ea61d950c842aaa55555555 <- ( 0ba9876543210 , eaaa55555555 ) + +[50,45]: + int 17530eca86420aaa55555555 <- ( 0ba9876543210 , 0aaa55555555 ) + +[50,44]: + int 0ba9876543210aaa55555555 <- ( 0ba9876543210 , aaa55555555 ) + +[50,43]: + int 05d4c3b2a19082aa55555555 <- ( 0ba9876543210 , 2aa55555555 ) + +[50,42]: + int 02ea61d950c842aa55555555 <- ( 0ba9876543210 , eaa55555555 ) + +[50,41]: + int 17530eca86420aa55555555 <- ( 0ba9876543210 , 0aa55555555 ) + +[50,40]: + int 0ba9876543210aa55555555 <- ( 0ba9876543210 , aa55555555 ) + +[50,39]: + int 05d4c3b2a19082a55555555 <- ( 0ba9876543210 , 2a55555555 ) + +[50,38]: + int 02ea61d950c842a55555555 <- ( 0ba9876543210 , ea55555555 ) + +[50,37]: + int 17530eca86420a55555555 <- ( 0ba9876543210 , 0a55555555 ) + +[50,36]: + int 0ba9876543210a55555555 <- ( 0ba9876543210 , a55555555 ) + +[50,35]: + int 05d4c3b2a1908255555555 <- ( 0ba9876543210 , 255555555 ) + +[50,34]: + int 02ea61d950c84255555555 <- ( 0ba9876543210 , e55555555 ) + +[50,33]: + int 17530eca8642055555555 <- ( 0ba9876543210 , 055555555 ) + +[50,32]: + int 0ba987654321055555555 <- ( 0ba9876543210 , 55555555 ) + +[50,31]: + int 05d4c3b2a190855555555 <- ( 0ba9876543210 , d5555555 ) + +[50,30]: + int 02ea61d950c8415555555 <- ( 0ba9876543210 , 15555555 ) + +[50,29]: + int 17530eca864215555555 <- ( 0ba9876543210 , f5555555 ) + +[50,28]: + int 0ba98765432105555555 <- ( 0ba9876543210 , 5555555 ) + +[50,27]: + int 05d4c3b2a19085555555 <- ( 0ba9876543210 , d555555 ) + +[50,26]: + int 02ea61d950c841555555 <- ( 0ba9876543210 , 1555555 ) + +[50,25]: + int 17530eca86421555555 <- ( 0ba9876543210 , f555555 ) + +[50,24]: + int 0ba9876543210555555 <- ( 0ba9876543210 , 555555 ) + +[50,23]: + int 05d4c3b2a1908555555 <- ( 0ba9876543210 , d55555 ) + +[50,22]: + int 02ea61d950c84155555 <- ( 0ba9876543210 , 155555 ) + +[50,21]: + int 17530eca8642155555 <- ( 0ba9876543210 , f55555 ) + +[50,20]: + int 0ba987654321055555 <- ( 0ba9876543210 , 55555 ) + +[50,19]: + int 05d4c3b2a190855555 <- ( 0ba9876543210 , d5555 ) + +[50,18]: + int 02ea61d950c8415555 <- ( 0ba9876543210 , 15555 ) + +[50,17]: + int 17530eca864215555 <- ( 0ba9876543210 , f5555 ) + +[50,16]: + int 0ba98765432105555 <- ( 0ba9876543210 , 5555 ) + +[50,15]: + int 05d4c3b2a19085555 <- ( 0ba9876543210 , d555 ) + +[50,14]: + int 02ea61d950c841555 <- ( 0ba9876543210 , 1555 ) + +[50,13]: + int 17530eca86421555 <- ( 0ba9876543210 , f555 ) + +[50,12]: + int 0ba9876543210555 <- ( 0ba9876543210 , 555 ) + +[50,11]: + int 05d4c3b2a1908555 <- ( 0ba9876543210 , d55 ) + +[50,10]: + int 02ea61d950c84155 <- ( 0ba9876543210 , 155 ) + +[50,9]: + int 17530eca8642155 <- ( 0ba9876543210 , f55 ) + +[50,8]: + int 0ba987654321055 <- ( 0ba9876543210 , 55 ) + +[50,7]: + int 05d4c3b2a190855 <- ( 0ba9876543210 , d5 ) + +[50,6]: + int 02ea61d950c8415 <- ( 0ba9876543210 , 15 ) + +[50,5]: + int 17530eca864215 <- ( 0ba9876543210 , f5 ) + +[50,4]: + int 0ba98765432105 <- ( 0ba9876543210 , 5 ) + +[50,3]: + int 05d4c3b2a19085 <- ( 0ba9876543210 , d ) + +[50,2]: + int 02ea61d950c841 <- ( 0ba9876543210 , 1 ) + +[50,1]: + int 17530eca86421 <- ( 0ba9876543210 , f ) + +[49,64]: + int 0ba9876543210aaaaaaaa55555555 <- ( 0ba9876543210 , aaaaaaaa55555555 ) + +[49,63]: + int 05d4c3b2a19082aaaaaaa55555555 <- ( 0ba9876543210 , 2aaaaaaa55555555 ) + +[49,62]: + int 2ea61d950c842aaaaaaa55555555 <- ( 0ba9876543210 , eaaaaaaa55555555 ) + +[49,61]: + int 17530eca86420aaaaaaa55555555 <- ( 0ba9876543210 , 0aaaaaaa55555555 ) + +[49,60]: + int 0ba9876543210aaaaaaa55555555 <- ( 0ba9876543210 , aaaaaaa55555555 ) + +[49,59]: + int 05d4c3b2a19082aaaaaa55555555 <- ( 0ba9876543210 , 2aaaaaa55555555 ) + +[49,58]: + int 2ea61d950c842aaaaaa55555555 <- ( 0ba9876543210 , eaaaaaa55555555 ) + +[49,57]: + int 17530eca86420aaaaaa55555555 <- ( 0ba9876543210 , 0aaaaaa55555555 ) + +[49,56]: + int 0ba9876543210aaaaaa55555555 <- ( 0ba9876543210 , aaaaaa55555555 ) + +[49,55]: + int 05d4c3b2a19082aaaaa55555555 <- ( 0ba9876543210 , 2aaaaa55555555 ) + +[49,54]: + int 2ea61d950c842aaaaa55555555 <- ( 0ba9876543210 , eaaaaa55555555 ) + +[49,53]: + int 17530eca86420aaaaa55555555 <- ( 0ba9876543210 , 0aaaaa55555555 ) + +[49,52]: + int 0ba9876543210aaaaa55555555 <- ( 0ba9876543210 , aaaaa55555555 ) + +[49,51]: + int 05d4c3b2a19082aaaa55555555 <- ( 0ba9876543210 , 2aaaa55555555 ) + +[49,50]: + int 2ea61d950c842aaaa55555555 <- ( 0ba9876543210 , eaaaa55555555 ) + +[49,49]: + int 17530eca86420aaaa55555555 <- ( 0ba9876543210 , 0aaaa55555555 ) + +[49,48]: + int 0ba9876543210aaaa55555555 <- ( 0ba9876543210 , aaaa55555555 ) + +[49,47]: + int 05d4c3b2a19082aaa55555555 <- ( 0ba9876543210 , 2aaa55555555 ) + +[49,46]: + int 2ea61d950c842aaa55555555 <- ( 0ba9876543210 , eaaa55555555 ) + +[49,45]: + int 17530eca86420aaa55555555 <- ( 0ba9876543210 , 0aaa55555555 ) + +[49,44]: + int 0ba9876543210aaa55555555 <- ( 0ba9876543210 , aaa55555555 ) + +[49,43]: + int 05d4c3b2a19082aa55555555 <- ( 0ba9876543210 , 2aa55555555 ) + +[49,42]: + int 2ea61d950c842aa55555555 <- ( 0ba9876543210 , eaa55555555 ) + +[49,41]: + int 17530eca86420aa55555555 <- ( 0ba9876543210 , 0aa55555555 ) + +[49,40]: + int 0ba9876543210aa55555555 <- ( 0ba9876543210 , aa55555555 ) + +[49,39]: + int 05d4c3b2a19082a55555555 <- ( 0ba9876543210 , 2a55555555 ) + +[49,38]: + int 2ea61d950c842a55555555 <- ( 0ba9876543210 , ea55555555 ) + +[49,37]: + int 17530eca86420a55555555 <- ( 0ba9876543210 , 0a55555555 ) + +[49,36]: + int 0ba9876543210a55555555 <- ( 0ba9876543210 , a55555555 ) + +[49,35]: + int 05d4c3b2a1908255555555 <- ( 0ba9876543210 , 255555555 ) + +[49,34]: + int 2ea61d950c84255555555 <- ( 0ba9876543210 , e55555555 ) + +[49,33]: + int 17530eca8642055555555 <- ( 0ba9876543210 , 055555555 ) + +[49,32]: + int 0ba987654321055555555 <- ( 0ba9876543210 , 55555555 ) + +[49,31]: + int 05d4c3b2a190855555555 <- ( 0ba9876543210 , d5555555 ) + +[49,30]: + int 2ea61d950c8415555555 <- ( 0ba9876543210 , 15555555 ) + +[49,29]: + int 17530eca864215555555 <- ( 0ba9876543210 , f5555555 ) + +[49,28]: + int 0ba98765432105555555 <- ( 0ba9876543210 , 5555555 ) + +[49,27]: + int 05d4c3b2a19085555555 <- ( 0ba9876543210 , d555555 ) + +[49,26]: + int 2ea61d950c841555555 <- ( 0ba9876543210 , 1555555 ) + +[49,25]: + int 17530eca86421555555 <- ( 0ba9876543210 , f555555 ) + +[49,24]: + int 0ba9876543210555555 <- ( 0ba9876543210 , 555555 ) + +[49,23]: + int 05d4c3b2a1908555555 <- ( 0ba9876543210 , d55555 ) + +[49,22]: + int 2ea61d950c84155555 <- ( 0ba9876543210 , 155555 ) + +[49,21]: + int 17530eca8642155555 <- ( 0ba9876543210 , f55555 ) + +[49,20]: + int 0ba987654321055555 <- ( 0ba9876543210 , 55555 ) + +[49,19]: + int 05d4c3b2a190855555 <- ( 0ba9876543210 , d5555 ) + +[49,18]: + int 2ea61d950c8415555 <- ( 0ba9876543210 , 15555 ) + +[49,17]: + int 17530eca864215555 <- ( 0ba9876543210 , f5555 ) + +[49,16]: + int 0ba98765432105555 <- ( 0ba9876543210 , 5555 ) + +[49,15]: + int 05d4c3b2a19085555 <- ( 0ba9876543210 , d555 ) + +[49,14]: + int 2ea61d950c841555 <- ( 0ba9876543210 , 1555 ) + +[49,13]: + int 17530eca86421555 <- ( 0ba9876543210 , f555 ) + +[49,12]: + int 0ba9876543210555 <- ( 0ba9876543210 , 555 ) + +[49,11]: + int 05d4c3b2a1908555 <- ( 0ba9876543210 , d55 ) + +[49,10]: + int 2ea61d950c84155 <- ( 0ba9876543210 , 155 ) + +[49,9]: + int 17530eca8642155 <- ( 0ba9876543210 , f55 ) + +[49,8]: + int 0ba987654321055 <- ( 0ba9876543210 , 55 ) + +[49,7]: + int 05d4c3b2a190855 <- ( 0ba9876543210 , d5 ) + +[49,6]: + int 2ea61d950c8415 <- ( 0ba9876543210 , 15 ) + +[49,5]: + int 17530eca864215 <- ( 0ba9876543210 , f5 ) + +[49,4]: + int 0ba98765432105 <- ( 0ba9876543210 , 5 ) + +[49,3]: + int 05d4c3b2a19085 <- ( 0ba9876543210 , d ) + +[49,2]: + int 2ea61d950c841 <- ( 0ba9876543210 , 1 ) + +[49,1]: + int 17530eca86421 <- ( 0ba9876543210 , f ) + +[48,64]: + int 0ba9876543210aaaaaaaa55555555 <- ( ba9876543210 , aaaaaaaa55555555 ) + +[48,63]: + int 5d4c3b2a19082aaaaaaa55555555 <- ( ba9876543210 , 2aaaaaaa55555555 ) + +[48,62]: + int 2ea61d950c842aaaaaaa55555555 <- ( ba9876543210 , eaaaaaaa55555555 ) + +[48,61]: + int 17530eca86420aaaaaaa55555555 <- ( ba9876543210 , 0aaaaaaa55555555 ) + +[48,60]: + int 0ba9876543210aaaaaaa55555555 <- ( ba9876543210 , aaaaaaa55555555 ) + +[48,59]: + int 5d4c3b2a19082aaaaaa55555555 <- ( ba9876543210 , 2aaaaaa55555555 ) + +[48,58]: + int 2ea61d950c842aaaaaa55555555 <- ( ba9876543210 , eaaaaaa55555555 ) + +[48,57]: + int 17530eca86420aaaaaa55555555 <- ( ba9876543210 , 0aaaaaa55555555 ) + +[48,56]: + int 0ba9876543210aaaaaa55555555 <- ( ba9876543210 , aaaaaa55555555 ) + +[48,55]: + int 5d4c3b2a19082aaaaa55555555 <- ( ba9876543210 , 2aaaaa55555555 ) + +[48,54]: + int 2ea61d950c842aaaaa55555555 <- ( ba9876543210 , eaaaaa55555555 ) + +[48,53]: + int 17530eca86420aaaaa55555555 <- ( ba9876543210 , 0aaaaa55555555 ) + +[48,52]: + int 0ba9876543210aaaaa55555555 <- ( ba9876543210 , aaaaa55555555 ) + +[48,51]: + int 5d4c3b2a19082aaaa55555555 <- ( ba9876543210 , 2aaaa55555555 ) + +[48,50]: + int 2ea61d950c842aaaa55555555 <- ( ba9876543210 , eaaaa55555555 ) + +[48,49]: + int 17530eca86420aaaa55555555 <- ( ba9876543210 , 0aaaa55555555 ) + +[48,48]: + int 0ba9876543210aaaa55555555 <- ( ba9876543210 , aaaa55555555 ) + +[48,47]: + int 5d4c3b2a19082aaa55555555 <- ( ba9876543210 , 2aaa55555555 ) + +[48,46]: + int 2ea61d950c842aaa55555555 <- ( ba9876543210 , eaaa55555555 ) + +[48,45]: + int 17530eca86420aaa55555555 <- ( ba9876543210 , 0aaa55555555 ) + +[48,44]: + int 0ba9876543210aaa55555555 <- ( ba9876543210 , aaa55555555 ) + +[48,43]: + int 5d4c3b2a19082aa55555555 <- ( ba9876543210 , 2aa55555555 ) + +[48,42]: + int 2ea61d950c842aa55555555 <- ( ba9876543210 , eaa55555555 ) + +[48,41]: + int 17530eca86420aa55555555 <- ( ba9876543210 , 0aa55555555 ) + +[48,40]: + int 0ba9876543210aa55555555 <- ( ba9876543210 , aa55555555 ) + +[48,39]: + int 5d4c3b2a19082a55555555 <- ( ba9876543210 , 2a55555555 ) + +[48,38]: + int 2ea61d950c842a55555555 <- ( ba9876543210 , ea55555555 ) + +[48,37]: + int 17530eca86420a55555555 <- ( ba9876543210 , 0a55555555 ) + +[48,36]: + int 0ba9876543210a55555555 <- ( ba9876543210 , a55555555 ) + +[48,35]: + int 5d4c3b2a1908255555555 <- ( ba9876543210 , 255555555 ) + +[48,34]: + int 2ea61d950c84255555555 <- ( ba9876543210 , e55555555 ) + +[48,33]: + int 17530eca8642055555555 <- ( ba9876543210 , 055555555 ) + +[48,32]: + int 0ba987654321055555555 <- ( ba9876543210 , 55555555 ) + +[48,31]: + int 5d4c3b2a190855555555 <- ( ba9876543210 , d5555555 ) + +[48,30]: + int 2ea61d950c8415555555 <- ( ba9876543210 , 15555555 ) + +[48,29]: + int 17530eca864215555555 <- ( ba9876543210 , f5555555 ) + +[48,28]: + int 0ba98765432105555555 <- ( ba9876543210 , 5555555 ) + +[48,27]: + int 5d4c3b2a19085555555 <- ( ba9876543210 , d555555 ) + +[48,26]: + int 2ea61d950c841555555 <- ( ba9876543210 , 1555555 ) + +[48,25]: + int 17530eca86421555555 <- ( ba9876543210 , f555555 ) + +[48,24]: + int 0ba9876543210555555 <- ( ba9876543210 , 555555 ) + +[48,23]: + int 5d4c3b2a1908555555 <- ( ba9876543210 , d55555 ) + +[48,22]: + int 2ea61d950c84155555 <- ( ba9876543210 , 155555 ) + +[48,21]: + int 17530eca8642155555 <- ( ba9876543210 , f55555 ) + +[48,20]: + int 0ba987654321055555 <- ( ba9876543210 , 55555 ) + +[48,19]: + int 5d4c3b2a190855555 <- ( ba9876543210 , d5555 ) + +[48,18]: + int 2ea61d950c8415555 <- ( ba9876543210 , 15555 ) + +[48,17]: + int 17530eca864215555 <- ( ba9876543210 , f5555 ) + +[48,16]: + int 0ba98765432105555 <- ( ba9876543210 , 5555 ) + +[48,15]: + int 5d4c3b2a19085555 <- ( ba9876543210 , d555 ) + +[48,14]: + int 2ea61d950c841555 <- ( ba9876543210 , 1555 ) + +[48,13]: + int 17530eca86421555 <- ( ba9876543210 , f555 ) + +[48,12]: + int 0ba9876543210555 <- ( ba9876543210 , 555 ) + +[48,11]: + int 5d4c3b2a1908555 <- ( ba9876543210 , d55 ) + +[48,10]: + int 2ea61d950c84155 <- ( ba9876543210 , 155 ) + +[48,9]: + int 17530eca8642155 <- ( ba9876543210 , f55 ) + +[48,8]: + int 0ba987654321055 <- ( ba9876543210 , 55 ) + +[48,7]: + int 5d4c3b2a190855 <- ( ba9876543210 , d5 ) + +[48,6]: + int 2ea61d950c8415 <- ( ba9876543210 , 15 ) + +[48,5]: + int 17530eca864215 <- ( ba9876543210 , f5 ) + +[48,4]: + int 0ba98765432105 <- ( ba9876543210 , 5 ) + +[48,3]: + int 5d4c3b2a19085 <- ( ba9876543210 , d ) + +[48,2]: + int 2ea61d950c841 <- ( ba9876543210 , 1 ) + +[48,1]: + int 17530eca86421 <- ( ba9876543210 , f ) + +[47,64]: + int 3a9876543210aaaaaaaa55555555 <- ( 3a9876543210 , aaaaaaaa55555555 ) + +[47,63]: + int 1d4c3b2a19082aaaaaaa55555555 <- ( 3a9876543210 , 2aaaaaaa55555555 ) + +[47,62]: + int 0ea61d950c842aaaaaaa55555555 <- ( 3a9876543210 , eaaaaaaa55555555 ) + +[47,61]: + int 07530eca86420aaaaaaa55555555 <- ( 3a9876543210 , 0aaaaaaa55555555 ) + +[47,60]: + int 3a9876543210aaaaaaa55555555 <- ( 3a9876543210 , aaaaaaa55555555 ) + +[47,59]: + int 1d4c3b2a19082aaaaaa55555555 <- ( 3a9876543210 , 2aaaaaa55555555 ) + +[47,58]: + int 0ea61d950c842aaaaaa55555555 <- ( 3a9876543210 , eaaaaaa55555555 ) + +[47,57]: + int 07530eca86420aaaaaa55555555 <- ( 3a9876543210 , 0aaaaaa55555555 ) + +[47,56]: + int 3a9876543210aaaaaa55555555 <- ( 3a9876543210 , aaaaaa55555555 ) + +[47,55]: + int 1d4c3b2a19082aaaaa55555555 <- ( 3a9876543210 , 2aaaaa55555555 ) + +[47,54]: + int 0ea61d950c842aaaaa55555555 <- ( 3a9876543210 , eaaaaa55555555 ) + +[47,53]: + int 07530eca86420aaaaa55555555 <- ( 3a9876543210 , 0aaaaa55555555 ) + +[47,52]: + int 3a9876543210aaaaa55555555 <- ( 3a9876543210 , aaaaa55555555 ) + +[47,51]: + int 1d4c3b2a19082aaaa55555555 <- ( 3a9876543210 , 2aaaa55555555 ) + +[47,50]: + int 0ea61d950c842aaaa55555555 <- ( 3a9876543210 , eaaaa55555555 ) + +[47,49]: + int 07530eca86420aaaa55555555 <- ( 3a9876543210 , 0aaaa55555555 ) + +[47,48]: + int 3a9876543210aaaa55555555 <- ( 3a9876543210 , aaaa55555555 ) + +[47,47]: + int 1d4c3b2a19082aaa55555555 <- ( 3a9876543210 , 2aaa55555555 ) + +[47,46]: + int 0ea61d950c842aaa55555555 <- ( 3a9876543210 , eaaa55555555 ) + +[47,45]: + int 07530eca86420aaa55555555 <- ( 3a9876543210 , 0aaa55555555 ) + +[47,44]: + int 3a9876543210aaa55555555 <- ( 3a9876543210 , aaa55555555 ) + +[47,43]: + int 1d4c3b2a19082aa55555555 <- ( 3a9876543210 , 2aa55555555 ) + +[47,42]: + int 0ea61d950c842aa55555555 <- ( 3a9876543210 , eaa55555555 ) + +[47,41]: + int 07530eca86420aa55555555 <- ( 3a9876543210 , 0aa55555555 ) + +[47,40]: + int 3a9876543210aa55555555 <- ( 3a9876543210 , aa55555555 ) + +[47,39]: + int 1d4c3b2a19082a55555555 <- ( 3a9876543210 , 2a55555555 ) + +[47,38]: + int 0ea61d950c842a55555555 <- ( 3a9876543210 , ea55555555 ) + +[47,37]: + int 07530eca86420a55555555 <- ( 3a9876543210 , 0a55555555 ) + +[47,36]: + int 3a9876543210a55555555 <- ( 3a9876543210 , a55555555 ) + +[47,35]: + int 1d4c3b2a1908255555555 <- ( 3a9876543210 , 255555555 ) + +[47,34]: + int 0ea61d950c84255555555 <- ( 3a9876543210 , e55555555 ) + +[47,33]: + int 07530eca8642055555555 <- ( 3a9876543210 , 055555555 ) + +[47,32]: + int 3a987654321055555555 <- ( 3a9876543210 , 55555555 ) + +[47,31]: + int 1d4c3b2a190855555555 <- ( 3a9876543210 , d5555555 ) + +[47,30]: + int 0ea61d950c8415555555 <- ( 3a9876543210 , 15555555 ) + +[47,29]: + int 07530eca864215555555 <- ( 3a9876543210 , f5555555 ) + +[47,28]: + int 3a98765432105555555 <- ( 3a9876543210 , 5555555 ) + +[47,27]: + int 1d4c3b2a19085555555 <- ( 3a9876543210 , d555555 ) + +[47,26]: + int 0ea61d950c841555555 <- ( 3a9876543210 , 1555555 ) + +[47,25]: + int 07530eca86421555555 <- ( 3a9876543210 , f555555 ) + +[47,24]: + int 3a9876543210555555 <- ( 3a9876543210 , 555555 ) + +[47,23]: + int 1d4c3b2a1908555555 <- ( 3a9876543210 , d55555 ) + +[47,22]: + int 0ea61d950c84155555 <- ( 3a9876543210 , 155555 ) + +[47,21]: + int 07530eca8642155555 <- ( 3a9876543210 , f55555 ) + +[47,20]: + int 3a987654321055555 <- ( 3a9876543210 , 55555 ) + +[47,19]: + int 1d4c3b2a190855555 <- ( 3a9876543210 , d5555 ) + +[47,18]: + int 0ea61d950c8415555 <- ( 3a9876543210 , 15555 ) + +[47,17]: + int 07530eca864215555 <- ( 3a9876543210 , f5555 ) + +[47,16]: + int 3a98765432105555 <- ( 3a9876543210 , 5555 ) + +[47,15]: + int 1d4c3b2a19085555 <- ( 3a9876543210 , d555 ) + +[47,14]: + int 0ea61d950c841555 <- ( 3a9876543210 , 1555 ) + +[47,13]: + int 07530eca86421555 <- ( 3a9876543210 , f555 ) + +[47,12]: + int 3a9876543210555 <- ( 3a9876543210 , 555 ) + +[47,11]: + int 1d4c3b2a1908555 <- ( 3a9876543210 , d55 ) + +[47,10]: + int 0ea61d950c84155 <- ( 3a9876543210 , 155 ) + +[47,9]: + int 07530eca8642155 <- ( 3a9876543210 , f55 ) + +[47,8]: + int 3a987654321055 <- ( 3a9876543210 , 55 ) + +[47,7]: + int 1d4c3b2a190855 <- ( 3a9876543210 , d5 ) + +[47,6]: + int 0ea61d950c8415 <- ( 3a9876543210 , 15 ) + +[47,5]: + int 07530eca864215 <- ( 3a9876543210 , f5 ) + +[47,4]: + int 3a98765432105 <- ( 3a9876543210 , 5 ) + +[47,3]: + int 1d4c3b2a19085 <- ( 3a9876543210 , d ) + +[47,2]: + int 0ea61d950c841 <- ( 3a9876543210 , 1 ) + +[47,1]: + int 07530eca86421 <- ( 3a9876543210 , f ) + +[46,64]: + int 3a9876543210aaaaaaaa55555555 <- ( fa9876543210 , aaaaaaaa55555555 ) + +[46,63]: + int 1d4c3b2a19082aaaaaaa55555555 <- ( fa9876543210 , 2aaaaaaa55555555 ) + +[46,62]: + int 0ea61d950c842aaaaaaa55555555 <- ( fa9876543210 , eaaaaaaa55555555 ) + +[46,61]: + int 7530eca86420aaaaaaa55555555 <- ( fa9876543210 , 0aaaaaaa55555555 ) + +[46,60]: + int 3a9876543210aaaaaaa55555555 <- ( fa9876543210 , aaaaaaa55555555 ) + +[46,59]: + int 1d4c3b2a19082aaaaaa55555555 <- ( fa9876543210 , 2aaaaaa55555555 ) + +[46,58]: + int 0ea61d950c842aaaaaa55555555 <- ( fa9876543210 , eaaaaaa55555555 ) + +[46,57]: + int 7530eca86420aaaaaa55555555 <- ( fa9876543210 , 0aaaaaa55555555 ) + +[46,56]: + int 3a9876543210aaaaaa55555555 <- ( fa9876543210 , aaaaaa55555555 ) + +[46,55]: + int 1d4c3b2a19082aaaaa55555555 <- ( fa9876543210 , 2aaaaa55555555 ) + +[46,54]: + int 0ea61d950c842aaaaa55555555 <- ( fa9876543210 , eaaaaa55555555 ) + +[46,53]: + int 7530eca86420aaaaa55555555 <- ( fa9876543210 , 0aaaaa55555555 ) + +[46,52]: + int 3a9876543210aaaaa55555555 <- ( fa9876543210 , aaaaa55555555 ) + +[46,51]: + int 1d4c3b2a19082aaaa55555555 <- ( fa9876543210 , 2aaaa55555555 ) + +[46,50]: + int 0ea61d950c842aaaa55555555 <- ( fa9876543210 , eaaaa55555555 ) + +[46,49]: + int 7530eca86420aaaa55555555 <- ( fa9876543210 , 0aaaa55555555 ) + +[46,48]: + int 3a9876543210aaaa55555555 <- ( fa9876543210 , aaaa55555555 ) + +[46,47]: + int 1d4c3b2a19082aaa55555555 <- ( fa9876543210 , 2aaa55555555 ) + +[46,46]: + int 0ea61d950c842aaa55555555 <- ( fa9876543210 , eaaa55555555 ) + +[46,45]: + int 7530eca86420aaa55555555 <- ( fa9876543210 , 0aaa55555555 ) + +[46,44]: + int 3a9876543210aaa55555555 <- ( fa9876543210 , aaa55555555 ) + +[46,43]: + int 1d4c3b2a19082aa55555555 <- ( fa9876543210 , 2aa55555555 ) + +[46,42]: + int 0ea61d950c842aa55555555 <- ( fa9876543210 , eaa55555555 ) + +[46,41]: + int 7530eca86420aa55555555 <- ( fa9876543210 , 0aa55555555 ) + +[46,40]: + int 3a9876543210aa55555555 <- ( fa9876543210 , aa55555555 ) + +[46,39]: + int 1d4c3b2a19082a55555555 <- ( fa9876543210 , 2a55555555 ) + +[46,38]: + int 0ea61d950c842a55555555 <- ( fa9876543210 , ea55555555 ) + +[46,37]: + int 7530eca86420a55555555 <- ( fa9876543210 , 0a55555555 ) + +[46,36]: + int 3a9876543210a55555555 <- ( fa9876543210 , a55555555 ) + +[46,35]: + int 1d4c3b2a1908255555555 <- ( fa9876543210 , 255555555 ) + +[46,34]: + int 0ea61d950c84255555555 <- ( fa9876543210 , e55555555 ) + +[46,33]: + int 7530eca8642055555555 <- ( fa9876543210 , 055555555 ) + +[46,32]: + int 3a987654321055555555 <- ( fa9876543210 , 55555555 ) + +[46,31]: + int 1d4c3b2a190855555555 <- ( fa9876543210 , d5555555 ) + +[46,30]: + int 0ea61d950c8415555555 <- ( fa9876543210 , 15555555 ) + +[46,29]: + int 7530eca864215555555 <- ( fa9876543210 , f5555555 ) + +[46,28]: + int 3a98765432105555555 <- ( fa9876543210 , 5555555 ) + +[46,27]: + int 1d4c3b2a19085555555 <- ( fa9876543210 , d555555 ) + +[46,26]: + int 0ea61d950c841555555 <- ( fa9876543210 , 1555555 ) + +[46,25]: + int 7530eca86421555555 <- ( fa9876543210 , f555555 ) + +[46,24]: + int 3a9876543210555555 <- ( fa9876543210 , 555555 ) + +[46,23]: + int 1d4c3b2a1908555555 <- ( fa9876543210 , d55555 ) + +[46,22]: + int 0ea61d950c84155555 <- ( fa9876543210 , 155555 ) + +[46,21]: + int 7530eca8642155555 <- ( fa9876543210 , f55555 ) + +[46,20]: + int 3a987654321055555 <- ( fa9876543210 , 55555 ) + +[46,19]: + int 1d4c3b2a190855555 <- ( fa9876543210 , d5555 ) + +[46,18]: + int 0ea61d950c8415555 <- ( fa9876543210 , 15555 ) + +[46,17]: + int 7530eca864215555 <- ( fa9876543210 , f5555 ) + +[46,16]: + int 3a98765432105555 <- ( fa9876543210 , 5555 ) + +[46,15]: + int 1d4c3b2a19085555 <- ( fa9876543210 , d555 ) + +[46,14]: + int 0ea61d950c841555 <- ( fa9876543210 , 1555 ) + +[46,13]: + int 7530eca86421555 <- ( fa9876543210 , f555 ) + +[46,12]: + int 3a9876543210555 <- ( fa9876543210 , 555 ) + +[46,11]: + int 1d4c3b2a1908555 <- ( fa9876543210 , d55 ) + +[46,10]: + int 0ea61d950c84155 <- ( fa9876543210 , 155 ) + +[46,9]: + int 7530eca8642155 <- ( fa9876543210 , f55 ) + +[46,8]: + int 3a987654321055 <- ( fa9876543210 , 55 ) + +[46,7]: + int 1d4c3b2a190855 <- ( fa9876543210 , d5 ) + +[46,6]: + int 0ea61d950c8415 <- ( fa9876543210 , 15 ) + +[46,5]: + int 7530eca864215 <- ( fa9876543210 , f5 ) + +[46,4]: + int 3a98765432105 <- ( fa9876543210 , 5 ) + +[46,3]: + int 1d4c3b2a19085 <- ( fa9876543210 , d ) + +[46,2]: + int 0ea61d950c841 <- ( fa9876543210 , 1 ) + +[46,1]: + int 7530eca86421 <- ( fa9876543210 , f ) + +[45,64]: + int 1a9876543210aaaaaaaa55555555 <- ( fa9876543210 , aaaaaaaa55555555 ) + +[45,63]: + int 0d4c3b2a19082aaaaaaa55555555 <- ( fa9876543210 , 2aaaaaaa55555555 ) + +[45,62]: + int 6a61d950c842aaaaaaa55555555 <- ( fa9876543210 , eaaaaaaa55555555 ) + +[45,61]: + int 3530eca86420aaaaaaa55555555 <- ( fa9876543210 , 0aaaaaaa55555555 ) + +[45,60]: + int 1a9876543210aaaaaaa55555555 <- ( fa9876543210 , aaaaaaa55555555 ) + +[45,59]: + int 0d4c3b2a19082aaaaaa55555555 <- ( fa9876543210 , 2aaaaaa55555555 ) + +[45,58]: + int 6a61d950c842aaaaaa55555555 <- ( fa9876543210 , eaaaaaa55555555 ) + +[45,57]: + int 3530eca86420aaaaaa55555555 <- ( fa9876543210 , 0aaaaaa55555555 ) + +[45,56]: + int 1a9876543210aaaaaa55555555 <- ( fa9876543210 , aaaaaa55555555 ) + +[45,55]: + int 0d4c3b2a19082aaaaa55555555 <- ( fa9876543210 , 2aaaaa55555555 ) + +[45,54]: + int 6a61d950c842aaaaa55555555 <- ( fa9876543210 , eaaaaa55555555 ) + +[45,53]: + int 3530eca86420aaaaa55555555 <- ( fa9876543210 , 0aaaaa55555555 ) + +[45,52]: + int 1a9876543210aaaaa55555555 <- ( fa9876543210 , aaaaa55555555 ) + +[45,51]: + int 0d4c3b2a19082aaaa55555555 <- ( fa9876543210 , 2aaaa55555555 ) + +[45,50]: + int 6a61d950c842aaaa55555555 <- ( fa9876543210 , eaaaa55555555 ) + +[45,49]: + int 3530eca86420aaaa55555555 <- ( fa9876543210 , 0aaaa55555555 ) + +[45,48]: + int 1a9876543210aaaa55555555 <- ( fa9876543210 , aaaa55555555 ) + +[45,47]: + int 0d4c3b2a19082aaa55555555 <- ( fa9876543210 , 2aaa55555555 ) + +[45,46]: + int 6a61d950c842aaa55555555 <- ( fa9876543210 , eaaa55555555 ) + +[45,45]: + int 3530eca86420aaa55555555 <- ( fa9876543210 , 0aaa55555555 ) + +[45,44]: + int 1a9876543210aaa55555555 <- ( fa9876543210 , aaa55555555 ) + +[45,43]: + int 0d4c3b2a19082aa55555555 <- ( fa9876543210 , 2aa55555555 ) + +[45,42]: + int 6a61d950c842aa55555555 <- ( fa9876543210 , eaa55555555 ) + +[45,41]: + int 3530eca86420aa55555555 <- ( fa9876543210 , 0aa55555555 ) + +[45,40]: + int 1a9876543210aa55555555 <- ( fa9876543210 , aa55555555 ) + +[45,39]: + int 0d4c3b2a19082a55555555 <- ( fa9876543210 , 2a55555555 ) + +[45,38]: + int 6a61d950c842a55555555 <- ( fa9876543210 , ea55555555 ) + +[45,37]: + int 3530eca86420a55555555 <- ( fa9876543210 , 0a55555555 ) + +[45,36]: + int 1a9876543210a55555555 <- ( fa9876543210 , a55555555 ) + +[45,35]: + int 0d4c3b2a1908255555555 <- ( fa9876543210 , 255555555 ) + +[45,34]: + int 6a61d950c84255555555 <- ( fa9876543210 , e55555555 ) + +[45,33]: + int 3530eca8642055555555 <- ( fa9876543210 , 055555555 ) + +[45,32]: + int 1a987654321055555555 <- ( fa9876543210 , 55555555 ) + +[45,31]: + int 0d4c3b2a190855555555 <- ( fa9876543210 , d5555555 ) + +[45,30]: + int 6a61d950c8415555555 <- ( fa9876543210 , 15555555 ) + +[45,29]: + int 3530eca864215555555 <- ( fa9876543210 , f5555555 ) + +[45,28]: + int 1a98765432105555555 <- ( fa9876543210 , 5555555 ) + +[45,27]: + int 0d4c3b2a19085555555 <- ( fa9876543210 , d555555 ) + +[45,26]: + int 6a61d950c841555555 <- ( fa9876543210 , 1555555 ) + +[45,25]: + int 3530eca86421555555 <- ( fa9876543210 , f555555 ) + +[45,24]: + int 1a9876543210555555 <- ( fa9876543210 , 555555 ) + +[45,23]: + int 0d4c3b2a1908555555 <- ( fa9876543210 , d55555 ) + +[45,22]: + int 6a61d950c84155555 <- ( fa9876543210 , 155555 ) + +[45,21]: + int 3530eca8642155555 <- ( fa9876543210 , f55555 ) + +[45,20]: + int 1a987654321055555 <- ( fa9876543210 , 55555 ) + +[45,19]: + int 0d4c3b2a190855555 <- ( fa9876543210 , d5555 ) + +[45,18]: + int 6a61d950c8415555 <- ( fa9876543210 , 15555 ) + +[45,17]: + int 3530eca864215555 <- ( fa9876543210 , f5555 ) + +[45,16]: + int 1a98765432105555 <- ( fa9876543210 , 5555 ) + +[45,15]: + int 0d4c3b2a19085555 <- ( fa9876543210 , d555 ) + +[45,14]: + int 6a61d950c841555 <- ( fa9876543210 , 1555 ) + +[45,13]: + int 3530eca86421555 <- ( fa9876543210 , f555 ) + +[45,12]: + int 1a9876543210555 <- ( fa9876543210 , 555 ) + +[45,11]: + int 0d4c3b2a1908555 <- ( fa9876543210 , d55 ) + +[45,10]: + int 6a61d950c84155 <- ( fa9876543210 , 155 ) + +[45,9]: + int 3530eca8642155 <- ( fa9876543210 , f55 ) + +[45,8]: + int 1a987654321055 <- ( fa9876543210 , 55 ) + +[45,7]: + int 0d4c3b2a190855 <- ( fa9876543210 , d5 ) + +[45,6]: + int 6a61d950c8415 <- ( fa9876543210 , 15 ) + +[45,5]: + int 3530eca864215 <- ( fa9876543210 , f5 ) + +[45,4]: + int 1a98765432105 <- ( fa9876543210 , 5 ) + +[45,3]: + int 0d4c3b2a19085 <- ( fa9876543210 , d ) + +[45,2]: + int 6a61d950c841 <- ( fa9876543210 , 1 ) + +[45,1]: + int 3530eca86421 <- ( fa9876543210 , f ) + +[44,64]: + int 0a9876543210aaaaaaaa55555555 <- ( a9876543210 , aaaaaaaa55555555 ) + +[44,63]: + int 54c3b2a19082aaaaaaa55555555 <- ( a9876543210 , 2aaaaaaa55555555 ) + +[44,62]: + int 2a61d950c842aaaaaaa55555555 <- ( a9876543210 , eaaaaaaa55555555 ) + +[44,61]: + int 1530eca86420aaaaaaa55555555 <- ( a9876543210 , 0aaaaaaa55555555 ) + +[44,60]: + int 0a9876543210aaaaaaa55555555 <- ( a9876543210 , aaaaaaa55555555 ) + +[44,59]: + int 54c3b2a19082aaaaaa55555555 <- ( a9876543210 , 2aaaaaa55555555 ) + +[44,58]: + int 2a61d950c842aaaaaa55555555 <- ( a9876543210 , eaaaaaa55555555 ) + +[44,57]: + int 1530eca86420aaaaaa55555555 <- ( a9876543210 , 0aaaaaa55555555 ) + +[44,56]: + int 0a9876543210aaaaaa55555555 <- ( a9876543210 , aaaaaa55555555 ) + +[44,55]: + int 54c3b2a19082aaaaa55555555 <- ( a9876543210 , 2aaaaa55555555 ) + +[44,54]: + int 2a61d950c842aaaaa55555555 <- ( a9876543210 , eaaaaa55555555 ) + +[44,53]: + int 1530eca86420aaaaa55555555 <- ( a9876543210 , 0aaaaa55555555 ) + +[44,52]: + int 0a9876543210aaaaa55555555 <- ( a9876543210 , aaaaa55555555 ) + +[44,51]: + int 54c3b2a19082aaaa55555555 <- ( a9876543210 , 2aaaa55555555 ) + +[44,50]: + int 2a61d950c842aaaa55555555 <- ( a9876543210 , eaaaa55555555 ) + +[44,49]: + int 1530eca86420aaaa55555555 <- ( a9876543210 , 0aaaa55555555 ) + +[44,48]: + int 0a9876543210aaaa55555555 <- ( a9876543210 , aaaa55555555 ) + +[44,47]: + int 54c3b2a19082aaa55555555 <- ( a9876543210 , 2aaa55555555 ) + +[44,46]: + int 2a61d950c842aaa55555555 <- ( a9876543210 , eaaa55555555 ) + +[44,45]: + int 1530eca86420aaa55555555 <- ( a9876543210 , 0aaa55555555 ) + +[44,44]: + int 0a9876543210aaa55555555 <- ( a9876543210 , aaa55555555 ) + +[44,43]: + int 54c3b2a19082aa55555555 <- ( a9876543210 , 2aa55555555 ) + +[44,42]: + int 2a61d950c842aa55555555 <- ( a9876543210 , eaa55555555 ) + +[44,41]: + int 1530eca86420aa55555555 <- ( a9876543210 , 0aa55555555 ) + +[44,40]: + int 0a9876543210aa55555555 <- ( a9876543210 , aa55555555 ) + +[44,39]: + int 54c3b2a19082a55555555 <- ( a9876543210 , 2a55555555 ) + +[44,38]: + int 2a61d950c842a55555555 <- ( a9876543210 , ea55555555 ) + +[44,37]: + int 1530eca86420a55555555 <- ( a9876543210 , 0a55555555 ) + +[44,36]: + int 0a9876543210a55555555 <- ( a9876543210 , a55555555 ) + +[44,35]: + int 54c3b2a1908255555555 <- ( a9876543210 , 255555555 ) + +[44,34]: + int 2a61d950c84255555555 <- ( a9876543210 , e55555555 ) + +[44,33]: + int 1530eca8642055555555 <- ( a9876543210 , 055555555 ) + +[44,32]: + int 0a987654321055555555 <- ( a9876543210 , 55555555 ) + +[44,31]: + int 54c3b2a190855555555 <- ( a9876543210 , d5555555 ) + +[44,30]: + int 2a61d950c8415555555 <- ( a9876543210 , 15555555 ) + +[44,29]: + int 1530eca864215555555 <- ( a9876543210 , f5555555 ) + +[44,28]: + int 0a98765432105555555 <- ( a9876543210 , 5555555 ) + +[44,27]: + int 54c3b2a19085555555 <- ( a9876543210 , d555555 ) + +[44,26]: + int 2a61d950c841555555 <- ( a9876543210 , 1555555 ) + +[44,25]: + int 1530eca86421555555 <- ( a9876543210 , f555555 ) + +[44,24]: + int 0a9876543210555555 <- ( a9876543210 , 555555 ) + +[44,23]: + int 54c3b2a1908555555 <- ( a9876543210 , d55555 ) + +[44,22]: + int 2a61d950c84155555 <- ( a9876543210 , 155555 ) + +[44,21]: + int 1530eca8642155555 <- ( a9876543210 , f55555 ) + +[44,20]: + int 0a987654321055555 <- ( a9876543210 , 55555 ) + +[44,19]: + int 54c3b2a190855555 <- ( a9876543210 , d5555 ) + +[44,18]: + int 2a61d950c8415555 <- ( a9876543210 , 15555 ) + +[44,17]: + int 1530eca864215555 <- ( a9876543210 , f5555 ) + +[44,16]: + int 0a98765432105555 <- ( a9876543210 , 5555 ) + +[44,15]: + int 54c3b2a19085555 <- ( a9876543210 , d555 ) + +[44,14]: + int 2a61d950c841555 <- ( a9876543210 , 1555 ) + +[44,13]: + int 1530eca86421555 <- ( a9876543210 , f555 ) + +[44,12]: + int 0a9876543210555 <- ( a9876543210 , 555 ) + +[44,11]: + int 54c3b2a1908555 <- ( a9876543210 , d55 ) + +[44,10]: + int 2a61d950c84155 <- ( a9876543210 , 155 ) + +[44,9]: + int 1530eca8642155 <- ( a9876543210 , f55 ) + +[44,8]: + int 0a987654321055 <- ( a9876543210 , 55 ) + +[44,7]: + int 54c3b2a190855 <- ( a9876543210 , d5 ) + +[44,6]: + int 2a61d950c8415 <- ( a9876543210 , 15 ) + +[44,5]: + int 1530eca864215 <- ( a9876543210 , f5 ) + +[44,4]: + int 0a98765432105 <- ( a9876543210 , 5 ) + +[44,3]: + int 54c3b2a19085 <- ( a9876543210 , d ) + +[44,2]: + int 2a61d950c841 <- ( a9876543210 , 1 ) + +[44,1]: + int 1530eca86421 <- ( a9876543210 , f ) + +[43,64]: + int 29876543210aaaaaaaa55555555 <- ( 29876543210 , aaaaaaaa55555555 ) + +[43,63]: + int 14c3b2a19082aaaaaaa55555555 <- ( 29876543210 , 2aaaaaaa55555555 ) + +[43,62]: + int 0a61d950c842aaaaaaa55555555 <- ( 29876543210 , eaaaaaaa55555555 ) + +[43,61]: + int 0530eca86420aaaaaaa55555555 <- ( 29876543210 , 0aaaaaaa55555555 ) + +[43,60]: + int 29876543210aaaaaaa55555555 <- ( 29876543210 , aaaaaaa55555555 ) + +[43,59]: + int 14c3b2a19082aaaaaa55555555 <- ( 29876543210 , 2aaaaaa55555555 ) + +[43,58]: + int 0a61d950c842aaaaaa55555555 <- ( 29876543210 , eaaaaaa55555555 ) + +[43,57]: + int 0530eca86420aaaaaa55555555 <- ( 29876543210 , 0aaaaaa55555555 ) + +[43,56]: + int 29876543210aaaaaa55555555 <- ( 29876543210 , aaaaaa55555555 ) + +[43,55]: + int 14c3b2a19082aaaaa55555555 <- ( 29876543210 , 2aaaaa55555555 ) + +[43,54]: + int 0a61d950c842aaaaa55555555 <- ( 29876543210 , eaaaaa55555555 ) + +[43,53]: + int 0530eca86420aaaaa55555555 <- ( 29876543210 , 0aaaaa55555555 ) + +[43,52]: + int 29876543210aaaaa55555555 <- ( 29876543210 , aaaaa55555555 ) + +[43,51]: + int 14c3b2a19082aaaa55555555 <- ( 29876543210 , 2aaaa55555555 ) + +[43,50]: + int 0a61d950c842aaaa55555555 <- ( 29876543210 , eaaaa55555555 ) + +[43,49]: + int 0530eca86420aaaa55555555 <- ( 29876543210 , 0aaaa55555555 ) + +[43,48]: + int 29876543210aaaa55555555 <- ( 29876543210 , aaaa55555555 ) + +[43,47]: + int 14c3b2a19082aaa55555555 <- ( 29876543210 , 2aaa55555555 ) + +[43,46]: + int 0a61d950c842aaa55555555 <- ( 29876543210 , eaaa55555555 ) + +[43,45]: + int 0530eca86420aaa55555555 <- ( 29876543210 , 0aaa55555555 ) + +[43,44]: + int 29876543210aaa55555555 <- ( 29876543210 , aaa55555555 ) + +[43,43]: + int 14c3b2a19082aa55555555 <- ( 29876543210 , 2aa55555555 ) + +[43,42]: + int 0a61d950c842aa55555555 <- ( 29876543210 , eaa55555555 ) + +[43,41]: + int 0530eca86420aa55555555 <- ( 29876543210 , 0aa55555555 ) + +[43,40]: + int 29876543210aa55555555 <- ( 29876543210 , aa55555555 ) + +[43,39]: + int 14c3b2a19082a55555555 <- ( 29876543210 , 2a55555555 ) + +[43,38]: + int 0a61d950c842a55555555 <- ( 29876543210 , ea55555555 ) + +[43,37]: + int 0530eca86420a55555555 <- ( 29876543210 , 0a55555555 ) + +[43,36]: + int 29876543210a55555555 <- ( 29876543210 , a55555555 ) + +[43,35]: + int 14c3b2a1908255555555 <- ( 29876543210 , 255555555 ) + +[43,34]: + int 0a61d950c84255555555 <- ( 29876543210 , e55555555 ) + +[43,33]: + int 0530eca8642055555555 <- ( 29876543210 , 055555555 ) + +[43,32]: + int 2987654321055555555 <- ( 29876543210 , 55555555 ) + +[43,31]: + int 14c3b2a190855555555 <- ( 29876543210 , d5555555 ) + +[43,30]: + int 0a61d950c8415555555 <- ( 29876543210 , 15555555 ) + +[43,29]: + int 0530eca864215555555 <- ( 29876543210 , f5555555 ) + +[43,28]: + int 298765432105555555 <- ( 29876543210 , 5555555 ) + +[43,27]: + int 14c3b2a19085555555 <- ( 29876543210 , d555555 ) + +[43,26]: + int 0a61d950c841555555 <- ( 29876543210 , 1555555 ) + +[43,25]: + int 0530eca86421555555 <- ( 29876543210 , f555555 ) + +[43,24]: + int 29876543210555555 <- ( 29876543210 , 555555 ) + +[43,23]: + int 14c3b2a1908555555 <- ( 29876543210 , d55555 ) + +[43,22]: + int 0a61d950c84155555 <- ( 29876543210 , 155555 ) + +[43,21]: + int 0530eca8642155555 <- ( 29876543210 , f55555 ) + +[43,20]: + int 2987654321055555 <- ( 29876543210 , 55555 ) + +[43,19]: + int 14c3b2a190855555 <- ( 29876543210 , d5555 ) + +[43,18]: + int 0a61d950c8415555 <- ( 29876543210 , 15555 ) + +[43,17]: + int 0530eca864215555 <- ( 29876543210 , f5555 ) + +[43,16]: + int 298765432105555 <- ( 29876543210 , 5555 ) + +[43,15]: + int 14c3b2a19085555 <- ( 29876543210 , d555 ) + +[43,14]: + int 0a61d950c841555 <- ( 29876543210 , 1555 ) + +[43,13]: + int 0530eca86421555 <- ( 29876543210 , f555 ) + +[43,12]: + int 29876543210555 <- ( 29876543210 , 555 ) + +[43,11]: + int 14c3b2a1908555 <- ( 29876543210 , d55 ) + +[43,10]: + int 0a61d950c84155 <- ( 29876543210 , 155 ) + +[43,9]: + int 0530eca8642155 <- ( 29876543210 , f55 ) + +[43,8]: + int 2987654321055 <- ( 29876543210 , 55 ) + +[43,7]: + int 14c3b2a190855 <- ( 29876543210 , d5 ) + +[43,6]: + int 0a61d950c8415 <- ( 29876543210 , 15 ) + +[43,5]: + int 0530eca864215 <- ( 29876543210 , f5 ) + +[43,4]: + int 298765432105 <- ( 29876543210 , 5 ) + +[43,3]: + int 14c3b2a19085 <- ( 29876543210 , d ) + +[43,2]: + int 0a61d950c841 <- ( 29876543210 , 1 ) + +[43,1]: + int 0530eca86421 <- ( 29876543210 , f ) + +[42,64]: + int 29876543210aaaaaaaa55555555 <- ( e9876543210 , aaaaaaaa55555555 ) + +[42,63]: + int 14c3b2a19082aaaaaaa55555555 <- ( e9876543210 , 2aaaaaaa55555555 ) + +[42,62]: + int 0a61d950c842aaaaaaa55555555 <- ( e9876543210 , eaaaaaaa55555555 ) + +[42,61]: + int 530eca86420aaaaaaa55555555 <- ( e9876543210 , 0aaaaaaa55555555 ) + +[42,60]: + int 29876543210aaaaaaa55555555 <- ( e9876543210 , aaaaaaa55555555 ) + +[42,59]: + int 14c3b2a19082aaaaaa55555555 <- ( e9876543210 , 2aaaaaa55555555 ) + +[42,58]: + int 0a61d950c842aaaaaa55555555 <- ( e9876543210 , eaaaaaa55555555 ) + +[42,57]: + int 530eca86420aaaaaa55555555 <- ( e9876543210 , 0aaaaaa55555555 ) + +[42,56]: + int 29876543210aaaaaa55555555 <- ( e9876543210 , aaaaaa55555555 ) + +[42,55]: + int 14c3b2a19082aaaaa55555555 <- ( e9876543210 , 2aaaaa55555555 ) + +[42,54]: + int 0a61d950c842aaaaa55555555 <- ( e9876543210 , eaaaaa55555555 ) + +[42,53]: + int 530eca86420aaaaa55555555 <- ( e9876543210 , 0aaaaa55555555 ) + +[42,52]: + int 29876543210aaaaa55555555 <- ( e9876543210 , aaaaa55555555 ) + +[42,51]: + int 14c3b2a19082aaaa55555555 <- ( e9876543210 , 2aaaa55555555 ) + +[42,50]: + int 0a61d950c842aaaa55555555 <- ( e9876543210 , eaaaa55555555 ) + +[42,49]: + int 530eca86420aaaa55555555 <- ( e9876543210 , 0aaaa55555555 ) + +[42,48]: + int 29876543210aaaa55555555 <- ( e9876543210 , aaaa55555555 ) + +[42,47]: + int 14c3b2a19082aaa55555555 <- ( e9876543210 , 2aaa55555555 ) + +[42,46]: + int 0a61d950c842aaa55555555 <- ( e9876543210 , eaaa55555555 ) + +[42,45]: + int 530eca86420aaa55555555 <- ( e9876543210 , 0aaa55555555 ) + +[42,44]: + int 29876543210aaa55555555 <- ( e9876543210 , aaa55555555 ) + +[42,43]: + int 14c3b2a19082aa55555555 <- ( e9876543210 , 2aa55555555 ) + +[42,42]: + int 0a61d950c842aa55555555 <- ( e9876543210 , eaa55555555 ) + +[42,41]: + int 530eca86420aa55555555 <- ( e9876543210 , 0aa55555555 ) + +[42,40]: + int 29876543210aa55555555 <- ( e9876543210 , aa55555555 ) + +[42,39]: + int 14c3b2a19082a55555555 <- ( e9876543210 , 2a55555555 ) + +[42,38]: + int 0a61d950c842a55555555 <- ( e9876543210 , ea55555555 ) + +[42,37]: + int 530eca86420a55555555 <- ( e9876543210 , 0a55555555 ) + +[42,36]: + int 29876543210a55555555 <- ( e9876543210 , a55555555 ) + +[42,35]: + int 14c3b2a1908255555555 <- ( e9876543210 , 255555555 ) + +[42,34]: + int 0a61d950c84255555555 <- ( e9876543210 , e55555555 ) + +[42,33]: + int 530eca8642055555555 <- ( e9876543210 , 055555555 ) + +[42,32]: + int 2987654321055555555 <- ( e9876543210 , 55555555 ) + +[42,31]: + int 14c3b2a190855555555 <- ( e9876543210 , d5555555 ) + +[42,30]: + int 0a61d950c8415555555 <- ( e9876543210 , 15555555 ) + +[42,29]: + int 530eca864215555555 <- ( e9876543210 , f5555555 ) + +[42,28]: + int 298765432105555555 <- ( e9876543210 , 5555555 ) + +[42,27]: + int 14c3b2a19085555555 <- ( e9876543210 , d555555 ) + +[42,26]: + int 0a61d950c841555555 <- ( e9876543210 , 1555555 ) + +[42,25]: + int 530eca86421555555 <- ( e9876543210 , f555555 ) + +[42,24]: + int 29876543210555555 <- ( e9876543210 , 555555 ) + +[42,23]: + int 14c3b2a1908555555 <- ( e9876543210 , d55555 ) + +[42,22]: + int 0a61d950c84155555 <- ( e9876543210 , 155555 ) + +[42,21]: + int 530eca8642155555 <- ( e9876543210 , f55555 ) + +[42,20]: + int 2987654321055555 <- ( e9876543210 , 55555 ) + +[42,19]: + int 14c3b2a190855555 <- ( e9876543210 , d5555 ) + +[42,18]: + int 0a61d950c8415555 <- ( e9876543210 , 15555 ) + +[42,17]: + int 530eca864215555 <- ( e9876543210 , f5555 ) + +[42,16]: + int 298765432105555 <- ( e9876543210 , 5555 ) + +[42,15]: + int 14c3b2a19085555 <- ( e9876543210 , d555 ) + +[42,14]: + int 0a61d950c841555 <- ( e9876543210 , 1555 ) + +[42,13]: + int 530eca86421555 <- ( e9876543210 , f555 ) + +[42,12]: + int 29876543210555 <- ( e9876543210 , 555 ) + +[42,11]: + int 14c3b2a1908555 <- ( e9876543210 , d55 ) + +[42,10]: + int 0a61d950c84155 <- ( e9876543210 , 155 ) + +[42,9]: + int 530eca8642155 <- ( e9876543210 , f55 ) + +[42,8]: + int 2987654321055 <- ( e9876543210 , 55 ) + +[42,7]: + int 14c3b2a190855 <- ( e9876543210 , d5 ) + +[42,6]: + int 0a61d950c8415 <- ( e9876543210 , 15 ) + +[42,5]: + int 530eca864215 <- ( e9876543210 , f5 ) + +[42,4]: + int 298765432105 <- ( e9876543210 , 5 ) + +[42,3]: + int 14c3b2a19085 <- ( e9876543210 , d ) + +[42,2]: + int 0a61d950c841 <- ( e9876543210 , 1 ) + +[42,1]: + int 530eca86421 <- ( e9876543210 , f ) + +[41,64]: + int 09876543210aaaaaaaa55555555 <- ( 09876543210 , aaaaaaaa55555555 ) + +[41,63]: + int 04c3b2a19082aaaaaaa55555555 <- ( 09876543210 , 2aaaaaaa55555555 ) + +[41,62]: + int 261d950c842aaaaaaa55555555 <- ( 09876543210 , eaaaaaaa55555555 ) + +[41,61]: + int 130eca86420aaaaaaa55555555 <- ( 09876543210 , 0aaaaaaa55555555 ) + +[41,60]: + int 09876543210aaaaaaa55555555 <- ( 09876543210 , aaaaaaa55555555 ) + +[41,59]: + int 04c3b2a19082aaaaaa55555555 <- ( 09876543210 , 2aaaaaa55555555 ) + +[41,58]: + int 261d950c842aaaaaa55555555 <- ( 09876543210 , eaaaaaa55555555 ) + +[41,57]: + int 130eca86420aaaaaa55555555 <- ( 09876543210 , 0aaaaaa55555555 ) + +[41,56]: + int 09876543210aaaaaa55555555 <- ( 09876543210 , aaaaaa55555555 ) + +[41,55]: + int 04c3b2a19082aaaaa55555555 <- ( 09876543210 , 2aaaaa55555555 ) + +[41,54]: + int 261d950c842aaaaa55555555 <- ( 09876543210 , eaaaaa55555555 ) + +[41,53]: + int 130eca86420aaaaa55555555 <- ( 09876543210 , 0aaaaa55555555 ) + +[41,52]: + int 09876543210aaaaa55555555 <- ( 09876543210 , aaaaa55555555 ) + +[41,51]: + int 04c3b2a19082aaaa55555555 <- ( 09876543210 , 2aaaa55555555 ) + +[41,50]: + int 261d950c842aaaa55555555 <- ( 09876543210 , eaaaa55555555 ) + +[41,49]: + int 130eca86420aaaa55555555 <- ( 09876543210 , 0aaaa55555555 ) + +[41,48]: + int 09876543210aaaa55555555 <- ( 09876543210 , aaaa55555555 ) + +[41,47]: + int 04c3b2a19082aaa55555555 <- ( 09876543210 , 2aaa55555555 ) + +[41,46]: + int 261d950c842aaa55555555 <- ( 09876543210 , eaaa55555555 ) + +[41,45]: + int 130eca86420aaa55555555 <- ( 09876543210 , 0aaa55555555 ) + +[41,44]: + int 09876543210aaa55555555 <- ( 09876543210 , aaa55555555 ) + +[41,43]: + int 04c3b2a19082aa55555555 <- ( 09876543210 , 2aa55555555 ) + +[41,42]: + int 261d950c842aa55555555 <- ( 09876543210 , eaa55555555 ) + +[41,41]: + int 130eca86420aa55555555 <- ( 09876543210 , 0aa55555555 ) + +[41,40]: + int 09876543210aa55555555 <- ( 09876543210 , aa55555555 ) + +[41,39]: + int 04c3b2a19082a55555555 <- ( 09876543210 , 2a55555555 ) + +[41,38]: + int 261d950c842a55555555 <- ( 09876543210 , ea55555555 ) + +[41,37]: + int 130eca86420a55555555 <- ( 09876543210 , 0a55555555 ) + +[41,36]: + int 09876543210a55555555 <- ( 09876543210 , a55555555 ) + +[41,35]: + int 04c3b2a1908255555555 <- ( 09876543210 , 255555555 ) + +[41,34]: + int 261d950c84255555555 <- ( 09876543210 , e55555555 ) + +[41,33]: + int 130eca8642055555555 <- ( 09876543210 , 055555555 ) + +[41,32]: + int 0987654321055555555 <- ( 09876543210 , 55555555 ) + +[41,31]: + int 04c3b2a190855555555 <- ( 09876543210 , d5555555 ) + +[41,30]: + int 261d950c8415555555 <- ( 09876543210 , 15555555 ) + +[41,29]: + int 130eca864215555555 <- ( 09876543210 , f5555555 ) + +[41,28]: + int 098765432105555555 <- ( 09876543210 , 5555555 ) + +[41,27]: + int 04c3b2a19085555555 <- ( 09876543210 , d555555 ) + +[41,26]: + int 261d950c841555555 <- ( 09876543210 , 1555555 ) + +[41,25]: + int 130eca86421555555 <- ( 09876543210 , f555555 ) + +[41,24]: + int 09876543210555555 <- ( 09876543210 , 555555 ) + +[41,23]: + int 04c3b2a1908555555 <- ( 09876543210 , d55555 ) + +[41,22]: + int 261d950c84155555 <- ( 09876543210 , 155555 ) + +[41,21]: + int 130eca8642155555 <- ( 09876543210 , f55555 ) + +[41,20]: + int 0987654321055555 <- ( 09876543210 , 55555 ) + +[41,19]: + int 04c3b2a190855555 <- ( 09876543210 , d5555 ) + +[41,18]: + int 261d950c8415555 <- ( 09876543210 , 15555 ) + +[41,17]: + int 130eca864215555 <- ( 09876543210 , f5555 ) + +[41,16]: + int 098765432105555 <- ( 09876543210 , 5555 ) + +[41,15]: + int 04c3b2a19085555 <- ( 09876543210 , d555 ) + +[41,14]: + int 261d950c841555 <- ( 09876543210 , 1555 ) + +[41,13]: + int 130eca86421555 <- ( 09876543210 , f555 ) + +[41,12]: + int 09876543210555 <- ( 09876543210 , 555 ) + +[41,11]: + int 04c3b2a1908555 <- ( 09876543210 , d55 ) + +[41,10]: + int 261d950c84155 <- ( 09876543210 , 155 ) + +[41,9]: + int 130eca8642155 <- ( 09876543210 , f55 ) + +[41,8]: + int 0987654321055 <- ( 09876543210 , 55 ) + +[41,7]: + int 04c3b2a190855 <- ( 09876543210 , d5 ) + +[41,6]: + int 261d950c8415 <- ( 09876543210 , 15 ) + +[41,5]: + int 130eca864215 <- ( 09876543210 , f5 ) + +[41,4]: + int 098765432105 <- ( 09876543210 , 5 ) + +[41,3]: + int 04c3b2a19085 <- ( 09876543210 , d ) + +[41,2]: + int 261d950c841 <- ( 09876543210 , 1 ) + +[41,1]: + int 130eca86421 <- ( 09876543210 , f ) + +[40,64]: + int 09876543210aaaaaaaa55555555 <- ( 9876543210 , aaaaaaaa55555555 ) + +[40,63]: + int 4c3b2a19082aaaaaaa55555555 <- ( 9876543210 , 2aaaaaaa55555555 ) + +[40,62]: + int 261d950c842aaaaaaa55555555 <- ( 9876543210 , eaaaaaaa55555555 ) + +[40,61]: + int 130eca86420aaaaaaa55555555 <- ( 9876543210 , 0aaaaaaa55555555 ) + +[40,60]: + int 09876543210aaaaaaa55555555 <- ( 9876543210 , aaaaaaa55555555 ) + +[40,59]: + int 4c3b2a19082aaaaaa55555555 <- ( 9876543210 , 2aaaaaa55555555 ) + +[40,58]: + int 261d950c842aaaaaa55555555 <- ( 9876543210 , eaaaaaa55555555 ) + +[40,57]: + int 130eca86420aaaaaa55555555 <- ( 9876543210 , 0aaaaaa55555555 ) + +[40,56]: + int 09876543210aaaaaa55555555 <- ( 9876543210 , aaaaaa55555555 ) + +[40,55]: + int 4c3b2a19082aaaaa55555555 <- ( 9876543210 , 2aaaaa55555555 ) + +[40,54]: + int 261d950c842aaaaa55555555 <- ( 9876543210 , eaaaaa55555555 ) + +[40,53]: + int 130eca86420aaaaa55555555 <- ( 9876543210 , 0aaaaa55555555 ) + +[40,52]: + int 09876543210aaaaa55555555 <- ( 9876543210 , aaaaa55555555 ) + +[40,51]: + int 4c3b2a19082aaaa55555555 <- ( 9876543210 , 2aaaa55555555 ) + +[40,50]: + int 261d950c842aaaa55555555 <- ( 9876543210 , eaaaa55555555 ) + +[40,49]: + int 130eca86420aaaa55555555 <- ( 9876543210 , 0aaaa55555555 ) + +[40,48]: + int 09876543210aaaa55555555 <- ( 9876543210 , aaaa55555555 ) + +[40,47]: + int 4c3b2a19082aaa55555555 <- ( 9876543210 , 2aaa55555555 ) + +[40,46]: + int 261d950c842aaa55555555 <- ( 9876543210 , eaaa55555555 ) + +[40,45]: + int 130eca86420aaa55555555 <- ( 9876543210 , 0aaa55555555 ) + +[40,44]: + int 09876543210aaa55555555 <- ( 9876543210 , aaa55555555 ) + +[40,43]: + int 4c3b2a19082aa55555555 <- ( 9876543210 , 2aa55555555 ) + +[40,42]: + int 261d950c842aa55555555 <- ( 9876543210 , eaa55555555 ) + +[40,41]: + int 130eca86420aa55555555 <- ( 9876543210 , 0aa55555555 ) + +[40,40]: + int 09876543210aa55555555 <- ( 9876543210 , aa55555555 ) + +[40,39]: + int 4c3b2a19082a55555555 <- ( 9876543210 , 2a55555555 ) + +[40,38]: + int 261d950c842a55555555 <- ( 9876543210 , ea55555555 ) + +[40,37]: + int 130eca86420a55555555 <- ( 9876543210 , 0a55555555 ) + +[40,36]: + int 09876543210a55555555 <- ( 9876543210 , a55555555 ) + +[40,35]: + int 4c3b2a1908255555555 <- ( 9876543210 , 255555555 ) + +[40,34]: + int 261d950c84255555555 <- ( 9876543210 , e55555555 ) + +[40,33]: + int 130eca8642055555555 <- ( 9876543210 , 055555555 ) + +[40,32]: + int 0987654321055555555 <- ( 9876543210 , 55555555 ) + +[40,31]: + int 4c3b2a190855555555 <- ( 9876543210 , d5555555 ) + +[40,30]: + int 261d950c8415555555 <- ( 9876543210 , 15555555 ) + +[40,29]: + int 130eca864215555555 <- ( 9876543210 , f5555555 ) + +[40,28]: + int 098765432105555555 <- ( 9876543210 , 5555555 ) + +[40,27]: + int 4c3b2a19085555555 <- ( 9876543210 , d555555 ) + +[40,26]: + int 261d950c841555555 <- ( 9876543210 , 1555555 ) + +[40,25]: + int 130eca86421555555 <- ( 9876543210 , f555555 ) + +[40,24]: + int 09876543210555555 <- ( 9876543210 , 555555 ) + +[40,23]: + int 4c3b2a1908555555 <- ( 9876543210 , d55555 ) + +[40,22]: + int 261d950c84155555 <- ( 9876543210 , 155555 ) + +[40,21]: + int 130eca8642155555 <- ( 9876543210 , f55555 ) + +[40,20]: + int 0987654321055555 <- ( 9876543210 , 55555 ) + +[40,19]: + int 4c3b2a190855555 <- ( 9876543210 , d5555 ) + +[40,18]: + int 261d950c8415555 <- ( 9876543210 , 15555 ) + +[40,17]: + int 130eca864215555 <- ( 9876543210 , f5555 ) + +[40,16]: + int 098765432105555 <- ( 9876543210 , 5555 ) + +[40,15]: + int 4c3b2a19085555 <- ( 9876543210 , d555 ) + +[40,14]: + int 261d950c841555 <- ( 9876543210 , 1555 ) + +[40,13]: + int 130eca86421555 <- ( 9876543210 , f555 ) + +[40,12]: + int 09876543210555 <- ( 9876543210 , 555 ) + +[40,11]: + int 4c3b2a1908555 <- ( 9876543210 , d55 ) + +[40,10]: + int 261d950c84155 <- ( 9876543210 , 155 ) + +[40,9]: + int 130eca8642155 <- ( 9876543210 , f55 ) + +[40,8]: + int 0987654321055 <- ( 9876543210 , 55 ) + +[40,7]: + int 4c3b2a190855 <- ( 9876543210 , d5 ) + +[40,6]: + int 261d950c8415 <- ( 9876543210 , 15 ) + +[40,5]: + int 130eca864215 <- ( 9876543210 , f5 ) + +[40,4]: + int 098765432105 <- ( 9876543210 , 5 ) + +[40,3]: + int 4c3b2a19085 <- ( 9876543210 , d ) + +[40,2]: + int 261d950c841 <- ( 9876543210 , 1 ) + +[40,1]: + int 130eca86421 <- ( 9876543210 , f ) + +[39,64]: + int 1876543210aaaaaaaa55555555 <- ( 1876543210 , aaaaaaaa55555555 ) + +[39,63]: + int 0c3b2a19082aaaaaaa55555555 <- ( 1876543210 , 2aaaaaaa55555555 ) + +[39,62]: + int 061d950c842aaaaaaa55555555 <- ( 1876543210 , eaaaaaaa55555555 ) + +[39,61]: + int 030eca86420aaaaaaa55555555 <- ( 1876543210 , 0aaaaaaa55555555 ) + +[39,60]: + int 1876543210aaaaaaa55555555 <- ( 1876543210 , aaaaaaa55555555 ) + +[39,59]: + int 0c3b2a19082aaaaaa55555555 <- ( 1876543210 , 2aaaaaa55555555 ) + +[39,58]: + int 061d950c842aaaaaa55555555 <- ( 1876543210 , eaaaaaa55555555 ) + +[39,57]: + int 030eca86420aaaaaa55555555 <- ( 1876543210 , 0aaaaaa55555555 ) + +[39,56]: + int 1876543210aaaaaa55555555 <- ( 1876543210 , aaaaaa55555555 ) + +[39,55]: + int 0c3b2a19082aaaaa55555555 <- ( 1876543210 , 2aaaaa55555555 ) + +[39,54]: + int 061d950c842aaaaa55555555 <- ( 1876543210 , eaaaaa55555555 ) + +[39,53]: + int 030eca86420aaaaa55555555 <- ( 1876543210 , 0aaaaa55555555 ) + +[39,52]: + int 1876543210aaaaa55555555 <- ( 1876543210 , aaaaa55555555 ) + +[39,51]: + int 0c3b2a19082aaaa55555555 <- ( 1876543210 , 2aaaa55555555 ) + +[39,50]: + int 061d950c842aaaa55555555 <- ( 1876543210 , eaaaa55555555 ) + +[39,49]: + int 030eca86420aaaa55555555 <- ( 1876543210 , 0aaaa55555555 ) + +[39,48]: + int 1876543210aaaa55555555 <- ( 1876543210 , aaaa55555555 ) + +[39,47]: + int 0c3b2a19082aaa55555555 <- ( 1876543210 , 2aaa55555555 ) + +[39,46]: + int 061d950c842aaa55555555 <- ( 1876543210 , eaaa55555555 ) + +[39,45]: + int 030eca86420aaa55555555 <- ( 1876543210 , 0aaa55555555 ) + +[39,44]: + int 1876543210aaa55555555 <- ( 1876543210 , aaa55555555 ) + +[39,43]: + int 0c3b2a19082aa55555555 <- ( 1876543210 , 2aa55555555 ) + +[39,42]: + int 061d950c842aa55555555 <- ( 1876543210 , eaa55555555 ) + +[39,41]: + int 030eca86420aa55555555 <- ( 1876543210 , 0aa55555555 ) + +[39,40]: + int 1876543210aa55555555 <- ( 1876543210 , aa55555555 ) + +[39,39]: + int 0c3b2a19082a55555555 <- ( 1876543210 , 2a55555555 ) + +[39,38]: + int 061d950c842a55555555 <- ( 1876543210 , ea55555555 ) + +[39,37]: + int 030eca86420a55555555 <- ( 1876543210 , 0a55555555 ) + +[39,36]: + int 1876543210a55555555 <- ( 1876543210 , a55555555 ) + +[39,35]: + int 0c3b2a1908255555555 <- ( 1876543210 , 255555555 ) + +[39,34]: + int 061d950c84255555555 <- ( 1876543210 , e55555555 ) + +[39,33]: + int 030eca8642055555555 <- ( 1876543210 , 055555555 ) + +[39,32]: + int 187654321055555555 <- ( 1876543210 , 55555555 ) + +[39,31]: + int 0c3b2a190855555555 <- ( 1876543210 , d5555555 ) + +[39,30]: + int 061d950c8415555555 <- ( 1876543210 , 15555555 ) + +[39,29]: + int 030eca864215555555 <- ( 1876543210 , f5555555 ) + +[39,28]: + int 18765432105555555 <- ( 1876543210 , 5555555 ) + +[39,27]: + int 0c3b2a19085555555 <- ( 1876543210 , d555555 ) + +[39,26]: + int 061d950c841555555 <- ( 1876543210 , 1555555 ) + +[39,25]: + int 030eca86421555555 <- ( 1876543210 , f555555 ) + +[39,24]: + int 1876543210555555 <- ( 1876543210 , 555555 ) + +[39,23]: + int 0c3b2a1908555555 <- ( 1876543210 , d55555 ) + +[39,22]: + int 061d950c84155555 <- ( 1876543210 , 155555 ) + +[39,21]: + int 030eca8642155555 <- ( 1876543210 , f55555 ) + +[39,20]: + int 187654321055555 <- ( 1876543210 , 55555 ) + +[39,19]: + int 0c3b2a190855555 <- ( 1876543210 , d5555 ) + +[39,18]: + int 061d950c8415555 <- ( 1876543210 , 15555 ) + +[39,17]: + int 030eca864215555 <- ( 1876543210 , f5555 ) + +[39,16]: + int 18765432105555 <- ( 1876543210 , 5555 ) + +[39,15]: + int 0c3b2a19085555 <- ( 1876543210 , d555 ) + +[39,14]: + int 061d950c841555 <- ( 1876543210 , 1555 ) + +[39,13]: + int 030eca86421555 <- ( 1876543210 , f555 ) + +[39,12]: + int 1876543210555 <- ( 1876543210 , 555 ) + +[39,11]: + int 0c3b2a1908555 <- ( 1876543210 , d55 ) + +[39,10]: + int 061d950c84155 <- ( 1876543210 , 155 ) + +[39,9]: + int 030eca8642155 <- ( 1876543210 , f55 ) + +[39,8]: + int 187654321055 <- ( 1876543210 , 55 ) + +[39,7]: + int 0c3b2a190855 <- ( 1876543210 , d5 ) + +[39,6]: + int 061d950c8415 <- ( 1876543210 , 15 ) + +[39,5]: + int 030eca864215 <- ( 1876543210 , f5 ) + +[39,4]: + int 18765432105 <- ( 1876543210 , 5 ) + +[39,3]: + int 0c3b2a19085 <- ( 1876543210 , d ) + +[39,2]: + int 061d950c841 <- ( 1876543210 , 1 ) + +[39,1]: + int 030eca86421 <- ( 1876543210 , f ) + +[38,64]: + int 1876543210aaaaaaaa55555555 <- ( 1876543210 , aaaaaaaa55555555 ) + +[38,63]: + int 0c3b2a19082aaaaaaa55555555 <- ( 1876543210 , 2aaaaaaa55555555 ) + +[38,62]: + int 061d950c842aaaaaaa55555555 <- ( 1876543210 , eaaaaaaa55555555 ) + +[38,61]: + int 30eca86420aaaaaaa55555555 <- ( 1876543210 , 0aaaaaaa55555555 ) + +[38,60]: + int 1876543210aaaaaaa55555555 <- ( 1876543210 , aaaaaaa55555555 ) + +[38,59]: + int 0c3b2a19082aaaaaa55555555 <- ( 1876543210 , 2aaaaaa55555555 ) + +[38,58]: + int 061d950c842aaaaaa55555555 <- ( 1876543210 , eaaaaaa55555555 ) + +[38,57]: + int 30eca86420aaaaaa55555555 <- ( 1876543210 , 0aaaaaa55555555 ) + +[38,56]: + int 1876543210aaaaaa55555555 <- ( 1876543210 , aaaaaa55555555 ) + +[38,55]: + int 0c3b2a19082aaaaa55555555 <- ( 1876543210 , 2aaaaa55555555 ) + +[38,54]: + int 061d950c842aaaaa55555555 <- ( 1876543210 , eaaaaa55555555 ) + +[38,53]: + int 30eca86420aaaaa55555555 <- ( 1876543210 , 0aaaaa55555555 ) + +[38,52]: + int 1876543210aaaaa55555555 <- ( 1876543210 , aaaaa55555555 ) + +[38,51]: + int 0c3b2a19082aaaa55555555 <- ( 1876543210 , 2aaaa55555555 ) + +[38,50]: + int 061d950c842aaaa55555555 <- ( 1876543210 , eaaaa55555555 ) + +[38,49]: + int 30eca86420aaaa55555555 <- ( 1876543210 , 0aaaa55555555 ) + +[38,48]: + int 1876543210aaaa55555555 <- ( 1876543210 , aaaa55555555 ) + +[38,47]: + int 0c3b2a19082aaa55555555 <- ( 1876543210 , 2aaa55555555 ) + +[38,46]: + int 061d950c842aaa55555555 <- ( 1876543210 , eaaa55555555 ) + +[38,45]: + int 30eca86420aaa55555555 <- ( 1876543210 , 0aaa55555555 ) + +[38,44]: + int 1876543210aaa55555555 <- ( 1876543210 , aaa55555555 ) + +[38,43]: + int 0c3b2a19082aa55555555 <- ( 1876543210 , 2aa55555555 ) + +[38,42]: + int 061d950c842aa55555555 <- ( 1876543210 , eaa55555555 ) + +[38,41]: + int 30eca86420aa55555555 <- ( 1876543210 , 0aa55555555 ) + +[38,40]: + int 1876543210aa55555555 <- ( 1876543210 , aa55555555 ) + +[38,39]: + int 0c3b2a19082a55555555 <- ( 1876543210 , 2a55555555 ) + +[38,38]: + int 061d950c842a55555555 <- ( 1876543210 , ea55555555 ) + +[38,37]: + int 30eca86420a55555555 <- ( 1876543210 , 0a55555555 ) + +[38,36]: + int 1876543210a55555555 <- ( 1876543210 , a55555555 ) + +[38,35]: + int 0c3b2a1908255555555 <- ( 1876543210 , 255555555 ) + +[38,34]: + int 061d950c84255555555 <- ( 1876543210 , e55555555 ) + +[38,33]: + int 30eca8642055555555 <- ( 1876543210 , 055555555 ) + +[38,32]: + int 187654321055555555 <- ( 1876543210 , 55555555 ) + +[38,31]: + int 0c3b2a190855555555 <- ( 1876543210 , d5555555 ) + +[38,30]: + int 061d950c8415555555 <- ( 1876543210 , 15555555 ) + +[38,29]: + int 30eca864215555555 <- ( 1876543210 , f5555555 ) + +[38,28]: + int 18765432105555555 <- ( 1876543210 , 5555555 ) + +[38,27]: + int 0c3b2a19085555555 <- ( 1876543210 , d555555 ) + +[38,26]: + int 061d950c841555555 <- ( 1876543210 , 1555555 ) + +[38,25]: + int 30eca86421555555 <- ( 1876543210 , f555555 ) + +[38,24]: + int 1876543210555555 <- ( 1876543210 , 555555 ) + +[38,23]: + int 0c3b2a1908555555 <- ( 1876543210 , d55555 ) + +[38,22]: + int 061d950c84155555 <- ( 1876543210 , 155555 ) + +[38,21]: + int 30eca8642155555 <- ( 1876543210 , f55555 ) + +[38,20]: + int 187654321055555 <- ( 1876543210 , 55555 ) + +[38,19]: + int 0c3b2a190855555 <- ( 1876543210 , d5555 ) + +[38,18]: + int 061d950c8415555 <- ( 1876543210 , 15555 ) + +[38,17]: + int 30eca864215555 <- ( 1876543210 , f5555 ) + +[38,16]: + int 18765432105555 <- ( 1876543210 , 5555 ) + +[38,15]: + int 0c3b2a19085555 <- ( 1876543210 , d555 ) + +[38,14]: + int 061d950c841555 <- ( 1876543210 , 1555 ) + +[38,13]: + int 30eca86421555 <- ( 1876543210 , f555 ) + +[38,12]: + int 1876543210555 <- ( 1876543210 , 555 ) + +[38,11]: + int 0c3b2a1908555 <- ( 1876543210 , d55 ) + +[38,10]: + int 061d950c84155 <- ( 1876543210 , 155 ) + +[38,9]: + int 30eca8642155 <- ( 1876543210 , f55 ) + +[38,8]: + int 187654321055 <- ( 1876543210 , 55 ) + +[38,7]: + int 0c3b2a190855 <- ( 1876543210 , d5 ) + +[38,6]: + int 061d950c8415 <- ( 1876543210 , 15 ) + +[38,5]: + int 30eca864215 <- ( 1876543210 , f5 ) + +[38,4]: + int 18765432105 <- ( 1876543210 , 5 ) + +[38,3]: + int 0c3b2a19085 <- ( 1876543210 , d ) + +[38,2]: + int 061d950c841 <- ( 1876543210 , 1 ) + +[38,1]: + int 30eca86421 <- ( 1876543210 , f ) + +[37,64]: + int 1876543210aaaaaaaa55555555 <- ( f876543210 , aaaaaaaa55555555 ) + +[37,63]: + int 0c3b2a19082aaaaaaa55555555 <- ( f876543210 , 2aaaaaaa55555555 ) + +[37,62]: + int 61d950c842aaaaaaa55555555 <- ( f876543210 , eaaaaaaa55555555 ) + +[37,61]: + int 30eca86420aaaaaaa55555555 <- ( f876543210 , 0aaaaaaa55555555 ) + +[37,60]: + int 1876543210aaaaaaa55555555 <- ( f876543210 , aaaaaaa55555555 ) + +[37,59]: + int 0c3b2a19082aaaaaa55555555 <- ( f876543210 , 2aaaaaa55555555 ) + +[37,58]: + int 61d950c842aaaaaa55555555 <- ( f876543210 , eaaaaaa55555555 ) + +[37,57]: + int 30eca86420aaaaaa55555555 <- ( f876543210 , 0aaaaaa55555555 ) + +[37,56]: + int 1876543210aaaaaa55555555 <- ( f876543210 , aaaaaa55555555 ) + +[37,55]: + int 0c3b2a19082aaaaa55555555 <- ( f876543210 , 2aaaaa55555555 ) + +[37,54]: + int 61d950c842aaaaa55555555 <- ( f876543210 , eaaaaa55555555 ) + +[37,53]: + int 30eca86420aaaaa55555555 <- ( f876543210 , 0aaaaa55555555 ) + +[37,52]: + int 1876543210aaaaa55555555 <- ( f876543210 , aaaaa55555555 ) + +[37,51]: + int 0c3b2a19082aaaa55555555 <- ( f876543210 , 2aaaa55555555 ) + +[37,50]: + int 61d950c842aaaa55555555 <- ( f876543210 , eaaaa55555555 ) + +[37,49]: + int 30eca86420aaaa55555555 <- ( f876543210 , 0aaaa55555555 ) + +[37,48]: + int 1876543210aaaa55555555 <- ( f876543210 , aaaa55555555 ) + +[37,47]: + int 0c3b2a19082aaa55555555 <- ( f876543210 , 2aaa55555555 ) + +[37,46]: + int 61d950c842aaa55555555 <- ( f876543210 , eaaa55555555 ) + +[37,45]: + int 30eca86420aaa55555555 <- ( f876543210 , 0aaa55555555 ) + +[37,44]: + int 1876543210aaa55555555 <- ( f876543210 , aaa55555555 ) + +[37,43]: + int 0c3b2a19082aa55555555 <- ( f876543210 , 2aa55555555 ) + +[37,42]: + int 61d950c842aa55555555 <- ( f876543210 , eaa55555555 ) + +[37,41]: + int 30eca86420aa55555555 <- ( f876543210 , 0aa55555555 ) + +[37,40]: + int 1876543210aa55555555 <- ( f876543210 , aa55555555 ) + +[37,39]: + int 0c3b2a19082a55555555 <- ( f876543210 , 2a55555555 ) + +[37,38]: + int 61d950c842a55555555 <- ( f876543210 , ea55555555 ) + +[37,37]: + int 30eca86420a55555555 <- ( f876543210 , 0a55555555 ) + +[37,36]: + int 1876543210a55555555 <- ( f876543210 , a55555555 ) + +[37,35]: + int 0c3b2a1908255555555 <- ( f876543210 , 255555555 ) + +[37,34]: + int 61d950c84255555555 <- ( f876543210 , e55555555 ) + +[37,33]: + int 30eca8642055555555 <- ( f876543210 , 055555555 ) + +[37,32]: + int 187654321055555555 <- ( f876543210 , 55555555 ) + +[37,31]: + int 0c3b2a190855555555 <- ( f876543210 , d5555555 ) + +[37,30]: + int 61d950c8415555555 <- ( f876543210 , 15555555 ) + +[37,29]: + int 30eca864215555555 <- ( f876543210 , f5555555 ) + +[37,28]: + int 18765432105555555 <- ( f876543210 , 5555555 ) + +[37,27]: + int 0c3b2a19085555555 <- ( f876543210 , d555555 ) + +[37,26]: + int 61d950c841555555 <- ( f876543210 , 1555555 ) + +[37,25]: + int 30eca86421555555 <- ( f876543210 , f555555 ) + +[37,24]: + int 1876543210555555 <- ( f876543210 , 555555 ) + +[37,23]: + int 0c3b2a1908555555 <- ( f876543210 , d55555 ) + +[37,22]: + int 61d950c84155555 <- ( f876543210 , 155555 ) + +[37,21]: + int 30eca8642155555 <- ( f876543210 , f55555 ) + +[37,20]: + int 187654321055555 <- ( f876543210 , 55555 ) + +[37,19]: + int 0c3b2a190855555 <- ( f876543210 , d5555 ) + +[37,18]: + int 61d950c8415555 <- ( f876543210 , 15555 ) + +[37,17]: + int 30eca864215555 <- ( f876543210 , f5555 ) + +[37,16]: + int 18765432105555 <- ( f876543210 , 5555 ) + +[37,15]: + int 0c3b2a19085555 <- ( f876543210 , d555 ) + +[37,14]: + int 61d950c841555 <- ( f876543210 , 1555 ) + +[37,13]: + int 30eca86421555 <- ( f876543210 , f555 ) + +[37,12]: + int 1876543210555 <- ( f876543210 , 555 ) + +[37,11]: + int 0c3b2a1908555 <- ( f876543210 , d55 ) + +[37,10]: + int 61d950c84155 <- ( f876543210 , 155 ) + +[37,9]: + int 30eca8642155 <- ( f876543210 , f55 ) + +[37,8]: + int 187654321055 <- ( f876543210 , 55 ) + +[37,7]: + int 0c3b2a190855 <- ( f876543210 , d5 ) + +[37,6]: + int 61d950c8415 <- ( f876543210 , 15 ) + +[37,5]: + int 30eca864215 <- ( f876543210 , f5 ) + +[37,4]: + int 18765432105 <- ( f876543210 , 5 ) + +[37,3]: + int 0c3b2a19085 <- ( f876543210 , d ) + +[37,2]: + int 61d950c841 <- ( f876543210 , 1 ) + +[37,1]: + int 30eca86421 <- ( f876543210 , f ) + +[36,64]: + int 0876543210aaaaaaaa55555555 <- ( 876543210 , aaaaaaaa55555555 ) + +[36,63]: + int 43b2a19082aaaaaaa55555555 <- ( 876543210 , 2aaaaaaa55555555 ) + +[36,62]: + int 21d950c842aaaaaaa55555555 <- ( 876543210 , eaaaaaaa55555555 ) + +[36,61]: + int 10eca86420aaaaaaa55555555 <- ( 876543210 , 0aaaaaaa55555555 ) + +[36,60]: + int 0876543210aaaaaaa55555555 <- ( 876543210 , aaaaaaa55555555 ) + +[36,59]: + int 43b2a19082aaaaaa55555555 <- ( 876543210 , 2aaaaaa55555555 ) + +[36,58]: + int 21d950c842aaaaaa55555555 <- ( 876543210 , eaaaaaa55555555 ) + +[36,57]: + int 10eca86420aaaaaa55555555 <- ( 876543210 , 0aaaaaa55555555 ) + +[36,56]: + int 0876543210aaaaaa55555555 <- ( 876543210 , aaaaaa55555555 ) + +[36,55]: + int 43b2a19082aaaaa55555555 <- ( 876543210 , 2aaaaa55555555 ) + +[36,54]: + int 21d950c842aaaaa55555555 <- ( 876543210 , eaaaaa55555555 ) + +[36,53]: + int 10eca86420aaaaa55555555 <- ( 876543210 , 0aaaaa55555555 ) + +[36,52]: + int 0876543210aaaaa55555555 <- ( 876543210 , aaaaa55555555 ) + +[36,51]: + int 43b2a19082aaaa55555555 <- ( 876543210 , 2aaaa55555555 ) + +[36,50]: + int 21d950c842aaaa55555555 <- ( 876543210 , eaaaa55555555 ) + +[36,49]: + int 10eca86420aaaa55555555 <- ( 876543210 , 0aaaa55555555 ) + +[36,48]: + int 0876543210aaaa55555555 <- ( 876543210 , aaaa55555555 ) + +[36,47]: + int 43b2a19082aaa55555555 <- ( 876543210 , 2aaa55555555 ) + +[36,46]: + int 21d950c842aaa55555555 <- ( 876543210 , eaaa55555555 ) + +[36,45]: + int 10eca86420aaa55555555 <- ( 876543210 , 0aaa55555555 ) + +[36,44]: + int 0876543210aaa55555555 <- ( 876543210 , aaa55555555 ) + +[36,43]: + int 43b2a19082aa55555555 <- ( 876543210 , 2aa55555555 ) + +[36,42]: + int 21d950c842aa55555555 <- ( 876543210 , eaa55555555 ) + +[36,41]: + int 10eca86420aa55555555 <- ( 876543210 , 0aa55555555 ) + +[36,40]: + int 0876543210aa55555555 <- ( 876543210 , aa55555555 ) + +[36,39]: + int 43b2a19082a55555555 <- ( 876543210 , 2a55555555 ) + +[36,38]: + int 21d950c842a55555555 <- ( 876543210 , ea55555555 ) + +[36,37]: + int 10eca86420a55555555 <- ( 876543210 , 0a55555555 ) + +[36,36]: + int 0876543210a55555555 <- ( 876543210 , a55555555 ) + +[36,35]: + int 43b2a1908255555555 <- ( 876543210 , 255555555 ) + +[36,34]: + int 21d950c84255555555 <- ( 876543210 , e55555555 ) + +[36,33]: + int 10eca8642055555555 <- ( 876543210 , 055555555 ) + +[36,32]: + int 087654321055555555 <- ( 876543210 , 55555555 ) + +[36,31]: + int 43b2a190855555555 <- ( 876543210 , d5555555 ) + +[36,30]: + int 21d950c8415555555 <- ( 876543210 , 15555555 ) + +[36,29]: + int 10eca864215555555 <- ( 876543210 , f5555555 ) + +[36,28]: + int 08765432105555555 <- ( 876543210 , 5555555 ) + +[36,27]: + int 43b2a19085555555 <- ( 876543210 , d555555 ) + +[36,26]: + int 21d950c841555555 <- ( 876543210 , 1555555 ) + +[36,25]: + int 10eca86421555555 <- ( 876543210 , f555555 ) + +[36,24]: + int 0876543210555555 <- ( 876543210 , 555555 ) + +[36,23]: + int 43b2a1908555555 <- ( 876543210 , d55555 ) + +[36,22]: + int 21d950c84155555 <- ( 876543210 , 155555 ) + +[36,21]: + int 10eca8642155555 <- ( 876543210 , f55555 ) + +[36,20]: + int 087654321055555 <- ( 876543210 , 55555 ) + +[36,19]: + int 43b2a190855555 <- ( 876543210 , d5555 ) + +[36,18]: + int 21d950c8415555 <- ( 876543210 , 15555 ) + +[36,17]: + int 10eca864215555 <- ( 876543210 , f5555 ) + +[36,16]: + int 08765432105555 <- ( 876543210 , 5555 ) + +[36,15]: + int 43b2a19085555 <- ( 876543210 , d555 ) + +[36,14]: + int 21d950c841555 <- ( 876543210 , 1555 ) + +[36,13]: + int 10eca86421555 <- ( 876543210 , f555 ) + +[36,12]: + int 0876543210555 <- ( 876543210 , 555 ) + +[36,11]: + int 43b2a1908555 <- ( 876543210 , d55 ) + +[36,10]: + int 21d950c84155 <- ( 876543210 , 155 ) + +[36,9]: + int 10eca8642155 <- ( 876543210 , f55 ) + +[36,8]: + int 087654321055 <- ( 876543210 , 55 ) + +[36,7]: + int 43b2a190855 <- ( 876543210 , d5 ) + +[36,6]: + int 21d950c8415 <- ( 876543210 , 15 ) + +[36,5]: + int 10eca864215 <- ( 876543210 , f5 ) + +[36,4]: + int 08765432105 <- ( 876543210 , 5 ) + +[36,3]: + int 43b2a19085 <- ( 876543210 , d ) + +[36,2]: + int 21d950c841 <- ( 876543210 , 1 ) + +[36,1]: + int 10eca86421 <- ( 876543210 , f ) + +[35,64]: + int 076543210aaaaaaaa55555555 <- ( 076543210 , aaaaaaaa55555555 ) + +[35,63]: + int 03b2a19082aaaaaaa55555555 <- ( 076543210 , 2aaaaaaa55555555 ) + +[35,62]: + int 01d950c842aaaaaaa55555555 <- ( 076543210 , eaaaaaaa55555555 ) + +[35,61]: + int 00eca86420aaaaaaa55555555 <- ( 076543210 , 0aaaaaaa55555555 ) + +[35,60]: + int 076543210aaaaaaa55555555 <- ( 076543210 , aaaaaaa55555555 ) + +[35,59]: + int 03b2a19082aaaaaa55555555 <- ( 076543210 , 2aaaaaa55555555 ) + +[35,58]: + int 01d950c842aaaaaa55555555 <- ( 076543210 , eaaaaaa55555555 ) + +[35,57]: + int 00eca86420aaaaaa55555555 <- ( 076543210 , 0aaaaaa55555555 ) + +[35,56]: + int 076543210aaaaaa55555555 <- ( 076543210 , aaaaaa55555555 ) + +[35,55]: + int 03b2a19082aaaaa55555555 <- ( 076543210 , 2aaaaa55555555 ) + +[35,54]: + int 01d950c842aaaaa55555555 <- ( 076543210 , eaaaaa55555555 ) + +[35,53]: + int 00eca86420aaaaa55555555 <- ( 076543210 , 0aaaaa55555555 ) + +[35,52]: + int 076543210aaaaa55555555 <- ( 076543210 , aaaaa55555555 ) + +[35,51]: + int 03b2a19082aaaa55555555 <- ( 076543210 , 2aaaa55555555 ) + +[35,50]: + int 01d950c842aaaa55555555 <- ( 076543210 , eaaaa55555555 ) + +[35,49]: + int 00eca86420aaaa55555555 <- ( 076543210 , 0aaaa55555555 ) + +[35,48]: + int 076543210aaaa55555555 <- ( 076543210 , aaaa55555555 ) + +[35,47]: + int 03b2a19082aaa55555555 <- ( 076543210 , 2aaa55555555 ) + +[35,46]: + int 01d950c842aaa55555555 <- ( 076543210 , eaaa55555555 ) + +[35,45]: + int 00eca86420aaa55555555 <- ( 076543210 , 0aaa55555555 ) + +[35,44]: + int 076543210aaa55555555 <- ( 076543210 , aaa55555555 ) + +[35,43]: + int 03b2a19082aa55555555 <- ( 076543210 , 2aa55555555 ) + +[35,42]: + int 01d950c842aa55555555 <- ( 076543210 , eaa55555555 ) + +[35,41]: + int 00eca86420aa55555555 <- ( 076543210 , 0aa55555555 ) + +[35,40]: + int 076543210aa55555555 <- ( 076543210 , aa55555555 ) + +[35,39]: + int 03b2a19082a55555555 <- ( 076543210 , 2a55555555 ) + +[35,38]: + int 01d950c842a55555555 <- ( 076543210 , ea55555555 ) + +[35,37]: + int 00eca86420a55555555 <- ( 076543210 , 0a55555555 ) + +[35,36]: + int 076543210a55555555 <- ( 076543210 , a55555555 ) + +[35,35]: + int 03b2a1908255555555 <- ( 076543210 , 255555555 ) + +[35,34]: + int 01d950c84255555555 <- ( 076543210 , e55555555 ) + +[35,33]: + int 00eca8642055555555 <- ( 076543210 , 055555555 ) + +[35,32]: + int 07654321055555555 <- ( 076543210 , 55555555 ) + +[35,31]: + int 03b2a190855555555 <- ( 076543210 , d5555555 ) + +[35,30]: + int 01d950c8415555555 <- ( 076543210 , 15555555 ) + +[35,29]: + int 00eca864215555555 <- ( 076543210 , f5555555 ) + +[35,28]: + int 0765432105555555 <- ( 076543210 , 5555555 ) + +[35,27]: + int 03b2a19085555555 <- ( 076543210 , d555555 ) + +[35,26]: + int 01d950c841555555 <- ( 076543210 , 1555555 ) + +[35,25]: + int 00eca86421555555 <- ( 076543210 , f555555 ) + +[35,24]: + int 076543210555555 <- ( 076543210 , 555555 ) + +[35,23]: + int 03b2a1908555555 <- ( 076543210 , d55555 ) + +[35,22]: + int 01d950c84155555 <- ( 076543210 , 155555 ) + +[35,21]: + int 00eca8642155555 <- ( 076543210 , f55555 ) + +[35,20]: + int 07654321055555 <- ( 076543210 , 55555 ) + +[35,19]: + int 03b2a190855555 <- ( 076543210 , d5555 ) + +[35,18]: + int 01d950c8415555 <- ( 076543210 , 15555 ) + +[35,17]: + int 00eca864215555 <- ( 076543210 , f5555 ) + +[35,16]: + int 0765432105555 <- ( 076543210 , 5555 ) + +[35,15]: + int 03b2a19085555 <- ( 076543210 , d555 ) + +[35,14]: + int 01d950c841555 <- ( 076543210 , 1555 ) + +[35,13]: + int 00eca86421555 <- ( 076543210 , f555 ) + +[35,12]: + int 076543210555 <- ( 076543210 , 555 ) + +[35,11]: + int 03b2a1908555 <- ( 076543210 , d55 ) + +[35,10]: + int 01d950c84155 <- ( 076543210 , 155 ) + +[35,9]: + int 00eca8642155 <- ( 076543210 , f55 ) + +[35,8]: + int 07654321055 <- ( 076543210 , 55 ) + +[35,7]: + int 03b2a190855 <- ( 076543210 , d5 ) + +[35,6]: + int 01d950c8415 <- ( 076543210 , 15 ) + +[35,5]: + int 00eca864215 <- ( 076543210 , f5 ) + +[35,4]: + int 0765432105 <- ( 076543210 , 5 ) + +[35,3]: + int 03b2a19085 <- ( 076543210 , d ) + +[35,2]: + int 01d950c841 <- ( 076543210 , 1 ) + +[35,1]: + int 00eca86421 <- ( 076543210 , f ) + +[34,64]: + int 076543210aaaaaaaa55555555 <- ( 076543210 , aaaaaaaa55555555 ) + +[34,63]: + int 03b2a19082aaaaaaa55555555 <- ( 076543210 , 2aaaaaaa55555555 ) + +[34,62]: + int 01d950c842aaaaaaa55555555 <- ( 076543210 , eaaaaaaa55555555 ) + +[34,61]: + int 0eca86420aaaaaaa55555555 <- ( 076543210 , 0aaaaaaa55555555 ) + +[34,60]: + int 076543210aaaaaaa55555555 <- ( 076543210 , aaaaaaa55555555 ) + +[34,59]: + int 03b2a19082aaaaaa55555555 <- ( 076543210 , 2aaaaaa55555555 ) + +[34,58]: + int 01d950c842aaaaaa55555555 <- ( 076543210 , eaaaaaa55555555 ) + +[34,57]: + int 0eca86420aaaaaa55555555 <- ( 076543210 , 0aaaaaa55555555 ) + +[34,56]: + int 076543210aaaaaa55555555 <- ( 076543210 , aaaaaa55555555 ) + +[34,55]: + int 03b2a19082aaaaa55555555 <- ( 076543210 , 2aaaaa55555555 ) + +[34,54]: + int 01d950c842aaaaa55555555 <- ( 076543210 , eaaaaa55555555 ) + +[34,53]: + int 0eca86420aaaaa55555555 <- ( 076543210 , 0aaaaa55555555 ) + +[34,52]: + int 076543210aaaaa55555555 <- ( 076543210 , aaaaa55555555 ) + +[34,51]: + int 03b2a19082aaaa55555555 <- ( 076543210 , 2aaaa55555555 ) + +[34,50]: + int 01d950c842aaaa55555555 <- ( 076543210 , eaaaa55555555 ) + +[34,49]: + int 0eca86420aaaa55555555 <- ( 076543210 , 0aaaa55555555 ) + +[34,48]: + int 076543210aaaa55555555 <- ( 076543210 , aaaa55555555 ) + +[34,47]: + int 03b2a19082aaa55555555 <- ( 076543210 , 2aaa55555555 ) + +[34,46]: + int 01d950c842aaa55555555 <- ( 076543210 , eaaa55555555 ) + +[34,45]: + int 0eca86420aaa55555555 <- ( 076543210 , 0aaa55555555 ) + +[34,44]: + int 076543210aaa55555555 <- ( 076543210 , aaa55555555 ) + +[34,43]: + int 03b2a19082aa55555555 <- ( 076543210 , 2aa55555555 ) + +[34,42]: + int 01d950c842aa55555555 <- ( 076543210 , eaa55555555 ) + +[34,41]: + int 0eca86420aa55555555 <- ( 076543210 , 0aa55555555 ) + +[34,40]: + int 076543210aa55555555 <- ( 076543210 , aa55555555 ) + +[34,39]: + int 03b2a19082a55555555 <- ( 076543210 , 2a55555555 ) + +[34,38]: + int 01d950c842a55555555 <- ( 076543210 , ea55555555 ) + +[34,37]: + int 0eca86420a55555555 <- ( 076543210 , 0a55555555 ) + +[34,36]: + int 076543210a55555555 <- ( 076543210 , a55555555 ) + +[34,35]: + int 03b2a1908255555555 <- ( 076543210 , 255555555 ) + +[34,34]: + int 01d950c84255555555 <- ( 076543210 , e55555555 ) + +[34,33]: + int 0eca8642055555555 <- ( 076543210 , 055555555 ) + +[34,32]: + int 07654321055555555 <- ( 076543210 , 55555555 ) + +[34,31]: + int 03b2a190855555555 <- ( 076543210 , d5555555 ) + +[34,30]: + int 01d950c8415555555 <- ( 076543210 , 15555555 ) + +[34,29]: + int 0eca864215555555 <- ( 076543210 , f5555555 ) + +[34,28]: + int 0765432105555555 <- ( 076543210 , 5555555 ) + +[34,27]: + int 03b2a19085555555 <- ( 076543210 , d555555 ) + +[34,26]: + int 01d950c841555555 <- ( 076543210 , 1555555 ) + +[34,25]: + int 0eca86421555555 <- ( 076543210 , f555555 ) + +[34,24]: + int 076543210555555 <- ( 076543210 , 555555 ) + +[34,23]: + int 03b2a1908555555 <- ( 076543210 , d55555 ) + +[34,22]: + int 01d950c84155555 <- ( 076543210 , 155555 ) + +[34,21]: + int 0eca8642155555 <- ( 076543210 , f55555 ) + +[34,20]: + int 07654321055555 <- ( 076543210 , 55555 ) + +[34,19]: + int 03b2a190855555 <- ( 076543210 , d5555 ) + +[34,18]: + int 01d950c8415555 <- ( 076543210 , 15555 ) + +[34,17]: + int 0eca864215555 <- ( 076543210 , f5555 ) + +[34,16]: + int 0765432105555 <- ( 076543210 , 5555 ) + +[34,15]: + int 03b2a19085555 <- ( 076543210 , d555 ) + +[34,14]: + int 01d950c841555 <- ( 076543210 , 1555 ) + +[34,13]: + int 0eca86421555 <- ( 076543210 , f555 ) + +[34,12]: + int 076543210555 <- ( 076543210 , 555 ) + +[34,11]: + int 03b2a1908555 <- ( 076543210 , d55 ) + +[34,10]: + int 01d950c84155 <- ( 076543210 , 155 ) + +[34,9]: + int 0eca8642155 <- ( 076543210 , f55 ) + +[34,8]: + int 07654321055 <- ( 076543210 , 55 ) + +[34,7]: + int 03b2a190855 <- ( 076543210 , d5 ) + +[34,6]: + int 01d950c8415 <- ( 076543210 , 15 ) + +[34,5]: + int 0eca864215 <- ( 076543210 , f5 ) + +[34,4]: + int 0765432105 <- ( 076543210 , 5 ) + +[34,3]: + int 03b2a19085 <- ( 076543210 , d ) + +[34,2]: + int 01d950c841 <- ( 076543210 , 1 ) + +[34,1]: + int 0eca86421 <- ( 076543210 , f ) + +[33,64]: + int 076543210aaaaaaaa55555555 <- ( 076543210 , aaaaaaaa55555555 ) + +[33,63]: + int 03b2a19082aaaaaaa55555555 <- ( 076543210 , 2aaaaaaa55555555 ) + +[33,62]: + int 1d950c842aaaaaaa55555555 <- ( 076543210 , eaaaaaaa55555555 ) + +[33,61]: + int 0eca86420aaaaaaa55555555 <- ( 076543210 , 0aaaaaaa55555555 ) + +[33,60]: + int 076543210aaaaaaa55555555 <- ( 076543210 , aaaaaaa55555555 ) + +[33,59]: + int 03b2a19082aaaaaa55555555 <- ( 076543210 , 2aaaaaa55555555 ) + +[33,58]: + int 1d950c842aaaaaa55555555 <- ( 076543210 , eaaaaaa55555555 ) + +[33,57]: + int 0eca86420aaaaaa55555555 <- ( 076543210 , 0aaaaaa55555555 ) + +[33,56]: + int 076543210aaaaaa55555555 <- ( 076543210 , aaaaaa55555555 ) + +[33,55]: + int 03b2a19082aaaaa55555555 <- ( 076543210 , 2aaaaa55555555 ) + +[33,54]: + int 1d950c842aaaaa55555555 <- ( 076543210 , eaaaaa55555555 ) + +[33,53]: + int 0eca86420aaaaa55555555 <- ( 076543210 , 0aaaaa55555555 ) + +[33,52]: + int 076543210aaaaa55555555 <- ( 076543210 , aaaaa55555555 ) + +[33,51]: + int 03b2a19082aaaa55555555 <- ( 076543210 , 2aaaa55555555 ) + +[33,50]: + int 1d950c842aaaa55555555 <- ( 076543210 , eaaaa55555555 ) + +[33,49]: + int 0eca86420aaaa55555555 <- ( 076543210 , 0aaaa55555555 ) + +[33,48]: + int 076543210aaaa55555555 <- ( 076543210 , aaaa55555555 ) + +[33,47]: + int 03b2a19082aaa55555555 <- ( 076543210 , 2aaa55555555 ) + +[33,46]: + int 1d950c842aaa55555555 <- ( 076543210 , eaaa55555555 ) + +[33,45]: + int 0eca86420aaa55555555 <- ( 076543210 , 0aaa55555555 ) + +[33,44]: + int 076543210aaa55555555 <- ( 076543210 , aaa55555555 ) + +[33,43]: + int 03b2a19082aa55555555 <- ( 076543210 , 2aa55555555 ) + +[33,42]: + int 1d950c842aa55555555 <- ( 076543210 , eaa55555555 ) + +[33,41]: + int 0eca86420aa55555555 <- ( 076543210 , 0aa55555555 ) + +[33,40]: + int 076543210aa55555555 <- ( 076543210 , aa55555555 ) + +[33,39]: + int 03b2a19082a55555555 <- ( 076543210 , 2a55555555 ) + +[33,38]: + int 1d950c842a55555555 <- ( 076543210 , ea55555555 ) + +[33,37]: + int 0eca86420a55555555 <- ( 076543210 , 0a55555555 ) + +[33,36]: + int 076543210a55555555 <- ( 076543210 , a55555555 ) + +[33,35]: + int 03b2a1908255555555 <- ( 076543210 , 255555555 ) + +[33,34]: + int 1d950c84255555555 <- ( 076543210 , e55555555 ) + +[33,33]: + int 0eca8642055555555 <- ( 076543210 , 055555555 ) + +[33,32]: + int 07654321055555555 <- ( 076543210 , 55555555 ) + +[33,31]: + int 03b2a190855555555 <- ( 076543210 , d5555555 ) + +[33,30]: + int 1d950c8415555555 <- ( 076543210 , 15555555 ) + +[33,29]: + int 0eca864215555555 <- ( 076543210 , f5555555 ) + +[33,28]: + int 0765432105555555 <- ( 076543210 , 5555555 ) + +[33,27]: + int 03b2a19085555555 <- ( 076543210 , d555555 ) + +[33,26]: + int 1d950c841555555 <- ( 076543210 , 1555555 ) + +[33,25]: + int 0eca86421555555 <- ( 076543210 , f555555 ) + +[33,24]: + int 076543210555555 <- ( 076543210 , 555555 ) + +[33,23]: + int 03b2a1908555555 <- ( 076543210 , d55555 ) + +[33,22]: + int 1d950c84155555 <- ( 076543210 , 155555 ) + +[33,21]: + int 0eca8642155555 <- ( 076543210 , f55555 ) + +[33,20]: + int 07654321055555 <- ( 076543210 , 55555 ) + +[33,19]: + int 03b2a190855555 <- ( 076543210 , d5555 ) + +[33,18]: + int 1d950c8415555 <- ( 076543210 , 15555 ) + +[33,17]: + int 0eca864215555 <- ( 076543210 , f5555 ) + +[33,16]: + int 0765432105555 <- ( 076543210 , 5555 ) + +[33,15]: + int 03b2a19085555 <- ( 076543210 , d555 ) + +[33,14]: + int 1d950c841555 <- ( 076543210 , 1555 ) + +[33,13]: + int 0eca86421555 <- ( 076543210 , f555 ) + +[33,12]: + int 076543210555 <- ( 076543210 , 555 ) + +[33,11]: + int 03b2a1908555 <- ( 076543210 , d55 ) + +[33,10]: + int 1d950c84155 <- ( 076543210 , 155 ) + +[33,9]: + int 0eca8642155 <- ( 076543210 , f55 ) + +[33,8]: + int 07654321055 <- ( 076543210 , 55 ) + +[33,7]: + int 03b2a190855 <- ( 076543210 , d5 ) + +[33,6]: + int 1d950c8415 <- ( 076543210 , 15 ) + +[33,5]: + int 0eca864215 <- ( 076543210 , f5 ) + +[33,4]: + int 0765432105 <- ( 076543210 , 5 ) + +[33,3]: + int 03b2a19085 <- ( 076543210 , d ) + +[33,2]: + int 1d950c841 <- ( 076543210 , 1 ) + +[33,1]: + int 0eca86421 <- ( 076543210 , f ) + +[32,64]: + int 076543210aaaaaaaa55555555 <- ( 76543210 , aaaaaaaa55555555 ) + +[32,63]: + int 3b2a19082aaaaaaa55555555 <- ( 76543210 , 2aaaaaaa55555555 ) + +[32,62]: + int 1d950c842aaaaaaa55555555 <- ( 76543210 , eaaaaaaa55555555 ) + +[32,61]: + int 0eca86420aaaaaaa55555555 <- ( 76543210 , 0aaaaaaa55555555 ) + +[32,60]: + int 076543210aaaaaaa55555555 <- ( 76543210 , aaaaaaa55555555 ) + +[32,59]: + int 3b2a19082aaaaaa55555555 <- ( 76543210 , 2aaaaaa55555555 ) + +[32,58]: + int 1d950c842aaaaaa55555555 <- ( 76543210 , eaaaaaa55555555 ) + +[32,57]: + int 0eca86420aaaaaa55555555 <- ( 76543210 , 0aaaaaa55555555 ) + +[32,56]: + int 076543210aaaaaa55555555 <- ( 76543210 , aaaaaa55555555 ) + +[32,55]: + int 3b2a19082aaaaa55555555 <- ( 76543210 , 2aaaaa55555555 ) + +[32,54]: + int 1d950c842aaaaa55555555 <- ( 76543210 , eaaaaa55555555 ) + +[32,53]: + int 0eca86420aaaaa55555555 <- ( 76543210 , 0aaaaa55555555 ) + +[32,52]: + int 076543210aaaaa55555555 <- ( 76543210 , aaaaa55555555 ) + +[32,51]: + int 3b2a19082aaaa55555555 <- ( 76543210 , 2aaaa55555555 ) + +[32,50]: + int 1d950c842aaaa55555555 <- ( 76543210 , eaaaa55555555 ) + +[32,49]: + int 0eca86420aaaa55555555 <- ( 76543210 , 0aaaa55555555 ) + +[32,48]: + int 076543210aaaa55555555 <- ( 76543210 , aaaa55555555 ) + +[32,47]: + int 3b2a19082aaa55555555 <- ( 76543210 , 2aaa55555555 ) + +[32,46]: + int 1d950c842aaa55555555 <- ( 76543210 , eaaa55555555 ) + +[32,45]: + int 0eca86420aaa55555555 <- ( 76543210 , 0aaa55555555 ) + +[32,44]: + int 076543210aaa55555555 <- ( 76543210 , aaa55555555 ) + +[32,43]: + int 3b2a19082aa55555555 <- ( 76543210 , 2aa55555555 ) + +[32,42]: + int 1d950c842aa55555555 <- ( 76543210 , eaa55555555 ) + +[32,41]: + int 0eca86420aa55555555 <- ( 76543210 , 0aa55555555 ) + +[32,40]: + int 076543210aa55555555 <- ( 76543210 , aa55555555 ) + +[32,39]: + int 3b2a19082a55555555 <- ( 76543210 , 2a55555555 ) + +[32,38]: + int 1d950c842a55555555 <- ( 76543210 , ea55555555 ) + +[32,37]: + int 0eca86420a55555555 <- ( 76543210 , 0a55555555 ) + +[32,36]: + int 076543210a55555555 <- ( 76543210 , a55555555 ) + +[32,35]: + int 3b2a1908255555555 <- ( 76543210 , 255555555 ) + +[32,34]: + int 1d950c84255555555 <- ( 76543210 , e55555555 ) + +[32,33]: + int 0eca8642055555555 <- ( 76543210 , 055555555 ) + +[32,32]: + int 07654321055555555 <- ( 76543210 , 55555555 ) + +[32,31]: + int 3b2a190855555555 <- ( 76543210 , d5555555 ) + +[32,30]: + int 1d950c8415555555 <- ( 76543210 , 15555555 ) + +[32,29]: + int 0eca864215555555 <- ( 76543210 , f5555555 ) + +[32,28]: + int 0765432105555555 <- ( 76543210 , 5555555 ) + +[32,27]: + int 3b2a19085555555 <- ( 76543210 , d555555 ) + +[32,26]: + int 1d950c841555555 <- ( 76543210 , 1555555 ) + +[32,25]: + int 0eca86421555555 <- ( 76543210 , f555555 ) + +[32,24]: + int 076543210555555 <- ( 76543210 , 555555 ) + +[32,23]: + int 3b2a1908555555 <- ( 76543210 , d55555 ) + +[32,22]: + int 1d950c84155555 <- ( 76543210 , 155555 ) + +[32,21]: + int 0eca8642155555 <- ( 76543210 , f55555 ) + +[32,20]: + int 07654321055555 <- ( 76543210 , 55555 ) + +[32,19]: + int 3b2a190855555 <- ( 76543210 , d5555 ) + +[32,18]: + int 1d950c8415555 <- ( 76543210 , 15555 ) + +[32,17]: + int 0eca864215555 <- ( 76543210 , f5555 ) + +[32,16]: + int 0765432105555 <- ( 76543210 , 5555 ) + +[32,15]: + int 3b2a19085555 <- ( 76543210 , d555 ) + +[32,14]: + int 1d950c841555 <- ( 76543210 , 1555 ) + +[32,13]: + int 0eca86421555 <- ( 76543210 , f555 ) + +[32,12]: + int 076543210555 <- ( 76543210 , 555 ) + +[32,11]: + int 3b2a1908555 <- ( 76543210 , d55 ) + +[32,10]: + int 1d950c84155 <- ( 76543210 , 155 ) + +[32,9]: + int 0eca8642155 <- ( 76543210 , f55 ) + +[32,8]: + int 07654321055 <- ( 76543210 , 55 ) + +[32,7]: + int 3b2a190855 <- ( 76543210 , d5 ) + +[32,6]: + int 1d950c8415 <- ( 76543210 , 15 ) + +[32,5]: + int 0eca864215 <- ( 76543210 , f5 ) + +[32,4]: + int 0765432105 <- ( 76543210 , 5 ) + +[32,3]: + int 3b2a19085 <- ( 76543210 , d ) + +[32,2]: + int 1d950c841 <- ( 76543210 , 1 ) + +[32,1]: + int 0eca86421 <- ( 76543210 , f ) + +[31,64]: + int 76543210aaaaaaaa55555555 <- ( f6543210 , aaaaaaaa55555555 ) + +[31,63]: + int 3b2a19082aaaaaaa55555555 <- ( f6543210 , 2aaaaaaa55555555 ) + +[31,62]: + int 1d950c842aaaaaaa55555555 <- ( f6543210 , eaaaaaaa55555555 ) + +[31,61]: + int 0eca86420aaaaaaa55555555 <- ( f6543210 , 0aaaaaaa55555555 ) + +[31,60]: + int 76543210aaaaaaa55555555 <- ( f6543210 , aaaaaaa55555555 ) + +[31,59]: + int 3b2a19082aaaaaa55555555 <- ( f6543210 , 2aaaaaa55555555 ) + +[31,58]: + int 1d950c842aaaaaa55555555 <- ( f6543210 , eaaaaaa55555555 ) + +[31,57]: + int 0eca86420aaaaaa55555555 <- ( f6543210 , 0aaaaaa55555555 ) + +[31,56]: + int 76543210aaaaaa55555555 <- ( f6543210 , aaaaaa55555555 ) + +[31,55]: + int 3b2a19082aaaaa55555555 <- ( f6543210 , 2aaaaa55555555 ) + +[31,54]: + int 1d950c842aaaaa55555555 <- ( f6543210 , eaaaaa55555555 ) + +[31,53]: + int 0eca86420aaaaa55555555 <- ( f6543210 , 0aaaaa55555555 ) + +[31,52]: + int 76543210aaaaa55555555 <- ( f6543210 , aaaaa55555555 ) + +[31,51]: + int 3b2a19082aaaa55555555 <- ( f6543210 , 2aaaa55555555 ) + +[31,50]: + int 1d950c842aaaa55555555 <- ( f6543210 , eaaaa55555555 ) + +[31,49]: + int 0eca86420aaaa55555555 <- ( f6543210 , 0aaaa55555555 ) + +[31,48]: + int 76543210aaaa55555555 <- ( f6543210 , aaaa55555555 ) + +[31,47]: + int 3b2a19082aaa55555555 <- ( f6543210 , 2aaa55555555 ) + +[31,46]: + int 1d950c842aaa55555555 <- ( f6543210 , eaaa55555555 ) + +[31,45]: + int 0eca86420aaa55555555 <- ( f6543210 , 0aaa55555555 ) + +[31,44]: + int 76543210aaa55555555 <- ( f6543210 , aaa55555555 ) + +[31,43]: + int 3b2a19082aa55555555 <- ( f6543210 , 2aa55555555 ) + +[31,42]: + int 1d950c842aa55555555 <- ( f6543210 , eaa55555555 ) + +[31,41]: + int 0eca86420aa55555555 <- ( f6543210 , 0aa55555555 ) + +[31,40]: + int 76543210aa55555555 <- ( f6543210 , aa55555555 ) + +[31,39]: + int 3b2a19082a55555555 <- ( f6543210 , 2a55555555 ) + +[31,38]: + int 1d950c842a55555555 <- ( f6543210 , ea55555555 ) + +[31,37]: + int 0eca86420a55555555 <- ( f6543210 , 0a55555555 ) + +[31,36]: + int 76543210a55555555 <- ( f6543210 , a55555555 ) + +[31,35]: + int 3b2a1908255555555 <- ( f6543210 , 255555555 ) + +[31,34]: + int 1d950c84255555555 <- ( f6543210 , e55555555 ) + +[31,33]: + int 0eca8642055555555 <- ( f6543210 , 055555555 ) + +[31,32]: + int 7654321055555555 <- ( f6543210 , 55555555 ) + +[31,31]: + int 3b2a190855555555 <- ( f6543210 , d5555555 ) + +[31,30]: + int 1d950c8415555555 <- ( f6543210 , 15555555 ) + +[31,29]: + int 0eca864215555555 <- ( f6543210 , f5555555 ) + +[31,28]: + int 765432105555555 <- ( f6543210 , 5555555 ) + +[31,27]: + int 3b2a19085555555 <- ( f6543210 , d555555 ) + +[31,26]: + int 1d950c841555555 <- ( f6543210 , 1555555 ) + +[31,25]: + int 0eca86421555555 <- ( f6543210 , f555555 ) + +[31,24]: + int 76543210555555 <- ( f6543210 , 555555 ) + +[31,23]: + int 3b2a1908555555 <- ( f6543210 , d55555 ) + +[31,22]: + int 1d950c84155555 <- ( f6543210 , 155555 ) + +[31,21]: + int 0eca8642155555 <- ( f6543210 , f55555 ) + +[31,20]: + int 7654321055555 <- ( f6543210 , 55555 ) + +[31,19]: + int 3b2a190855555 <- ( f6543210 , d5555 ) + +[31,18]: + int 1d950c8415555 <- ( f6543210 , 15555 ) + +[31,17]: + int 0eca864215555 <- ( f6543210 , f5555 ) + +[31,16]: + int 765432105555 <- ( f6543210 , 5555 ) + +[31,15]: + int 3b2a19085555 <- ( f6543210 , d555 ) + +[31,14]: + int 1d950c841555 <- ( f6543210 , 1555 ) + +[31,13]: + int 0eca86421555 <- ( f6543210 , f555 ) + +[31,12]: + int 76543210555 <- ( f6543210 , 555 ) + +[31,11]: + int 3b2a1908555 <- ( f6543210 , d55 ) + +[31,10]: + int 1d950c84155 <- ( f6543210 , 155 ) + +[31,9]: + int 0eca8642155 <- ( f6543210 , f55 ) + +[31,8]: + int 7654321055 <- ( f6543210 , 55 ) + +[31,7]: + int 3b2a190855 <- ( f6543210 , d5 ) + +[31,6]: + int 1d950c8415 <- ( f6543210 , 15 ) + +[31,5]: + int 0eca864215 <- ( f6543210 , f5 ) + +[31,4]: + int 765432105 <- ( f6543210 , 5 ) + +[31,3]: + int 3b2a19085 <- ( f6543210 , d ) + +[31,2]: + int 1d950c841 <- ( f6543210 , 1 ) + +[31,1]: + int 0eca86421 <- ( f6543210 , f ) + +[30,64]: + int 36543210aaaaaaaa55555555 <- ( f6543210 , aaaaaaaa55555555 ) + +[30,63]: + int 1b2a19082aaaaaaa55555555 <- ( f6543210 , 2aaaaaaa55555555 ) + +[30,62]: + int 0d950c842aaaaaaa55555555 <- ( f6543210 , eaaaaaaa55555555 ) + +[30,61]: + int 6ca86420aaaaaaa55555555 <- ( f6543210 , 0aaaaaaa55555555 ) + +[30,60]: + int 36543210aaaaaaa55555555 <- ( f6543210 , aaaaaaa55555555 ) + +[30,59]: + int 1b2a19082aaaaaa55555555 <- ( f6543210 , 2aaaaaa55555555 ) + +[30,58]: + int 0d950c842aaaaaa55555555 <- ( f6543210 , eaaaaaa55555555 ) + +[30,57]: + int 6ca86420aaaaaa55555555 <- ( f6543210 , 0aaaaaa55555555 ) + +[30,56]: + int 36543210aaaaaa55555555 <- ( f6543210 , aaaaaa55555555 ) + +[30,55]: + int 1b2a19082aaaaa55555555 <- ( f6543210 , 2aaaaa55555555 ) + +[30,54]: + int 0d950c842aaaaa55555555 <- ( f6543210 , eaaaaa55555555 ) + +[30,53]: + int 6ca86420aaaaa55555555 <- ( f6543210 , 0aaaaa55555555 ) + +[30,52]: + int 36543210aaaaa55555555 <- ( f6543210 , aaaaa55555555 ) + +[30,51]: + int 1b2a19082aaaa55555555 <- ( f6543210 , 2aaaa55555555 ) + +[30,50]: + int 0d950c842aaaa55555555 <- ( f6543210 , eaaaa55555555 ) + +[30,49]: + int 6ca86420aaaa55555555 <- ( f6543210 , 0aaaa55555555 ) + +[30,48]: + int 36543210aaaa55555555 <- ( f6543210 , aaaa55555555 ) + +[30,47]: + int 1b2a19082aaa55555555 <- ( f6543210 , 2aaa55555555 ) + +[30,46]: + int 0d950c842aaa55555555 <- ( f6543210 , eaaa55555555 ) + +[30,45]: + int 6ca86420aaa55555555 <- ( f6543210 , 0aaa55555555 ) + +[30,44]: + int 36543210aaa55555555 <- ( f6543210 , aaa55555555 ) + +[30,43]: + int 1b2a19082aa55555555 <- ( f6543210 , 2aa55555555 ) + +[30,42]: + int 0d950c842aa55555555 <- ( f6543210 , eaa55555555 ) + +[30,41]: + int 6ca86420aa55555555 <- ( f6543210 , 0aa55555555 ) + +[30,40]: + int 36543210aa55555555 <- ( f6543210 , aa55555555 ) + +[30,39]: + int 1b2a19082a55555555 <- ( f6543210 , 2a55555555 ) + +[30,38]: + int 0d950c842a55555555 <- ( f6543210 , ea55555555 ) + +[30,37]: + int 6ca86420a55555555 <- ( f6543210 , 0a55555555 ) + +[30,36]: + int 36543210a55555555 <- ( f6543210 , a55555555 ) + +[30,35]: + int 1b2a1908255555555 <- ( f6543210 , 255555555 ) + +[30,34]: + int 0d950c84255555555 <- ( f6543210 , e55555555 ) + +[30,33]: + int 6ca8642055555555 <- ( f6543210 , 055555555 ) + +[30,32]: + int 3654321055555555 <- ( f6543210 , 55555555 ) + +[30,31]: + int 1b2a190855555555 <- ( f6543210 , d5555555 ) + +[30,30]: + int 0d950c8415555555 <- ( f6543210 , 15555555 ) + +[30,29]: + int 6ca864215555555 <- ( f6543210 , f5555555 ) + +[30,28]: + int 365432105555555 <- ( f6543210 , 5555555 ) + +[30,27]: + int 1b2a19085555555 <- ( f6543210 , d555555 ) + +[30,26]: + int 0d950c841555555 <- ( f6543210 , 1555555 ) + +[30,25]: + int 6ca86421555555 <- ( f6543210 , f555555 ) + +[30,24]: + int 36543210555555 <- ( f6543210 , 555555 ) + +[30,23]: + int 1b2a1908555555 <- ( f6543210 , d55555 ) + +[30,22]: + int 0d950c84155555 <- ( f6543210 , 155555 ) + +[30,21]: + int 6ca8642155555 <- ( f6543210 , f55555 ) + +[30,20]: + int 3654321055555 <- ( f6543210 , 55555 ) + +[30,19]: + int 1b2a190855555 <- ( f6543210 , d5555 ) + +[30,18]: + int 0d950c8415555 <- ( f6543210 , 15555 ) + +[30,17]: + int 6ca864215555 <- ( f6543210 , f5555 ) + +[30,16]: + int 365432105555 <- ( f6543210 , 5555 ) + +[30,15]: + int 1b2a19085555 <- ( f6543210 , d555 ) + +[30,14]: + int 0d950c841555 <- ( f6543210 , 1555 ) + +[30,13]: + int 6ca86421555 <- ( f6543210 , f555 ) + +[30,12]: + int 36543210555 <- ( f6543210 , 555 ) + +[30,11]: + int 1b2a1908555 <- ( f6543210 , d55 ) + +[30,10]: + int 0d950c84155 <- ( f6543210 , 155 ) + +[30,9]: + int 6ca8642155 <- ( f6543210 , f55 ) + +[30,8]: + int 3654321055 <- ( f6543210 , 55 ) + +[30,7]: + int 1b2a190855 <- ( f6543210 , d5 ) + +[30,6]: + int 0d950c8415 <- ( f6543210 , 15 ) + +[30,5]: + int 6ca864215 <- ( f6543210 , f5 ) + +[30,4]: + int 365432105 <- ( f6543210 , 5 ) + +[30,3]: + int 1b2a19085 <- ( f6543210 , d ) + +[30,2]: + int 0d950c841 <- ( f6543210 , 1 ) + +[30,1]: + int 6ca86421 <- ( f6543210 , f ) + +[29,64]: + int 16543210aaaaaaaa55555555 <- ( f6543210 , aaaaaaaa55555555 ) + +[29,63]: + int 0b2a19082aaaaaaa55555555 <- ( f6543210 , 2aaaaaaa55555555 ) + +[29,62]: + int 5950c842aaaaaaa55555555 <- ( f6543210 , eaaaaaaa55555555 ) + +[29,61]: + int 2ca86420aaaaaaa55555555 <- ( f6543210 , 0aaaaaaa55555555 ) + +[29,60]: + int 16543210aaaaaaa55555555 <- ( f6543210 , aaaaaaa55555555 ) + +[29,59]: + int 0b2a19082aaaaaa55555555 <- ( f6543210 , 2aaaaaa55555555 ) + +[29,58]: + int 5950c842aaaaaa55555555 <- ( f6543210 , eaaaaaa55555555 ) + +[29,57]: + int 2ca86420aaaaaa55555555 <- ( f6543210 , 0aaaaaa55555555 ) + +[29,56]: + int 16543210aaaaaa55555555 <- ( f6543210 , aaaaaa55555555 ) + +[29,55]: + int 0b2a19082aaaaa55555555 <- ( f6543210 , 2aaaaa55555555 ) + +[29,54]: + int 5950c842aaaaa55555555 <- ( f6543210 , eaaaaa55555555 ) + +[29,53]: + int 2ca86420aaaaa55555555 <- ( f6543210 , 0aaaaa55555555 ) + +[29,52]: + int 16543210aaaaa55555555 <- ( f6543210 , aaaaa55555555 ) + +[29,51]: + int 0b2a19082aaaa55555555 <- ( f6543210 , 2aaaa55555555 ) + +[29,50]: + int 5950c842aaaa55555555 <- ( f6543210 , eaaaa55555555 ) + +[29,49]: + int 2ca86420aaaa55555555 <- ( f6543210 , 0aaaa55555555 ) + +[29,48]: + int 16543210aaaa55555555 <- ( f6543210 , aaaa55555555 ) + +[29,47]: + int 0b2a19082aaa55555555 <- ( f6543210 , 2aaa55555555 ) + +[29,46]: + int 5950c842aaa55555555 <- ( f6543210 , eaaa55555555 ) + +[29,45]: + int 2ca86420aaa55555555 <- ( f6543210 , 0aaa55555555 ) + +[29,44]: + int 16543210aaa55555555 <- ( f6543210 , aaa55555555 ) + +[29,43]: + int 0b2a19082aa55555555 <- ( f6543210 , 2aa55555555 ) + +[29,42]: + int 5950c842aa55555555 <- ( f6543210 , eaa55555555 ) + +[29,41]: + int 2ca86420aa55555555 <- ( f6543210 , 0aa55555555 ) + +[29,40]: + int 16543210aa55555555 <- ( f6543210 , aa55555555 ) + +[29,39]: + int 0b2a19082a55555555 <- ( f6543210 , 2a55555555 ) + +[29,38]: + int 5950c842a55555555 <- ( f6543210 , ea55555555 ) + +[29,37]: + int 2ca86420a55555555 <- ( f6543210 , 0a55555555 ) + +[29,36]: + int 16543210a55555555 <- ( f6543210 , a55555555 ) + +[29,35]: + int 0b2a1908255555555 <- ( f6543210 , 255555555 ) + +[29,34]: + int 5950c84255555555 <- ( f6543210 , e55555555 ) + +[29,33]: + int 2ca8642055555555 <- ( f6543210 , 055555555 ) + +[29,32]: + int 1654321055555555 <- ( f6543210 , 55555555 ) + +[29,31]: + int 0b2a190855555555 <- ( f6543210 , d5555555 ) + +[29,30]: + int 5950c8415555555 <- ( f6543210 , 15555555 ) + +[29,29]: + int 2ca864215555555 <- ( f6543210 , f5555555 ) + +[29,28]: + int 165432105555555 <- ( f6543210 , 5555555 ) + +[29,27]: + int 0b2a19085555555 <- ( f6543210 , d555555 ) + +[29,26]: + int 5950c841555555 <- ( f6543210 , 1555555 ) + +[29,25]: + int 2ca86421555555 <- ( f6543210 , f555555 ) + +[29,24]: + int 16543210555555 <- ( f6543210 , 555555 ) + +[29,23]: + int 0b2a1908555555 <- ( f6543210 , d55555 ) + +[29,22]: + int 5950c84155555 <- ( f6543210 , 155555 ) + +[29,21]: + int 2ca8642155555 <- ( f6543210 , f55555 ) + +[29,20]: + int 1654321055555 <- ( f6543210 , 55555 ) + +[29,19]: + int 0b2a190855555 <- ( f6543210 , d5555 ) + +[29,18]: + int 5950c8415555 <- ( f6543210 , 15555 ) + +[29,17]: + int 2ca864215555 <- ( f6543210 , f5555 ) + +[29,16]: + int 165432105555 <- ( f6543210 , 5555 ) + +[29,15]: + int 0b2a19085555 <- ( f6543210 , d555 ) + +[29,14]: + int 5950c841555 <- ( f6543210 , 1555 ) + +[29,13]: + int 2ca86421555 <- ( f6543210 , f555 ) + +[29,12]: + int 16543210555 <- ( f6543210 , 555 ) + +[29,11]: + int 0b2a1908555 <- ( f6543210 , d55 ) + +[29,10]: + int 5950c84155 <- ( f6543210 , 155 ) + +[29,9]: + int 2ca8642155 <- ( f6543210 , f55 ) + +[29,8]: + int 1654321055 <- ( f6543210 , 55 ) + +[29,7]: + int 0b2a190855 <- ( f6543210 , d5 ) + +[29,6]: + int 5950c8415 <- ( f6543210 , 15 ) + +[29,5]: + int 2ca864215 <- ( f6543210 , f5 ) + +[29,4]: + int 165432105 <- ( f6543210 , 5 ) + +[29,3]: + int 0b2a19085 <- ( f6543210 , d ) + +[29,2]: + int 5950c841 <- ( f6543210 , 1 ) + +[29,1]: + int 2ca86421 <- ( f6543210 , f ) + +[28,64]: + int 06543210aaaaaaaa55555555 <- ( 6543210 , aaaaaaaa55555555 ) + +[28,63]: + int 32a19082aaaaaaa55555555 <- ( 6543210 , 2aaaaaaa55555555 ) + +[28,62]: + int 1950c842aaaaaaa55555555 <- ( 6543210 , eaaaaaaa55555555 ) + +[28,61]: + int 0ca86420aaaaaaa55555555 <- ( 6543210 , 0aaaaaaa55555555 ) + +[28,60]: + int 06543210aaaaaaa55555555 <- ( 6543210 , aaaaaaa55555555 ) + +[28,59]: + int 32a19082aaaaaa55555555 <- ( 6543210 , 2aaaaaa55555555 ) + +[28,58]: + int 1950c842aaaaaa55555555 <- ( 6543210 , eaaaaaa55555555 ) + +[28,57]: + int 0ca86420aaaaaa55555555 <- ( 6543210 , 0aaaaaa55555555 ) + +[28,56]: + int 06543210aaaaaa55555555 <- ( 6543210 , aaaaaa55555555 ) + +[28,55]: + int 32a19082aaaaa55555555 <- ( 6543210 , 2aaaaa55555555 ) + +[28,54]: + int 1950c842aaaaa55555555 <- ( 6543210 , eaaaaa55555555 ) + +[28,53]: + int 0ca86420aaaaa55555555 <- ( 6543210 , 0aaaaa55555555 ) + +[28,52]: + int 06543210aaaaa55555555 <- ( 6543210 , aaaaa55555555 ) + +[28,51]: + int 32a19082aaaa55555555 <- ( 6543210 , 2aaaa55555555 ) + +[28,50]: + int 1950c842aaaa55555555 <- ( 6543210 , eaaaa55555555 ) + +[28,49]: + int 0ca86420aaaa55555555 <- ( 6543210 , 0aaaa55555555 ) + +[28,48]: + int 06543210aaaa55555555 <- ( 6543210 , aaaa55555555 ) + +[28,47]: + int 32a19082aaa55555555 <- ( 6543210 , 2aaa55555555 ) + +[28,46]: + int 1950c842aaa55555555 <- ( 6543210 , eaaa55555555 ) + +[28,45]: + int 0ca86420aaa55555555 <- ( 6543210 , 0aaa55555555 ) + +[28,44]: + int 06543210aaa55555555 <- ( 6543210 , aaa55555555 ) + +[28,43]: + int 32a19082aa55555555 <- ( 6543210 , 2aa55555555 ) + +[28,42]: + int 1950c842aa55555555 <- ( 6543210 , eaa55555555 ) + +[28,41]: + int 0ca86420aa55555555 <- ( 6543210 , 0aa55555555 ) + +[28,40]: + int 06543210aa55555555 <- ( 6543210 , aa55555555 ) + +[28,39]: + int 32a19082a55555555 <- ( 6543210 , 2a55555555 ) + +[28,38]: + int 1950c842a55555555 <- ( 6543210 , ea55555555 ) + +[28,37]: + int 0ca86420a55555555 <- ( 6543210 , 0a55555555 ) + +[28,36]: + int 06543210a55555555 <- ( 6543210 , a55555555 ) + +[28,35]: + int 32a1908255555555 <- ( 6543210 , 255555555 ) + +[28,34]: + int 1950c84255555555 <- ( 6543210 , e55555555 ) + +[28,33]: + int 0ca8642055555555 <- ( 6543210 , 055555555 ) + +[28,32]: + int 0654321055555555 <- ( 6543210 , 55555555 ) + +[28,31]: + int 32a190855555555 <- ( 6543210 , d5555555 ) + +[28,30]: + int 1950c8415555555 <- ( 6543210 , 15555555 ) + +[28,29]: + int 0ca864215555555 <- ( 6543210 , f5555555 ) + +[28,28]: + int 065432105555555 <- ( 6543210 , 5555555 ) + +[28,27]: + int 32a19085555555 <- ( 6543210 , d555555 ) + +[28,26]: + int 1950c841555555 <- ( 6543210 , 1555555 ) + +[28,25]: + int 0ca86421555555 <- ( 6543210 , f555555 ) + +[28,24]: + int 06543210555555 <- ( 6543210 , 555555 ) + +[28,23]: + int 32a1908555555 <- ( 6543210 , d55555 ) + +[28,22]: + int 1950c84155555 <- ( 6543210 , 155555 ) + +[28,21]: + int 0ca8642155555 <- ( 6543210 , f55555 ) + +[28,20]: + int 0654321055555 <- ( 6543210 , 55555 ) + +[28,19]: + int 32a190855555 <- ( 6543210 , d5555 ) + +[28,18]: + int 1950c8415555 <- ( 6543210 , 15555 ) + +[28,17]: + int 0ca864215555 <- ( 6543210 , f5555 ) + +[28,16]: + int 065432105555 <- ( 6543210 , 5555 ) + +[28,15]: + int 32a19085555 <- ( 6543210 , d555 ) + +[28,14]: + int 1950c841555 <- ( 6543210 , 1555 ) + +[28,13]: + int 0ca86421555 <- ( 6543210 , f555 ) + +[28,12]: + int 06543210555 <- ( 6543210 , 555 ) + +[28,11]: + int 32a1908555 <- ( 6543210 , d55 ) + +[28,10]: + int 1950c84155 <- ( 6543210 , 155 ) + +[28,9]: + int 0ca8642155 <- ( 6543210 , f55 ) + +[28,8]: + int 0654321055 <- ( 6543210 , 55 ) + +[28,7]: + int 32a190855 <- ( 6543210 , d5 ) + +[28,6]: + int 1950c8415 <- ( 6543210 , 15 ) + +[28,5]: + int 0ca864215 <- ( 6543210 , f5 ) + +[28,4]: + int 065432105 <- ( 6543210 , 5 ) + +[28,3]: + int 32a19085 <- ( 6543210 , d ) + +[28,2]: + int 1950c841 <- ( 6543210 , 1 ) + +[28,1]: + int 0ca86421 <- ( 6543210 , f ) + +[27,64]: + int 6543210aaaaaaaa55555555 <- ( e543210 , aaaaaaaa55555555 ) + +[27,63]: + int 32a19082aaaaaaa55555555 <- ( e543210 , 2aaaaaaa55555555 ) + +[27,62]: + int 1950c842aaaaaaa55555555 <- ( e543210 , eaaaaaaa55555555 ) + +[27,61]: + int 0ca86420aaaaaaa55555555 <- ( e543210 , 0aaaaaaa55555555 ) + +[27,60]: + int 6543210aaaaaaa55555555 <- ( e543210 , aaaaaaa55555555 ) + +[27,59]: + int 32a19082aaaaaa55555555 <- ( e543210 , 2aaaaaa55555555 ) + +[27,58]: + int 1950c842aaaaaa55555555 <- ( e543210 , eaaaaaa55555555 ) + +[27,57]: + int 0ca86420aaaaaa55555555 <- ( e543210 , 0aaaaaa55555555 ) + +[27,56]: + int 6543210aaaaaa55555555 <- ( e543210 , aaaaaa55555555 ) + +[27,55]: + int 32a19082aaaaa55555555 <- ( e543210 , 2aaaaa55555555 ) + +[27,54]: + int 1950c842aaaaa55555555 <- ( e543210 , eaaaaa55555555 ) + +[27,53]: + int 0ca86420aaaaa55555555 <- ( e543210 , 0aaaaa55555555 ) + +[27,52]: + int 6543210aaaaa55555555 <- ( e543210 , aaaaa55555555 ) + +[27,51]: + int 32a19082aaaa55555555 <- ( e543210 , 2aaaa55555555 ) + +[27,50]: + int 1950c842aaaa55555555 <- ( e543210 , eaaaa55555555 ) + +[27,49]: + int 0ca86420aaaa55555555 <- ( e543210 , 0aaaa55555555 ) + +[27,48]: + int 6543210aaaa55555555 <- ( e543210 , aaaa55555555 ) + +[27,47]: + int 32a19082aaa55555555 <- ( e543210 , 2aaa55555555 ) + +[27,46]: + int 1950c842aaa55555555 <- ( e543210 , eaaa55555555 ) + +[27,45]: + int 0ca86420aaa55555555 <- ( e543210 , 0aaa55555555 ) + +[27,44]: + int 6543210aaa55555555 <- ( e543210 , aaa55555555 ) + +[27,43]: + int 32a19082aa55555555 <- ( e543210 , 2aa55555555 ) + +[27,42]: + int 1950c842aa55555555 <- ( e543210 , eaa55555555 ) + +[27,41]: + int 0ca86420aa55555555 <- ( e543210 , 0aa55555555 ) + +[27,40]: + int 6543210aa55555555 <- ( e543210 , aa55555555 ) + +[27,39]: + int 32a19082a55555555 <- ( e543210 , 2a55555555 ) + +[27,38]: + int 1950c842a55555555 <- ( e543210 , ea55555555 ) + +[27,37]: + int 0ca86420a55555555 <- ( e543210 , 0a55555555 ) + +[27,36]: + int 6543210a55555555 <- ( e543210 , a55555555 ) + +[27,35]: + int 32a1908255555555 <- ( e543210 , 255555555 ) + +[27,34]: + int 1950c84255555555 <- ( e543210 , e55555555 ) + +[27,33]: + int 0ca8642055555555 <- ( e543210 , 055555555 ) + +[27,32]: + int 654321055555555 <- ( e543210 , 55555555 ) + +[27,31]: + int 32a190855555555 <- ( e543210 , d5555555 ) + +[27,30]: + int 1950c8415555555 <- ( e543210 , 15555555 ) + +[27,29]: + int 0ca864215555555 <- ( e543210 , f5555555 ) + +[27,28]: + int 65432105555555 <- ( e543210 , 5555555 ) + +[27,27]: + int 32a19085555555 <- ( e543210 , d555555 ) + +[27,26]: + int 1950c841555555 <- ( e543210 , 1555555 ) + +[27,25]: + int 0ca86421555555 <- ( e543210 , f555555 ) + +[27,24]: + int 6543210555555 <- ( e543210 , 555555 ) + +[27,23]: + int 32a1908555555 <- ( e543210 , d55555 ) + +[27,22]: + int 1950c84155555 <- ( e543210 , 155555 ) + +[27,21]: + int 0ca8642155555 <- ( e543210 , f55555 ) + +[27,20]: + int 654321055555 <- ( e543210 , 55555 ) + +[27,19]: + int 32a190855555 <- ( e543210 , d5555 ) + +[27,18]: + int 1950c8415555 <- ( e543210 , 15555 ) + +[27,17]: + int 0ca864215555 <- ( e543210 , f5555 ) + +[27,16]: + int 65432105555 <- ( e543210 , 5555 ) + +[27,15]: + int 32a19085555 <- ( e543210 , d555 ) + +[27,14]: + int 1950c841555 <- ( e543210 , 1555 ) + +[27,13]: + int 0ca86421555 <- ( e543210 , f555 ) + +[27,12]: + int 6543210555 <- ( e543210 , 555 ) + +[27,11]: + int 32a1908555 <- ( e543210 , d55 ) + +[27,10]: + int 1950c84155 <- ( e543210 , 155 ) + +[27,9]: + int 0ca8642155 <- ( e543210 , f55 ) + +[27,8]: + int 654321055 <- ( e543210 , 55 ) + +[27,7]: + int 32a190855 <- ( e543210 , d5 ) + +[27,6]: + int 1950c8415 <- ( e543210 , 15 ) + +[27,5]: + int 0ca864215 <- ( e543210 , f5 ) + +[27,4]: + int 65432105 <- ( e543210 , 5 ) + +[27,3]: + int 32a19085 <- ( e543210 , d ) + +[27,2]: + int 1950c841 <- ( e543210 , 1 ) + +[27,1]: + int 0ca86421 <- ( e543210 , f ) + +[26,64]: + int 2543210aaaaaaaa55555555 <- ( e543210 , aaaaaaaa55555555 ) + +[26,63]: + int 12a19082aaaaaaa55555555 <- ( e543210 , 2aaaaaaa55555555 ) + +[26,62]: + int 0950c842aaaaaaa55555555 <- ( e543210 , eaaaaaaa55555555 ) + +[26,61]: + int 4a86420aaaaaaa55555555 <- ( e543210 , 0aaaaaaa55555555 ) + +[26,60]: + int 2543210aaaaaaa55555555 <- ( e543210 , aaaaaaa55555555 ) + +[26,59]: + int 12a19082aaaaaa55555555 <- ( e543210 , 2aaaaaa55555555 ) + +[26,58]: + int 0950c842aaaaaa55555555 <- ( e543210 , eaaaaaa55555555 ) + +[26,57]: + int 4a86420aaaaaa55555555 <- ( e543210 , 0aaaaaa55555555 ) + +[26,56]: + int 2543210aaaaaa55555555 <- ( e543210 , aaaaaa55555555 ) + +[26,55]: + int 12a19082aaaaa55555555 <- ( e543210 , 2aaaaa55555555 ) + +[26,54]: + int 0950c842aaaaa55555555 <- ( e543210 , eaaaaa55555555 ) + +[26,53]: + int 4a86420aaaaa55555555 <- ( e543210 , 0aaaaa55555555 ) + +[26,52]: + int 2543210aaaaa55555555 <- ( e543210 , aaaaa55555555 ) + +[26,51]: + int 12a19082aaaa55555555 <- ( e543210 , 2aaaa55555555 ) + +[26,50]: + int 0950c842aaaa55555555 <- ( e543210 , eaaaa55555555 ) + +[26,49]: + int 4a86420aaaa55555555 <- ( e543210 , 0aaaa55555555 ) + +[26,48]: + int 2543210aaaa55555555 <- ( e543210 , aaaa55555555 ) + +[26,47]: + int 12a19082aaa55555555 <- ( e543210 , 2aaa55555555 ) + +[26,46]: + int 0950c842aaa55555555 <- ( e543210 , eaaa55555555 ) + +[26,45]: + int 4a86420aaa55555555 <- ( e543210 , 0aaa55555555 ) + +[26,44]: + int 2543210aaa55555555 <- ( e543210 , aaa55555555 ) + +[26,43]: + int 12a19082aa55555555 <- ( e543210 , 2aa55555555 ) + +[26,42]: + int 0950c842aa55555555 <- ( e543210 , eaa55555555 ) + +[26,41]: + int 4a86420aa55555555 <- ( e543210 , 0aa55555555 ) + +[26,40]: + int 2543210aa55555555 <- ( e543210 , aa55555555 ) + +[26,39]: + int 12a19082a55555555 <- ( e543210 , 2a55555555 ) + +[26,38]: + int 0950c842a55555555 <- ( e543210 , ea55555555 ) + +[26,37]: + int 4a86420a55555555 <- ( e543210 , 0a55555555 ) + +[26,36]: + int 2543210a55555555 <- ( e543210 , a55555555 ) + +[26,35]: + int 12a1908255555555 <- ( e543210 , 255555555 ) + +[26,34]: + int 0950c84255555555 <- ( e543210 , e55555555 ) + +[26,33]: + int 4a8642055555555 <- ( e543210 , 055555555 ) + +[26,32]: + int 254321055555555 <- ( e543210 , 55555555 ) + +[26,31]: + int 12a190855555555 <- ( e543210 , d5555555 ) + +[26,30]: + int 0950c8415555555 <- ( e543210 , 15555555 ) + +[26,29]: + int 4a864215555555 <- ( e543210 , f5555555 ) + +[26,28]: + int 25432105555555 <- ( e543210 , 5555555 ) + +[26,27]: + int 12a19085555555 <- ( e543210 , d555555 ) + +[26,26]: + int 0950c841555555 <- ( e543210 , 1555555 ) + +[26,25]: + int 4a86421555555 <- ( e543210 , f555555 ) + +[26,24]: + int 2543210555555 <- ( e543210 , 555555 ) + +[26,23]: + int 12a1908555555 <- ( e543210 , d55555 ) + +[26,22]: + int 0950c84155555 <- ( e543210 , 155555 ) + +[26,21]: + int 4a8642155555 <- ( e543210 , f55555 ) + +[26,20]: + int 254321055555 <- ( e543210 , 55555 ) + +[26,19]: + int 12a190855555 <- ( e543210 , d5555 ) + +[26,18]: + int 0950c8415555 <- ( e543210 , 15555 ) + +[26,17]: + int 4a864215555 <- ( e543210 , f5555 ) + +[26,16]: + int 25432105555 <- ( e543210 , 5555 ) + +[26,15]: + int 12a19085555 <- ( e543210 , d555 ) + +[26,14]: + int 0950c841555 <- ( e543210 , 1555 ) + +[26,13]: + int 4a86421555 <- ( e543210 , f555 ) + +[26,12]: + int 2543210555 <- ( e543210 , 555 ) + +[26,11]: + int 12a1908555 <- ( e543210 , d55 ) + +[26,10]: + int 0950c84155 <- ( e543210 , 155 ) + +[26,9]: + int 4a8642155 <- ( e543210 , f55 ) + +[26,8]: + int 254321055 <- ( e543210 , 55 ) + +[26,7]: + int 12a190855 <- ( e543210 , d5 ) + +[26,6]: + int 0950c8415 <- ( e543210 , 15 ) + +[26,5]: + int 4a864215 <- ( e543210 , f5 ) + +[26,4]: + int 25432105 <- ( e543210 , 5 ) + +[26,3]: + int 12a19085 <- ( e543210 , d ) + +[26,2]: + int 0950c841 <- ( e543210 , 1 ) + +[26,1]: + int 4a86421 <- ( e543210 , f ) + +[25,64]: + int 0543210aaaaaaaa55555555 <- ( 0543210 , aaaaaaaa55555555 ) + +[25,63]: + int 02a19082aaaaaaa55555555 <- ( 0543210 , 2aaaaaaa55555555 ) + +[25,62]: + int 150c842aaaaaaa55555555 <- ( 0543210 , eaaaaaaa55555555 ) + +[25,61]: + int 0a86420aaaaaaa55555555 <- ( 0543210 , 0aaaaaaa55555555 ) + +[25,60]: + int 0543210aaaaaaa55555555 <- ( 0543210 , aaaaaaa55555555 ) + +[25,59]: + int 02a19082aaaaaa55555555 <- ( 0543210 , 2aaaaaa55555555 ) + +[25,58]: + int 150c842aaaaaa55555555 <- ( 0543210 , eaaaaaa55555555 ) + +[25,57]: + int 0a86420aaaaaa55555555 <- ( 0543210 , 0aaaaaa55555555 ) + +[25,56]: + int 0543210aaaaaa55555555 <- ( 0543210 , aaaaaa55555555 ) + +[25,55]: + int 02a19082aaaaa55555555 <- ( 0543210 , 2aaaaa55555555 ) + +[25,54]: + int 150c842aaaaa55555555 <- ( 0543210 , eaaaaa55555555 ) + +[25,53]: + int 0a86420aaaaa55555555 <- ( 0543210 , 0aaaaa55555555 ) + +[25,52]: + int 0543210aaaaa55555555 <- ( 0543210 , aaaaa55555555 ) + +[25,51]: + int 02a19082aaaa55555555 <- ( 0543210 , 2aaaa55555555 ) + +[25,50]: + int 150c842aaaa55555555 <- ( 0543210 , eaaaa55555555 ) + +[25,49]: + int 0a86420aaaa55555555 <- ( 0543210 , 0aaaa55555555 ) + +[25,48]: + int 0543210aaaa55555555 <- ( 0543210 , aaaa55555555 ) + +[25,47]: + int 02a19082aaa55555555 <- ( 0543210 , 2aaa55555555 ) + +[25,46]: + int 150c842aaa55555555 <- ( 0543210 , eaaa55555555 ) + +[25,45]: + int 0a86420aaa55555555 <- ( 0543210 , 0aaa55555555 ) + +[25,44]: + int 0543210aaa55555555 <- ( 0543210 , aaa55555555 ) + +[25,43]: + int 02a19082aa55555555 <- ( 0543210 , 2aa55555555 ) + +[25,42]: + int 150c842aa55555555 <- ( 0543210 , eaa55555555 ) + +[25,41]: + int 0a86420aa55555555 <- ( 0543210 , 0aa55555555 ) + +[25,40]: + int 0543210aa55555555 <- ( 0543210 , aa55555555 ) + +[25,39]: + int 02a19082a55555555 <- ( 0543210 , 2a55555555 ) + +[25,38]: + int 150c842a55555555 <- ( 0543210 , ea55555555 ) + +[25,37]: + int 0a86420a55555555 <- ( 0543210 , 0a55555555 ) + +[25,36]: + int 0543210a55555555 <- ( 0543210 , a55555555 ) + +[25,35]: + int 02a1908255555555 <- ( 0543210 , 255555555 ) + +[25,34]: + int 150c84255555555 <- ( 0543210 , e55555555 ) + +[25,33]: + int 0a8642055555555 <- ( 0543210 , 055555555 ) + +[25,32]: + int 054321055555555 <- ( 0543210 , 55555555 ) + +[25,31]: + int 02a190855555555 <- ( 0543210 , d5555555 ) + +[25,30]: + int 150c8415555555 <- ( 0543210 , 15555555 ) + +[25,29]: + int 0a864215555555 <- ( 0543210 , f5555555 ) + +[25,28]: + int 05432105555555 <- ( 0543210 , 5555555 ) + +[25,27]: + int 02a19085555555 <- ( 0543210 , d555555 ) + +[25,26]: + int 150c841555555 <- ( 0543210 , 1555555 ) + +[25,25]: + int 0a86421555555 <- ( 0543210 , f555555 ) + +[25,24]: + int 0543210555555 <- ( 0543210 , 555555 ) + +[25,23]: + int 02a1908555555 <- ( 0543210 , d55555 ) + +[25,22]: + int 150c84155555 <- ( 0543210 , 155555 ) + +[25,21]: + int 0a8642155555 <- ( 0543210 , f55555 ) + +[25,20]: + int 054321055555 <- ( 0543210 , 55555 ) + +[25,19]: + int 02a190855555 <- ( 0543210 , d5555 ) + +[25,18]: + int 150c8415555 <- ( 0543210 , 15555 ) + +[25,17]: + int 0a864215555 <- ( 0543210 , f5555 ) + +[25,16]: + int 05432105555 <- ( 0543210 , 5555 ) + +[25,15]: + int 02a19085555 <- ( 0543210 , d555 ) + +[25,14]: + int 150c841555 <- ( 0543210 , 1555 ) + +[25,13]: + int 0a86421555 <- ( 0543210 , f555 ) + +[25,12]: + int 0543210555 <- ( 0543210 , 555 ) + +[25,11]: + int 02a1908555 <- ( 0543210 , d55 ) + +[25,10]: + int 150c84155 <- ( 0543210 , 155 ) + +[25,9]: + int 0a8642155 <- ( 0543210 , f55 ) + +[25,8]: + int 054321055 <- ( 0543210 , 55 ) + +[25,7]: + int 02a190855 <- ( 0543210 , d5 ) + +[25,6]: + int 150c8415 <- ( 0543210 , 15 ) + +[25,5]: + int 0a864215 <- ( 0543210 , f5 ) + +[25,4]: + int 05432105 <- ( 0543210 , 5 ) + +[25,3]: + int 02a19085 <- ( 0543210 , d ) + +[25,2]: + int 150c841 <- ( 0543210 , 1 ) + +[25,1]: + int 0a86421 <- ( 0543210 , f ) + +[24,64]: + int 0543210aaaaaaaa55555555 <- ( 543210 , aaaaaaaa55555555 ) + +[24,63]: + int 2a19082aaaaaaa55555555 <- ( 543210 , 2aaaaaaa55555555 ) + +[24,62]: + int 150c842aaaaaaa55555555 <- ( 543210 , eaaaaaaa55555555 ) + +[24,61]: + int 0a86420aaaaaaa55555555 <- ( 543210 , 0aaaaaaa55555555 ) + +[24,60]: + int 0543210aaaaaaa55555555 <- ( 543210 , aaaaaaa55555555 ) + +[24,59]: + int 2a19082aaaaaa55555555 <- ( 543210 , 2aaaaaa55555555 ) + +[24,58]: + int 150c842aaaaaa55555555 <- ( 543210 , eaaaaaa55555555 ) + +[24,57]: + int 0a86420aaaaaa55555555 <- ( 543210 , 0aaaaaa55555555 ) + +[24,56]: + int 0543210aaaaaa55555555 <- ( 543210 , aaaaaa55555555 ) + +[24,55]: + int 2a19082aaaaa55555555 <- ( 543210 , 2aaaaa55555555 ) + +[24,54]: + int 150c842aaaaa55555555 <- ( 543210 , eaaaaa55555555 ) + +[24,53]: + int 0a86420aaaaa55555555 <- ( 543210 , 0aaaaa55555555 ) + +[24,52]: + int 0543210aaaaa55555555 <- ( 543210 , aaaaa55555555 ) + +[24,51]: + int 2a19082aaaa55555555 <- ( 543210 , 2aaaa55555555 ) + +[24,50]: + int 150c842aaaa55555555 <- ( 543210 , eaaaa55555555 ) + +[24,49]: + int 0a86420aaaa55555555 <- ( 543210 , 0aaaa55555555 ) + +[24,48]: + int 0543210aaaa55555555 <- ( 543210 , aaaa55555555 ) + +[24,47]: + int 2a19082aaa55555555 <- ( 543210 , 2aaa55555555 ) + +[24,46]: + int 150c842aaa55555555 <- ( 543210 , eaaa55555555 ) + +[24,45]: + int 0a86420aaa55555555 <- ( 543210 , 0aaa55555555 ) + +[24,44]: + int 0543210aaa55555555 <- ( 543210 , aaa55555555 ) + +[24,43]: + int 2a19082aa55555555 <- ( 543210 , 2aa55555555 ) + +[24,42]: + int 150c842aa55555555 <- ( 543210 , eaa55555555 ) + +[24,41]: + int 0a86420aa55555555 <- ( 543210 , 0aa55555555 ) + +[24,40]: + int 0543210aa55555555 <- ( 543210 , aa55555555 ) + +[24,39]: + int 2a19082a55555555 <- ( 543210 , 2a55555555 ) + +[24,38]: + int 150c842a55555555 <- ( 543210 , ea55555555 ) + +[24,37]: + int 0a86420a55555555 <- ( 543210 , 0a55555555 ) + +[24,36]: + int 0543210a55555555 <- ( 543210 , a55555555 ) + +[24,35]: + int 2a1908255555555 <- ( 543210 , 255555555 ) + +[24,34]: + int 150c84255555555 <- ( 543210 , e55555555 ) + +[24,33]: + int 0a8642055555555 <- ( 543210 , 055555555 ) + +[24,32]: + int 054321055555555 <- ( 543210 , 55555555 ) + +[24,31]: + int 2a190855555555 <- ( 543210 , d5555555 ) + +[24,30]: + int 150c8415555555 <- ( 543210 , 15555555 ) + +[24,29]: + int 0a864215555555 <- ( 543210 , f5555555 ) + +[24,28]: + int 05432105555555 <- ( 543210 , 5555555 ) + +[24,27]: + int 2a19085555555 <- ( 543210 , d555555 ) + +[24,26]: + int 150c841555555 <- ( 543210 , 1555555 ) + +[24,25]: + int 0a86421555555 <- ( 543210 , f555555 ) + +[24,24]: + int 0543210555555 <- ( 543210 , 555555 ) + +[24,23]: + int 2a1908555555 <- ( 543210 , d55555 ) + +[24,22]: + int 150c84155555 <- ( 543210 , 155555 ) + +[24,21]: + int 0a8642155555 <- ( 543210 , f55555 ) + +[24,20]: + int 054321055555 <- ( 543210 , 55555 ) + +[24,19]: + int 2a190855555 <- ( 543210 , d5555 ) + +[24,18]: + int 150c8415555 <- ( 543210 , 15555 ) + +[24,17]: + int 0a864215555 <- ( 543210 , f5555 ) + +[24,16]: + int 05432105555 <- ( 543210 , 5555 ) + +[24,15]: + int 2a19085555 <- ( 543210 , d555 ) + +[24,14]: + int 150c841555 <- ( 543210 , 1555 ) + +[24,13]: + int 0a86421555 <- ( 543210 , f555 ) + +[24,12]: + int 0543210555 <- ( 543210 , 555 ) + +[24,11]: + int 2a1908555 <- ( 543210 , d55 ) + +[24,10]: + int 150c84155 <- ( 543210 , 155 ) + +[24,9]: + int 0a8642155 <- ( 543210 , f55 ) + +[24,8]: + int 054321055 <- ( 543210 , 55 ) + +[24,7]: + int 2a190855 <- ( 543210 , d5 ) + +[24,6]: + int 150c8415 <- ( 543210 , 15 ) + +[24,5]: + int 0a864215 <- ( 543210 , f5 ) + +[24,4]: + int 05432105 <- ( 543210 , 5 ) + +[24,3]: + int 2a19085 <- ( 543210 , d ) + +[24,2]: + int 150c841 <- ( 543210 , 1 ) + +[24,1]: + int 0a86421 <- ( 543210 , f ) + +[23,64]: + int 543210aaaaaaaa55555555 <- ( d43210 , aaaaaaaa55555555 ) + +[23,63]: + int 2a19082aaaaaaa55555555 <- ( d43210 , 2aaaaaaa55555555 ) + +[23,62]: + int 150c842aaaaaaa55555555 <- ( d43210 , eaaaaaaa55555555 ) + +[23,61]: + int 0a86420aaaaaaa55555555 <- ( d43210 , 0aaaaaaa55555555 ) + +[23,60]: + int 543210aaaaaaa55555555 <- ( d43210 , aaaaaaa55555555 ) + +[23,59]: + int 2a19082aaaaaa55555555 <- ( d43210 , 2aaaaaa55555555 ) + +[23,58]: + int 150c842aaaaaa55555555 <- ( d43210 , eaaaaaa55555555 ) + +[23,57]: + int 0a86420aaaaaa55555555 <- ( d43210 , 0aaaaaa55555555 ) + +[23,56]: + int 543210aaaaaa55555555 <- ( d43210 , aaaaaa55555555 ) + +[23,55]: + int 2a19082aaaaa55555555 <- ( d43210 , 2aaaaa55555555 ) + +[23,54]: + int 150c842aaaaa55555555 <- ( d43210 , eaaaaa55555555 ) + +[23,53]: + int 0a86420aaaaa55555555 <- ( d43210 , 0aaaaa55555555 ) + +[23,52]: + int 543210aaaaa55555555 <- ( d43210 , aaaaa55555555 ) + +[23,51]: + int 2a19082aaaa55555555 <- ( d43210 , 2aaaa55555555 ) + +[23,50]: + int 150c842aaaa55555555 <- ( d43210 , eaaaa55555555 ) + +[23,49]: + int 0a86420aaaa55555555 <- ( d43210 , 0aaaa55555555 ) + +[23,48]: + int 543210aaaa55555555 <- ( d43210 , aaaa55555555 ) + +[23,47]: + int 2a19082aaa55555555 <- ( d43210 , 2aaa55555555 ) + +[23,46]: + int 150c842aaa55555555 <- ( d43210 , eaaa55555555 ) + +[23,45]: + int 0a86420aaa55555555 <- ( d43210 , 0aaa55555555 ) + +[23,44]: + int 543210aaa55555555 <- ( d43210 , aaa55555555 ) + +[23,43]: + int 2a19082aa55555555 <- ( d43210 , 2aa55555555 ) + +[23,42]: + int 150c842aa55555555 <- ( d43210 , eaa55555555 ) + +[23,41]: + int 0a86420aa55555555 <- ( d43210 , 0aa55555555 ) + +[23,40]: + int 543210aa55555555 <- ( d43210 , aa55555555 ) + +[23,39]: + int 2a19082a55555555 <- ( d43210 , 2a55555555 ) + +[23,38]: + int 150c842a55555555 <- ( d43210 , ea55555555 ) + +[23,37]: + int 0a86420a55555555 <- ( d43210 , 0a55555555 ) + +[23,36]: + int 543210a55555555 <- ( d43210 , a55555555 ) + +[23,35]: + int 2a1908255555555 <- ( d43210 , 255555555 ) + +[23,34]: + int 150c84255555555 <- ( d43210 , e55555555 ) + +[23,33]: + int 0a8642055555555 <- ( d43210 , 055555555 ) + +[23,32]: + int 54321055555555 <- ( d43210 , 55555555 ) + +[23,31]: + int 2a190855555555 <- ( d43210 , d5555555 ) + +[23,30]: + int 150c8415555555 <- ( d43210 , 15555555 ) + +[23,29]: + int 0a864215555555 <- ( d43210 , f5555555 ) + +[23,28]: + int 5432105555555 <- ( d43210 , 5555555 ) + +[23,27]: + int 2a19085555555 <- ( d43210 , d555555 ) + +[23,26]: + int 150c841555555 <- ( d43210 , 1555555 ) + +[23,25]: + int 0a86421555555 <- ( d43210 , f555555 ) + +[23,24]: + int 543210555555 <- ( d43210 , 555555 ) + +[23,23]: + int 2a1908555555 <- ( d43210 , d55555 ) + +[23,22]: + int 150c84155555 <- ( d43210 , 155555 ) + +[23,21]: + int 0a8642155555 <- ( d43210 , f55555 ) + +[23,20]: + int 54321055555 <- ( d43210 , 55555 ) + +[23,19]: + int 2a190855555 <- ( d43210 , d5555 ) + +[23,18]: + int 150c8415555 <- ( d43210 , 15555 ) + +[23,17]: + int 0a864215555 <- ( d43210 , f5555 ) + +[23,16]: + int 5432105555 <- ( d43210 , 5555 ) + +[23,15]: + int 2a19085555 <- ( d43210 , d555 ) + +[23,14]: + int 150c841555 <- ( d43210 , 1555 ) + +[23,13]: + int 0a86421555 <- ( d43210 , f555 ) + +[23,12]: + int 543210555 <- ( d43210 , 555 ) + +[23,11]: + int 2a1908555 <- ( d43210 , d55 ) + +[23,10]: + int 150c84155 <- ( d43210 , 155 ) + +[23,9]: + int 0a8642155 <- ( d43210 , f55 ) + +[23,8]: + int 54321055 <- ( d43210 , 55 ) + +[23,7]: + int 2a190855 <- ( d43210 , d5 ) + +[23,6]: + int 150c8415 <- ( d43210 , 15 ) + +[23,5]: + int 0a864215 <- ( d43210 , f5 ) + +[23,4]: + int 5432105 <- ( d43210 , 5 ) + +[23,3]: + int 2a19085 <- ( d43210 , d ) + +[23,2]: + int 150c841 <- ( d43210 , 1 ) + +[23,1]: + int 0a86421 <- ( d43210 , f ) + +[22,64]: + int 143210aaaaaaaa55555555 <- ( 143210 , aaaaaaaa55555555 ) + +[22,63]: + int 0a19082aaaaaaa55555555 <- ( 143210 , 2aaaaaaa55555555 ) + +[22,62]: + int 050c842aaaaaaa55555555 <- ( 143210 , eaaaaaaa55555555 ) + +[22,61]: + int 286420aaaaaaa55555555 <- ( 143210 , 0aaaaaaa55555555 ) + +[22,60]: + int 143210aaaaaaa55555555 <- ( 143210 , aaaaaaa55555555 ) + +[22,59]: + int 0a19082aaaaaa55555555 <- ( 143210 , 2aaaaaa55555555 ) + +[22,58]: + int 050c842aaaaaa55555555 <- ( 143210 , eaaaaaa55555555 ) + +[22,57]: + int 286420aaaaaa55555555 <- ( 143210 , 0aaaaaa55555555 ) + +[22,56]: + int 143210aaaaaa55555555 <- ( 143210 , aaaaaa55555555 ) + +[22,55]: + int 0a19082aaaaa55555555 <- ( 143210 , 2aaaaa55555555 ) + +[22,54]: + int 050c842aaaaa55555555 <- ( 143210 , eaaaaa55555555 ) + +[22,53]: + int 286420aaaaa55555555 <- ( 143210 , 0aaaaa55555555 ) + +[22,52]: + int 143210aaaaa55555555 <- ( 143210 , aaaaa55555555 ) + +[22,51]: + int 0a19082aaaa55555555 <- ( 143210 , 2aaaa55555555 ) + +[22,50]: + int 050c842aaaa55555555 <- ( 143210 , eaaaa55555555 ) + +[22,49]: + int 286420aaaa55555555 <- ( 143210 , 0aaaa55555555 ) + +[22,48]: + int 143210aaaa55555555 <- ( 143210 , aaaa55555555 ) + +[22,47]: + int 0a19082aaa55555555 <- ( 143210 , 2aaa55555555 ) + +[22,46]: + int 050c842aaa55555555 <- ( 143210 , eaaa55555555 ) + +[22,45]: + int 286420aaa55555555 <- ( 143210 , 0aaa55555555 ) + +[22,44]: + int 143210aaa55555555 <- ( 143210 , aaa55555555 ) + +[22,43]: + int 0a19082aa55555555 <- ( 143210 , 2aa55555555 ) + +[22,42]: + int 050c842aa55555555 <- ( 143210 , eaa55555555 ) + +[22,41]: + int 286420aa55555555 <- ( 143210 , 0aa55555555 ) + +[22,40]: + int 143210aa55555555 <- ( 143210 , aa55555555 ) + +[22,39]: + int 0a19082a55555555 <- ( 143210 , 2a55555555 ) + +[22,38]: + int 050c842a55555555 <- ( 143210 , ea55555555 ) + +[22,37]: + int 286420a55555555 <- ( 143210 , 0a55555555 ) + +[22,36]: + int 143210a55555555 <- ( 143210 , a55555555 ) + +[22,35]: + int 0a1908255555555 <- ( 143210 , 255555555 ) + +[22,34]: + int 050c84255555555 <- ( 143210 , e55555555 ) + +[22,33]: + int 28642055555555 <- ( 143210 , 055555555 ) + +[22,32]: + int 14321055555555 <- ( 143210 , 55555555 ) + +[22,31]: + int 0a190855555555 <- ( 143210 , d5555555 ) + +[22,30]: + int 050c8415555555 <- ( 143210 , 15555555 ) + +[22,29]: + int 2864215555555 <- ( 143210 , f5555555 ) + +[22,28]: + int 1432105555555 <- ( 143210 , 5555555 ) + +[22,27]: + int 0a19085555555 <- ( 143210 , d555555 ) + +[22,26]: + int 050c841555555 <- ( 143210 , 1555555 ) + +[22,25]: + int 286421555555 <- ( 143210 , f555555 ) + +[22,24]: + int 143210555555 <- ( 143210 , 555555 ) + +[22,23]: + int 0a1908555555 <- ( 143210 , d55555 ) + +[22,22]: + int 050c84155555 <- ( 143210 , 155555 ) + +[22,21]: + int 28642155555 <- ( 143210 , f55555 ) + +[22,20]: + int 14321055555 <- ( 143210 , 55555 ) + +[22,19]: + int 0a190855555 <- ( 143210 , d5555 ) + +[22,18]: + int 050c8415555 <- ( 143210 , 15555 ) + +[22,17]: + int 2864215555 <- ( 143210 , f5555 ) + +[22,16]: + int 1432105555 <- ( 143210 , 5555 ) + +[22,15]: + int 0a19085555 <- ( 143210 , d555 ) + +[22,14]: + int 050c841555 <- ( 143210 , 1555 ) + +[22,13]: + int 286421555 <- ( 143210 , f555 ) + +[22,12]: + int 143210555 <- ( 143210 , 555 ) + +[22,11]: + int 0a1908555 <- ( 143210 , d55 ) + +[22,10]: + int 050c84155 <- ( 143210 , 155 ) + +[22,9]: + int 28642155 <- ( 143210 , f55 ) + +[22,8]: + int 14321055 <- ( 143210 , 55 ) + +[22,7]: + int 0a190855 <- ( 143210 , d5 ) + +[22,6]: + int 050c8415 <- ( 143210 , 15 ) + +[22,5]: + int 2864215 <- ( 143210 , f5 ) + +[22,4]: + int 1432105 <- ( 143210 , 5 ) + +[22,3]: + int 0a19085 <- ( 143210 , d ) + +[22,2]: + int 050c841 <- ( 143210 , 1 ) + +[22,1]: + int 286421 <- ( 143210 , f ) + +[21,64]: + int 143210aaaaaaaa55555555 <- ( f43210 , aaaaaaaa55555555 ) + +[21,63]: + int 0a19082aaaaaaa55555555 <- ( f43210 , 2aaaaaaa55555555 ) + +[21,62]: + int 50c842aaaaaaa55555555 <- ( f43210 , eaaaaaaa55555555 ) + +[21,61]: + int 286420aaaaaaa55555555 <- ( f43210 , 0aaaaaaa55555555 ) + +[21,60]: + int 143210aaaaaaa55555555 <- ( f43210 , aaaaaaa55555555 ) + +[21,59]: + int 0a19082aaaaaa55555555 <- ( f43210 , 2aaaaaa55555555 ) + +[21,58]: + int 50c842aaaaaa55555555 <- ( f43210 , eaaaaaa55555555 ) + +[21,57]: + int 286420aaaaaa55555555 <- ( f43210 , 0aaaaaa55555555 ) + +[21,56]: + int 143210aaaaaa55555555 <- ( f43210 , aaaaaa55555555 ) + +[21,55]: + int 0a19082aaaaa55555555 <- ( f43210 , 2aaaaa55555555 ) + +[21,54]: + int 50c842aaaaa55555555 <- ( f43210 , eaaaaa55555555 ) + +[21,53]: + int 286420aaaaa55555555 <- ( f43210 , 0aaaaa55555555 ) + +[21,52]: + int 143210aaaaa55555555 <- ( f43210 , aaaaa55555555 ) + +[21,51]: + int 0a19082aaaa55555555 <- ( f43210 , 2aaaa55555555 ) + +[21,50]: + int 50c842aaaa55555555 <- ( f43210 , eaaaa55555555 ) + +[21,49]: + int 286420aaaa55555555 <- ( f43210 , 0aaaa55555555 ) + +[21,48]: + int 143210aaaa55555555 <- ( f43210 , aaaa55555555 ) + +[21,47]: + int 0a19082aaa55555555 <- ( f43210 , 2aaa55555555 ) + +[21,46]: + int 50c842aaa55555555 <- ( f43210 , eaaa55555555 ) + +[21,45]: + int 286420aaa55555555 <- ( f43210 , 0aaa55555555 ) + +[21,44]: + int 143210aaa55555555 <- ( f43210 , aaa55555555 ) + +[21,43]: + int 0a19082aa55555555 <- ( f43210 , 2aa55555555 ) + +[21,42]: + int 50c842aa55555555 <- ( f43210 , eaa55555555 ) + +[21,41]: + int 286420aa55555555 <- ( f43210 , 0aa55555555 ) + +[21,40]: + int 143210aa55555555 <- ( f43210 , aa55555555 ) + +[21,39]: + int 0a19082a55555555 <- ( f43210 , 2a55555555 ) + +[21,38]: + int 50c842a55555555 <- ( f43210 , ea55555555 ) + +[21,37]: + int 286420a55555555 <- ( f43210 , 0a55555555 ) + +[21,36]: + int 143210a55555555 <- ( f43210 , a55555555 ) + +[21,35]: + int 0a1908255555555 <- ( f43210 , 255555555 ) + +[21,34]: + int 50c84255555555 <- ( f43210 , e55555555 ) + +[21,33]: + int 28642055555555 <- ( f43210 , 055555555 ) + +[21,32]: + int 14321055555555 <- ( f43210 , 55555555 ) + +[21,31]: + int 0a190855555555 <- ( f43210 , d5555555 ) + +[21,30]: + int 50c8415555555 <- ( f43210 , 15555555 ) + +[21,29]: + int 2864215555555 <- ( f43210 , f5555555 ) + +[21,28]: + int 1432105555555 <- ( f43210 , 5555555 ) + +[21,27]: + int 0a19085555555 <- ( f43210 , d555555 ) + +[21,26]: + int 50c841555555 <- ( f43210 , 1555555 ) + +[21,25]: + int 286421555555 <- ( f43210 , f555555 ) + +[21,24]: + int 143210555555 <- ( f43210 , 555555 ) + +[21,23]: + int 0a1908555555 <- ( f43210 , d55555 ) + +[21,22]: + int 50c84155555 <- ( f43210 , 155555 ) + +[21,21]: + int 28642155555 <- ( f43210 , f55555 ) + +[21,20]: + int 14321055555 <- ( f43210 , 55555 ) + +[21,19]: + int 0a190855555 <- ( f43210 , d5555 ) + +[21,18]: + int 50c8415555 <- ( f43210 , 15555 ) + +[21,17]: + int 2864215555 <- ( f43210 , f5555 ) + +[21,16]: + int 1432105555 <- ( f43210 , 5555 ) + +[21,15]: + int 0a19085555 <- ( f43210 , d555 ) + +[21,14]: + int 50c841555 <- ( f43210 , 1555 ) + +[21,13]: + int 286421555 <- ( f43210 , f555 ) + +[21,12]: + int 143210555 <- ( f43210 , 555 ) + +[21,11]: + int 0a1908555 <- ( f43210 , d55 ) + +[21,10]: + int 50c84155 <- ( f43210 , 155 ) + +[21,9]: + int 28642155 <- ( f43210 , f55 ) + +[21,8]: + int 14321055 <- ( f43210 , 55 ) + +[21,7]: + int 0a190855 <- ( f43210 , d5 ) + +[21,6]: + int 50c8415 <- ( f43210 , 15 ) + +[21,5]: + int 2864215 <- ( f43210 , f5 ) + +[21,4]: + int 1432105 <- ( f43210 , 5 ) + +[21,3]: + int 0a19085 <- ( f43210 , d ) + +[21,2]: + int 50c841 <- ( f43210 , 1 ) + +[21,1]: + int 286421 <- ( f43210 , f ) + +[20,64]: + int 043210aaaaaaaa55555555 <- ( 43210 , aaaaaaaa55555555 ) + +[20,63]: + int 219082aaaaaaa55555555 <- ( 43210 , 2aaaaaaa55555555 ) + +[20,62]: + int 10c842aaaaaaa55555555 <- ( 43210 , eaaaaaaa55555555 ) + +[20,61]: + int 086420aaaaaaa55555555 <- ( 43210 , 0aaaaaaa55555555 ) + +[20,60]: + int 043210aaaaaaa55555555 <- ( 43210 , aaaaaaa55555555 ) + +[20,59]: + int 219082aaaaaa55555555 <- ( 43210 , 2aaaaaa55555555 ) + +[20,58]: + int 10c842aaaaaa55555555 <- ( 43210 , eaaaaaa55555555 ) + +[20,57]: + int 086420aaaaaa55555555 <- ( 43210 , 0aaaaaa55555555 ) + +[20,56]: + int 043210aaaaaa55555555 <- ( 43210 , aaaaaa55555555 ) + +[20,55]: + int 219082aaaaa55555555 <- ( 43210 , 2aaaaa55555555 ) + +[20,54]: + int 10c842aaaaa55555555 <- ( 43210 , eaaaaa55555555 ) + +[20,53]: + int 086420aaaaa55555555 <- ( 43210 , 0aaaaa55555555 ) + +[20,52]: + int 043210aaaaa55555555 <- ( 43210 , aaaaa55555555 ) + +[20,51]: + int 219082aaaa55555555 <- ( 43210 , 2aaaa55555555 ) + +[20,50]: + int 10c842aaaa55555555 <- ( 43210 , eaaaa55555555 ) + +[20,49]: + int 086420aaaa55555555 <- ( 43210 , 0aaaa55555555 ) + +[20,48]: + int 043210aaaa55555555 <- ( 43210 , aaaa55555555 ) + +[20,47]: + int 219082aaa55555555 <- ( 43210 , 2aaa55555555 ) + +[20,46]: + int 10c842aaa55555555 <- ( 43210 , eaaa55555555 ) + +[20,45]: + int 086420aaa55555555 <- ( 43210 , 0aaa55555555 ) + +[20,44]: + int 043210aaa55555555 <- ( 43210 , aaa55555555 ) + +[20,43]: + int 219082aa55555555 <- ( 43210 , 2aa55555555 ) + +[20,42]: + int 10c842aa55555555 <- ( 43210 , eaa55555555 ) + +[20,41]: + int 086420aa55555555 <- ( 43210 , 0aa55555555 ) + +[20,40]: + int 043210aa55555555 <- ( 43210 , aa55555555 ) + +[20,39]: + int 219082a55555555 <- ( 43210 , 2a55555555 ) + +[20,38]: + int 10c842a55555555 <- ( 43210 , ea55555555 ) + +[20,37]: + int 086420a55555555 <- ( 43210 , 0a55555555 ) + +[20,36]: + int 043210a55555555 <- ( 43210 , a55555555 ) + +[20,35]: + int 21908255555555 <- ( 43210 , 255555555 ) + +[20,34]: + int 10c84255555555 <- ( 43210 , e55555555 ) + +[20,33]: + int 08642055555555 <- ( 43210 , 055555555 ) + +[20,32]: + int 04321055555555 <- ( 43210 , 55555555 ) + +[20,31]: + int 2190855555555 <- ( 43210 , d5555555 ) + +[20,30]: + int 10c8415555555 <- ( 43210 , 15555555 ) + +[20,29]: + int 0864215555555 <- ( 43210 , f5555555 ) + +[20,28]: + int 0432105555555 <- ( 43210 , 5555555 ) + +[20,27]: + int 219085555555 <- ( 43210 , d555555 ) + +[20,26]: + int 10c841555555 <- ( 43210 , 1555555 ) + +[20,25]: + int 086421555555 <- ( 43210 , f555555 ) + +[20,24]: + int 043210555555 <- ( 43210 , 555555 ) + +[20,23]: + int 21908555555 <- ( 43210 , d55555 ) + +[20,22]: + int 10c84155555 <- ( 43210 , 155555 ) + +[20,21]: + int 08642155555 <- ( 43210 , f55555 ) + +[20,20]: + int 04321055555 <- ( 43210 , 55555 ) + +[20,19]: + int 2190855555 <- ( 43210 , d5555 ) + +[20,18]: + int 10c8415555 <- ( 43210 , 15555 ) + +[20,17]: + int 0864215555 <- ( 43210 , f5555 ) + +[20,16]: + int 0432105555 <- ( 43210 , 5555 ) + +[20,15]: + int 219085555 <- ( 43210 , d555 ) + +[20,14]: + int 10c841555 <- ( 43210 , 1555 ) + +[20,13]: + int 086421555 <- ( 43210 , f555 ) + +[20,12]: + int 043210555 <- ( 43210 , 555 ) + +[20,11]: + int 21908555 <- ( 43210 , d55 ) + +[20,10]: + int 10c84155 <- ( 43210 , 155 ) + +[20,9]: + int 08642155 <- ( 43210 , f55 ) + +[20,8]: + int 04321055 <- ( 43210 , 55 ) + +[20,7]: + int 2190855 <- ( 43210 , d5 ) + +[20,6]: + int 10c8415 <- ( 43210 , 15 ) + +[20,5]: + int 0864215 <- ( 43210 , f5 ) + +[20,4]: + int 0432105 <- ( 43210 , 5 ) + +[20,3]: + int 219085 <- ( 43210 , d ) + +[20,2]: + int 10c841 <- ( 43210 , 1 ) + +[20,1]: + int 086421 <- ( 43210 , f ) + +[19,64]: + int 43210aaaaaaaa55555555 <- ( c3210 , aaaaaaaa55555555 ) + +[19,63]: + int 219082aaaaaaa55555555 <- ( c3210 , 2aaaaaaa55555555 ) + +[19,62]: + int 10c842aaaaaaa55555555 <- ( c3210 , eaaaaaaa55555555 ) + +[19,61]: + int 086420aaaaaaa55555555 <- ( c3210 , 0aaaaaaa55555555 ) + +[19,60]: + int 43210aaaaaaa55555555 <- ( c3210 , aaaaaaa55555555 ) + +[19,59]: + int 219082aaaaaa55555555 <- ( c3210 , 2aaaaaa55555555 ) + +[19,58]: + int 10c842aaaaaa55555555 <- ( c3210 , eaaaaaa55555555 ) + +[19,57]: + int 086420aaaaaa55555555 <- ( c3210 , 0aaaaaa55555555 ) + +[19,56]: + int 43210aaaaaa55555555 <- ( c3210 , aaaaaa55555555 ) + +[19,55]: + int 219082aaaaa55555555 <- ( c3210 , 2aaaaa55555555 ) + +[19,54]: + int 10c842aaaaa55555555 <- ( c3210 , eaaaaa55555555 ) + +[19,53]: + int 086420aaaaa55555555 <- ( c3210 , 0aaaaa55555555 ) + +[19,52]: + int 43210aaaaa55555555 <- ( c3210 , aaaaa55555555 ) + +[19,51]: + int 219082aaaa55555555 <- ( c3210 , 2aaaa55555555 ) + +[19,50]: + int 10c842aaaa55555555 <- ( c3210 , eaaaa55555555 ) + +[19,49]: + int 086420aaaa55555555 <- ( c3210 , 0aaaa55555555 ) + +[19,48]: + int 43210aaaa55555555 <- ( c3210 , aaaa55555555 ) + +[19,47]: + int 219082aaa55555555 <- ( c3210 , 2aaa55555555 ) + +[19,46]: + int 10c842aaa55555555 <- ( c3210 , eaaa55555555 ) + +[19,45]: + int 086420aaa55555555 <- ( c3210 , 0aaa55555555 ) + +[19,44]: + int 43210aaa55555555 <- ( c3210 , aaa55555555 ) + +[19,43]: + int 219082aa55555555 <- ( c3210 , 2aa55555555 ) + +[19,42]: + int 10c842aa55555555 <- ( c3210 , eaa55555555 ) + +[19,41]: + int 086420aa55555555 <- ( c3210 , 0aa55555555 ) + +[19,40]: + int 43210aa55555555 <- ( c3210 , aa55555555 ) + +[19,39]: + int 219082a55555555 <- ( c3210 , 2a55555555 ) + +[19,38]: + int 10c842a55555555 <- ( c3210 , ea55555555 ) + +[19,37]: + int 086420a55555555 <- ( c3210 , 0a55555555 ) + +[19,36]: + int 43210a55555555 <- ( c3210 , a55555555 ) + +[19,35]: + int 21908255555555 <- ( c3210 , 255555555 ) + +[19,34]: + int 10c84255555555 <- ( c3210 , e55555555 ) + +[19,33]: + int 08642055555555 <- ( c3210 , 055555555 ) + +[19,32]: + int 4321055555555 <- ( c3210 , 55555555 ) + +[19,31]: + int 2190855555555 <- ( c3210 , d5555555 ) + +[19,30]: + int 10c8415555555 <- ( c3210 , 15555555 ) + +[19,29]: + int 0864215555555 <- ( c3210 , f5555555 ) + +[19,28]: + int 432105555555 <- ( c3210 , 5555555 ) + +[19,27]: + int 219085555555 <- ( c3210 , d555555 ) + +[19,26]: + int 10c841555555 <- ( c3210 , 1555555 ) + +[19,25]: + int 086421555555 <- ( c3210 , f555555 ) + +[19,24]: + int 43210555555 <- ( c3210 , 555555 ) + +[19,23]: + int 21908555555 <- ( c3210 , d55555 ) + +[19,22]: + int 10c84155555 <- ( c3210 , 155555 ) + +[19,21]: + int 08642155555 <- ( c3210 , f55555 ) + +[19,20]: + int 4321055555 <- ( c3210 , 55555 ) + +[19,19]: + int 2190855555 <- ( c3210 , d5555 ) + +[19,18]: + int 10c8415555 <- ( c3210 , 15555 ) + +[19,17]: + int 0864215555 <- ( c3210 , f5555 ) + +[19,16]: + int 432105555 <- ( c3210 , 5555 ) + +[19,15]: + int 219085555 <- ( c3210 , d555 ) + +[19,14]: + int 10c841555 <- ( c3210 , 1555 ) + +[19,13]: + int 086421555 <- ( c3210 , f555 ) + +[19,12]: + int 43210555 <- ( c3210 , 555 ) + +[19,11]: + int 21908555 <- ( c3210 , d55 ) + +[19,10]: + int 10c84155 <- ( c3210 , 155 ) + +[19,9]: + int 08642155 <- ( c3210 , f55 ) + +[19,8]: + int 4321055 <- ( c3210 , 55 ) + +[19,7]: + int 2190855 <- ( c3210 , d5 ) + +[19,6]: + int 10c8415 <- ( c3210 , 15 ) + +[19,5]: + int 0864215 <- ( c3210 , f5 ) + +[19,4]: + int 432105 <- ( c3210 , 5 ) + +[19,3]: + int 219085 <- ( c3210 , d ) + +[19,2]: + int 10c841 <- ( c3210 , 1 ) + +[19,1]: + int 086421 <- ( c3210 , f ) + +[18,64]: + int 03210aaaaaaaa55555555 <- ( 03210 , aaaaaaaa55555555 ) + +[18,63]: + int 019082aaaaaaa55555555 <- ( 03210 , 2aaaaaaa55555555 ) + +[18,62]: + int 00c842aaaaaaa55555555 <- ( 03210 , eaaaaaaa55555555 ) + +[18,61]: + int 06420aaaaaaa55555555 <- ( 03210 , 0aaaaaaa55555555 ) + +[18,60]: + int 03210aaaaaaa55555555 <- ( 03210 , aaaaaaa55555555 ) + +[18,59]: + int 019082aaaaaa55555555 <- ( 03210 , 2aaaaaa55555555 ) + +[18,58]: + int 00c842aaaaaa55555555 <- ( 03210 , eaaaaaa55555555 ) + +[18,57]: + int 06420aaaaaa55555555 <- ( 03210 , 0aaaaaa55555555 ) + +[18,56]: + int 03210aaaaaa55555555 <- ( 03210 , aaaaaa55555555 ) + +[18,55]: + int 019082aaaaa55555555 <- ( 03210 , 2aaaaa55555555 ) + +[18,54]: + int 00c842aaaaa55555555 <- ( 03210 , eaaaaa55555555 ) + +[18,53]: + int 06420aaaaa55555555 <- ( 03210 , 0aaaaa55555555 ) + +[18,52]: + int 03210aaaaa55555555 <- ( 03210 , aaaaa55555555 ) + +[18,51]: + int 019082aaaa55555555 <- ( 03210 , 2aaaa55555555 ) + +[18,50]: + int 00c842aaaa55555555 <- ( 03210 , eaaaa55555555 ) + +[18,49]: + int 06420aaaa55555555 <- ( 03210 , 0aaaa55555555 ) + +[18,48]: + int 03210aaaa55555555 <- ( 03210 , aaaa55555555 ) + +[18,47]: + int 019082aaa55555555 <- ( 03210 , 2aaa55555555 ) + +[18,46]: + int 00c842aaa55555555 <- ( 03210 , eaaa55555555 ) + +[18,45]: + int 06420aaa55555555 <- ( 03210 , 0aaa55555555 ) + +[18,44]: + int 03210aaa55555555 <- ( 03210 , aaa55555555 ) + +[18,43]: + int 019082aa55555555 <- ( 03210 , 2aa55555555 ) + +[18,42]: + int 00c842aa55555555 <- ( 03210 , eaa55555555 ) + +[18,41]: + int 06420aa55555555 <- ( 03210 , 0aa55555555 ) + +[18,40]: + int 03210aa55555555 <- ( 03210 , aa55555555 ) + +[18,39]: + int 019082a55555555 <- ( 03210 , 2a55555555 ) + +[18,38]: + int 00c842a55555555 <- ( 03210 , ea55555555 ) + +[18,37]: + int 06420a55555555 <- ( 03210 , 0a55555555 ) + +[18,36]: + int 03210a55555555 <- ( 03210 , a55555555 ) + +[18,35]: + int 01908255555555 <- ( 03210 , 255555555 ) + +[18,34]: + int 00c84255555555 <- ( 03210 , e55555555 ) + +[18,33]: + int 0642055555555 <- ( 03210 , 055555555 ) + +[18,32]: + int 0321055555555 <- ( 03210 , 55555555 ) + +[18,31]: + int 0190855555555 <- ( 03210 , d5555555 ) + +[18,30]: + int 00c8415555555 <- ( 03210 , 15555555 ) + +[18,29]: + int 064215555555 <- ( 03210 , f5555555 ) + +[18,28]: + int 032105555555 <- ( 03210 , 5555555 ) + +[18,27]: + int 019085555555 <- ( 03210 , d555555 ) + +[18,26]: + int 00c841555555 <- ( 03210 , 1555555 ) + +[18,25]: + int 06421555555 <- ( 03210 , f555555 ) + +[18,24]: + int 03210555555 <- ( 03210 , 555555 ) + +[18,23]: + int 01908555555 <- ( 03210 , d55555 ) + +[18,22]: + int 00c84155555 <- ( 03210 , 155555 ) + +[18,21]: + int 0642155555 <- ( 03210 , f55555 ) + +[18,20]: + int 0321055555 <- ( 03210 , 55555 ) + +[18,19]: + int 0190855555 <- ( 03210 , d5555 ) + +[18,18]: + int 00c8415555 <- ( 03210 , 15555 ) + +[18,17]: + int 064215555 <- ( 03210 , f5555 ) + +[18,16]: + int 032105555 <- ( 03210 , 5555 ) + +[18,15]: + int 019085555 <- ( 03210 , d555 ) + +[18,14]: + int 00c841555 <- ( 03210 , 1555 ) + +[18,13]: + int 06421555 <- ( 03210 , f555 ) + +[18,12]: + int 03210555 <- ( 03210 , 555 ) + +[18,11]: + int 01908555 <- ( 03210 , d55 ) + +[18,10]: + int 00c84155 <- ( 03210 , 155 ) + +[18,9]: + int 0642155 <- ( 03210 , f55 ) + +[18,8]: + int 0321055 <- ( 03210 , 55 ) + +[18,7]: + int 0190855 <- ( 03210 , d5 ) + +[18,6]: + int 00c8415 <- ( 03210 , 15 ) + +[18,5]: + int 064215 <- ( 03210 , f5 ) + +[18,4]: + int 032105 <- ( 03210 , 5 ) + +[18,3]: + int 019085 <- ( 03210 , d ) + +[18,2]: + int 00c841 <- ( 03210 , 1 ) + +[18,1]: + int 06421 <- ( 03210 , f ) + +[17,64]: + int 03210aaaaaaaa55555555 <- ( 03210 , aaaaaaaa55555555 ) + +[17,63]: + int 019082aaaaaaa55555555 <- ( 03210 , 2aaaaaaa55555555 ) + +[17,62]: + int 0c842aaaaaaa55555555 <- ( 03210 , eaaaaaaa55555555 ) + +[17,61]: + int 06420aaaaaaa55555555 <- ( 03210 , 0aaaaaaa55555555 ) + +[17,60]: + int 03210aaaaaaa55555555 <- ( 03210 , aaaaaaa55555555 ) + +[17,59]: + int 019082aaaaaa55555555 <- ( 03210 , 2aaaaaa55555555 ) + +[17,58]: + int 0c842aaaaaa55555555 <- ( 03210 , eaaaaaa55555555 ) + +[17,57]: + int 06420aaaaaa55555555 <- ( 03210 , 0aaaaaa55555555 ) + +[17,56]: + int 03210aaaaaa55555555 <- ( 03210 , aaaaaa55555555 ) + +[17,55]: + int 019082aaaaa55555555 <- ( 03210 , 2aaaaa55555555 ) + +[17,54]: + int 0c842aaaaa55555555 <- ( 03210 , eaaaaa55555555 ) + +[17,53]: + int 06420aaaaa55555555 <- ( 03210 , 0aaaaa55555555 ) + +[17,52]: + int 03210aaaaa55555555 <- ( 03210 , aaaaa55555555 ) + +[17,51]: + int 019082aaaa55555555 <- ( 03210 , 2aaaa55555555 ) + +[17,50]: + int 0c842aaaa55555555 <- ( 03210 , eaaaa55555555 ) + +[17,49]: + int 06420aaaa55555555 <- ( 03210 , 0aaaa55555555 ) + +[17,48]: + int 03210aaaa55555555 <- ( 03210 , aaaa55555555 ) + +[17,47]: + int 019082aaa55555555 <- ( 03210 , 2aaa55555555 ) + +[17,46]: + int 0c842aaa55555555 <- ( 03210 , eaaa55555555 ) + +[17,45]: + int 06420aaa55555555 <- ( 03210 , 0aaa55555555 ) + +[17,44]: + int 03210aaa55555555 <- ( 03210 , aaa55555555 ) + +[17,43]: + int 019082aa55555555 <- ( 03210 , 2aa55555555 ) + +[17,42]: + int 0c842aa55555555 <- ( 03210 , eaa55555555 ) + +[17,41]: + int 06420aa55555555 <- ( 03210 , 0aa55555555 ) + +[17,40]: + int 03210aa55555555 <- ( 03210 , aa55555555 ) + +[17,39]: + int 019082a55555555 <- ( 03210 , 2a55555555 ) + +[17,38]: + int 0c842a55555555 <- ( 03210 , ea55555555 ) + +[17,37]: + int 06420a55555555 <- ( 03210 , 0a55555555 ) + +[17,36]: + int 03210a55555555 <- ( 03210 , a55555555 ) + +[17,35]: + int 01908255555555 <- ( 03210 , 255555555 ) + +[17,34]: + int 0c84255555555 <- ( 03210 , e55555555 ) + +[17,33]: + int 0642055555555 <- ( 03210 , 055555555 ) + +[17,32]: + int 0321055555555 <- ( 03210 , 55555555 ) + +[17,31]: + int 0190855555555 <- ( 03210 , d5555555 ) + +[17,30]: + int 0c8415555555 <- ( 03210 , 15555555 ) + +[17,29]: + int 064215555555 <- ( 03210 , f5555555 ) + +[17,28]: + int 032105555555 <- ( 03210 , 5555555 ) + +[17,27]: + int 019085555555 <- ( 03210 , d555555 ) + +[17,26]: + int 0c841555555 <- ( 03210 , 1555555 ) + +[17,25]: + int 06421555555 <- ( 03210 , f555555 ) + +[17,24]: + int 03210555555 <- ( 03210 , 555555 ) + +[17,23]: + int 01908555555 <- ( 03210 , d55555 ) + +[17,22]: + int 0c84155555 <- ( 03210 , 155555 ) + +[17,21]: + int 0642155555 <- ( 03210 , f55555 ) + +[17,20]: + int 0321055555 <- ( 03210 , 55555 ) + +[17,19]: + int 0190855555 <- ( 03210 , d5555 ) + +[17,18]: + int 0c8415555 <- ( 03210 , 15555 ) + +[17,17]: + int 064215555 <- ( 03210 , f5555 ) + +[17,16]: + int 032105555 <- ( 03210 , 5555 ) + +[17,15]: + int 019085555 <- ( 03210 , d555 ) + +[17,14]: + int 0c841555 <- ( 03210 , 1555 ) + +[17,13]: + int 06421555 <- ( 03210 , f555 ) + +[17,12]: + int 03210555 <- ( 03210 , 555 ) + +[17,11]: + int 01908555 <- ( 03210 , d55 ) + +[17,10]: + int 0c84155 <- ( 03210 , 155 ) + +[17,9]: + int 0642155 <- ( 03210 , f55 ) + +[17,8]: + int 0321055 <- ( 03210 , 55 ) + +[17,7]: + int 0190855 <- ( 03210 , d5 ) + +[17,6]: + int 0c8415 <- ( 03210 , 15 ) + +[17,5]: + int 064215 <- ( 03210 , f5 ) + +[17,4]: + int 032105 <- ( 03210 , 5 ) + +[17,3]: + int 019085 <- ( 03210 , d ) + +[17,2]: + int 0c841 <- ( 03210 , 1 ) + +[17,1]: + int 06421 <- ( 03210 , f ) + +[16,64]: + int 03210aaaaaaaa55555555 <- ( 3210 , aaaaaaaa55555555 ) + +[16,63]: + int 19082aaaaaaa55555555 <- ( 3210 , 2aaaaaaa55555555 ) + +[16,62]: + int 0c842aaaaaaa55555555 <- ( 3210 , eaaaaaaa55555555 ) + +[16,61]: + int 06420aaaaaaa55555555 <- ( 3210 , 0aaaaaaa55555555 ) + +[16,60]: + int 03210aaaaaaa55555555 <- ( 3210 , aaaaaaa55555555 ) + +[16,59]: + int 19082aaaaaa55555555 <- ( 3210 , 2aaaaaa55555555 ) + +[16,58]: + int 0c842aaaaaa55555555 <- ( 3210 , eaaaaaa55555555 ) + +[16,57]: + int 06420aaaaaa55555555 <- ( 3210 , 0aaaaaa55555555 ) + +[16,56]: + int 03210aaaaaa55555555 <- ( 3210 , aaaaaa55555555 ) + +[16,55]: + int 19082aaaaa55555555 <- ( 3210 , 2aaaaa55555555 ) + +[16,54]: + int 0c842aaaaa55555555 <- ( 3210 , eaaaaa55555555 ) + +[16,53]: + int 06420aaaaa55555555 <- ( 3210 , 0aaaaa55555555 ) + +[16,52]: + int 03210aaaaa55555555 <- ( 3210 , aaaaa55555555 ) + +[16,51]: + int 19082aaaa55555555 <- ( 3210 , 2aaaa55555555 ) + +[16,50]: + int 0c842aaaa55555555 <- ( 3210 , eaaaa55555555 ) + +[16,49]: + int 06420aaaa55555555 <- ( 3210 , 0aaaa55555555 ) + +[16,48]: + int 03210aaaa55555555 <- ( 3210 , aaaa55555555 ) + +[16,47]: + int 19082aaa55555555 <- ( 3210 , 2aaa55555555 ) + +[16,46]: + int 0c842aaa55555555 <- ( 3210 , eaaa55555555 ) + +[16,45]: + int 06420aaa55555555 <- ( 3210 , 0aaa55555555 ) + +[16,44]: + int 03210aaa55555555 <- ( 3210 , aaa55555555 ) + +[16,43]: + int 19082aa55555555 <- ( 3210 , 2aa55555555 ) + +[16,42]: + int 0c842aa55555555 <- ( 3210 , eaa55555555 ) + +[16,41]: + int 06420aa55555555 <- ( 3210 , 0aa55555555 ) + +[16,40]: + int 03210aa55555555 <- ( 3210 , aa55555555 ) + +[16,39]: + int 19082a55555555 <- ( 3210 , 2a55555555 ) + +[16,38]: + int 0c842a55555555 <- ( 3210 , ea55555555 ) + +[16,37]: + int 06420a55555555 <- ( 3210 , 0a55555555 ) + +[16,36]: + int 03210a55555555 <- ( 3210 , a55555555 ) + +[16,35]: + int 1908255555555 <- ( 3210 , 255555555 ) + +[16,34]: + int 0c84255555555 <- ( 3210 , e55555555 ) + +[16,33]: + int 0642055555555 <- ( 3210 , 055555555 ) + +[16,32]: + int 0321055555555 <- ( 3210 , 55555555 ) + +[16,31]: + int 190855555555 <- ( 3210 , d5555555 ) + +[16,30]: + int 0c8415555555 <- ( 3210 , 15555555 ) + +[16,29]: + int 064215555555 <- ( 3210 , f5555555 ) + +[16,28]: + int 032105555555 <- ( 3210 , 5555555 ) + +[16,27]: + int 19085555555 <- ( 3210 , d555555 ) + +[16,26]: + int 0c841555555 <- ( 3210 , 1555555 ) + +[16,25]: + int 06421555555 <- ( 3210 , f555555 ) + +[16,24]: + int 03210555555 <- ( 3210 , 555555 ) + +[16,23]: + int 1908555555 <- ( 3210 , d55555 ) + +[16,22]: + int 0c84155555 <- ( 3210 , 155555 ) + +[16,21]: + int 0642155555 <- ( 3210 , f55555 ) + +[16,20]: + int 0321055555 <- ( 3210 , 55555 ) + +[16,19]: + int 190855555 <- ( 3210 , d5555 ) + +[16,18]: + int 0c8415555 <- ( 3210 , 15555 ) + +[16,17]: + int 064215555 <- ( 3210 , f5555 ) + +[16,16]: + int 032105555 <- ( 3210 , 5555 ) + +[16,15]: + int 19085555 <- ( 3210 , d555 ) + +[16,14]: + int 0c841555 <- ( 3210 , 1555 ) + +[16,13]: + int 06421555 <- ( 3210 , f555 ) + +[16,12]: + int 03210555 <- ( 3210 , 555 ) + +[16,11]: + int 1908555 <- ( 3210 , d55 ) + +[16,10]: + int 0c84155 <- ( 3210 , 155 ) + +[16,9]: + int 0642155 <- ( 3210 , f55 ) + +[16,8]: + int 0321055 <- ( 3210 , 55 ) + +[16,7]: + int 190855 <- ( 3210 , d5 ) + +[16,6]: + int 0c8415 <- ( 3210 , 15 ) + +[16,5]: + int 064215 <- ( 3210 , f5 ) + +[16,4]: + int 032105 <- ( 3210 , 5 ) + +[16,3]: + int 19085 <- ( 3210 , d ) + +[16,2]: + int 0c841 <- ( 3210 , 1 ) + +[16,1]: + int 06421 <- ( 3210 , f ) + +[15,64]: + int 3210aaaaaaaa55555555 <- ( 3210 , aaaaaaaa55555555 ) + +[15,63]: + int 19082aaaaaaa55555555 <- ( 3210 , 2aaaaaaa55555555 ) + +[15,62]: + int 0c842aaaaaaa55555555 <- ( 3210 , eaaaaaaa55555555 ) + +[15,61]: + int 06420aaaaaaa55555555 <- ( 3210 , 0aaaaaaa55555555 ) + +[15,60]: + int 3210aaaaaaa55555555 <- ( 3210 , aaaaaaa55555555 ) + +[15,59]: + int 19082aaaaaa55555555 <- ( 3210 , 2aaaaaa55555555 ) + +[15,58]: + int 0c842aaaaaa55555555 <- ( 3210 , eaaaaaa55555555 ) + +[15,57]: + int 06420aaaaaa55555555 <- ( 3210 , 0aaaaaa55555555 ) + +[15,56]: + int 3210aaaaaa55555555 <- ( 3210 , aaaaaa55555555 ) + +[15,55]: + int 19082aaaaa55555555 <- ( 3210 , 2aaaaa55555555 ) + +[15,54]: + int 0c842aaaaa55555555 <- ( 3210 , eaaaaa55555555 ) + +[15,53]: + int 06420aaaaa55555555 <- ( 3210 , 0aaaaa55555555 ) + +[15,52]: + int 3210aaaaa55555555 <- ( 3210 , aaaaa55555555 ) + +[15,51]: + int 19082aaaa55555555 <- ( 3210 , 2aaaa55555555 ) + +[15,50]: + int 0c842aaaa55555555 <- ( 3210 , eaaaa55555555 ) + +[15,49]: + int 06420aaaa55555555 <- ( 3210 , 0aaaa55555555 ) + +[15,48]: + int 3210aaaa55555555 <- ( 3210 , aaaa55555555 ) + +[15,47]: + int 19082aaa55555555 <- ( 3210 , 2aaa55555555 ) + +[15,46]: + int 0c842aaa55555555 <- ( 3210 , eaaa55555555 ) + +[15,45]: + int 06420aaa55555555 <- ( 3210 , 0aaa55555555 ) + +[15,44]: + int 3210aaa55555555 <- ( 3210 , aaa55555555 ) + +[15,43]: + int 19082aa55555555 <- ( 3210 , 2aa55555555 ) + +[15,42]: + int 0c842aa55555555 <- ( 3210 , eaa55555555 ) + +[15,41]: + int 06420aa55555555 <- ( 3210 , 0aa55555555 ) + +[15,40]: + int 3210aa55555555 <- ( 3210 , aa55555555 ) + +[15,39]: + int 19082a55555555 <- ( 3210 , 2a55555555 ) + +[15,38]: + int 0c842a55555555 <- ( 3210 , ea55555555 ) + +[15,37]: + int 06420a55555555 <- ( 3210 , 0a55555555 ) + +[15,36]: + int 3210a55555555 <- ( 3210 , a55555555 ) + +[15,35]: + int 1908255555555 <- ( 3210 , 255555555 ) + +[15,34]: + int 0c84255555555 <- ( 3210 , e55555555 ) + +[15,33]: + int 0642055555555 <- ( 3210 , 055555555 ) + +[15,32]: + int 321055555555 <- ( 3210 , 55555555 ) + +[15,31]: + int 190855555555 <- ( 3210 , d5555555 ) + +[15,30]: + int 0c8415555555 <- ( 3210 , 15555555 ) + +[15,29]: + int 064215555555 <- ( 3210 , f5555555 ) + +[15,28]: + int 32105555555 <- ( 3210 , 5555555 ) + +[15,27]: + int 19085555555 <- ( 3210 , d555555 ) + +[15,26]: + int 0c841555555 <- ( 3210 , 1555555 ) + +[15,25]: + int 06421555555 <- ( 3210 , f555555 ) + +[15,24]: + int 3210555555 <- ( 3210 , 555555 ) + +[15,23]: + int 1908555555 <- ( 3210 , d55555 ) + +[15,22]: + int 0c84155555 <- ( 3210 , 155555 ) + +[15,21]: + int 0642155555 <- ( 3210 , f55555 ) + +[15,20]: + int 321055555 <- ( 3210 , 55555 ) + +[15,19]: + int 190855555 <- ( 3210 , d5555 ) + +[15,18]: + int 0c8415555 <- ( 3210 , 15555 ) + +[15,17]: + int 064215555 <- ( 3210 , f5555 ) + +[15,16]: + int 32105555 <- ( 3210 , 5555 ) + +[15,15]: + int 19085555 <- ( 3210 , d555 ) + +[15,14]: + int 0c841555 <- ( 3210 , 1555 ) + +[15,13]: + int 06421555 <- ( 3210 , f555 ) + +[15,12]: + int 3210555 <- ( 3210 , 555 ) + +[15,11]: + int 1908555 <- ( 3210 , d55 ) + +[15,10]: + int 0c84155 <- ( 3210 , 155 ) + +[15,9]: + int 0642155 <- ( 3210 , f55 ) + +[15,8]: + int 321055 <- ( 3210 , 55 ) + +[15,7]: + int 190855 <- ( 3210 , d5 ) + +[15,6]: + int 0c8415 <- ( 3210 , 15 ) + +[15,5]: + int 064215 <- ( 3210 , f5 ) + +[15,4]: + int 32105 <- ( 3210 , 5 ) + +[15,3]: + int 19085 <- ( 3210 , d ) + +[15,2]: + int 0c841 <- ( 3210 , 1 ) + +[15,1]: + int 06421 <- ( 3210 , f ) + +[14,64]: + int 3210aaaaaaaa55555555 <- ( f210 , aaaaaaaa55555555 ) + +[14,63]: + int 19082aaaaaaa55555555 <- ( f210 , 2aaaaaaa55555555 ) + +[14,62]: + int 0c842aaaaaaa55555555 <- ( f210 , eaaaaaaa55555555 ) + +[14,61]: + int 6420aaaaaaa55555555 <- ( f210 , 0aaaaaaa55555555 ) + +[14,60]: + int 3210aaaaaaa55555555 <- ( f210 , aaaaaaa55555555 ) + +[14,59]: + int 19082aaaaaa55555555 <- ( f210 , 2aaaaaa55555555 ) + +[14,58]: + int 0c842aaaaaa55555555 <- ( f210 , eaaaaaa55555555 ) + +[14,57]: + int 6420aaaaaa55555555 <- ( f210 , 0aaaaaa55555555 ) + +[14,56]: + int 3210aaaaaa55555555 <- ( f210 , aaaaaa55555555 ) + +[14,55]: + int 19082aaaaa55555555 <- ( f210 , 2aaaaa55555555 ) + +[14,54]: + int 0c842aaaaa55555555 <- ( f210 , eaaaaa55555555 ) + +[14,53]: + int 6420aaaaa55555555 <- ( f210 , 0aaaaa55555555 ) + +[14,52]: + int 3210aaaaa55555555 <- ( f210 , aaaaa55555555 ) + +[14,51]: + int 19082aaaa55555555 <- ( f210 , 2aaaa55555555 ) + +[14,50]: + int 0c842aaaa55555555 <- ( f210 , eaaaa55555555 ) + +[14,49]: + int 6420aaaa55555555 <- ( f210 , 0aaaa55555555 ) + +[14,48]: + int 3210aaaa55555555 <- ( f210 , aaaa55555555 ) + +[14,47]: + int 19082aaa55555555 <- ( f210 , 2aaa55555555 ) + +[14,46]: + int 0c842aaa55555555 <- ( f210 , eaaa55555555 ) + +[14,45]: + int 6420aaa55555555 <- ( f210 , 0aaa55555555 ) + +[14,44]: + int 3210aaa55555555 <- ( f210 , aaa55555555 ) + +[14,43]: + int 19082aa55555555 <- ( f210 , 2aa55555555 ) + +[14,42]: + int 0c842aa55555555 <- ( f210 , eaa55555555 ) + +[14,41]: + int 6420aa55555555 <- ( f210 , 0aa55555555 ) + +[14,40]: + int 3210aa55555555 <- ( f210 , aa55555555 ) + +[14,39]: + int 19082a55555555 <- ( f210 , 2a55555555 ) + +[14,38]: + int 0c842a55555555 <- ( f210 , ea55555555 ) + +[14,37]: + int 6420a55555555 <- ( f210 , 0a55555555 ) + +[14,36]: + int 3210a55555555 <- ( f210 , a55555555 ) + +[14,35]: + int 1908255555555 <- ( f210 , 255555555 ) + +[14,34]: + int 0c84255555555 <- ( f210 , e55555555 ) + +[14,33]: + int 642055555555 <- ( f210 , 055555555 ) + +[14,32]: + int 321055555555 <- ( f210 , 55555555 ) + +[14,31]: + int 190855555555 <- ( f210 , d5555555 ) + +[14,30]: + int 0c8415555555 <- ( f210 , 15555555 ) + +[14,29]: + int 64215555555 <- ( f210 , f5555555 ) + +[14,28]: + int 32105555555 <- ( f210 , 5555555 ) + +[14,27]: + int 19085555555 <- ( f210 , d555555 ) + +[14,26]: + int 0c841555555 <- ( f210 , 1555555 ) + +[14,25]: + int 6421555555 <- ( f210 , f555555 ) + +[14,24]: + int 3210555555 <- ( f210 , 555555 ) + +[14,23]: + int 1908555555 <- ( f210 , d55555 ) + +[14,22]: + int 0c84155555 <- ( f210 , 155555 ) + +[14,21]: + int 642155555 <- ( f210 , f55555 ) + +[14,20]: + int 321055555 <- ( f210 , 55555 ) + +[14,19]: + int 190855555 <- ( f210 , d5555 ) + +[14,18]: + int 0c8415555 <- ( f210 , 15555 ) + +[14,17]: + int 64215555 <- ( f210 , f5555 ) + +[14,16]: + int 32105555 <- ( f210 , 5555 ) + +[14,15]: + int 19085555 <- ( f210 , d555 ) + +[14,14]: + int 0c841555 <- ( f210 , 1555 ) + +[14,13]: + int 6421555 <- ( f210 , f555 ) + +[14,12]: + int 3210555 <- ( f210 , 555 ) + +[14,11]: + int 1908555 <- ( f210 , d55 ) + +[14,10]: + int 0c84155 <- ( f210 , 155 ) + +[14,9]: + int 642155 <- ( f210 , f55 ) + +[14,8]: + int 321055 <- ( f210 , 55 ) + +[14,7]: + int 190855 <- ( f210 , d5 ) + +[14,6]: + int 0c8415 <- ( f210 , 15 ) + +[14,5]: + int 64215 <- ( f210 , f5 ) + +[14,4]: + int 32105 <- ( f210 , 5 ) + +[14,3]: + int 19085 <- ( f210 , d ) + +[14,2]: + int 0c841 <- ( f210 , 1 ) + +[14,1]: + int 6421 <- ( f210 , f ) + +[13,64]: + int 1210aaaaaaaa55555555 <- ( f210 , aaaaaaaa55555555 ) + +[13,63]: + int 09082aaaaaaa55555555 <- ( f210 , 2aaaaaaa55555555 ) + +[13,62]: + int 4842aaaaaaa55555555 <- ( f210 , eaaaaaaa55555555 ) + +[13,61]: + int 2420aaaaaaa55555555 <- ( f210 , 0aaaaaaa55555555 ) + +[13,60]: + int 1210aaaaaaa55555555 <- ( f210 , aaaaaaa55555555 ) + +[13,59]: + int 09082aaaaaa55555555 <- ( f210 , 2aaaaaa55555555 ) + +[13,58]: + int 4842aaaaaa55555555 <- ( f210 , eaaaaaa55555555 ) + +[13,57]: + int 2420aaaaaa55555555 <- ( f210 , 0aaaaaa55555555 ) + +[13,56]: + int 1210aaaaaa55555555 <- ( f210 , aaaaaa55555555 ) + +[13,55]: + int 09082aaaaa55555555 <- ( f210 , 2aaaaa55555555 ) + +[13,54]: + int 4842aaaaa55555555 <- ( f210 , eaaaaa55555555 ) + +[13,53]: + int 2420aaaaa55555555 <- ( f210 , 0aaaaa55555555 ) + +[13,52]: + int 1210aaaaa55555555 <- ( f210 , aaaaa55555555 ) + +[13,51]: + int 09082aaaa55555555 <- ( f210 , 2aaaa55555555 ) + +[13,50]: + int 4842aaaa55555555 <- ( f210 , eaaaa55555555 ) + +[13,49]: + int 2420aaaa55555555 <- ( f210 , 0aaaa55555555 ) + +[13,48]: + int 1210aaaa55555555 <- ( f210 , aaaa55555555 ) + +[13,47]: + int 09082aaa55555555 <- ( f210 , 2aaa55555555 ) + +[13,46]: + int 4842aaa55555555 <- ( f210 , eaaa55555555 ) + +[13,45]: + int 2420aaa55555555 <- ( f210 , 0aaa55555555 ) + +[13,44]: + int 1210aaa55555555 <- ( f210 , aaa55555555 ) + +[13,43]: + int 09082aa55555555 <- ( f210 , 2aa55555555 ) + +[13,42]: + int 4842aa55555555 <- ( f210 , eaa55555555 ) + +[13,41]: + int 2420aa55555555 <- ( f210 , 0aa55555555 ) + +[13,40]: + int 1210aa55555555 <- ( f210 , aa55555555 ) + +[13,39]: + int 09082a55555555 <- ( f210 , 2a55555555 ) + +[13,38]: + int 4842a55555555 <- ( f210 , ea55555555 ) + +[13,37]: + int 2420a55555555 <- ( f210 , 0a55555555 ) + +[13,36]: + int 1210a55555555 <- ( f210 , a55555555 ) + +[13,35]: + int 0908255555555 <- ( f210 , 255555555 ) + +[13,34]: + int 484255555555 <- ( f210 , e55555555 ) + +[13,33]: + int 242055555555 <- ( f210 , 055555555 ) + +[13,32]: + int 121055555555 <- ( f210 , 55555555 ) + +[13,31]: + int 090855555555 <- ( f210 , d5555555 ) + +[13,30]: + int 48415555555 <- ( f210 , 15555555 ) + +[13,29]: + int 24215555555 <- ( f210 , f5555555 ) + +[13,28]: + int 12105555555 <- ( f210 , 5555555 ) + +[13,27]: + int 09085555555 <- ( f210 , d555555 ) + +[13,26]: + int 4841555555 <- ( f210 , 1555555 ) + +[13,25]: + int 2421555555 <- ( f210 , f555555 ) + +[13,24]: + int 1210555555 <- ( f210 , 555555 ) + +[13,23]: + int 0908555555 <- ( f210 , d55555 ) + +[13,22]: + int 484155555 <- ( f210 , 155555 ) + +[13,21]: + int 242155555 <- ( f210 , f55555 ) + +[13,20]: + int 121055555 <- ( f210 , 55555 ) + +[13,19]: + int 090855555 <- ( f210 , d5555 ) + +[13,18]: + int 48415555 <- ( f210 , 15555 ) + +[13,17]: + int 24215555 <- ( f210 , f5555 ) + +[13,16]: + int 12105555 <- ( f210 , 5555 ) + +[13,15]: + int 09085555 <- ( f210 , d555 ) + +[13,14]: + int 4841555 <- ( f210 , 1555 ) + +[13,13]: + int 2421555 <- ( f210 , f555 ) + +[13,12]: + int 1210555 <- ( f210 , 555 ) + +[13,11]: + int 0908555 <- ( f210 , d55 ) + +[13,10]: + int 484155 <- ( f210 , 155 ) + +[13,9]: + int 242155 <- ( f210 , f55 ) + +[13,8]: + int 121055 <- ( f210 , 55 ) + +[13,7]: + int 090855 <- ( f210 , d5 ) + +[13,6]: + int 48415 <- ( f210 , 15 ) + +[13,5]: + int 24215 <- ( f210 , f5 ) + +[13,4]: + int 12105 <- ( f210 , 5 ) + +[13,3]: + int 09085 <- ( f210 , d ) + +[13,2]: + int 4841 <- ( f210 , 1 ) + +[13,1]: + int 2421 <- ( f210 , f ) + +[12,64]: + int 0210aaaaaaaa55555555 <- ( 210 , aaaaaaaa55555555 ) + +[12,63]: + int 1082aaaaaaa55555555 <- ( 210 , 2aaaaaaa55555555 ) + +[12,62]: + int 0842aaaaaaa55555555 <- ( 210 , eaaaaaaa55555555 ) + +[12,61]: + int 0420aaaaaaa55555555 <- ( 210 , 0aaaaaaa55555555 ) + +[12,60]: + int 0210aaaaaaa55555555 <- ( 210 , aaaaaaa55555555 ) + +[12,59]: + int 1082aaaaaa55555555 <- ( 210 , 2aaaaaa55555555 ) + +[12,58]: + int 0842aaaaaa55555555 <- ( 210 , eaaaaaa55555555 ) + +[12,57]: + int 0420aaaaaa55555555 <- ( 210 , 0aaaaaa55555555 ) + +[12,56]: + int 0210aaaaaa55555555 <- ( 210 , aaaaaa55555555 ) + +[12,55]: + int 1082aaaaa55555555 <- ( 210 , 2aaaaa55555555 ) + +[12,54]: + int 0842aaaaa55555555 <- ( 210 , eaaaaa55555555 ) + +[12,53]: + int 0420aaaaa55555555 <- ( 210 , 0aaaaa55555555 ) + +[12,52]: + int 0210aaaaa55555555 <- ( 210 , aaaaa55555555 ) + +[12,51]: + int 1082aaaa55555555 <- ( 210 , 2aaaa55555555 ) + +[12,50]: + int 0842aaaa55555555 <- ( 210 , eaaaa55555555 ) + +[12,49]: + int 0420aaaa55555555 <- ( 210 , 0aaaa55555555 ) + +[12,48]: + int 0210aaaa55555555 <- ( 210 , aaaa55555555 ) + +[12,47]: + int 1082aaa55555555 <- ( 210 , 2aaa55555555 ) + +[12,46]: + int 0842aaa55555555 <- ( 210 , eaaa55555555 ) + +[12,45]: + int 0420aaa55555555 <- ( 210 , 0aaa55555555 ) + +[12,44]: + int 0210aaa55555555 <- ( 210 , aaa55555555 ) + +[12,43]: + int 1082aa55555555 <- ( 210 , 2aa55555555 ) + +[12,42]: + int 0842aa55555555 <- ( 210 , eaa55555555 ) + +[12,41]: + int 0420aa55555555 <- ( 210 , 0aa55555555 ) + +[12,40]: + int 0210aa55555555 <- ( 210 , aa55555555 ) + +[12,39]: + int 1082a55555555 <- ( 210 , 2a55555555 ) + +[12,38]: + int 0842a55555555 <- ( 210 , ea55555555 ) + +[12,37]: + int 0420a55555555 <- ( 210 , 0a55555555 ) + +[12,36]: + int 0210a55555555 <- ( 210 , a55555555 ) + +[12,35]: + int 108255555555 <- ( 210 , 255555555 ) + +[12,34]: + int 084255555555 <- ( 210 , e55555555 ) + +[12,33]: + int 042055555555 <- ( 210 , 055555555 ) + +[12,32]: + int 021055555555 <- ( 210 , 55555555 ) + +[12,31]: + int 10855555555 <- ( 210 , d5555555 ) + +[12,30]: + int 08415555555 <- ( 210 , 15555555 ) + +[12,29]: + int 04215555555 <- ( 210 , f5555555 ) + +[12,28]: + int 02105555555 <- ( 210 , 5555555 ) + +[12,27]: + int 1085555555 <- ( 210 , d555555 ) + +[12,26]: + int 0841555555 <- ( 210 , 1555555 ) + +[12,25]: + int 0421555555 <- ( 210 , f555555 ) + +[12,24]: + int 0210555555 <- ( 210 , 555555 ) + +[12,23]: + int 108555555 <- ( 210 , d55555 ) + +[12,22]: + int 084155555 <- ( 210 , 155555 ) + +[12,21]: + int 042155555 <- ( 210 , f55555 ) + +[12,20]: + int 021055555 <- ( 210 , 55555 ) + +[12,19]: + int 10855555 <- ( 210 , d5555 ) + +[12,18]: + int 08415555 <- ( 210 , 15555 ) + +[12,17]: + int 04215555 <- ( 210 , f5555 ) + +[12,16]: + int 02105555 <- ( 210 , 5555 ) + +[12,15]: + int 1085555 <- ( 210 , d555 ) + +[12,14]: + int 0841555 <- ( 210 , 1555 ) + +[12,13]: + int 0421555 <- ( 210 , f555 ) + +[12,12]: + int 0210555 <- ( 210 , 555 ) + +[12,11]: + int 108555 <- ( 210 , d55 ) + +[12,10]: + int 084155 <- ( 210 , 155 ) + +[12,9]: + int 042155 <- ( 210 , f55 ) + +[12,8]: + int 021055 <- ( 210 , 55 ) + +[12,7]: + int 10855 <- ( 210 , d5 ) + +[12,6]: + int 08415 <- ( 210 , 15 ) + +[12,5]: + int 04215 <- ( 210 , f5 ) + +[12,4]: + int 02105 <- ( 210 , 5 ) + +[12,3]: + int 1085 <- ( 210 , d ) + +[12,2]: + int 0841 <- ( 210 , 1 ) + +[12,1]: + int 0421 <- ( 210 , f ) + +[11,64]: + int 210aaaaaaaa55555555 <- ( 210 , aaaaaaaa55555555 ) + +[11,63]: + int 1082aaaaaaa55555555 <- ( 210 , 2aaaaaaa55555555 ) + +[11,62]: + int 0842aaaaaaa55555555 <- ( 210 , eaaaaaaa55555555 ) + +[11,61]: + int 0420aaaaaaa55555555 <- ( 210 , 0aaaaaaa55555555 ) + +[11,60]: + int 210aaaaaaa55555555 <- ( 210 , aaaaaaa55555555 ) + +[11,59]: + int 1082aaaaaa55555555 <- ( 210 , 2aaaaaa55555555 ) + +[11,58]: + int 0842aaaaaa55555555 <- ( 210 , eaaaaaa55555555 ) + +[11,57]: + int 0420aaaaaa55555555 <- ( 210 , 0aaaaaa55555555 ) + +[11,56]: + int 210aaaaaa55555555 <- ( 210 , aaaaaa55555555 ) + +[11,55]: + int 1082aaaaa55555555 <- ( 210 , 2aaaaa55555555 ) + +[11,54]: + int 0842aaaaa55555555 <- ( 210 , eaaaaa55555555 ) + +[11,53]: + int 0420aaaaa55555555 <- ( 210 , 0aaaaa55555555 ) + +[11,52]: + int 210aaaaa55555555 <- ( 210 , aaaaa55555555 ) + +[11,51]: + int 1082aaaa55555555 <- ( 210 , 2aaaa55555555 ) + +[11,50]: + int 0842aaaa55555555 <- ( 210 , eaaaa55555555 ) + +[11,49]: + int 0420aaaa55555555 <- ( 210 , 0aaaa55555555 ) + +[11,48]: + int 210aaaa55555555 <- ( 210 , aaaa55555555 ) + +[11,47]: + int 1082aaa55555555 <- ( 210 , 2aaa55555555 ) + +[11,46]: + int 0842aaa55555555 <- ( 210 , eaaa55555555 ) + +[11,45]: + int 0420aaa55555555 <- ( 210 , 0aaa55555555 ) + +[11,44]: + int 210aaa55555555 <- ( 210 , aaa55555555 ) + +[11,43]: + int 1082aa55555555 <- ( 210 , 2aa55555555 ) + +[11,42]: + int 0842aa55555555 <- ( 210 , eaa55555555 ) + +[11,41]: + int 0420aa55555555 <- ( 210 , 0aa55555555 ) + +[11,40]: + int 210aa55555555 <- ( 210 , aa55555555 ) + +[11,39]: + int 1082a55555555 <- ( 210 , 2a55555555 ) + +[11,38]: + int 0842a55555555 <- ( 210 , ea55555555 ) + +[11,37]: + int 0420a55555555 <- ( 210 , 0a55555555 ) + +[11,36]: + int 210a55555555 <- ( 210 , a55555555 ) + +[11,35]: + int 108255555555 <- ( 210 , 255555555 ) + +[11,34]: + int 084255555555 <- ( 210 , e55555555 ) + +[11,33]: + int 042055555555 <- ( 210 , 055555555 ) + +[11,32]: + int 21055555555 <- ( 210 , 55555555 ) + +[11,31]: + int 10855555555 <- ( 210 , d5555555 ) + +[11,30]: + int 08415555555 <- ( 210 , 15555555 ) + +[11,29]: + int 04215555555 <- ( 210 , f5555555 ) + +[11,28]: + int 2105555555 <- ( 210 , 5555555 ) + +[11,27]: + int 1085555555 <- ( 210 , d555555 ) + +[11,26]: + int 0841555555 <- ( 210 , 1555555 ) + +[11,25]: + int 0421555555 <- ( 210 , f555555 ) + +[11,24]: + int 210555555 <- ( 210 , 555555 ) + +[11,23]: + int 108555555 <- ( 210 , d55555 ) + +[11,22]: + int 084155555 <- ( 210 , 155555 ) + +[11,21]: + int 042155555 <- ( 210 , f55555 ) + +[11,20]: + int 21055555 <- ( 210 , 55555 ) + +[11,19]: + int 10855555 <- ( 210 , d5555 ) + +[11,18]: + int 08415555 <- ( 210 , 15555 ) + +[11,17]: + int 04215555 <- ( 210 , f5555 ) + +[11,16]: + int 2105555 <- ( 210 , 5555 ) + +[11,15]: + int 1085555 <- ( 210 , d555 ) + +[11,14]: + int 0841555 <- ( 210 , 1555 ) + +[11,13]: + int 0421555 <- ( 210 , f555 ) + +[11,12]: + int 210555 <- ( 210 , 555 ) + +[11,11]: + int 108555 <- ( 210 , d55 ) + +[11,10]: + int 084155 <- ( 210 , 155 ) + +[11,9]: + int 042155 <- ( 210 , f55 ) + +[11,8]: + int 21055 <- ( 210 , 55 ) + +[11,7]: + int 10855 <- ( 210 , d5 ) + +[11,6]: + int 08415 <- ( 210 , 15 ) + +[11,5]: + int 04215 <- ( 210 , f5 ) + +[11,4]: + int 2105 <- ( 210 , 5 ) + +[11,3]: + int 1085 <- ( 210 , d ) + +[11,2]: + int 0841 <- ( 210 , 1 ) + +[11,1]: + int 0421 <- ( 210 , f ) + +[10,64]: + int 210aaaaaaaa55555555 <- ( e10 , aaaaaaaa55555555 ) + +[10,63]: + int 1082aaaaaaa55555555 <- ( e10 , 2aaaaaaa55555555 ) + +[10,62]: + int 0842aaaaaaa55555555 <- ( e10 , eaaaaaaa55555555 ) + +[10,61]: + int 420aaaaaaa55555555 <- ( e10 , 0aaaaaaa55555555 ) + +[10,60]: + int 210aaaaaaa55555555 <- ( e10 , aaaaaaa55555555 ) + +[10,59]: + int 1082aaaaaa55555555 <- ( e10 , 2aaaaaa55555555 ) + +[10,58]: + int 0842aaaaaa55555555 <- ( e10 , eaaaaaa55555555 ) + +[10,57]: + int 420aaaaaa55555555 <- ( e10 , 0aaaaaa55555555 ) + +[10,56]: + int 210aaaaaa55555555 <- ( e10 , aaaaaa55555555 ) + +[10,55]: + int 1082aaaaa55555555 <- ( e10 , 2aaaaa55555555 ) + +[10,54]: + int 0842aaaaa55555555 <- ( e10 , eaaaaa55555555 ) + +[10,53]: + int 420aaaaa55555555 <- ( e10 , 0aaaaa55555555 ) + +[10,52]: + int 210aaaaa55555555 <- ( e10 , aaaaa55555555 ) + +[10,51]: + int 1082aaaa55555555 <- ( e10 , 2aaaa55555555 ) + +[10,50]: + int 0842aaaa55555555 <- ( e10 , eaaaa55555555 ) + +[10,49]: + int 420aaaa55555555 <- ( e10 , 0aaaa55555555 ) + +[10,48]: + int 210aaaa55555555 <- ( e10 , aaaa55555555 ) + +[10,47]: + int 1082aaa55555555 <- ( e10 , 2aaa55555555 ) + +[10,46]: + int 0842aaa55555555 <- ( e10 , eaaa55555555 ) + +[10,45]: + int 420aaa55555555 <- ( e10 , 0aaa55555555 ) + +[10,44]: + int 210aaa55555555 <- ( e10 , aaa55555555 ) + +[10,43]: + int 1082aa55555555 <- ( e10 , 2aa55555555 ) + +[10,42]: + int 0842aa55555555 <- ( e10 , eaa55555555 ) + +[10,41]: + int 420aa55555555 <- ( e10 , 0aa55555555 ) + +[10,40]: + int 210aa55555555 <- ( e10 , aa55555555 ) + +[10,39]: + int 1082a55555555 <- ( e10 , 2a55555555 ) + +[10,38]: + int 0842a55555555 <- ( e10 , ea55555555 ) + +[10,37]: + int 420a55555555 <- ( e10 , 0a55555555 ) + +[10,36]: + int 210a55555555 <- ( e10 , a55555555 ) + +[10,35]: + int 108255555555 <- ( e10 , 255555555 ) + +[10,34]: + int 084255555555 <- ( e10 , e55555555 ) + +[10,33]: + int 42055555555 <- ( e10 , 055555555 ) + +[10,32]: + int 21055555555 <- ( e10 , 55555555 ) + +[10,31]: + int 10855555555 <- ( e10 , d5555555 ) + +[10,30]: + int 08415555555 <- ( e10 , 15555555 ) + +[10,29]: + int 4215555555 <- ( e10 , f5555555 ) + +[10,28]: + int 2105555555 <- ( e10 , 5555555 ) + +[10,27]: + int 1085555555 <- ( e10 , d555555 ) + +[10,26]: + int 0841555555 <- ( e10 , 1555555 ) + +[10,25]: + int 421555555 <- ( e10 , f555555 ) + +[10,24]: + int 210555555 <- ( e10 , 555555 ) + +[10,23]: + int 108555555 <- ( e10 , d55555 ) + +[10,22]: + int 084155555 <- ( e10 , 155555 ) + +[10,21]: + int 42155555 <- ( e10 , f55555 ) + +[10,20]: + int 21055555 <- ( e10 , 55555 ) + +[10,19]: + int 10855555 <- ( e10 , d5555 ) + +[10,18]: + int 08415555 <- ( e10 , 15555 ) + +[10,17]: + int 4215555 <- ( e10 , f5555 ) + +[10,16]: + int 2105555 <- ( e10 , 5555 ) + +[10,15]: + int 1085555 <- ( e10 , d555 ) + +[10,14]: + int 0841555 <- ( e10 , 1555 ) + +[10,13]: + int 421555 <- ( e10 , f555 ) + +[10,12]: + int 210555 <- ( e10 , 555 ) + +[10,11]: + int 108555 <- ( e10 , d55 ) + +[10,10]: + int 084155 <- ( e10 , 155 ) + +[10,9]: + int 42155 <- ( e10 , f55 ) + +[10,8]: + int 21055 <- ( e10 , 55 ) + +[10,7]: + int 10855 <- ( e10 , d5 ) + +[10,6]: + int 08415 <- ( e10 , 15 ) + +[10,5]: + int 4215 <- ( e10 , f5 ) + +[10,4]: + int 2105 <- ( e10 , 5 ) + +[10,3]: + int 1085 <- ( e10 , d ) + +[10,2]: + int 0841 <- ( e10 , 1 ) + +[10,1]: + int 421 <- ( e10 , f ) + +[9,64]: + int 010aaaaaaaa55555555 <- ( 010 , aaaaaaaa55555555 ) + +[9,63]: + int 0082aaaaaaa55555555 <- ( 010 , 2aaaaaaa55555555 ) + +[9,62]: + int 042aaaaaaa55555555 <- ( 010 , eaaaaaaa55555555 ) + +[9,61]: + int 020aaaaaaa55555555 <- ( 010 , 0aaaaaaa55555555 ) + +[9,60]: + int 010aaaaaaa55555555 <- ( 010 , aaaaaaa55555555 ) + +[9,59]: + int 0082aaaaaa55555555 <- ( 010 , 2aaaaaa55555555 ) + +[9,58]: + int 042aaaaaa55555555 <- ( 010 , eaaaaaa55555555 ) + +[9,57]: + int 020aaaaaa55555555 <- ( 010 , 0aaaaaa55555555 ) + +[9,56]: + int 010aaaaaa55555555 <- ( 010 , aaaaaa55555555 ) + +[9,55]: + int 0082aaaaa55555555 <- ( 010 , 2aaaaa55555555 ) + +[9,54]: + int 042aaaaa55555555 <- ( 010 , eaaaaa55555555 ) + +[9,53]: + int 020aaaaa55555555 <- ( 010 , 0aaaaa55555555 ) + +[9,52]: + int 010aaaaa55555555 <- ( 010 , aaaaa55555555 ) + +[9,51]: + int 0082aaaa55555555 <- ( 010 , 2aaaa55555555 ) + +[9,50]: + int 042aaaa55555555 <- ( 010 , eaaaa55555555 ) + +[9,49]: + int 020aaaa55555555 <- ( 010 , 0aaaa55555555 ) + +[9,48]: + int 010aaaa55555555 <- ( 010 , aaaa55555555 ) + +[9,47]: + int 0082aaa55555555 <- ( 010 , 2aaa55555555 ) + +[9,46]: + int 042aaa55555555 <- ( 010 , eaaa55555555 ) + +[9,45]: + int 020aaa55555555 <- ( 010 , 0aaa55555555 ) + +[9,44]: + int 010aaa55555555 <- ( 010 , aaa55555555 ) + +[9,43]: + int 0082aa55555555 <- ( 010 , 2aa55555555 ) + +[9,42]: + int 042aa55555555 <- ( 010 , eaa55555555 ) + +[9,41]: + int 020aa55555555 <- ( 010 , 0aa55555555 ) + +[9,40]: + int 010aa55555555 <- ( 010 , aa55555555 ) + +[9,39]: + int 0082a55555555 <- ( 010 , 2a55555555 ) + +[9,38]: + int 042a55555555 <- ( 010 , ea55555555 ) + +[9,37]: + int 020a55555555 <- ( 010 , 0a55555555 ) + +[9,36]: + int 010a55555555 <- ( 010 , a55555555 ) + +[9,35]: + int 008255555555 <- ( 010 , 255555555 ) + +[9,34]: + int 04255555555 <- ( 010 , e55555555 ) + +[9,33]: + int 02055555555 <- ( 010 , 055555555 ) + +[9,32]: + int 01055555555 <- ( 010 , 55555555 ) + +[9,31]: + int 00855555555 <- ( 010 , d5555555 ) + +[9,30]: + int 0415555555 <- ( 010 , 15555555 ) + +[9,29]: + int 0215555555 <- ( 010 , f5555555 ) + +[9,28]: + int 0105555555 <- ( 010 , 5555555 ) + +[9,27]: + int 0085555555 <- ( 010 , d555555 ) + +[9,26]: + int 041555555 <- ( 010 , 1555555 ) + +[9,25]: + int 021555555 <- ( 010 , f555555 ) + +[9,24]: + int 010555555 <- ( 010 , 555555 ) + +[9,23]: + int 008555555 <- ( 010 , d55555 ) + +[9,22]: + int 04155555 <- ( 010 , 155555 ) + +[9,21]: + int 02155555 <- ( 010 , f55555 ) + +[9,20]: + int 01055555 <- ( 010 , 55555 ) + +[9,19]: + int 00855555 <- ( 010 , d5555 ) + +[9,18]: + int 0415555 <- ( 010 , 15555 ) + +[9,17]: + int 0215555 <- ( 010 , f5555 ) + +[9,16]: + int 0105555 <- ( 010 , 5555 ) + +[9,15]: + int 0085555 <- ( 010 , d555 ) + +[9,14]: + int 041555 <- ( 010 , 1555 ) + +[9,13]: + int 021555 <- ( 010 , f555 ) + +[9,12]: + int 010555 <- ( 010 , 555 ) + +[9,11]: + int 008555 <- ( 010 , d55 ) + +[9,10]: + int 04155 <- ( 010 , 155 ) + +[9,9]: + int 02155 <- ( 010 , f55 ) + +[9,8]: + int 01055 <- ( 010 , 55 ) + +[9,7]: + int 00855 <- ( 010 , d5 ) + +[9,6]: + int 0415 <- ( 010 , 15 ) + +[9,5]: + int 0215 <- ( 010 , f5 ) + +[9,4]: + int 0105 <- ( 010 , 5 ) + +[9,3]: + int 0085 <- ( 010 , d ) + +[9,2]: + int 041 <- ( 010 , 1 ) + +[9,1]: + int 021 <- ( 010 , f ) + +[8,64]: + int 010aaaaaaaa55555555 <- ( 10 , aaaaaaaa55555555 ) + +[8,63]: + int 082aaaaaaa55555555 <- ( 10 , 2aaaaaaa55555555 ) + +[8,62]: + int 042aaaaaaa55555555 <- ( 10 , eaaaaaaa55555555 ) + +[8,61]: + int 020aaaaaaa55555555 <- ( 10 , 0aaaaaaa55555555 ) + +[8,60]: + int 010aaaaaaa55555555 <- ( 10 , aaaaaaa55555555 ) + +[8,59]: + int 082aaaaaa55555555 <- ( 10 , 2aaaaaa55555555 ) + +[8,58]: + int 042aaaaaa55555555 <- ( 10 , eaaaaaa55555555 ) + +[8,57]: + int 020aaaaaa55555555 <- ( 10 , 0aaaaaa55555555 ) + +[8,56]: + int 010aaaaaa55555555 <- ( 10 , aaaaaa55555555 ) + +[8,55]: + int 082aaaaa55555555 <- ( 10 , 2aaaaa55555555 ) + +[8,54]: + int 042aaaaa55555555 <- ( 10 , eaaaaa55555555 ) + +[8,53]: + int 020aaaaa55555555 <- ( 10 , 0aaaaa55555555 ) + +[8,52]: + int 010aaaaa55555555 <- ( 10 , aaaaa55555555 ) + +[8,51]: + int 082aaaa55555555 <- ( 10 , 2aaaa55555555 ) + +[8,50]: + int 042aaaa55555555 <- ( 10 , eaaaa55555555 ) + +[8,49]: + int 020aaaa55555555 <- ( 10 , 0aaaa55555555 ) + +[8,48]: + int 010aaaa55555555 <- ( 10 , aaaa55555555 ) + +[8,47]: + int 082aaa55555555 <- ( 10 , 2aaa55555555 ) + +[8,46]: + int 042aaa55555555 <- ( 10 , eaaa55555555 ) + +[8,45]: + int 020aaa55555555 <- ( 10 , 0aaa55555555 ) + +[8,44]: + int 010aaa55555555 <- ( 10 , aaa55555555 ) + +[8,43]: + int 082aa55555555 <- ( 10 , 2aa55555555 ) + +[8,42]: + int 042aa55555555 <- ( 10 , eaa55555555 ) + +[8,41]: + int 020aa55555555 <- ( 10 , 0aa55555555 ) + +[8,40]: + int 010aa55555555 <- ( 10 , aa55555555 ) + +[8,39]: + int 082a55555555 <- ( 10 , 2a55555555 ) + +[8,38]: + int 042a55555555 <- ( 10 , ea55555555 ) + +[8,37]: + int 020a55555555 <- ( 10 , 0a55555555 ) + +[8,36]: + int 010a55555555 <- ( 10 , a55555555 ) + +[8,35]: + int 08255555555 <- ( 10 , 255555555 ) + +[8,34]: + int 04255555555 <- ( 10 , e55555555 ) + +[8,33]: + int 02055555555 <- ( 10 , 055555555 ) + +[8,32]: + int 01055555555 <- ( 10 , 55555555 ) + +[8,31]: + int 0855555555 <- ( 10 , d5555555 ) + +[8,30]: + int 0415555555 <- ( 10 , 15555555 ) + +[8,29]: + int 0215555555 <- ( 10 , f5555555 ) + +[8,28]: + int 0105555555 <- ( 10 , 5555555 ) + +[8,27]: + int 085555555 <- ( 10 , d555555 ) + +[8,26]: + int 041555555 <- ( 10 , 1555555 ) + +[8,25]: + int 021555555 <- ( 10 , f555555 ) + +[8,24]: + int 010555555 <- ( 10 , 555555 ) + +[8,23]: + int 08555555 <- ( 10 , d55555 ) + +[8,22]: + int 04155555 <- ( 10 , 155555 ) + +[8,21]: + int 02155555 <- ( 10 , f55555 ) + +[8,20]: + int 01055555 <- ( 10 , 55555 ) + +[8,19]: + int 0855555 <- ( 10 , d5555 ) + +[8,18]: + int 0415555 <- ( 10 , 15555 ) + +[8,17]: + int 0215555 <- ( 10 , f5555 ) + +[8,16]: + int 0105555 <- ( 10 , 5555 ) + +[8,15]: + int 085555 <- ( 10 , d555 ) + +[8,14]: + int 041555 <- ( 10 , 1555 ) + +[8,13]: + int 021555 <- ( 10 , f555 ) + +[8,12]: + int 010555 <- ( 10 , 555 ) + +[8,11]: + int 08555 <- ( 10 , d55 ) + +[8,10]: + int 04155 <- ( 10 , 155 ) + +[8,9]: + int 02155 <- ( 10 , f55 ) + +[8,8]: + int 01055 <- ( 10 , 55 ) + +[8,7]: + int 0855 <- ( 10 , d5 ) + +[8,6]: + int 0415 <- ( 10 , 15 ) + +[8,5]: + int 0215 <- ( 10 , f5 ) + +[8,4]: + int 0105 <- ( 10 , 5 ) + +[8,3]: + int 085 <- ( 10 , d ) + +[8,2]: + int 041 <- ( 10 , 1 ) + +[8,1]: + int 021 <- ( 10 , f ) + +[7,64]: + int 10aaaaaaaa55555555 <- ( 10 , aaaaaaaa55555555 ) + +[7,63]: + int 082aaaaaaa55555555 <- ( 10 , 2aaaaaaa55555555 ) + +[7,62]: + int 042aaaaaaa55555555 <- ( 10 , eaaaaaaa55555555 ) + +[7,61]: + int 020aaaaaaa55555555 <- ( 10 , 0aaaaaaa55555555 ) + +[7,60]: + int 10aaaaaaa55555555 <- ( 10 , aaaaaaa55555555 ) + +[7,59]: + int 082aaaaaa55555555 <- ( 10 , 2aaaaaa55555555 ) + +[7,58]: + int 042aaaaaa55555555 <- ( 10 , eaaaaaa55555555 ) + +[7,57]: + int 020aaaaaa55555555 <- ( 10 , 0aaaaaa55555555 ) + +[7,56]: + int 10aaaaaa55555555 <- ( 10 , aaaaaa55555555 ) + +[7,55]: + int 082aaaaa55555555 <- ( 10 , 2aaaaa55555555 ) + +[7,54]: + int 042aaaaa55555555 <- ( 10 , eaaaaa55555555 ) + +[7,53]: + int 020aaaaa55555555 <- ( 10 , 0aaaaa55555555 ) + +[7,52]: + int 10aaaaa55555555 <- ( 10 , aaaaa55555555 ) + +[7,51]: + int 082aaaa55555555 <- ( 10 , 2aaaa55555555 ) + +[7,50]: + int 042aaaa55555555 <- ( 10 , eaaaa55555555 ) + +[7,49]: + int 020aaaa55555555 <- ( 10 , 0aaaa55555555 ) + +[7,48]: + int 10aaaa55555555 <- ( 10 , aaaa55555555 ) + +[7,47]: + int 082aaa55555555 <- ( 10 , 2aaa55555555 ) + +[7,46]: + int 042aaa55555555 <- ( 10 , eaaa55555555 ) + +[7,45]: + int 020aaa55555555 <- ( 10 , 0aaa55555555 ) + +[7,44]: + int 10aaa55555555 <- ( 10 , aaa55555555 ) + +[7,43]: + int 082aa55555555 <- ( 10 , 2aa55555555 ) + +[7,42]: + int 042aa55555555 <- ( 10 , eaa55555555 ) + +[7,41]: + int 020aa55555555 <- ( 10 , 0aa55555555 ) + +[7,40]: + int 10aa55555555 <- ( 10 , aa55555555 ) + +[7,39]: + int 082a55555555 <- ( 10 , 2a55555555 ) + +[7,38]: + int 042a55555555 <- ( 10 , ea55555555 ) + +[7,37]: + int 020a55555555 <- ( 10 , 0a55555555 ) + +[7,36]: + int 10a55555555 <- ( 10 , a55555555 ) + +[7,35]: + int 08255555555 <- ( 10 , 255555555 ) + +[7,34]: + int 04255555555 <- ( 10 , e55555555 ) + +[7,33]: + int 02055555555 <- ( 10 , 055555555 ) + +[7,32]: + int 1055555555 <- ( 10 , 55555555 ) + +[7,31]: + int 0855555555 <- ( 10 , d5555555 ) + +[7,30]: + int 0415555555 <- ( 10 , 15555555 ) + +[7,29]: + int 0215555555 <- ( 10 , f5555555 ) + +[7,28]: + int 105555555 <- ( 10 , 5555555 ) + +[7,27]: + int 085555555 <- ( 10 , d555555 ) + +[7,26]: + int 041555555 <- ( 10 , 1555555 ) + +[7,25]: + int 021555555 <- ( 10 , f555555 ) + +[7,24]: + int 10555555 <- ( 10 , 555555 ) + +[7,23]: + int 08555555 <- ( 10 , d55555 ) + +[7,22]: + int 04155555 <- ( 10 , 155555 ) + +[7,21]: + int 02155555 <- ( 10 , f55555 ) + +[7,20]: + int 1055555 <- ( 10 , 55555 ) + +[7,19]: + int 0855555 <- ( 10 , d5555 ) + +[7,18]: + int 0415555 <- ( 10 , 15555 ) + +[7,17]: + int 0215555 <- ( 10 , f5555 ) + +[7,16]: + int 105555 <- ( 10 , 5555 ) + +[7,15]: + int 085555 <- ( 10 , d555 ) + +[7,14]: + int 041555 <- ( 10 , 1555 ) + +[7,13]: + int 021555 <- ( 10 , f555 ) + +[7,12]: + int 10555 <- ( 10 , 555 ) + +[7,11]: + int 08555 <- ( 10 , d55 ) + +[7,10]: + int 04155 <- ( 10 , 155 ) + +[7,9]: + int 02155 <- ( 10 , f55 ) + +[7,8]: + int 1055 <- ( 10 , 55 ) + +[7,7]: + int 0855 <- ( 10 , d5 ) + +[7,6]: + int 0415 <- ( 10 , 15 ) + +[7,5]: + int 0215 <- ( 10 , f5 ) + +[7,4]: + int 105 <- ( 10 , 5 ) + +[7,3]: + int 085 <- ( 10 , d ) + +[7,2]: + int 041 <- ( 10 , 1 ) + +[7,1]: + int 021 <- ( 10 , f ) + +[6,64]: + int 10aaaaaaaa55555555 <- ( 10 , aaaaaaaa55555555 ) + +[6,63]: + int 082aaaaaaa55555555 <- ( 10 , 2aaaaaaa55555555 ) + +[6,62]: + int 042aaaaaaa55555555 <- ( 10 , eaaaaaaa55555555 ) + +[6,61]: + int 20aaaaaaa55555555 <- ( 10 , 0aaaaaaa55555555 ) + +[6,60]: + int 10aaaaaaa55555555 <- ( 10 , aaaaaaa55555555 ) + +[6,59]: + int 082aaaaaa55555555 <- ( 10 , 2aaaaaa55555555 ) + +[6,58]: + int 042aaaaaa55555555 <- ( 10 , eaaaaaa55555555 ) + +[6,57]: + int 20aaaaaa55555555 <- ( 10 , 0aaaaaa55555555 ) + +[6,56]: + int 10aaaaaa55555555 <- ( 10 , aaaaaa55555555 ) + +[6,55]: + int 082aaaaa55555555 <- ( 10 , 2aaaaa55555555 ) + +[6,54]: + int 042aaaaa55555555 <- ( 10 , eaaaaa55555555 ) + +[6,53]: + int 20aaaaa55555555 <- ( 10 , 0aaaaa55555555 ) + +[6,52]: + int 10aaaaa55555555 <- ( 10 , aaaaa55555555 ) + +[6,51]: + int 082aaaa55555555 <- ( 10 , 2aaaa55555555 ) + +[6,50]: + int 042aaaa55555555 <- ( 10 , eaaaa55555555 ) + +[6,49]: + int 20aaaa55555555 <- ( 10 , 0aaaa55555555 ) + +[6,48]: + int 10aaaa55555555 <- ( 10 , aaaa55555555 ) + +[6,47]: + int 082aaa55555555 <- ( 10 , 2aaa55555555 ) + +[6,46]: + int 042aaa55555555 <- ( 10 , eaaa55555555 ) + +[6,45]: + int 20aaa55555555 <- ( 10 , 0aaa55555555 ) + +[6,44]: + int 10aaa55555555 <- ( 10 , aaa55555555 ) + +[6,43]: + int 082aa55555555 <- ( 10 , 2aa55555555 ) + +[6,42]: + int 042aa55555555 <- ( 10 , eaa55555555 ) + +[6,41]: + int 20aa55555555 <- ( 10 , 0aa55555555 ) + +[6,40]: + int 10aa55555555 <- ( 10 , aa55555555 ) + +[6,39]: + int 082a55555555 <- ( 10 , 2a55555555 ) + +[6,38]: + int 042a55555555 <- ( 10 , ea55555555 ) + +[6,37]: + int 20a55555555 <- ( 10 , 0a55555555 ) + +[6,36]: + int 10a55555555 <- ( 10 , a55555555 ) + +[6,35]: + int 08255555555 <- ( 10 , 255555555 ) + +[6,34]: + int 04255555555 <- ( 10 , e55555555 ) + +[6,33]: + int 2055555555 <- ( 10 , 055555555 ) + +[6,32]: + int 1055555555 <- ( 10 , 55555555 ) + +[6,31]: + int 0855555555 <- ( 10 , d5555555 ) + +[6,30]: + int 0415555555 <- ( 10 , 15555555 ) + +[6,29]: + int 215555555 <- ( 10 , f5555555 ) + +[6,28]: + int 105555555 <- ( 10 , 5555555 ) + +[6,27]: + int 085555555 <- ( 10 , d555555 ) + +[6,26]: + int 041555555 <- ( 10 , 1555555 ) + +[6,25]: + int 21555555 <- ( 10 , f555555 ) + +[6,24]: + int 10555555 <- ( 10 , 555555 ) + +[6,23]: + int 08555555 <- ( 10 , d55555 ) + +[6,22]: + int 04155555 <- ( 10 , 155555 ) + +[6,21]: + int 2155555 <- ( 10 , f55555 ) + +[6,20]: + int 1055555 <- ( 10 , 55555 ) + +[6,19]: + int 0855555 <- ( 10 , d5555 ) + +[6,18]: + int 0415555 <- ( 10 , 15555 ) + +[6,17]: + int 215555 <- ( 10 , f5555 ) + +[6,16]: + int 105555 <- ( 10 , 5555 ) + +[6,15]: + int 085555 <- ( 10 , d555 ) + +[6,14]: + int 041555 <- ( 10 , 1555 ) + +[6,13]: + int 21555 <- ( 10 , f555 ) + +[6,12]: + int 10555 <- ( 10 , 555 ) + +[6,11]: + int 08555 <- ( 10 , d55 ) + +[6,10]: + int 04155 <- ( 10 , 155 ) + +[6,9]: + int 2155 <- ( 10 , f55 ) + +[6,8]: + int 1055 <- ( 10 , 55 ) + +[6,7]: + int 0855 <- ( 10 , d5 ) + +[6,6]: + int 0415 <- ( 10 , 15 ) + +[6,5]: + int 215 <- ( 10 , f5 ) + +[6,4]: + int 105 <- ( 10 , 5 ) + +[6,3]: + int 085 <- ( 10 , d ) + +[6,2]: + int 041 <- ( 10 , 1 ) + +[6,1]: + int 21 <- ( 10 , f ) + +[5,64]: + int 10aaaaaaaa55555555 <- ( f0 , aaaaaaaa55555555 ) + +[5,63]: + int 082aaaaaaa55555555 <- ( f0 , 2aaaaaaa55555555 ) + +[5,62]: + int 42aaaaaaa55555555 <- ( f0 , eaaaaaaa55555555 ) + +[5,61]: + int 20aaaaaaa55555555 <- ( f0 , 0aaaaaaa55555555 ) + +[5,60]: + int 10aaaaaaa55555555 <- ( f0 , aaaaaaa55555555 ) + +[5,59]: + int 082aaaaaa55555555 <- ( f0 , 2aaaaaa55555555 ) + +[5,58]: + int 42aaaaaa55555555 <- ( f0 , eaaaaaa55555555 ) + +[5,57]: + int 20aaaaaa55555555 <- ( f0 , 0aaaaaa55555555 ) + +[5,56]: + int 10aaaaaa55555555 <- ( f0 , aaaaaa55555555 ) + +[5,55]: + int 082aaaaa55555555 <- ( f0 , 2aaaaa55555555 ) + +[5,54]: + int 42aaaaa55555555 <- ( f0 , eaaaaa55555555 ) + +[5,53]: + int 20aaaaa55555555 <- ( f0 , 0aaaaa55555555 ) + +[5,52]: + int 10aaaaa55555555 <- ( f0 , aaaaa55555555 ) + +[5,51]: + int 082aaaa55555555 <- ( f0 , 2aaaa55555555 ) + +[5,50]: + int 42aaaa55555555 <- ( f0 , eaaaa55555555 ) + +[5,49]: + int 20aaaa55555555 <- ( f0 , 0aaaa55555555 ) + +[5,48]: + int 10aaaa55555555 <- ( f0 , aaaa55555555 ) + +[5,47]: + int 082aaa55555555 <- ( f0 , 2aaa55555555 ) + +[5,46]: + int 42aaa55555555 <- ( f0 , eaaa55555555 ) + +[5,45]: + int 20aaa55555555 <- ( f0 , 0aaa55555555 ) + +[5,44]: + int 10aaa55555555 <- ( f0 , aaa55555555 ) + +[5,43]: + int 082aa55555555 <- ( f0 , 2aa55555555 ) + +[5,42]: + int 42aa55555555 <- ( f0 , eaa55555555 ) + +[5,41]: + int 20aa55555555 <- ( f0 , 0aa55555555 ) + +[5,40]: + int 10aa55555555 <- ( f0 , aa55555555 ) + +[5,39]: + int 082a55555555 <- ( f0 , 2a55555555 ) + +[5,38]: + int 42a55555555 <- ( f0 , ea55555555 ) + +[5,37]: + int 20a55555555 <- ( f0 , 0a55555555 ) + +[5,36]: + int 10a55555555 <- ( f0 , a55555555 ) + +[5,35]: + int 08255555555 <- ( f0 , 255555555 ) + +[5,34]: + int 4255555555 <- ( f0 , e55555555 ) + +[5,33]: + int 2055555555 <- ( f0 , 055555555 ) + +[5,32]: + int 1055555555 <- ( f0 , 55555555 ) + +[5,31]: + int 0855555555 <- ( f0 , d5555555 ) + +[5,30]: + int 415555555 <- ( f0 , 15555555 ) + +[5,29]: + int 215555555 <- ( f0 , f5555555 ) + +[5,28]: + int 105555555 <- ( f0 , 5555555 ) + +[5,27]: + int 085555555 <- ( f0 , d555555 ) + +[5,26]: + int 41555555 <- ( f0 , 1555555 ) + +[5,25]: + int 21555555 <- ( f0 , f555555 ) + +[5,24]: + int 10555555 <- ( f0 , 555555 ) + +[5,23]: + int 08555555 <- ( f0 , d55555 ) + +[5,22]: + int 4155555 <- ( f0 , 155555 ) + +[5,21]: + int 2155555 <- ( f0 , f55555 ) + +[5,20]: + int 1055555 <- ( f0 , 55555 ) + +[5,19]: + int 0855555 <- ( f0 , d5555 ) + +[5,18]: + int 415555 <- ( f0 , 15555 ) + +[5,17]: + int 215555 <- ( f0 , f5555 ) + +[5,16]: + int 105555 <- ( f0 , 5555 ) + +[5,15]: + int 085555 <- ( f0 , d555 ) + +[5,14]: + int 41555 <- ( f0 , 1555 ) + +[5,13]: + int 21555 <- ( f0 , f555 ) + +[5,12]: + int 10555 <- ( f0 , 555 ) + +[5,11]: + int 08555 <- ( f0 , d55 ) + +[5,10]: + int 4155 <- ( f0 , 155 ) + +[5,9]: + int 2155 <- ( f0 , f55 ) + +[5,8]: + int 1055 <- ( f0 , 55 ) + +[5,7]: + int 0855 <- ( f0 , d5 ) + +[5,6]: + int 415 <- ( f0 , 15 ) + +[5,5]: + int 215 <- ( f0 , f5 ) + +[5,4]: + int 105 <- ( f0 , 5 ) + +[5,3]: + int 085 <- ( f0 , d ) + +[5,2]: + int 41 <- ( f0 , 1 ) + +[5,1]: + int 21 <- ( f0 , f ) + +[4,64]: + int 00aaaaaaaa55555555 <- ( 0 , aaaaaaaa55555555 ) + +[4,63]: + int 02aaaaaaa55555555 <- ( 0 , 2aaaaaaa55555555 ) + +[4,62]: + int 02aaaaaaa55555555 <- ( 0 , eaaaaaaa55555555 ) + +[4,61]: + int 00aaaaaaa55555555 <- ( 0 , 0aaaaaaa55555555 ) + +[4,60]: + int 00aaaaaaa55555555 <- ( 0 , aaaaaaa55555555 ) + +[4,59]: + int 02aaaaaa55555555 <- ( 0 , 2aaaaaa55555555 ) + +[4,58]: + int 02aaaaaa55555555 <- ( 0 , eaaaaaa55555555 ) + +[4,57]: + int 00aaaaaa55555555 <- ( 0 , 0aaaaaa55555555 ) + +[4,56]: + int 00aaaaaa55555555 <- ( 0 , aaaaaa55555555 ) + +[4,55]: + int 02aaaaa55555555 <- ( 0 , 2aaaaa55555555 ) + +[4,54]: + int 02aaaaa55555555 <- ( 0 , eaaaaa55555555 ) + +[4,53]: + int 00aaaaa55555555 <- ( 0 , 0aaaaa55555555 ) + +[4,52]: + int 00aaaaa55555555 <- ( 0 , aaaaa55555555 ) + +[4,51]: + int 02aaaa55555555 <- ( 0 , 2aaaa55555555 ) + +[4,50]: + int 02aaaa55555555 <- ( 0 , eaaaa55555555 ) + +[4,49]: + int 00aaaa55555555 <- ( 0 , 0aaaa55555555 ) + +[4,48]: + int 00aaaa55555555 <- ( 0 , aaaa55555555 ) + +[4,47]: + int 02aaa55555555 <- ( 0 , 2aaa55555555 ) + +[4,46]: + int 02aaa55555555 <- ( 0 , eaaa55555555 ) + +[4,45]: + int 00aaa55555555 <- ( 0 , 0aaa55555555 ) + +[4,44]: + int 00aaa55555555 <- ( 0 , aaa55555555 ) + +[4,43]: + int 02aa55555555 <- ( 0 , 2aa55555555 ) + +[4,42]: + int 02aa55555555 <- ( 0 , eaa55555555 ) + +[4,41]: + int 00aa55555555 <- ( 0 , 0aa55555555 ) + +[4,40]: + int 00aa55555555 <- ( 0 , aa55555555 ) + +[4,39]: + int 02a55555555 <- ( 0 , 2a55555555 ) + +[4,38]: + int 02a55555555 <- ( 0 , ea55555555 ) + +[4,37]: + int 00a55555555 <- ( 0 , 0a55555555 ) + +[4,36]: + int 00a55555555 <- ( 0 , a55555555 ) + +[4,35]: + int 0255555555 <- ( 0 , 255555555 ) + +[4,34]: + int 0255555555 <- ( 0 , e55555555 ) + +[4,33]: + int 0055555555 <- ( 0 , 055555555 ) + +[4,32]: + int 0055555555 <- ( 0 , 55555555 ) + +[4,31]: + int 055555555 <- ( 0 , d5555555 ) + +[4,30]: + int 015555555 <- ( 0 , 15555555 ) + +[4,29]: + int 015555555 <- ( 0 , f5555555 ) + +[4,28]: + int 005555555 <- ( 0 , 5555555 ) + +[4,27]: + int 05555555 <- ( 0 , d555555 ) + +[4,26]: + int 01555555 <- ( 0 , 1555555 ) + +[4,25]: + int 01555555 <- ( 0 , f555555 ) + +[4,24]: + int 00555555 <- ( 0 , 555555 ) + +[4,23]: + int 0555555 <- ( 0 , d55555 ) + +[4,22]: + int 0155555 <- ( 0 , 155555 ) + +[4,21]: + int 0155555 <- ( 0 , f55555 ) + +[4,20]: + int 0055555 <- ( 0 , 55555 ) + +[4,19]: + int 055555 <- ( 0 , d5555 ) + +[4,18]: + int 015555 <- ( 0 , 15555 ) + +[4,17]: + int 015555 <- ( 0 , f5555 ) + +[4,16]: + int 005555 <- ( 0 , 5555 ) + +[4,15]: + int 05555 <- ( 0 , d555 ) + +[4,14]: + int 01555 <- ( 0 , 1555 ) + +[4,13]: + int 01555 <- ( 0 , f555 ) + +[4,12]: + int 00555 <- ( 0 , 555 ) + +[4,11]: + int 0555 <- ( 0 , d55 ) + +[4,10]: + int 0155 <- ( 0 , 155 ) + +[4,9]: + int 0155 <- ( 0 , f55 ) + +[4,8]: + int 0055 <- ( 0 , 55 ) + +[4,7]: + int 055 <- ( 0 , d5 ) + +[4,6]: + int 015 <- ( 0 , 15 ) + +[4,5]: + int 015 <- ( 0 , f5 ) + +[4,4]: + int 005 <- ( 0 , 5 ) + +[4,3]: + int 05 <- ( 0 , d ) + +[4,2]: + int 01 <- ( 0 , 1 ) + +[4,1]: + int 01 <- ( 0 , f ) + +[3,64]: + int 0aaaaaaaa55555555 <- ( 0 , aaaaaaaa55555555 ) + +[3,63]: + int 02aaaaaaa55555555 <- ( 0 , 2aaaaaaa55555555 ) + +[3,62]: + int 02aaaaaaa55555555 <- ( 0 , eaaaaaaa55555555 ) + +[3,61]: + int 00aaaaaaa55555555 <- ( 0 , 0aaaaaaa55555555 ) + +[3,60]: + int 0aaaaaaa55555555 <- ( 0 , aaaaaaa55555555 ) + +[3,59]: + int 02aaaaaa55555555 <- ( 0 , 2aaaaaa55555555 ) + +[3,58]: + int 02aaaaaa55555555 <- ( 0 , eaaaaaa55555555 ) + +[3,57]: + int 00aaaaaa55555555 <- ( 0 , 0aaaaaa55555555 ) + +[3,56]: + int 0aaaaaa55555555 <- ( 0 , aaaaaa55555555 ) + +[3,55]: + int 02aaaaa55555555 <- ( 0 , 2aaaaa55555555 ) + +[3,54]: + int 02aaaaa55555555 <- ( 0 , eaaaaa55555555 ) + +[3,53]: + int 00aaaaa55555555 <- ( 0 , 0aaaaa55555555 ) + +[3,52]: + int 0aaaaa55555555 <- ( 0 , aaaaa55555555 ) + +[3,51]: + int 02aaaa55555555 <- ( 0 , 2aaaa55555555 ) + +[3,50]: + int 02aaaa55555555 <- ( 0 , eaaaa55555555 ) + +[3,49]: + int 00aaaa55555555 <- ( 0 , 0aaaa55555555 ) + +[3,48]: + int 0aaaa55555555 <- ( 0 , aaaa55555555 ) + +[3,47]: + int 02aaa55555555 <- ( 0 , 2aaa55555555 ) + +[3,46]: + int 02aaa55555555 <- ( 0 , eaaa55555555 ) + +[3,45]: + int 00aaa55555555 <- ( 0 , 0aaa55555555 ) + +[3,44]: + int 0aaa55555555 <- ( 0 , aaa55555555 ) + +[3,43]: + int 02aa55555555 <- ( 0 , 2aa55555555 ) + +[3,42]: + int 02aa55555555 <- ( 0 , eaa55555555 ) + +[3,41]: + int 00aa55555555 <- ( 0 , 0aa55555555 ) + +[3,40]: + int 0aa55555555 <- ( 0 , aa55555555 ) + +[3,39]: + int 02a55555555 <- ( 0 , 2a55555555 ) + +[3,38]: + int 02a55555555 <- ( 0 , ea55555555 ) + +[3,37]: + int 00a55555555 <- ( 0 , 0a55555555 ) + +[3,36]: + int 0a55555555 <- ( 0 , a55555555 ) + +[3,35]: + int 0255555555 <- ( 0 , 255555555 ) + +[3,34]: + int 0255555555 <- ( 0 , e55555555 ) + +[3,33]: + int 0055555555 <- ( 0 , 055555555 ) + +[3,32]: + int 055555555 <- ( 0 , 55555555 ) + +[3,31]: + int 055555555 <- ( 0 , d5555555 ) + +[3,30]: + int 015555555 <- ( 0 , 15555555 ) + +[3,29]: + int 015555555 <- ( 0 , f5555555 ) + +[3,28]: + int 05555555 <- ( 0 , 5555555 ) + +[3,27]: + int 05555555 <- ( 0 , d555555 ) + +[3,26]: + int 01555555 <- ( 0 , 1555555 ) + +[3,25]: + int 01555555 <- ( 0 , f555555 ) + +[3,24]: + int 0555555 <- ( 0 , 555555 ) + +[3,23]: + int 0555555 <- ( 0 , d55555 ) + +[3,22]: + int 0155555 <- ( 0 , 155555 ) + +[3,21]: + int 0155555 <- ( 0 , f55555 ) + +[3,20]: + int 055555 <- ( 0 , 55555 ) + +[3,19]: + int 055555 <- ( 0 , d5555 ) + +[3,18]: + int 015555 <- ( 0 , 15555 ) + +[3,17]: + int 015555 <- ( 0 , f5555 ) + +[3,16]: + int 05555 <- ( 0 , 5555 ) + +[3,15]: + int 05555 <- ( 0 , d555 ) + +[3,14]: + int 01555 <- ( 0 , 1555 ) + +[3,13]: + int 01555 <- ( 0 , f555 ) + +[3,12]: + int 0555 <- ( 0 , 555 ) + +[3,11]: + int 0555 <- ( 0 , d55 ) + +[3,10]: + int 0155 <- ( 0 , 155 ) + +[3,9]: + int 0155 <- ( 0 , f55 ) + +[3,8]: + int 055 <- ( 0 , 55 ) + +[3,7]: + int 055 <- ( 0 , d5 ) + +[3,6]: + int 015 <- ( 0 , 15 ) + +[3,5]: + int 015 <- ( 0 , f5 ) + +[3,4]: + int 05 <- ( 0 , 5 ) + +[3,3]: + int 05 <- ( 0 , d ) + +[3,2]: + int 01 <- ( 0 , 1 ) + +[3,1]: + int 01 <- ( 0 , f ) + +[2,64]: + int 0aaaaaaaa55555555 <- ( 0 , aaaaaaaa55555555 ) + +[2,63]: + int 02aaaaaaa55555555 <- ( 0 , 2aaaaaaa55555555 ) + +[2,62]: + int 02aaaaaaa55555555 <- ( 0 , eaaaaaaa55555555 ) + +[2,61]: + int 0aaaaaaa55555555 <- ( 0 , 0aaaaaaa55555555 ) + +[2,60]: + int 0aaaaaaa55555555 <- ( 0 , aaaaaaa55555555 ) + +[2,59]: + int 02aaaaaa55555555 <- ( 0 , 2aaaaaa55555555 ) + +[2,58]: + int 02aaaaaa55555555 <- ( 0 , eaaaaaa55555555 ) + +[2,57]: + int 0aaaaaa55555555 <- ( 0 , 0aaaaaa55555555 ) + +[2,56]: + int 0aaaaaa55555555 <- ( 0 , aaaaaa55555555 ) + +[2,55]: + int 02aaaaa55555555 <- ( 0 , 2aaaaa55555555 ) + +[2,54]: + int 02aaaaa55555555 <- ( 0 , eaaaaa55555555 ) + +[2,53]: + int 0aaaaa55555555 <- ( 0 , 0aaaaa55555555 ) + +[2,52]: + int 0aaaaa55555555 <- ( 0 , aaaaa55555555 ) + +[2,51]: + int 02aaaa55555555 <- ( 0 , 2aaaa55555555 ) + +[2,50]: + int 02aaaa55555555 <- ( 0 , eaaaa55555555 ) + +[2,49]: + int 0aaaa55555555 <- ( 0 , 0aaaa55555555 ) + +[2,48]: + int 0aaaa55555555 <- ( 0 , aaaa55555555 ) + +[2,47]: + int 02aaa55555555 <- ( 0 , 2aaa55555555 ) + +[2,46]: + int 02aaa55555555 <- ( 0 , eaaa55555555 ) + +[2,45]: + int 0aaa55555555 <- ( 0 , 0aaa55555555 ) + +[2,44]: + int 0aaa55555555 <- ( 0 , aaa55555555 ) + +[2,43]: + int 02aa55555555 <- ( 0 , 2aa55555555 ) + +[2,42]: + int 02aa55555555 <- ( 0 , eaa55555555 ) + +[2,41]: + int 0aa55555555 <- ( 0 , 0aa55555555 ) + +[2,40]: + int 0aa55555555 <- ( 0 , aa55555555 ) + +[2,39]: + int 02a55555555 <- ( 0 , 2a55555555 ) + +[2,38]: + int 02a55555555 <- ( 0 , ea55555555 ) + +[2,37]: + int 0a55555555 <- ( 0 , 0a55555555 ) + +[2,36]: + int 0a55555555 <- ( 0 , a55555555 ) + +[2,35]: + int 0255555555 <- ( 0 , 255555555 ) + +[2,34]: + int 0255555555 <- ( 0 , e55555555 ) + +[2,33]: + int 055555555 <- ( 0 , 055555555 ) + +[2,32]: + int 055555555 <- ( 0 , 55555555 ) + +[2,31]: + int 055555555 <- ( 0 , d5555555 ) + +[2,30]: + int 015555555 <- ( 0 , 15555555 ) + +[2,29]: + int 15555555 <- ( 0 , f5555555 ) + +[2,28]: + int 05555555 <- ( 0 , 5555555 ) + +[2,27]: + int 05555555 <- ( 0 , d555555 ) + +[2,26]: + int 01555555 <- ( 0 , 1555555 ) + +[2,25]: + int 1555555 <- ( 0 , f555555 ) + +[2,24]: + int 0555555 <- ( 0 , 555555 ) + +[2,23]: + int 0555555 <- ( 0 , d55555 ) + +[2,22]: + int 0155555 <- ( 0 , 155555 ) + +[2,21]: + int 155555 <- ( 0 , f55555 ) + +[2,20]: + int 055555 <- ( 0 , 55555 ) + +[2,19]: + int 055555 <- ( 0 , d5555 ) + +[2,18]: + int 015555 <- ( 0 , 15555 ) + +[2,17]: + int 15555 <- ( 0 , f5555 ) + +[2,16]: + int 05555 <- ( 0 , 5555 ) + +[2,15]: + int 05555 <- ( 0 , d555 ) + +[2,14]: + int 01555 <- ( 0 , 1555 ) + +[2,13]: + int 1555 <- ( 0 , f555 ) + +[2,12]: + int 0555 <- ( 0 , 555 ) + +[2,11]: + int 0555 <- ( 0 , d55 ) + +[2,10]: + int 0155 <- ( 0 , 155 ) + +[2,9]: + int 155 <- ( 0 , f55 ) + +[2,8]: + int 055 <- ( 0 , 55 ) + +[2,7]: + int 055 <- ( 0 , d5 ) + +[2,6]: + int 015 <- ( 0 , 15 ) + +[2,5]: + int 15 <- ( 0 , f5 ) + +[2,4]: + int 05 <- ( 0 , 5 ) + +[2,3]: + int 05 <- ( 0 , d ) + +[2,2]: + int 01 <- ( 0 , 1 ) + +[2,1]: + int 1 <- ( 0 , f ) + +[1,64]: + int 0aaaaaaaa55555555 <- ( 0 , aaaaaaaa55555555 ) + +[1,63]: + int 02aaaaaaa55555555 <- ( 0 , 2aaaaaaa55555555 ) + +[1,62]: + int 2aaaaaaa55555555 <- ( 0 , eaaaaaaa55555555 ) + +[1,61]: + int 0aaaaaaa55555555 <- ( 0 , 0aaaaaaa55555555 ) + +[1,60]: + int 0aaaaaaa55555555 <- ( 0 , aaaaaaa55555555 ) + +[1,59]: + int 02aaaaaa55555555 <- ( 0 , 2aaaaaa55555555 ) + +[1,58]: + int 2aaaaaa55555555 <- ( 0 , eaaaaaa55555555 ) + +[1,57]: + int 0aaaaaa55555555 <- ( 0 , 0aaaaaa55555555 ) + +[1,56]: + int 0aaaaaa55555555 <- ( 0 , aaaaaa55555555 ) + +[1,55]: + int 02aaaaa55555555 <- ( 0 , 2aaaaa55555555 ) + +[1,54]: + int 2aaaaa55555555 <- ( 0 , eaaaaa55555555 ) + +[1,53]: + int 0aaaaa55555555 <- ( 0 , 0aaaaa55555555 ) + +[1,52]: + int 0aaaaa55555555 <- ( 0 , aaaaa55555555 ) + +[1,51]: + int 02aaaa55555555 <- ( 0 , 2aaaa55555555 ) + +[1,50]: + int 2aaaa55555555 <- ( 0 , eaaaa55555555 ) + +[1,49]: + int 0aaaa55555555 <- ( 0 , 0aaaa55555555 ) + +[1,48]: + int 0aaaa55555555 <- ( 0 , aaaa55555555 ) + +[1,47]: + int 02aaa55555555 <- ( 0 , 2aaa55555555 ) + +[1,46]: + int 2aaa55555555 <- ( 0 , eaaa55555555 ) + +[1,45]: + int 0aaa55555555 <- ( 0 , 0aaa55555555 ) + +[1,44]: + int 0aaa55555555 <- ( 0 , aaa55555555 ) + +[1,43]: + int 02aa55555555 <- ( 0 , 2aa55555555 ) + +[1,42]: + int 2aa55555555 <- ( 0 , eaa55555555 ) + +[1,41]: + int 0aa55555555 <- ( 0 , 0aa55555555 ) + +[1,40]: + int 0aa55555555 <- ( 0 , aa55555555 ) + +[1,39]: + int 02a55555555 <- ( 0 , 2a55555555 ) + +[1,38]: + int 2a55555555 <- ( 0 , ea55555555 ) + +[1,37]: + int 0a55555555 <- ( 0 , 0a55555555 ) + +[1,36]: + int 0a55555555 <- ( 0 , a55555555 ) + +[1,35]: + int 0255555555 <- ( 0 , 255555555 ) + +[1,34]: + int 255555555 <- ( 0 , e55555555 ) + +[1,33]: + int 055555555 <- ( 0 , 055555555 ) + +[1,32]: + int 055555555 <- ( 0 , 55555555 ) + +[1,31]: + int 055555555 <- ( 0 , d5555555 ) + +[1,30]: + int 15555555 <- ( 0 , 15555555 ) + +[1,29]: + int 15555555 <- ( 0 , f5555555 ) + +[1,28]: + int 05555555 <- ( 0 , 5555555 ) + +[1,27]: + int 05555555 <- ( 0 , d555555 ) + +[1,26]: + int 1555555 <- ( 0 , 1555555 ) + +[1,25]: + int 1555555 <- ( 0 , f555555 ) + +[1,24]: + int 0555555 <- ( 0 , 555555 ) + +[1,23]: + int 0555555 <- ( 0 , d55555 ) + +[1,22]: + int 155555 <- ( 0 , 155555 ) + +[1,21]: + int 155555 <- ( 0 , f55555 ) + +[1,20]: + int 055555 <- ( 0 , 55555 ) + +[1,19]: + int 055555 <- ( 0 , d5555 ) + +[1,18]: + int 15555 <- ( 0 , 15555 ) + +[1,17]: + int 15555 <- ( 0 , f5555 ) + +[1,16]: + int 05555 <- ( 0 , 5555 ) + +[1,15]: + int 05555 <- ( 0 , d555 ) + +[1,14]: + int 1555 <- ( 0 , 1555 ) + +[1,13]: + int 1555 <- ( 0 , f555 ) + +[1,12]: + int 0555 <- ( 0 , 555 ) + +[1,11]: + int 0555 <- ( 0 , d55 ) + +[1,10]: + int 155 <- ( 0 , 155 ) + +[1,9]: + int 155 <- ( 0 , f55 ) + +[1,8]: + int 055 <- ( 0 , 55 ) + +[1,7]: + int 055 <- ( 0 , d5 ) + +[1,6]: + int 15 <- ( 0 , 15 ) + +[1,5]: + int 15 <- ( 0 , f5 ) + +[1,4]: + int 05 <- ( 0 , 5 ) + +[1,3]: + int 05 <- ( 0 , d ) + +[1,2]: + int 1 <- ( 0 , 1 ) + +[1,1]: + int 1 <- ( 0 , f ) + +[64,64]: + int 0ffffffffffffffff0000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[64,63]: + int 7fffffffffffffff8000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[64,62]: + int 3fffffffffffffffc000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[64,61]: + int 1fffffffffffffffe000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[64,60]: + int 0ffffffffffffffff000000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[64,59]: + int 7fffffffffffffff800000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[64,58]: + int 3fffffffffffffffc00000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[64,57]: + int 1fffffffffffffffe00000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[64,56]: + int 0ffffffffffffffff00000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[64,55]: + int 7fffffffffffffff80000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[64,54]: + int 3fffffffffffffffc0000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[64,53]: + int 1fffffffffffffffe0000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[64,52]: + int 0ffffffffffffffff0000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[64,51]: + int 7fffffffffffffff8000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[64,50]: + int 3fffffffffffffffc000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[64,49]: + int 1fffffffffffffffe000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[64,48]: + int 0ffffffffffffffff000000000000 <- ( ffffffffffffffff , 000000000000 ) + +[64,47]: + int 7fffffffffffffff800000000000 <- ( ffffffffffffffff , 000000000000 ) + +[64,46]: + int 3fffffffffffffffc00000000000 <- ( ffffffffffffffff , 000000000000 ) + +[64,45]: + int 1fffffffffffffffe00000000000 <- ( ffffffffffffffff , 000000000000 ) + +[64,44]: + int 0ffffffffffffffff00000000000 <- ( ffffffffffffffff , 00000000000 ) + +[64,43]: + int 7fffffffffffffff80000000000 <- ( ffffffffffffffff , 00000000000 ) + +[64,42]: + int 3fffffffffffffffc0000000000 <- ( ffffffffffffffff , 00000000000 ) + +[64,41]: + int 1fffffffffffffffe0000000000 <- ( ffffffffffffffff , 00000000000 ) + +[64,40]: + int 0ffffffffffffffff0000000000 <- ( ffffffffffffffff , 0000000000 ) + +[64,39]: + int 7fffffffffffffff8000000000 <- ( ffffffffffffffff , 0000000000 ) + +[64,38]: + int 3fffffffffffffffc000000000 <- ( ffffffffffffffff , 0000000000 ) + +[64,37]: + int 1fffffffffffffffe000000000 <- ( ffffffffffffffff , 0000000000 ) + +[64,36]: + int 0ffffffffffffffff000000000 <- ( ffffffffffffffff , 000000000 ) + +[64,35]: + int 7fffffffffffffff800000000 <- ( ffffffffffffffff , 000000000 ) + +[64,34]: + int 3fffffffffffffffc00000000 <- ( ffffffffffffffff , 000000000 ) + +[64,33]: + int 1fffffffffffffffe00000000 <- ( ffffffffffffffff , 000000000 ) + +[64,32]: + int 0ffffffffffffffff00000000 <- ( ffffffffffffffff , 00000000 ) + +[64,31]: + int 7fffffffffffffff80000000 <- ( ffffffffffffffff , 00000000 ) + +[64,30]: + int 3fffffffffffffffc0000000 <- ( ffffffffffffffff , 00000000 ) + +[64,29]: + int 1fffffffffffffffe0000000 <- ( ffffffffffffffff , 00000000 ) + +[64,28]: + int 0ffffffffffffffff0000000 <- ( ffffffffffffffff , 0000000 ) + +[64,27]: + int 7fffffffffffffff8000000 <- ( ffffffffffffffff , 0000000 ) + +[64,26]: + int 3fffffffffffffffc000000 <- ( ffffffffffffffff , 0000000 ) + +[64,25]: + int 1fffffffffffffffe000000 <- ( ffffffffffffffff , 0000000 ) + +[64,24]: + int 0ffffffffffffffff000000 <- ( ffffffffffffffff , 000000 ) + +[64,23]: + int 7fffffffffffffff800000 <- ( ffffffffffffffff , 000000 ) + +[64,22]: + int 3fffffffffffffffc00000 <- ( ffffffffffffffff , 000000 ) + +[64,21]: + int 1fffffffffffffffe00000 <- ( ffffffffffffffff , 000000 ) + +[64,20]: + int 0ffffffffffffffff00000 <- ( ffffffffffffffff , 00000 ) + +[64,19]: + int 7fffffffffffffff80000 <- ( ffffffffffffffff , 00000 ) + +[64,18]: + int 3fffffffffffffffc0000 <- ( ffffffffffffffff , 00000 ) + +[64,17]: + int 1fffffffffffffffe0000 <- ( ffffffffffffffff , 00000 ) + +[64,16]: + int 0ffffffffffffffff0000 <- ( ffffffffffffffff , 0000 ) + +[64,15]: + int 7fffffffffffffff8000 <- ( ffffffffffffffff , 0000 ) + +[64,14]: + int 3fffffffffffffffc000 <- ( ffffffffffffffff , 0000 ) + +[64,13]: + int 1fffffffffffffffe000 <- ( ffffffffffffffff , 0000 ) + +[64,12]: + int 0ffffffffffffffff000 <- ( ffffffffffffffff , 000 ) + +[64,11]: + int 7fffffffffffffff800 <- ( ffffffffffffffff , 000 ) + +[64,10]: + int 3fffffffffffffffc00 <- ( ffffffffffffffff , 000 ) + +[64,9]: + int 1fffffffffffffffe00 <- ( ffffffffffffffff , 000 ) + +[64,8]: + int 0ffffffffffffffff00 <- ( ffffffffffffffff , 00 ) + +[64,7]: + int 7fffffffffffffff80 <- ( ffffffffffffffff , 00 ) + +[64,6]: + int 3fffffffffffffffc0 <- ( ffffffffffffffff , 00 ) + +[64,5]: + int 1fffffffffffffffe0 <- ( ffffffffffffffff , 00 ) + +[64,4]: + int 0ffffffffffffffff0 <- ( ffffffffffffffff , 0 ) + +[64,3]: + int 7fffffffffffffff8 <- ( ffffffffffffffff , 0 ) + +[64,2]: + int 3fffffffffffffffc <- ( ffffffffffffffff , 0 ) + +[64,1]: + int 1fffffffffffffffe <- ( ffffffffffffffff , 0 ) + +[63,64]: + int 7fffffffffffffff0000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[63,63]: + int 3fffffffffffffff8000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[63,62]: + int 1fffffffffffffffc000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[63,61]: + int 0fffffffffffffffe000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[63,60]: + int 7fffffffffffffff000000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[63,59]: + int 3fffffffffffffff800000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[63,58]: + int 1fffffffffffffffc00000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[63,57]: + int 0fffffffffffffffe00000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[63,56]: + int 7fffffffffffffff00000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[63,55]: + int 3fffffffffffffff80000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[63,54]: + int 1fffffffffffffffc0000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[63,53]: + int 0fffffffffffffffe0000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[63,52]: + int 7fffffffffffffff0000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[63,51]: + int 3fffffffffffffff8000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[63,50]: + int 1fffffffffffffffc000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[63,49]: + int 0fffffffffffffffe000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[63,48]: + int 7fffffffffffffff000000000000 <- ( ffffffffffffffff , 000000000000 ) + +[63,47]: + int 3fffffffffffffff800000000000 <- ( ffffffffffffffff , 000000000000 ) + +[63,46]: + int 1fffffffffffffffc00000000000 <- ( ffffffffffffffff , 000000000000 ) + +[63,45]: + int 0fffffffffffffffe00000000000 <- ( ffffffffffffffff , 000000000000 ) + +[63,44]: + int 7fffffffffffffff00000000000 <- ( ffffffffffffffff , 00000000000 ) + +[63,43]: + int 3fffffffffffffff80000000000 <- ( ffffffffffffffff , 00000000000 ) + +[63,42]: + int 1fffffffffffffffc0000000000 <- ( ffffffffffffffff , 00000000000 ) + +[63,41]: + int 0fffffffffffffffe0000000000 <- ( ffffffffffffffff , 00000000000 ) + +[63,40]: + int 7fffffffffffffff0000000000 <- ( ffffffffffffffff , 0000000000 ) + +[63,39]: + int 3fffffffffffffff8000000000 <- ( ffffffffffffffff , 0000000000 ) + +[63,38]: + int 1fffffffffffffffc000000000 <- ( ffffffffffffffff , 0000000000 ) + +[63,37]: + int 0fffffffffffffffe000000000 <- ( ffffffffffffffff , 0000000000 ) + +[63,36]: + int 7fffffffffffffff000000000 <- ( ffffffffffffffff , 000000000 ) + +[63,35]: + int 3fffffffffffffff800000000 <- ( ffffffffffffffff , 000000000 ) + +[63,34]: + int 1fffffffffffffffc00000000 <- ( ffffffffffffffff , 000000000 ) + +[63,33]: + int 0fffffffffffffffe00000000 <- ( ffffffffffffffff , 000000000 ) + +[63,32]: + int 7fffffffffffffff00000000 <- ( ffffffffffffffff , 00000000 ) + +[63,31]: + int 3fffffffffffffff80000000 <- ( ffffffffffffffff , 00000000 ) + +[63,30]: + int 1fffffffffffffffc0000000 <- ( ffffffffffffffff , 00000000 ) + +[63,29]: + int 0fffffffffffffffe0000000 <- ( ffffffffffffffff , 00000000 ) + +[63,28]: + int 7fffffffffffffff0000000 <- ( ffffffffffffffff , 0000000 ) + +[63,27]: + int 3fffffffffffffff8000000 <- ( ffffffffffffffff , 0000000 ) + +[63,26]: + int 1fffffffffffffffc000000 <- ( ffffffffffffffff , 0000000 ) + +[63,25]: + int 0fffffffffffffffe000000 <- ( ffffffffffffffff , 0000000 ) + +[63,24]: + int 7fffffffffffffff000000 <- ( ffffffffffffffff , 000000 ) + +[63,23]: + int 3fffffffffffffff800000 <- ( ffffffffffffffff , 000000 ) + +[63,22]: + int 1fffffffffffffffc00000 <- ( ffffffffffffffff , 000000 ) + +[63,21]: + int 0fffffffffffffffe00000 <- ( ffffffffffffffff , 000000 ) + +[63,20]: + int 7fffffffffffffff00000 <- ( ffffffffffffffff , 00000 ) + +[63,19]: + int 3fffffffffffffff80000 <- ( ffffffffffffffff , 00000 ) + +[63,18]: + int 1fffffffffffffffc0000 <- ( ffffffffffffffff , 00000 ) + +[63,17]: + int 0fffffffffffffffe0000 <- ( ffffffffffffffff , 00000 ) + +[63,16]: + int 7fffffffffffffff0000 <- ( ffffffffffffffff , 0000 ) + +[63,15]: + int 3fffffffffffffff8000 <- ( ffffffffffffffff , 0000 ) + +[63,14]: + int 1fffffffffffffffc000 <- ( ffffffffffffffff , 0000 ) + +[63,13]: + int 0fffffffffffffffe000 <- ( ffffffffffffffff , 0000 ) + +[63,12]: + int 7fffffffffffffff000 <- ( ffffffffffffffff , 000 ) + +[63,11]: + int 3fffffffffffffff800 <- ( ffffffffffffffff , 000 ) + +[63,10]: + int 1fffffffffffffffc00 <- ( ffffffffffffffff , 000 ) + +[63,9]: + int 0fffffffffffffffe00 <- ( ffffffffffffffff , 000 ) + +[63,8]: + int 7fffffffffffffff00 <- ( ffffffffffffffff , 00 ) + +[63,7]: + int 3fffffffffffffff80 <- ( ffffffffffffffff , 00 ) + +[63,6]: + int 1fffffffffffffffc0 <- ( ffffffffffffffff , 00 ) + +[63,5]: + int 0fffffffffffffffe0 <- ( ffffffffffffffff , 00 ) + +[63,4]: + int 7fffffffffffffff0 <- ( ffffffffffffffff , 0 ) + +[63,3]: + int 3fffffffffffffff8 <- ( ffffffffffffffff , 0 ) + +[63,2]: + int 1fffffffffffffffc <- ( ffffffffffffffff , 0 ) + +[63,1]: + int 0fffffffffffffffe <- ( ffffffffffffffff , 0 ) + +[62,64]: + int 3fffffffffffffff0000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[62,63]: + int 1fffffffffffffff8000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[62,62]: + int 0fffffffffffffffc000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[62,61]: + int 7ffffffffffffffe000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[62,60]: + int 3fffffffffffffff000000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[62,59]: + int 1fffffffffffffff800000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[62,58]: + int 0fffffffffffffffc00000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[62,57]: + int 7ffffffffffffffe00000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[62,56]: + int 3fffffffffffffff00000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[62,55]: + int 1fffffffffffffff80000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[62,54]: + int 0fffffffffffffffc0000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[62,53]: + int 7ffffffffffffffe0000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[62,52]: + int 3fffffffffffffff0000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[62,51]: + int 1fffffffffffffff8000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[62,50]: + int 0fffffffffffffffc000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[62,49]: + int 7ffffffffffffffe000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[62,48]: + int 3fffffffffffffff000000000000 <- ( ffffffffffffffff , 000000000000 ) + +[62,47]: + int 1fffffffffffffff800000000000 <- ( ffffffffffffffff , 000000000000 ) + +[62,46]: + int 0fffffffffffffffc00000000000 <- ( ffffffffffffffff , 000000000000 ) + +[62,45]: + int 7ffffffffffffffe00000000000 <- ( ffffffffffffffff , 000000000000 ) + +[62,44]: + int 3fffffffffffffff00000000000 <- ( ffffffffffffffff , 00000000000 ) + +[62,43]: + int 1fffffffffffffff80000000000 <- ( ffffffffffffffff , 00000000000 ) + +[62,42]: + int 0fffffffffffffffc0000000000 <- ( ffffffffffffffff , 00000000000 ) + +[62,41]: + int 7ffffffffffffffe0000000000 <- ( ffffffffffffffff , 00000000000 ) + +[62,40]: + int 3fffffffffffffff0000000000 <- ( ffffffffffffffff , 0000000000 ) + +[62,39]: + int 1fffffffffffffff8000000000 <- ( ffffffffffffffff , 0000000000 ) + +[62,38]: + int 0fffffffffffffffc000000000 <- ( ffffffffffffffff , 0000000000 ) + +[62,37]: + int 7ffffffffffffffe000000000 <- ( ffffffffffffffff , 0000000000 ) + +[62,36]: + int 3fffffffffffffff000000000 <- ( ffffffffffffffff , 000000000 ) + +[62,35]: + int 1fffffffffffffff800000000 <- ( ffffffffffffffff , 000000000 ) + +[62,34]: + int 0fffffffffffffffc00000000 <- ( ffffffffffffffff , 000000000 ) + +[62,33]: + int 7ffffffffffffffe00000000 <- ( ffffffffffffffff , 000000000 ) + +[62,32]: + int 3fffffffffffffff00000000 <- ( ffffffffffffffff , 00000000 ) + +[62,31]: + int 1fffffffffffffff80000000 <- ( ffffffffffffffff , 00000000 ) + +[62,30]: + int 0fffffffffffffffc0000000 <- ( ffffffffffffffff , 00000000 ) + +[62,29]: + int 7ffffffffffffffe0000000 <- ( ffffffffffffffff , 00000000 ) + +[62,28]: + int 3fffffffffffffff0000000 <- ( ffffffffffffffff , 0000000 ) + +[62,27]: + int 1fffffffffffffff8000000 <- ( ffffffffffffffff , 0000000 ) + +[62,26]: + int 0fffffffffffffffc000000 <- ( ffffffffffffffff , 0000000 ) + +[62,25]: + int 7ffffffffffffffe000000 <- ( ffffffffffffffff , 0000000 ) + +[62,24]: + int 3fffffffffffffff000000 <- ( ffffffffffffffff , 000000 ) + +[62,23]: + int 1fffffffffffffff800000 <- ( ffffffffffffffff , 000000 ) + +[62,22]: + int 0fffffffffffffffc00000 <- ( ffffffffffffffff , 000000 ) + +[62,21]: + int 7ffffffffffffffe00000 <- ( ffffffffffffffff , 000000 ) + +[62,20]: + int 3fffffffffffffff00000 <- ( ffffffffffffffff , 00000 ) + +[62,19]: + int 1fffffffffffffff80000 <- ( ffffffffffffffff , 00000 ) + +[62,18]: + int 0fffffffffffffffc0000 <- ( ffffffffffffffff , 00000 ) + +[62,17]: + int 7ffffffffffffffe0000 <- ( ffffffffffffffff , 00000 ) + +[62,16]: + int 3fffffffffffffff0000 <- ( ffffffffffffffff , 0000 ) + +[62,15]: + int 1fffffffffffffff8000 <- ( ffffffffffffffff , 0000 ) + +[62,14]: + int 0fffffffffffffffc000 <- ( ffffffffffffffff , 0000 ) + +[62,13]: + int 7ffffffffffffffe000 <- ( ffffffffffffffff , 0000 ) + +[62,12]: + int 3fffffffffffffff000 <- ( ffffffffffffffff , 000 ) + +[62,11]: + int 1fffffffffffffff800 <- ( ffffffffffffffff , 000 ) + +[62,10]: + int 0fffffffffffffffc00 <- ( ffffffffffffffff , 000 ) + +[62,9]: + int 7ffffffffffffffe00 <- ( ffffffffffffffff , 000 ) + +[62,8]: + int 3fffffffffffffff00 <- ( ffffffffffffffff , 00 ) + +[62,7]: + int 1fffffffffffffff80 <- ( ffffffffffffffff , 00 ) + +[62,6]: + int 0fffffffffffffffc0 <- ( ffffffffffffffff , 00 ) + +[62,5]: + int 7ffffffffffffffe0 <- ( ffffffffffffffff , 00 ) + +[62,4]: + int 3fffffffffffffff0 <- ( ffffffffffffffff , 0 ) + +[62,3]: + int 1fffffffffffffff8 <- ( ffffffffffffffff , 0 ) + +[62,2]: + int 0fffffffffffffffc <- ( ffffffffffffffff , 0 ) + +[62,1]: + int 7ffffffffffffffe <- ( ffffffffffffffff , 0 ) + +[61,64]: + int 1fffffffffffffff0000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[61,63]: + int 0fffffffffffffff8000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[61,62]: + int 7ffffffffffffffc000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[61,61]: + int 3ffffffffffffffe000000000000000 <- ( ffffffffffffffff , 0000000000000000 ) + +[61,60]: + int 1fffffffffffffff000000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[61,59]: + int 0fffffffffffffff800000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[61,58]: + int 7ffffffffffffffc00000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[61,57]: + int 3ffffffffffffffe00000000000000 <- ( ffffffffffffffff , 000000000000000 ) + +[61,56]: + int 1fffffffffffffff00000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[61,55]: + int 0fffffffffffffff80000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[61,54]: + int 7ffffffffffffffc0000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[61,53]: + int 3ffffffffffffffe0000000000000 <- ( ffffffffffffffff , 00000000000000 ) + +[61,52]: + int 1fffffffffffffff0000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[61,51]: + int 0fffffffffffffff8000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[61,50]: + int 7ffffffffffffffc000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[61,49]: + int 3ffffffffffffffe000000000000 <- ( ffffffffffffffff , 0000000000000 ) + +[61,48]: + int 1fffffffffffffff000000000000 <- ( ffffffffffffffff , 000000000000 ) + +[61,47]: + int 0fffffffffffffff800000000000 <- ( ffffffffffffffff , 000000000000 ) + +[61,46]: + int 7ffffffffffffffc00000000000 <- ( ffffffffffffffff , 000000000000 ) + +[61,45]: + int 3ffffffffffffffe00000000000 <- ( ffffffffffffffff , 000000000000 ) + +[61,44]: + int 1fffffffffffffff00000000000 <- ( ffffffffffffffff , 00000000000 ) + +[61,43]: + int 0fffffffffffffff80000000000 <- ( ffffffffffffffff , 00000000000 ) + +[61,42]: + int 7ffffffffffffffc0000000000 <- ( ffffffffffffffff , 00000000000 ) + +[61,41]: + int 3ffffffffffffffe0000000000 <- ( ffffffffffffffff , 00000000000 ) + +[61,40]: + int 1fffffffffffffff0000000000 <- ( ffffffffffffffff , 0000000000 ) + +[61,39]: + int 0fffffffffffffff8000000000 <- ( ffffffffffffffff , 0000000000 ) + +[61,38]: + int 7ffffffffffffffc000000000 <- ( ffffffffffffffff , 0000000000 ) + +[61,37]: + int 3ffffffffffffffe000000000 <- ( ffffffffffffffff , 0000000000 ) + +[61,36]: + int 1fffffffffffffff000000000 <- ( ffffffffffffffff , 000000000 ) + +[61,35]: + int 0fffffffffffffff800000000 <- ( ffffffffffffffff , 000000000 ) + +[61,34]: + int 7ffffffffffffffc00000000 <- ( ffffffffffffffff , 000000000 ) + +[61,33]: + int 3ffffffffffffffe00000000 <- ( ffffffffffffffff , 000000000 ) + +[61,32]: + int 1fffffffffffffff00000000 <- ( ffffffffffffffff , 00000000 ) + +[61,31]: + int 0fffffffffffffff80000000 <- ( ffffffffffffffff , 00000000 ) + +[61,30]: + int 7ffffffffffffffc0000000 <- ( ffffffffffffffff , 00000000 ) + +[61,29]: + int 3ffffffffffffffe0000000 <- ( ffffffffffffffff , 00000000 ) + +[61,28]: + int 1fffffffffffffff0000000 <- ( ffffffffffffffff , 0000000 ) + +[61,27]: + int 0fffffffffffffff8000000 <- ( ffffffffffffffff , 0000000 ) + +[61,26]: + int 7ffffffffffffffc000000 <- ( ffffffffffffffff , 0000000 ) + +[61,25]: + int 3ffffffffffffffe000000 <- ( ffffffffffffffff , 0000000 ) + +[61,24]: + int 1fffffffffffffff000000 <- ( ffffffffffffffff , 000000 ) + +[61,23]: + int 0fffffffffffffff800000 <- ( ffffffffffffffff , 000000 ) + +[61,22]: + int 7ffffffffffffffc00000 <- ( ffffffffffffffff , 000000 ) + +[61,21]: + int 3ffffffffffffffe00000 <- ( ffffffffffffffff , 000000 ) + +[61,20]: + int 1fffffffffffffff00000 <- ( ffffffffffffffff , 00000 ) + +[61,19]: + int 0fffffffffffffff80000 <- ( ffffffffffffffff , 00000 ) + +[61,18]: + int 7ffffffffffffffc0000 <- ( ffffffffffffffff , 00000 ) + +[61,17]: + int 3ffffffffffffffe0000 <- ( ffffffffffffffff , 00000 ) + +[61,16]: + int 1fffffffffffffff0000 <- ( ffffffffffffffff , 0000 ) + +[61,15]: + int 0fffffffffffffff8000 <- ( ffffffffffffffff , 0000 ) + +[61,14]: + int 7ffffffffffffffc000 <- ( ffffffffffffffff , 0000 ) + +[61,13]: + int 3ffffffffffffffe000 <- ( ffffffffffffffff , 0000 ) + +[61,12]: + int 1fffffffffffffff000 <- ( ffffffffffffffff , 000 ) + +[61,11]: + int 0fffffffffffffff800 <- ( ffffffffffffffff , 000 ) + +[61,10]: + int 7ffffffffffffffc00 <- ( ffffffffffffffff , 000 ) + +[61,9]: + int 3ffffffffffffffe00 <- ( ffffffffffffffff , 000 ) + +[61,8]: + int 1fffffffffffffff00 <- ( ffffffffffffffff , 00 ) + +[61,7]: + int 0fffffffffffffff80 <- ( ffffffffffffffff , 00 ) + +[61,6]: + int 7ffffffffffffffc0 <- ( ffffffffffffffff , 00 ) + +[61,5]: + int 3ffffffffffffffe0 <- ( ffffffffffffffff , 00 ) + +[61,4]: + int 1fffffffffffffff0 <- ( ffffffffffffffff , 0 ) + +[61,3]: + int 0fffffffffffffff8 <- ( ffffffffffffffff , 0 ) + +[61,2]: + int 7ffffffffffffffc <- ( ffffffffffffffff , 0 ) + +[61,1]: + int 3ffffffffffffffe <- ( ffffffffffffffff , 0 ) + +[60,64]: + int 0fffffffffffffff0000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[60,63]: + int 7ffffffffffffff8000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[60,62]: + int 3ffffffffffffffc000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[60,61]: + int 1ffffffffffffffe000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[60,60]: + int 0fffffffffffffff000000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[60,59]: + int 7ffffffffffffff800000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[60,58]: + int 3ffffffffffffffc00000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[60,57]: + int 1ffffffffffffffe00000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[60,56]: + int 0fffffffffffffff00000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[60,55]: + int 7ffffffffffffff80000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[60,54]: + int 3ffffffffffffffc0000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[60,53]: + int 1ffffffffffffffe0000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[60,52]: + int 0fffffffffffffff0000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[60,51]: + int 7ffffffffffffff8000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[60,50]: + int 3ffffffffffffffc000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[60,49]: + int 1ffffffffffffffe000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[60,48]: + int 0fffffffffffffff000000000000 <- ( fffffffffffffff , 000000000000 ) + +[60,47]: + int 7ffffffffffffff800000000000 <- ( fffffffffffffff , 000000000000 ) + +[60,46]: + int 3ffffffffffffffc00000000000 <- ( fffffffffffffff , 000000000000 ) + +[60,45]: + int 1ffffffffffffffe00000000000 <- ( fffffffffffffff , 000000000000 ) + +[60,44]: + int 0fffffffffffffff00000000000 <- ( fffffffffffffff , 00000000000 ) + +[60,43]: + int 7ffffffffffffff80000000000 <- ( fffffffffffffff , 00000000000 ) + +[60,42]: + int 3ffffffffffffffc0000000000 <- ( fffffffffffffff , 00000000000 ) + +[60,41]: + int 1ffffffffffffffe0000000000 <- ( fffffffffffffff , 00000000000 ) + +[60,40]: + int 0fffffffffffffff0000000000 <- ( fffffffffffffff , 0000000000 ) + +[60,39]: + int 7ffffffffffffff8000000000 <- ( fffffffffffffff , 0000000000 ) + +[60,38]: + int 3ffffffffffffffc000000000 <- ( fffffffffffffff , 0000000000 ) + +[60,37]: + int 1ffffffffffffffe000000000 <- ( fffffffffffffff , 0000000000 ) + +[60,36]: + int 0fffffffffffffff000000000 <- ( fffffffffffffff , 000000000 ) + +[60,35]: + int 7ffffffffffffff800000000 <- ( fffffffffffffff , 000000000 ) + +[60,34]: + int 3ffffffffffffffc00000000 <- ( fffffffffffffff , 000000000 ) + +[60,33]: + int 1ffffffffffffffe00000000 <- ( fffffffffffffff , 000000000 ) + +[60,32]: + int 0fffffffffffffff00000000 <- ( fffffffffffffff , 00000000 ) + +[60,31]: + int 7ffffffffffffff80000000 <- ( fffffffffffffff , 00000000 ) + +[60,30]: + int 3ffffffffffffffc0000000 <- ( fffffffffffffff , 00000000 ) + +[60,29]: + int 1ffffffffffffffe0000000 <- ( fffffffffffffff , 00000000 ) + +[60,28]: + int 0fffffffffffffff0000000 <- ( fffffffffffffff , 0000000 ) + +[60,27]: + int 7ffffffffffffff8000000 <- ( fffffffffffffff , 0000000 ) + +[60,26]: + int 3ffffffffffffffc000000 <- ( fffffffffffffff , 0000000 ) + +[60,25]: + int 1ffffffffffffffe000000 <- ( fffffffffffffff , 0000000 ) + +[60,24]: + int 0fffffffffffffff000000 <- ( fffffffffffffff , 000000 ) + +[60,23]: + int 7ffffffffffffff800000 <- ( fffffffffffffff , 000000 ) + +[60,22]: + int 3ffffffffffffffc00000 <- ( fffffffffffffff , 000000 ) + +[60,21]: + int 1ffffffffffffffe00000 <- ( fffffffffffffff , 000000 ) + +[60,20]: + int 0fffffffffffffff00000 <- ( fffffffffffffff , 00000 ) + +[60,19]: + int 7ffffffffffffff80000 <- ( fffffffffffffff , 00000 ) + +[60,18]: + int 3ffffffffffffffc0000 <- ( fffffffffffffff , 00000 ) + +[60,17]: + int 1ffffffffffffffe0000 <- ( fffffffffffffff , 00000 ) + +[60,16]: + int 0fffffffffffffff0000 <- ( fffffffffffffff , 0000 ) + +[60,15]: + int 7ffffffffffffff8000 <- ( fffffffffffffff , 0000 ) + +[60,14]: + int 3ffffffffffffffc000 <- ( fffffffffffffff , 0000 ) + +[60,13]: + int 1ffffffffffffffe000 <- ( fffffffffffffff , 0000 ) + +[60,12]: + int 0fffffffffffffff000 <- ( fffffffffffffff , 000 ) + +[60,11]: + int 7ffffffffffffff800 <- ( fffffffffffffff , 000 ) + +[60,10]: + int 3ffffffffffffffc00 <- ( fffffffffffffff , 000 ) + +[60,9]: + int 1ffffffffffffffe00 <- ( fffffffffffffff , 000 ) + +[60,8]: + int 0fffffffffffffff00 <- ( fffffffffffffff , 00 ) + +[60,7]: + int 7ffffffffffffff80 <- ( fffffffffffffff , 00 ) + +[60,6]: + int 3ffffffffffffffc0 <- ( fffffffffffffff , 00 ) + +[60,5]: + int 1ffffffffffffffe0 <- ( fffffffffffffff , 00 ) + +[60,4]: + int 0fffffffffffffff0 <- ( fffffffffffffff , 0 ) + +[60,3]: + int 7ffffffffffffff8 <- ( fffffffffffffff , 0 ) + +[60,2]: + int 3ffffffffffffffc <- ( fffffffffffffff , 0 ) + +[60,1]: + int 1ffffffffffffffe <- ( fffffffffffffff , 0 ) + +[59,64]: + int 7ffffffffffffff0000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[59,63]: + int 3ffffffffffffff8000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[59,62]: + int 1ffffffffffffffc000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[59,61]: + int 0ffffffffffffffe000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[59,60]: + int 7ffffffffffffff000000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[59,59]: + int 3ffffffffffffff800000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[59,58]: + int 1ffffffffffffffc00000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[59,57]: + int 0ffffffffffffffe00000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[59,56]: + int 7ffffffffffffff00000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[59,55]: + int 3ffffffffffffff80000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[59,54]: + int 1ffffffffffffffc0000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[59,53]: + int 0ffffffffffffffe0000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[59,52]: + int 7ffffffffffffff0000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[59,51]: + int 3ffffffffffffff8000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[59,50]: + int 1ffffffffffffffc000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[59,49]: + int 0ffffffffffffffe000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[59,48]: + int 7ffffffffffffff000000000000 <- ( fffffffffffffff , 000000000000 ) + +[59,47]: + int 3ffffffffffffff800000000000 <- ( fffffffffffffff , 000000000000 ) + +[59,46]: + int 1ffffffffffffffc00000000000 <- ( fffffffffffffff , 000000000000 ) + +[59,45]: + int 0ffffffffffffffe00000000000 <- ( fffffffffffffff , 000000000000 ) + +[59,44]: + int 7ffffffffffffff00000000000 <- ( fffffffffffffff , 00000000000 ) + +[59,43]: + int 3ffffffffffffff80000000000 <- ( fffffffffffffff , 00000000000 ) + +[59,42]: + int 1ffffffffffffffc0000000000 <- ( fffffffffffffff , 00000000000 ) + +[59,41]: + int 0ffffffffffffffe0000000000 <- ( fffffffffffffff , 00000000000 ) + +[59,40]: + int 7ffffffffffffff0000000000 <- ( fffffffffffffff , 0000000000 ) + +[59,39]: + int 3ffffffffffffff8000000000 <- ( fffffffffffffff , 0000000000 ) + +[59,38]: + int 1ffffffffffffffc000000000 <- ( fffffffffffffff , 0000000000 ) + +[59,37]: + int 0ffffffffffffffe000000000 <- ( fffffffffffffff , 0000000000 ) + +[59,36]: + int 7ffffffffffffff000000000 <- ( fffffffffffffff , 000000000 ) + +[59,35]: + int 3ffffffffffffff800000000 <- ( fffffffffffffff , 000000000 ) + +[59,34]: + int 1ffffffffffffffc00000000 <- ( fffffffffffffff , 000000000 ) + +[59,33]: + int 0ffffffffffffffe00000000 <- ( fffffffffffffff , 000000000 ) + +[59,32]: + int 7ffffffffffffff00000000 <- ( fffffffffffffff , 00000000 ) + +[59,31]: + int 3ffffffffffffff80000000 <- ( fffffffffffffff , 00000000 ) + +[59,30]: + int 1ffffffffffffffc0000000 <- ( fffffffffffffff , 00000000 ) + +[59,29]: + int 0ffffffffffffffe0000000 <- ( fffffffffffffff , 00000000 ) + +[59,28]: + int 7ffffffffffffff0000000 <- ( fffffffffffffff , 0000000 ) + +[59,27]: + int 3ffffffffffffff8000000 <- ( fffffffffffffff , 0000000 ) + +[59,26]: + int 1ffffffffffffffc000000 <- ( fffffffffffffff , 0000000 ) + +[59,25]: + int 0ffffffffffffffe000000 <- ( fffffffffffffff , 0000000 ) + +[59,24]: + int 7ffffffffffffff000000 <- ( fffffffffffffff , 000000 ) + +[59,23]: + int 3ffffffffffffff800000 <- ( fffffffffffffff , 000000 ) + +[59,22]: + int 1ffffffffffffffc00000 <- ( fffffffffffffff , 000000 ) + +[59,21]: + int 0ffffffffffffffe00000 <- ( fffffffffffffff , 000000 ) + +[59,20]: + int 7ffffffffffffff00000 <- ( fffffffffffffff , 00000 ) + +[59,19]: + int 3ffffffffffffff80000 <- ( fffffffffffffff , 00000 ) + +[59,18]: + int 1ffffffffffffffc0000 <- ( fffffffffffffff , 00000 ) + +[59,17]: + int 0ffffffffffffffe0000 <- ( fffffffffffffff , 00000 ) + +[59,16]: + int 7ffffffffffffff0000 <- ( fffffffffffffff , 0000 ) + +[59,15]: + int 3ffffffffffffff8000 <- ( fffffffffffffff , 0000 ) + +[59,14]: + int 1ffffffffffffffc000 <- ( fffffffffffffff , 0000 ) + +[59,13]: + int 0ffffffffffffffe000 <- ( fffffffffffffff , 0000 ) + +[59,12]: + int 7ffffffffffffff000 <- ( fffffffffffffff , 000 ) + +[59,11]: + int 3ffffffffffffff800 <- ( fffffffffffffff , 000 ) + +[59,10]: + int 1ffffffffffffffc00 <- ( fffffffffffffff , 000 ) + +[59,9]: + int 0ffffffffffffffe00 <- ( fffffffffffffff , 000 ) + +[59,8]: + int 7ffffffffffffff00 <- ( fffffffffffffff , 00 ) + +[59,7]: + int 3ffffffffffffff80 <- ( fffffffffffffff , 00 ) + +[59,6]: + int 1ffffffffffffffc0 <- ( fffffffffffffff , 00 ) + +[59,5]: + int 0ffffffffffffffe0 <- ( fffffffffffffff , 00 ) + +[59,4]: + int 7ffffffffffffff0 <- ( fffffffffffffff , 0 ) + +[59,3]: + int 3ffffffffffffff8 <- ( fffffffffffffff , 0 ) + +[59,2]: + int 1ffffffffffffffc <- ( fffffffffffffff , 0 ) + +[59,1]: + int 0ffffffffffffffe <- ( fffffffffffffff , 0 ) + +[58,64]: + int 3ffffffffffffff0000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[58,63]: + int 1ffffffffffffff8000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[58,62]: + int 0ffffffffffffffc000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[58,61]: + int 7fffffffffffffe000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[58,60]: + int 3ffffffffffffff000000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[58,59]: + int 1ffffffffffffff800000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[58,58]: + int 0ffffffffffffffc00000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[58,57]: + int 7fffffffffffffe00000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[58,56]: + int 3ffffffffffffff00000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[58,55]: + int 1ffffffffffffff80000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[58,54]: + int 0ffffffffffffffc0000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[58,53]: + int 7fffffffffffffe0000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[58,52]: + int 3ffffffffffffff0000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[58,51]: + int 1ffffffffffffff8000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[58,50]: + int 0ffffffffffffffc000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[58,49]: + int 7fffffffffffffe000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[58,48]: + int 3ffffffffffffff000000000000 <- ( fffffffffffffff , 000000000000 ) + +[58,47]: + int 1ffffffffffffff800000000000 <- ( fffffffffffffff , 000000000000 ) + +[58,46]: + int 0ffffffffffffffc00000000000 <- ( fffffffffffffff , 000000000000 ) + +[58,45]: + int 7fffffffffffffe00000000000 <- ( fffffffffffffff , 000000000000 ) + +[58,44]: + int 3ffffffffffffff00000000000 <- ( fffffffffffffff , 00000000000 ) + +[58,43]: + int 1ffffffffffffff80000000000 <- ( fffffffffffffff , 00000000000 ) + +[58,42]: + int 0ffffffffffffffc0000000000 <- ( fffffffffffffff , 00000000000 ) + +[58,41]: + int 7fffffffffffffe0000000000 <- ( fffffffffffffff , 00000000000 ) + +[58,40]: + int 3ffffffffffffff0000000000 <- ( fffffffffffffff , 0000000000 ) + +[58,39]: + int 1ffffffffffffff8000000000 <- ( fffffffffffffff , 0000000000 ) + +[58,38]: + int 0ffffffffffffffc000000000 <- ( fffffffffffffff , 0000000000 ) + +[58,37]: + int 7fffffffffffffe000000000 <- ( fffffffffffffff , 0000000000 ) + +[58,36]: + int 3ffffffffffffff000000000 <- ( fffffffffffffff , 000000000 ) + +[58,35]: + int 1ffffffffffffff800000000 <- ( fffffffffffffff , 000000000 ) + +[58,34]: + int 0ffffffffffffffc00000000 <- ( fffffffffffffff , 000000000 ) + +[58,33]: + int 7fffffffffffffe00000000 <- ( fffffffffffffff , 000000000 ) + +[58,32]: + int 3ffffffffffffff00000000 <- ( fffffffffffffff , 00000000 ) + +[58,31]: + int 1ffffffffffffff80000000 <- ( fffffffffffffff , 00000000 ) + +[58,30]: + int 0ffffffffffffffc0000000 <- ( fffffffffffffff , 00000000 ) + +[58,29]: + int 7fffffffffffffe0000000 <- ( fffffffffffffff , 00000000 ) + +[58,28]: + int 3ffffffffffffff0000000 <- ( fffffffffffffff , 0000000 ) + +[58,27]: + int 1ffffffffffffff8000000 <- ( fffffffffffffff , 0000000 ) + +[58,26]: + int 0ffffffffffffffc000000 <- ( fffffffffffffff , 0000000 ) + +[58,25]: + int 7fffffffffffffe000000 <- ( fffffffffffffff , 0000000 ) + +[58,24]: + int 3ffffffffffffff000000 <- ( fffffffffffffff , 000000 ) + +[58,23]: + int 1ffffffffffffff800000 <- ( fffffffffffffff , 000000 ) + +[58,22]: + int 0ffffffffffffffc00000 <- ( fffffffffffffff , 000000 ) + +[58,21]: + int 7fffffffffffffe00000 <- ( fffffffffffffff , 000000 ) + +[58,20]: + int 3ffffffffffffff00000 <- ( fffffffffffffff , 00000 ) + +[58,19]: + int 1ffffffffffffff80000 <- ( fffffffffffffff , 00000 ) + +[58,18]: + int 0ffffffffffffffc0000 <- ( fffffffffffffff , 00000 ) + +[58,17]: + int 7fffffffffffffe0000 <- ( fffffffffffffff , 00000 ) + +[58,16]: + int 3ffffffffffffff0000 <- ( fffffffffffffff , 0000 ) + +[58,15]: + int 1ffffffffffffff8000 <- ( fffffffffffffff , 0000 ) + +[58,14]: + int 0ffffffffffffffc000 <- ( fffffffffffffff , 0000 ) + +[58,13]: + int 7fffffffffffffe000 <- ( fffffffffffffff , 0000 ) + +[58,12]: + int 3ffffffffffffff000 <- ( fffffffffffffff , 000 ) + +[58,11]: + int 1ffffffffffffff800 <- ( fffffffffffffff , 000 ) + +[58,10]: + int 0ffffffffffffffc00 <- ( fffffffffffffff , 000 ) + +[58,9]: + int 7fffffffffffffe00 <- ( fffffffffffffff , 000 ) + +[58,8]: + int 3ffffffffffffff00 <- ( fffffffffffffff , 00 ) + +[58,7]: + int 1ffffffffffffff80 <- ( fffffffffffffff , 00 ) + +[58,6]: + int 0ffffffffffffffc0 <- ( fffffffffffffff , 00 ) + +[58,5]: + int 7fffffffffffffe0 <- ( fffffffffffffff , 00 ) + +[58,4]: + int 3ffffffffffffff0 <- ( fffffffffffffff , 0 ) + +[58,3]: + int 1ffffffffffffff8 <- ( fffffffffffffff , 0 ) + +[58,2]: + int 0ffffffffffffffc <- ( fffffffffffffff , 0 ) + +[58,1]: + int 7fffffffffffffe <- ( fffffffffffffff , 0 ) + +[57,64]: + int 1ffffffffffffff0000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[57,63]: + int 0ffffffffffffff8000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[57,62]: + int 7fffffffffffffc000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[57,61]: + int 3fffffffffffffe000000000000000 <- ( fffffffffffffff , 0000000000000000 ) + +[57,60]: + int 1ffffffffffffff000000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[57,59]: + int 0ffffffffffffff800000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[57,58]: + int 7fffffffffffffc00000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[57,57]: + int 3fffffffffffffe00000000000000 <- ( fffffffffffffff , 000000000000000 ) + +[57,56]: + int 1ffffffffffffff00000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[57,55]: + int 0ffffffffffffff80000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[57,54]: + int 7fffffffffffffc0000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[57,53]: + int 3fffffffffffffe0000000000000 <- ( fffffffffffffff , 00000000000000 ) + +[57,52]: + int 1ffffffffffffff0000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[57,51]: + int 0ffffffffffffff8000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[57,50]: + int 7fffffffffffffc000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[57,49]: + int 3fffffffffffffe000000000000 <- ( fffffffffffffff , 0000000000000 ) + +[57,48]: + int 1ffffffffffffff000000000000 <- ( fffffffffffffff , 000000000000 ) + +[57,47]: + int 0ffffffffffffff800000000000 <- ( fffffffffffffff , 000000000000 ) + +[57,46]: + int 7fffffffffffffc00000000000 <- ( fffffffffffffff , 000000000000 ) + +[57,45]: + int 3fffffffffffffe00000000000 <- ( fffffffffffffff , 000000000000 ) + +[57,44]: + int 1ffffffffffffff00000000000 <- ( fffffffffffffff , 00000000000 ) + +[57,43]: + int 0ffffffffffffff80000000000 <- ( fffffffffffffff , 00000000000 ) + +[57,42]: + int 7fffffffffffffc0000000000 <- ( fffffffffffffff , 00000000000 ) + +[57,41]: + int 3fffffffffffffe0000000000 <- ( fffffffffffffff , 00000000000 ) + +[57,40]: + int 1ffffffffffffff0000000000 <- ( fffffffffffffff , 0000000000 ) + +[57,39]: + int 0ffffffffffffff8000000000 <- ( fffffffffffffff , 0000000000 ) + +[57,38]: + int 7fffffffffffffc000000000 <- ( fffffffffffffff , 0000000000 ) + +[57,37]: + int 3fffffffffffffe000000000 <- ( fffffffffffffff , 0000000000 ) + +[57,36]: + int 1ffffffffffffff000000000 <- ( fffffffffffffff , 000000000 ) + +[57,35]: + int 0ffffffffffffff800000000 <- ( fffffffffffffff , 000000000 ) + +[57,34]: + int 7fffffffffffffc00000000 <- ( fffffffffffffff , 000000000 ) + +[57,33]: + int 3fffffffffffffe00000000 <- ( fffffffffffffff , 000000000 ) + +[57,32]: + int 1ffffffffffffff00000000 <- ( fffffffffffffff , 00000000 ) + +[57,31]: + int 0ffffffffffffff80000000 <- ( fffffffffffffff , 00000000 ) + +[57,30]: + int 7fffffffffffffc0000000 <- ( fffffffffffffff , 00000000 ) + +[57,29]: + int 3fffffffffffffe0000000 <- ( fffffffffffffff , 00000000 ) + +[57,28]: + int 1ffffffffffffff0000000 <- ( fffffffffffffff , 0000000 ) + +[57,27]: + int 0ffffffffffffff8000000 <- ( fffffffffffffff , 0000000 ) + +[57,26]: + int 7fffffffffffffc000000 <- ( fffffffffffffff , 0000000 ) + +[57,25]: + int 3fffffffffffffe000000 <- ( fffffffffffffff , 0000000 ) + +[57,24]: + int 1ffffffffffffff000000 <- ( fffffffffffffff , 000000 ) + +[57,23]: + int 0ffffffffffffff800000 <- ( fffffffffffffff , 000000 ) + +[57,22]: + int 7fffffffffffffc00000 <- ( fffffffffffffff , 000000 ) + +[57,21]: + int 3fffffffffffffe00000 <- ( fffffffffffffff , 000000 ) + +[57,20]: + int 1ffffffffffffff00000 <- ( fffffffffffffff , 00000 ) + +[57,19]: + int 0ffffffffffffff80000 <- ( fffffffffffffff , 00000 ) + +[57,18]: + int 7fffffffffffffc0000 <- ( fffffffffffffff , 00000 ) + +[57,17]: + int 3fffffffffffffe0000 <- ( fffffffffffffff , 00000 ) + +[57,16]: + int 1ffffffffffffff0000 <- ( fffffffffffffff , 0000 ) + +[57,15]: + int 0ffffffffffffff8000 <- ( fffffffffffffff , 0000 ) + +[57,14]: + int 7fffffffffffffc000 <- ( fffffffffffffff , 0000 ) + +[57,13]: + int 3fffffffffffffe000 <- ( fffffffffffffff , 0000 ) + +[57,12]: + int 1ffffffffffffff000 <- ( fffffffffffffff , 000 ) + +[57,11]: + int 0ffffffffffffff800 <- ( fffffffffffffff , 000 ) + +[57,10]: + int 7fffffffffffffc00 <- ( fffffffffffffff , 000 ) + +[57,9]: + int 3fffffffffffffe00 <- ( fffffffffffffff , 000 ) + +[57,8]: + int 1ffffffffffffff00 <- ( fffffffffffffff , 00 ) + +[57,7]: + int 0ffffffffffffff80 <- ( fffffffffffffff , 00 ) + +[57,6]: + int 7fffffffffffffc0 <- ( fffffffffffffff , 00 ) + +[57,5]: + int 3fffffffffffffe0 <- ( fffffffffffffff , 00 ) + +[57,4]: + int 1ffffffffffffff0 <- ( fffffffffffffff , 0 ) + +[57,3]: + int 0ffffffffffffff8 <- ( fffffffffffffff , 0 ) + +[57,2]: + int 7fffffffffffffc <- ( fffffffffffffff , 0 ) + +[57,1]: + int 3fffffffffffffe <- ( fffffffffffffff , 0 ) + +[56,64]: + int 0ffffffffffffff0000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[56,63]: + int 7fffffffffffff8000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[56,62]: + int 3fffffffffffffc000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[56,61]: + int 1fffffffffffffe000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[56,60]: + int 0ffffffffffffff000000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[56,59]: + int 7fffffffffffff800000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[56,58]: + int 3fffffffffffffc00000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[56,57]: + int 1fffffffffffffe00000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[56,56]: + int 0ffffffffffffff00000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[56,55]: + int 7fffffffffffff80000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[56,54]: + int 3fffffffffffffc0000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[56,53]: + int 1fffffffffffffe0000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[56,52]: + int 0ffffffffffffff0000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[56,51]: + int 7fffffffffffff8000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[56,50]: + int 3fffffffffffffc000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[56,49]: + int 1fffffffffffffe000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[56,48]: + int 0ffffffffffffff000000000000 <- ( ffffffffffffff , 000000000000 ) + +[56,47]: + int 7fffffffffffff800000000000 <- ( ffffffffffffff , 000000000000 ) + +[56,46]: + int 3fffffffffffffc00000000000 <- ( ffffffffffffff , 000000000000 ) + +[56,45]: + int 1fffffffffffffe00000000000 <- ( ffffffffffffff , 000000000000 ) + +[56,44]: + int 0ffffffffffffff00000000000 <- ( ffffffffffffff , 00000000000 ) + +[56,43]: + int 7fffffffffffff80000000000 <- ( ffffffffffffff , 00000000000 ) + +[56,42]: + int 3fffffffffffffc0000000000 <- ( ffffffffffffff , 00000000000 ) + +[56,41]: + int 1fffffffffffffe0000000000 <- ( ffffffffffffff , 00000000000 ) + +[56,40]: + int 0ffffffffffffff0000000000 <- ( ffffffffffffff , 0000000000 ) + +[56,39]: + int 7fffffffffffff8000000000 <- ( ffffffffffffff , 0000000000 ) + +[56,38]: + int 3fffffffffffffc000000000 <- ( ffffffffffffff , 0000000000 ) + +[56,37]: + int 1fffffffffffffe000000000 <- ( ffffffffffffff , 0000000000 ) + +[56,36]: + int 0ffffffffffffff000000000 <- ( ffffffffffffff , 000000000 ) + +[56,35]: + int 7fffffffffffff800000000 <- ( ffffffffffffff , 000000000 ) + +[56,34]: + int 3fffffffffffffc00000000 <- ( ffffffffffffff , 000000000 ) + +[56,33]: + int 1fffffffffffffe00000000 <- ( ffffffffffffff , 000000000 ) + +[56,32]: + int 0ffffffffffffff00000000 <- ( ffffffffffffff , 00000000 ) + +[56,31]: + int 7fffffffffffff80000000 <- ( ffffffffffffff , 00000000 ) + +[56,30]: + int 3fffffffffffffc0000000 <- ( ffffffffffffff , 00000000 ) + +[56,29]: + int 1fffffffffffffe0000000 <- ( ffffffffffffff , 00000000 ) + +[56,28]: + int 0ffffffffffffff0000000 <- ( ffffffffffffff , 0000000 ) + +[56,27]: + int 7fffffffffffff8000000 <- ( ffffffffffffff , 0000000 ) + +[56,26]: + int 3fffffffffffffc000000 <- ( ffffffffffffff , 0000000 ) + +[56,25]: + int 1fffffffffffffe000000 <- ( ffffffffffffff , 0000000 ) + +[56,24]: + int 0ffffffffffffff000000 <- ( ffffffffffffff , 000000 ) + +[56,23]: + int 7fffffffffffff800000 <- ( ffffffffffffff , 000000 ) + +[56,22]: + int 3fffffffffffffc00000 <- ( ffffffffffffff , 000000 ) + +[56,21]: + int 1fffffffffffffe00000 <- ( ffffffffffffff , 000000 ) + +[56,20]: + int 0ffffffffffffff00000 <- ( ffffffffffffff , 00000 ) + +[56,19]: + int 7fffffffffffff80000 <- ( ffffffffffffff , 00000 ) + +[56,18]: + int 3fffffffffffffc0000 <- ( ffffffffffffff , 00000 ) + +[56,17]: + int 1fffffffffffffe0000 <- ( ffffffffffffff , 00000 ) + +[56,16]: + int 0ffffffffffffff0000 <- ( ffffffffffffff , 0000 ) + +[56,15]: + int 7fffffffffffff8000 <- ( ffffffffffffff , 0000 ) + +[56,14]: + int 3fffffffffffffc000 <- ( ffffffffffffff , 0000 ) + +[56,13]: + int 1fffffffffffffe000 <- ( ffffffffffffff , 0000 ) + +[56,12]: + int 0ffffffffffffff000 <- ( ffffffffffffff , 000 ) + +[56,11]: + int 7fffffffffffff800 <- ( ffffffffffffff , 000 ) + +[56,10]: + int 3fffffffffffffc00 <- ( ffffffffffffff , 000 ) + +[56,9]: + int 1fffffffffffffe00 <- ( ffffffffffffff , 000 ) + +[56,8]: + int 0ffffffffffffff00 <- ( ffffffffffffff , 00 ) + +[56,7]: + int 7fffffffffffff80 <- ( ffffffffffffff , 00 ) + +[56,6]: + int 3fffffffffffffc0 <- ( ffffffffffffff , 00 ) + +[56,5]: + int 1fffffffffffffe0 <- ( ffffffffffffff , 00 ) + +[56,4]: + int 0ffffffffffffff0 <- ( ffffffffffffff , 0 ) + +[56,3]: + int 7fffffffffffff8 <- ( ffffffffffffff , 0 ) + +[56,2]: + int 3fffffffffffffc <- ( ffffffffffffff , 0 ) + +[56,1]: + int 1fffffffffffffe <- ( ffffffffffffff , 0 ) + +[55,64]: + int 7fffffffffffff0000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[55,63]: + int 3fffffffffffff8000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[55,62]: + int 1fffffffffffffc000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[55,61]: + int 0fffffffffffffe000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[55,60]: + int 7fffffffffffff000000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[55,59]: + int 3fffffffffffff800000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[55,58]: + int 1fffffffffffffc00000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[55,57]: + int 0fffffffffffffe00000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[55,56]: + int 7fffffffffffff00000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[55,55]: + int 3fffffffffffff80000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[55,54]: + int 1fffffffffffffc0000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[55,53]: + int 0fffffffffffffe0000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[55,52]: + int 7fffffffffffff0000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[55,51]: + int 3fffffffffffff8000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[55,50]: + int 1fffffffffffffc000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[55,49]: + int 0fffffffffffffe000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[55,48]: + int 7fffffffffffff000000000000 <- ( ffffffffffffff , 000000000000 ) + +[55,47]: + int 3fffffffffffff800000000000 <- ( ffffffffffffff , 000000000000 ) + +[55,46]: + int 1fffffffffffffc00000000000 <- ( ffffffffffffff , 000000000000 ) + +[55,45]: + int 0fffffffffffffe00000000000 <- ( ffffffffffffff , 000000000000 ) + +[55,44]: + int 7fffffffffffff00000000000 <- ( ffffffffffffff , 00000000000 ) + +[55,43]: + int 3fffffffffffff80000000000 <- ( ffffffffffffff , 00000000000 ) + +[55,42]: + int 1fffffffffffffc0000000000 <- ( ffffffffffffff , 00000000000 ) + +[55,41]: + int 0fffffffffffffe0000000000 <- ( ffffffffffffff , 00000000000 ) + +[55,40]: + int 7fffffffffffff0000000000 <- ( ffffffffffffff , 0000000000 ) + +[55,39]: + int 3fffffffffffff8000000000 <- ( ffffffffffffff , 0000000000 ) + +[55,38]: + int 1fffffffffffffc000000000 <- ( ffffffffffffff , 0000000000 ) + +[55,37]: + int 0fffffffffffffe000000000 <- ( ffffffffffffff , 0000000000 ) + +[55,36]: + int 7fffffffffffff000000000 <- ( ffffffffffffff , 000000000 ) + +[55,35]: + int 3fffffffffffff800000000 <- ( ffffffffffffff , 000000000 ) + +[55,34]: + int 1fffffffffffffc00000000 <- ( ffffffffffffff , 000000000 ) + +[55,33]: + int 0fffffffffffffe00000000 <- ( ffffffffffffff , 000000000 ) + +[55,32]: + int 7fffffffffffff00000000 <- ( ffffffffffffff , 00000000 ) + +[55,31]: + int 3fffffffffffff80000000 <- ( ffffffffffffff , 00000000 ) + +[55,30]: + int 1fffffffffffffc0000000 <- ( ffffffffffffff , 00000000 ) + +[55,29]: + int 0fffffffffffffe0000000 <- ( ffffffffffffff , 00000000 ) + +[55,28]: + int 7fffffffffffff0000000 <- ( ffffffffffffff , 0000000 ) + +[55,27]: + int 3fffffffffffff8000000 <- ( ffffffffffffff , 0000000 ) + +[55,26]: + int 1fffffffffffffc000000 <- ( ffffffffffffff , 0000000 ) + +[55,25]: + int 0fffffffffffffe000000 <- ( ffffffffffffff , 0000000 ) + +[55,24]: + int 7fffffffffffff000000 <- ( ffffffffffffff , 000000 ) + +[55,23]: + int 3fffffffffffff800000 <- ( ffffffffffffff , 000000 ) + +[55,22]: + int 1fffffffffffffc00000 <- ( ffffffffffffff , 000000 ) + +[55,21]: + int 0fffffffffffffe00000 <- ( ffffffffffffff , 000000 ) + +[55,20]: + int 7fffffffffffff00000 <- ( ffffffffffffff , 00000 ) + +[55,19]: + int 3fffffffffffff80000 <- ( ffffffffffffff , 00000 ) + +[55,18]: + int 1fffffffffffffc0000 <- ( ffffffffffffff , 00000 ) + +[55,17]: + int 0fffffffffffffe0000 <- ( ffffffffffffff , 00000 ) + +[55,16]: + int 7fffffffffffff0000 <- ( ffffffffffffff , 0000 ) + +[55,15]: + int 3fffffffffffff8000 <- ( ffffffffffffff , 0000 ) + +[55,14]: + int 1fffffffffffffc000 <- ( ffffffffffffff , 0000 ) + +[55,13]: + int 0fffffffffffffe000 <- ( ffffffffffffff , 0000 ) + +[55,12]: + int 7fffffffffffff000 <- ( ffffffffffffff , 000 ) + +[55,11]: + int 3fffffffffffff800 <- ( ffffffffffffff , 000 ) + +[55,10]: + int 1fffffffffffffc00 <- ( ffffffffffffff , 000 ) + +[55,9]: + int 0fffffffffffffe00 <- ( ffffffffffffff , 000 ) + +[55,8]: + int 7fffffffffffff00 <- ( ffffffffffffff , 00 ) + +[55,7]: + int 3fffffffffffff80 <- ( ffffffffffffff , 00 ) + +[55,6]: + int 1fffffffffffffc0 <- ( ffffffffffffff , 00 ) + +[55,5]: + int 0fffffffffffffe0 <- ( ffffffffffffff , 00 ) + +[55,4]: + int 7fffffffffffff0 <- ( ffffffffffffff , 0 ) + +[55,3]: + int 3fffffffffffff8 <- ( ffffffffffffff , 0 ) + +[55,2]: + int 1fffffffffffffc <- ( ffffffffffffff , 0 ) + +[55,1]: + int 0fffffffffffffe <- ( ffffffffffffff , 0 ) + +[54,64]: + int 3fffffffffffff0000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[54,63]: + int 1fffffffffffff8000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[54,62]: + int 0fffffffffffffc000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[54,61]: + int 7ffffffffffffe000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[54,60]: + int 3fffffffffffff000000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[54,59]: + int 1fffffffffffff800000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[54,58]: + int 0fffffffffffffc00000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[54,57]: + int 7ffffffffffffe00000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[54,56]: + int 3fffffffffffff00000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[54,55]: + int 1fffffffffffff80000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[54,54]: + int 0fffffffffffffc0000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[54,53]: + int 7ffffffffffffe0000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[54,52]: + int 3fffffffffffff0000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[54,51]: + int 1fffffffffffff8000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[54,50]: + int 0fffffffffffffc000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[54,49]: + int 7ffffffffffffe000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[54,48]: + int 3fffffffffffff000000000000 <- ( ffffffffffffff , 000000000000 ) + +[54,47]: + int 1fffffffffffff800000000000 <- ( ffffffffffffff , 000000000000 ) + +[54,46]: + int 0fffffffffffffc00000000000 <- ( ffffffffffffff , 000000000000 ) + +[54,45]: + int 7ffffffffffffe00000000000 <- ( ffffffffffffff , 000000000000 ) + +[54,44]: + int 3fffffffffffff00000000000 <- ( ffffffffffffff , 00000000000 ) + +[54,43]: + int 1fffffffffffff80000000000 <- ( ffffffffffffff , 00000000000 ) + +[54,42]: + int 0fffffffffffffc0000000000 <- ( ffffffffffffff , 00000000000 ) + +[54,41]: + int 7ffffffffffffe0000000000 <- ( ffffffffffffff , 00000000000 ) + +[54,40]: + int 3fffffffffffff0000000000 <- ( ffffffffffffff , 0000000000 ) + +[54,39]: + int 1fffffffffffff8000000000 <- ( ffffffffffffff , 0000000000 ) + +[54,38]: + int 0fffffffffffffc000000000 <- ( ffffffffffffff , 0000000000 ) + +[54,37]: + int 7ffffffffffffe000000000 <- ( ffffffffffffff , 0000000000 ) + +[54,36]: + int 3fffffffffffff000000000 <- ( ffffffffffffff , 000000000 ) + +[54,35]: + int 1fffffffffffff800000000 <- ( ffffffffffffff , 000000000 ) + +[54,34]: + int 0fffffffffffffc00000000 <- ( ffffffffffffff , 000000000 ) + +[54,33]: + int 7ffffffffffffe00000000 <- ( ffffffffffffff , 000000000 ) + +[54,32]: + int 3fffffffffffff00000000 <- ( ffffffffffffff , 00000000 ) + +[54,31]: + int 1fffffffffffff80000000 <- ( ffffffffffffff , 00000000 ) + +[54,30]: + int 0fffffffffffffc0000000 <- ( ffffffffffffff , 00000000 ) + +[54,29]: + int 7ffffffffffffe0000000 <- ( ffffffffffffff , 00000000 ) + +[54,28]: + int 3fffffffffffff0000000 <- ( ffffffffffffff , 0000000 ) + +[54,27]: + int 1fffffffffffff8000000 <- ( ffffffffffffff , 0000000 ) + +[54,26]: + int 0fffffffffffffc000000 <- ( ffffffffffffff , 0000000 ) + +[54,25]: + int 7ffffffffffffe000000 <- ( ffffffffffffff , 0000000 ) + +[54,24]: + int 3fffffffffffff000000 <- ( ffffffffffffff , 000000 ) + +[54,23]: + int 1fffffffffffff800000 <- ( ffffffffffffff , 000000 ) + +[54,22]: + int 0fffffffffffffc00000 <- ( ffffffffffffff , 000000 ) + +[54,21]: + int 7ffffffffffffe00000 <- ( ffffffffffffff , 000000 ) + +[54,20]: + int 3fffffffffffff00000 <- ( ffffffffffffff , 00000 ) + +[54,19]: + int 1fffffffffffff80000 <- ( ffffffffffffff , 00000 ) + +[54,18]: + int 0fffffffffffffc0000 <- ( ffffffffffffff , 00000 ) + +[54,17]: + int 7ffffffffffffe0000 <- ( ffffffffffffff , 00000 ) + +[54,16]: + int 3fffffffffffff0000 <- ( ffffffffffffff , 0000 ) + +[54,15]: + int 1fffffffffffff8000 <- ( ffffffffffffff , 0000 ) + +[54,14]: + int 0fffffffffffffc000 <- ( ffffffffffffff , 0000 ) + +[54,13]: + int 7ffffffffffffe000 <- ( ffffffffffffff , 0000 ) + +[54,12]: + int 3fffffffffffff000 <- ( ffffffffffffff , 000 ) + +[54,11]: + int 1fffffffffffff800 <- ( ffffffffffffff , 000 ) + +[54,10]: + int 0fffffffffffffc00 <- ( ffffffffffffff , 000 ) + +[54,9]: + int 7ffffffffffffe00 <- ( ffffffffffffff , 000 ) + +[54,8]: + int 3fffffffffffff00 <- ( ffffffffffffff , 00 ) + +[54,7]: + int 1fffffffffffff80 <- ( ffffffffffffff , 00 ) + +[54,6]: + int 0fffffffffffffc0 <- ( ffffffffffffff , 00 ) + +[54,5]: + int 7ffffffffffffe0 <- ( ffffffffffffff , 00 ) + +[54,4]: + int 3fffffffffffff0 <- ( ffffffffffffff , 0 ) + +[54,3]: + int 1fffffffffffff8 <- ( ffffffffffffff , 0 ) + +[54,2]: + int 0fffffffffffffc <- ( ffffffffffffff , 0 ) + +[54,1]: + int 7ffffffffffffe <- ( ffffffffffffff , 0 ) + +[53,64]: + int 1fffffffffffff0000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[53,63]: + int 0fffffffffffff8000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[53,62]: + int 7ffffffffffffc000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[53,61]: + int 3ffffffffffffe000000000000000 <- ( ffffffffffffff , 0000000000000000 ) + +[53,60]: + int 1fffffffffffff000000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[53,59]: + int 0fffffffffffff800000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[53,58]: + int 7ffffffffffffc00000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[53,57]: + int 3ffffffffffffe00000000000000 <- ( ffffffffffffff , 000000000000000 ) + +[53,56]: + int 1fffffffffffff00000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[53,55]: + int 0fffffffffffff80000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[53,54]: + int 7ffffffffffffc0000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[53,53]: + int 3ffffffffffffe0000000000000 <- ( ffffffffffffff , 00000000000000 ) + +[53,52]: + int 1fffffffffffff0000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[53,51]: + int 0fffffffffffff8000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[53,50]: + int 7ffffffffffffc000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[53,49]: + int 3ffffffffffffe000000000000 <- ( ffffffffffffff , 0000000000000 ) + +[53,48]: + int 1fffffffffffff000000000000 <- ( ffffffffffffff , 000000000000 ) + +[53,47]: + int 0fffffffffffff800000000000 <- ( ffffffffffffff , 000000000000 ) + +[53,46]: + int 7ffffffffffffc00000000000 <- ( ffffffffffffff , 000000000000 ) + +[53,45]: + int 3ffffffffffffe00000000000 <- ( ffffffffffffff , 000000000000 ) + +[53,44]: + int 1fffffffffffff00000000000 <- ( ffffffffffffff , 00000000000 ) + +[53,43]: + int 0fffffffffffff80000000000 <- ( ffffffffffffff , 00000000000 ) + +[53,42]: + int 7ffffffffffffc0000000000 <- ( ffffffffffffff , 00000000000 ) + +[53,41]: + int 3ffffffffffffe0000000000 <- ( ffffffffffffff , 00000000000 ) + +[53,40]: + int 1fffffffffffff0000000000 <- ( ffffffffffffff , 0000000000 ) + +[53,39]: + int 0fffffffffffff8000000000 <- ( ffffffffffffff , 0000000000 ) + +[53,38]: + int 7ffffffffffffc000000000 <- ( ffffffffffffff , 0000000000 ) + +[53,37]: + int 3ffffffffffffe000000000 <- ( ffffffffffffff , 0000000000 ) + +[53,36]: + int 1fffffffffffff000000000 <- ( ffffffffffffff , 000000000 ) + +[53,35]: + int 0fffffffffffff800000000 <- ( ffffffffffffff , 000000000 ) + +[53,34]: + int 7ffffffffffffc00000000 <- ( ffffffffffffff , 000000000 ) + +[53,33]: + int 3ffffffffffffe00000000 <- ( ffffffffffffff , 000000000 ) + +[53,32]: + int 1fffffffffffff00000000 <- ( ffffffffffffff , 00000000 ) + +[53,31]: + int 0fffffffffffff80000000 <- ( ffffffffffffff , 00000000 ) + +[53,30]: + int 7ffffffffffffc0000000 <- ( ffffffffffffff , 00000000 ) + +[53,29]: + int 3ffffffffffffe0000000 <- ( ffffffffffffff , 00000000 ) + +[53,28]: + int 1fffffffffffff0000000 <- ( ffffffffffffff , 0000000 ) + +[53,27]: + int 0fffffffffffff8000000 <- ( ffffffffffffff , 0000000 ) + +[53,26]: + int 7ffffffffffffc000000 <- ( ffffffffffffff , 0000000 ) + +[53,25]: + int 3ffffffffffffe000000 <- ( ffffffffffffff , 0000000 ) + +[53,24]: + int 1fffffffffffff000000 <- ( ffffffffffffff , 000000 ) + +[53,23]: + int 0fffffffffffff800000 <- ( ffffffffffffff , 000000 ) + +[53,22]: + int 7ffffffffffffc00000 <- ( ffffffffffffff , 000000 ) + +[53,21]: + int 3ffffffffffffe00000 <- ( ffffffffffffff , 000000 ) + +[53,20]: + int 1fffffffffffff00000 <- ( ffffffffffffff , 00000 ) + +[53,19]: + int 0fffffffffffff80000 <- ( ffffffffffffff , 00000 ) + +[53,18]: + int 7ffffffffffffc0000 <- ( ffffffffffffff , 00000 ) + +[53,17]: + int 3ffffffffffffe0000 <- ( ffffffffffffff , 00000 ) + +[53,16]: + int 1fffffffffffff0000 <- ( ffffffffffffff , 0000 ) + +[53,15]: + int 0fffffffffffff8000 <- ( ffffffffffffff , 0000 ) + +[53,14]: + int 7ffffffffffffc000 <- ( ffffffffffffff , 0000 ) + +[53,13]: + int 3ffffffffffffe000 <- ( ffffffffffffff , 0000 ) + +[53,12]: + int 1fffffffffffff000 <- ( ffffffffffffff , 000 ) + +[53,11]: + int 0fffffffffffff800 <- ( ffffffffffffff , 000 ) + +[53,10]: + int 7ffffffffffffc00 <- ( ffffffffffffff , 000 ) + +[53,9]: + int 3ffffffffffffe00 <- ( ffffffffffffff , 000 ) + +[53,8]: + int 1fffffffffffff00 <- ( ffffffffffffff , 00 ) + +[53,7]: + int 0fffffffffffff80 <- ( ffffffffffffff , 00 ) + +[53,6]: + int 7ffffffffffffc0 <- ( ffffffffffffff , 00 ) + +[53,5]: + int 3ffffffffffffe0 <- ( ffffffffffffff , 00 ) + +[53,4]: + int 1fffffffffffff0 <- ( ffffffffffffff , 0 ) + +[53,3]: + int 0fffffffffffff8 <- ( ffffffffffffff , 0 ) + +[53,2]: + int 7ffffffffffffc <- ( ffffffffffffff , 0 ) + +[53,1]: + int 3ffffffffffffe <- ( ffffffffffffff , 0 ) + +[52,64]: + int 0fffffffffffff0000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[52,63]: + int 7ffffffffffff8000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[52,62]: + int 3ffffffffffffc000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[52,61]: + int 1ffffffffffffe000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[52,60]: + int 0fffffffffffff000000000000000 <- ( fffffffffffff , 000000000000000 ) + +[52,59]: + int 7ffffffffffff800000000000000 <- ( fffffffffffff , 000000000000000 ) + +[52,58]: + int 3ffffffffffffc00000000000000 <- ( fffffffffffff , 000000000000000 ) + +[52,57]: + int 1ffffffffffffe00000000000000 <- ( fffffffffffff , 000000000000000 ) + +[52,56]: + int 0fffffffffffff00000000000000 <- ( fffffffffffff , 00000000000000 ) + +[52,55]: + int 7ffffffffffff80000000000000 <- ( fffffffffffff , 00000000000000 ) + +[52,54]: + int 3ffffffffffffc0000000000000 <- ( fffffffffffff , 00000000000000 ) + +[52,53]: + int 1ffffffffffffe0000000000000 <- ( fffffffffffff , 00000000000000 ) + +[52,52]: + int 0fffffffffffff0000000000000 <- ( fffffffffffff , 0000000000000 ) + +[52,51]: + int 7ffffffffffff8000000000000 <- ( fffffffffffff , 0000000000000 ) + +[52,50]: + int 3ffffffffffffc000000000000 <- ( fffffffffffff , 0000000000000 ) + +[52,49]: + int 1ffffffffffffe000000000000 <- ( fffffffffffff , 0000000000000 ) + +[52,48]: + int 0fffffffffffff000000000000 <- ( fffffffffffff , 000000000000 ) + +[52,47]: + int 7ffffffffffff800000000000 <- ( fffffffffffff , 000000000000 ) + +[52,46]: + int 3ffffffffffffc00000000000 <- ( fffffffffffff , 000000000000 ) + +[52,45]: + int 1ffffffffffffe00000000000 <- ( fffffffffffff , 000000000000 ) + +[52,44]: + int 0fffffffffffff00000000000 <- ( fffffffffffff , 00000000000 ) + +[52,43]: + int 7ffffffffffff80000000000 <- ( fffffffffffff , 00000000000 ) + +[52,42]: + int 3ffffffffffffc0000000000 <- ( fffffffffffff , 00000000000 ) + +[52,41]: + int 1ffffffffffffe0000000000 <- ( fffffffffffff , 00000000000 ) + +[52,40]: + int 0fffffffffffff0000000000 <- ( fffffffffffff , 0000000000 ) + +[52,39]: + int 7ffffffffffff8000000000 <- ( fffffffffffff , 0000000000 ) + +[52,38]: + int 3ffffffffffffc000000000 <- ( fffffffffffff , 0000000000 ) + +[52,37]: + int 1ffffffffffffe000000000 <- ( fffffffffffff , 0000000000 ) + +[52,36]: + int 0fffffffffffff000000000 <- ( fffffffffffff , 000000000 ) + +[52,35]: + int 7ffffffffffff800000000 <- ( fffffffffffff , 000000000 ) + +[52,34]: + int 3ffffffffffffc00000000 <- ( fffffffffffff , 000000000 ) + +[52,33]: + int 1ffffffffffffe00000000 <- ( fffffffffffff , 000000000 ) + +[52,32]: + int 0fffffffffffff00000000 <- ( fffffffffffff , 00000000 ) + +[52,31]: + int 7ffffffffffff80000000 <- ( fffffffffffff , 00000000 ) + +[52,30]: + int 3ffffffffffffc0000000 <- ( fffffffffffff , 00000000 ) + +[52,29]: + int 1ffffffffffffe0000000 <- ( fffffffffffff , 00000000 ) + +[52,28]: + int 0fffffffffffff0000000 <- ( fffffffffffff , 0000000 ) + +[52,27]: + int 7ffffffffffff8000000 <- ( fffffffffffff , 0000000 ) + +[52,26]: + int 3ffffffffffffc000000 <- ( fffffffffffff , 0000000 ) + +[52,25]: + int 1ffffffffffffe000000 <- ( fffffffffffff , 0000000 ) + +[52,24]: + int 0fffffffffffff000000 <- ( fffffffffffff , 000000 ) + +[52,23]: + int 7ffffffffffff800000 <- ( fffffffffffff , 000000 ) + +[52,22]: + int 3ffffffffffffc00000 <- ( fffffffffffff , 000000 ) + +[52,21]: + int 1ffffffffffffe00000 <- ( fffffffffffff , 000000 ) + +[52,20]: + int 0fffffffffffff00000 <- ( fffffffffffff , 00000 ) + +[52,19]: + int 7ffffffffffff80000 <- ( fffffffffffff , 00000 ) + +[52,18]: + int 3ffffffffffffc0000 <- ( fffffffffffff , 00000 ) + +[52,17]: + int 1ffffffffffffe0000 <- ( fffffffffffff , 00000 ) + +[52,16]: + int 0fffffffffffff0000 <- ( fffffffffffff , 0000 ) + +[52,15]: + int 7ffffffffffff8000 <- ( fffffffffffff , 0000 ) + +[52,14]: + int 3ffffffffffffc000 <- ( fffffffffffff , 0000 ) + +[52,13]: + int 1ffffffffffffe000 <- ( fffffffffffff , 0000 ) + +[52,12]: + int 0fffffffffffff000 <- ( fffffffffffff , 000 ) + +[52,11]: + int 7ffffffffffff800 <- ( fffffffffffff , 000 ) + +[52,10]: + int 3ffffffffffffc00 <- ( fffffffffffff , 000 ) + +[52,9]: + int 1ffffffffffffe00 <- ( fffffffffffff , 000 ) + +[52,8]: + int 0fffffffffffff00 <- ( fffffffffffff , 00 ) + +[52,7]: + int 7ffffffffffff80 <- ( fffffffffffff , 00 ) + +[52,6]: + int 3ffffffffffffc0 <- ( fffffffffffff , 00 ) + +[52,5]: + int 1ffffffffffffe0 <- ( fffffffffffff , 00 ) + +[52,4]: + int 0fffffffffffff0 <- ( fffffffffffff , 0 ) + +[52,3]: + int 7ffffffffffff8 <- ( fffffffffffff , 0 ) + +[52,2]: + int 3ffffffffffffc <- ( fffffffffffff , 0 ) + +[52,1]: + int 1ffffffffffffe <- ( fffffffffffff , 0 ) + +[51,64]: + int 7ffffffffffff0000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[51,63]: + int 3ffffffffffff8000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[51,62]: + int 1ffffffffffffc000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[51,61]: + int 0ffffffffffffe000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[51,60]: + int 7ffffffffffff000000000000000 <- ( fffffffffffff , 000000000000000 ) + +[51,59]: + int 3ffffffffffff800000000000000 <- ( fffffffffffff , 000000000000000 ) + +[51,58]: + int 1ffffffffffffc00000000000000 <- ( fffffffffffff , 000000000000000 ) + +[51,57]: + int 0ffffffffffffe00000000000000 <- ( fffffffffffff , 000000000000000 ) + +[51,56]: + int 7ffffffffffff00000000000000 <- ( fffffffffffff , 00000000000000 ) + +[51,55]: + int 3ffffffffffff80000000000000 <- ( fffffffffffff , 00000000000000 ) + +[51,54]: + int 1ffffffffffffc0000000000000 <- ( fffffffffffff , 00000000000000 ) + +[51,53]: + int 0ffffffffffffe0000000000000 <- ( fffffffffffff , 00000000000000 ) + +[51,52]: + int 7ffffffffffff0000000000000 <- ( fffffffffffff , 0000000000000 ) + +[51,51]: + int 3ffffffffffff8000000000000 <- ( fffffffffffff , 0000000000000 ) + +[51,50]: + int 1ffffffffffffc000000000000 <- ( fffffffffffff , 0000000000000 ) + +[51,49]: + int 0ffffffffffffe000000000000 <- ( fffffffffffff , 0000000000000 ) + +[51,48]: + int 7ffffffffffff000000000000 <- ( fffffffffffff , 000000000000 ) + +[51,47]: + int 3ffffffffffff800000000000 <- ( fffffffffffff , 000000000000 ) + +[51,46]: + int 1ffffffffffffc00000000000 <- ( fffffffffffff , 000000000000 ) + +[51,45]: + int 0ffffffffffffe00000000000 <- ( fffffffffffff , 000000000000 ) + +[51,44]: + int 7ffffffffffff00000000000 <- ( fffffffffffff , 00000000000 ) + +[51,43]: + int 3ffffffffffff80000000000 <- ( fffffffffffff , 00000000000 ) + +[51,42]: + int 1ffffffffffffc0000000000 <- ( fffffffffffff , 00000000000 ) + +[51,41]: + int 0ffffffffffffe0000000000 <- ( fffffffffffff , 00000000000 ) + +[51,40]: + int 7ffffffffffff0000000000 <- ( fffffffffffff , 0000000000 ) + +[51,39]: + int 3ffffffffffff8000000000 <- ( fffffffffffff , 0000000000 ) + +[51,38]: + int 1ffffffffffffc000000000 <- ( fffffffffffff , 0000000000 ) + +[51,37]: + int 0ffffffffffffe000000000 <- ( fffffffffffff , 0000000000 ) + +[51,36]: + int 7ffffffffffff000000000 <- ( fffffffffffff , 000000000 ) + +[51,35]: + int 3ffffffffffff800000000 <- ( fffffffffffff , 000000000 ) + +[51,34]: + int 1ffffffffffffc00000000 <- ( fffffffffffff , 000000000 ) + +[51,33]: + int 0ffffffffffffe00000000 <- ( fffffffffffff , 000000000 ) + +[51,32]: + int 7ffffffffffff00000000 <- ( fffffffffffff , 00000000 ) + +[51,31]: + int 3ffffffffffff80000000 <- ( fffffffffffff , 00000000 ) + +[51,30]: + int 1ffffffffffffc0000000 <- ( fffffffffffff , 00000000 ) + +[51,29]: + int 0ffffffffffffe0000000 <- ( fffffffffffff , 00000000 ) + +[51,28]: + int 7ffffffffffff0000000 <- ( fffffffffffff , 0000000 ) + +[51,27]: + int 3ffffffffffff8000000 <- ( fffffffffffff , 0000000 ) + +[51,26]: + int 1ffffffffffffc000000 <- ( fffffffffffff , 0000000 ) + +[51,25]: + int 0ffffffffffffe000000 <- ( fffffffffffff , 0000000 ) + +[51,24]: + int 7ffffffffffff000000 <- ( fffffffffffff , 000000 ) + +[51,23]: + int 3ffffffffffff800000 <- ( fffffffffffff , 000000 ) + +[51,22]: + int 1ffffffffffffc00000 <- ( fffffffffffff , 000000 ) + +[51,21]: + int 0ffffffffffffe00000 <- ( fffffffffffff , 000000 ) + +[51,20]: + int 7ffffffffffff00000 <- ( fffffffffffff , 00000 ) + +[51,19]: + int 3ffffffffffff80000 <- ( fffffffffffff , 00000 ) + +[51,18]: + int 1ffffffffffffc0000 <- ( fffffffffffff , 00000 ) + +[51,17]: + int 0ffffffffffffe0000 <- ( fffffffffffff , 00000 ) + +[51,16]: + int 7ffffffffffff0000 <- ( fffffffffffff , 0000 ) + +[51,15]: + int 3ffffffffffff8000 <- ( fffffffffffff , 0000 ) + +[51,14]: + int 1ffffffffffffc000 <- ( fffffffffffff , 0000 ) + +[51,13]: + int 0ffffffffffffe000 <- ( fffffffffffff , 0000 ) + +[51,12]: + int 7ffffffffffff000 <- ( fffffffffffff , 000 ) + +[51,11]: + int 3ffffffffffff800 <- ( fffffffffffff , 000 ) + +[51,10]: + int 1ffffffffffffc00 <- ( fffffffffffff , 000 ) + +[51,9]: + int 0ffffffffffffe00 <- ( fffffffffffff , 000 ) + +[51,8]: + int 7ffffffffffff00 <- ( fffffffffffff , 00 ) + +[51,7]: + int 3ffffffffffff80 <- ( fffffffffffff , 00 ) + +[51,6]: + int 1ffffffffffffc0 <- ( fffffffffffff , 00 ) + +[51,5]: + int 0ffffffffffffe0 <- ( fffffffffffff , 00 ) + +[51,4]: + int 7ffffffffffff0 <- ( fffffffffffff , 0 ) + +[51,3]: + int 3ffffffffffff8 <- ( fffffffffffff , 0 ) + +[51,2]: + int 1ffffffffffffc <- ( fffffffffffff , 0 ) + +[51,1]: + int 0ffffffffffffe <- ( fffffffffffff , 0 ) + +[50,64]: + int 3ffffffffffff0000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[50,63]: + int 1ffffffffffff8000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[50,62]: + int 0ffffffffffffc000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[50,61]: + int 7fffffffffffe000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[50,60]: + int 3ffffffffffff000000000000000 <- ( fffffffffffff , 000000000000000 ) + +[50,59]: + int 1ffffffffffff800000000000000 <- ( fffffffffffff , 000000000000000 ) + +[50,58]: + int 0ffffffffffffc00000000000000 <- ( fffffffffffff , 000000000000000 ) + +[50,57]: + int 7fffffffffffe00000000000000 <- ( fffffffffffff , 000000000000000 ) + +[50,56]: + int 3ffffffffffff00000000000000 <- ( fffffffffffff , 00000000000000 ) + +[50,55]: + int 1ffffffffffff80000000000000 <- ( fffffffffffff , 00000000000000 ) + +[50,54]: + int 0ffffffffffffc0000000000000 <- ( fffffffffffff , 00000000000000 ) + +[50,53]: + int 7fffffffffffe0000000000000 <- ( fffffffffffff , 00000000000000 ) + +[50,52]: + int 3ffffffffffff0000000000000 <- ( fffffffffffff , 0000000000000 ) + +[50,51]: + int 1ffffffffffff8000000000000 <- ( fffffffffffff , 0000000000000 ) + +[50,50]: + int 0ffffffffffffc000000000000 <- ( fffffffffffff , 0000000000000 ) + +[50,49]: + int 7fffffffffffe000000000000 <- ( fffffffffffff , 0000000000000 ) + +[50,48]: + int 3ffffffffffff000000000000 <- ( fffffffffffff , 000000000000 ) + +[50,47]: + int 1ffffffffffff800000000000 <- ( fffffffffffff , 000000000000 ) + +[50,46]: + int 0ffffffffffffc00000000000 <- ( fffffffffffff , 000000000000 ) + +[50,45]: + int 7fffffffffffe00000000000 <- ( fffffffffffff , 000000000000 ) + +[50,44]: + int 3ffffffffffff00000000000 <- ( fffffffffffff , 00000000000 ) + +[50,43]: + int 1ffffffffffff80000000000 <- ( fffffffffffff , 00000000000 ) + +[50,42]: + int 0ffffffffffffc0000000000 <- ( fffffffffffff , 00000000000 ) + +[50,41]: + int 7fffffffffffe0000000000 <- ( fffffffffffff , 00000000000 ) + +[50,40]: + int 3ffffffffffff0000000000 <- ( fffffffffffff , 0000000000 ) + +[50,39]: + int 1ffffffffffff8000000000 <- ( fffffffffffff , 0000000000 ) + +[50,38]: + int 0ffffffffffffc000000000 <- ( fffffffffffff , 0000000000 ) + +[50,37]: + int 7fffffffffffe000000000 <- ( fffffffffffff , 0000000000 ) + +[50,36]: + int 3ffffffffffff000000000 <- ( fffffffffffff , 000000000 ) + +[50,35]: + int 1ffffffffffff800000000 <- ( fffffffffffff , 000000000 ) + +[50,34]: + int 0ffffffffffffc00000000 <- ( fffffffffffff , 000000000 ) + +[50,33]: + int 7fffffffffffe00000000 <- ( fffffffffffff , 000000000 ) + +[50,32]: + int 3ffffffffffff00000000 <- ( fffffffffffff , 00000000 ) + +[50,31]: + int 1ffffffffffff80000000 <- ( fffffffffffff , 00000000 ) + +[50,30]: + int 0ffffffffffffc0000000 <- ( fffffffffffff , 00000000 ) + +[50,29]: + int 7fffffffffffe0000000 <- ( fffffffffffff , 00000000 ) + +[50,28]: + int 3ffffffffffff0000000 <- ( fffffffffffff , 0000000 ) + +[50,27]: + int 1ffffffffffff8000000 <- ( fffffffffffff , 0000000 ) + +[50,26]: + int 0ffffffffffffc000000 <- ( fffffffffffff , 0000000 ) + +[50,25]: + int 7fffffffffffe000000 <- ( fffffffffffff , 0000000 ) + +[50,24]: + int 3ffffffffffff000000 <- ( fffffffffffff , 000000 ) + +[50,23]: + int 1ffffffffffff800000 <- ( fffffffffffff , 000000 ) + +[50,22]: + int 0ffffffffffffc00000 <- ( fffffffffffff , 000000 ) + +[50,21]: + int 7fffffffffffe00000 <- ( fffffffffffff , 000000 ) + +[50,20]: + int 3ffffffffffff00000 <- ( fffffffffffff , 00000 ) + +[50,19]: + int 1ffffffffffff80000 <- ( fffffffffffff , 00000 ) + +[50,18]: + int 0ffffffffffffc0000 <- ( fffffffffffff , 00000 ) + +[50,17]: + int 7fffffffffffe0000 <- ( fffffffffffff , 00000 ) + +[50,16]: + int 3ffffffffffff0000 <- ( fffffffffffff , 0000 ) + +[50,15]: + int 1ffffffffffff8000 <- ( fffffffffffff , 0000 ) + +[50,14]: + int 0ffffffffffffc000 <- ( fffffffffffff , 0000 ) + +[50,13]: + int 7fffffffffffe000 <- ( fffffffffffff , 0000 ) + +[50,12]: + int 3ffffffffffff000 <- ( fffffffffffff , 000 ) + +[50,11]: + int 1ffffffffffff800 <- ( fffffffffffff , 000 ) + +[50,10]: + int 0ffffffffffffc00 <- ( fffffffffffff , 000 ) + +[50,9]: + int 7fffffffffffe00 <- ( fffffffffffff , 000 ) + +[50,8]: + int 3ffffffffffff00 <- ( fffffffffffff , 00 ) + +[50,7]: + int 1ffffffffffff80 <- ( fffffffffffff , 00 ) + +[50,6]: + int 0ffffffffffffc0 <- ( fffffffffffff , 00 ) + +[50,5]: + int 7fffffffffffe0 <- ( fffffffffffff , 00 ) + +[50,4]: + int 3ffffffffffff0 <- ( fffffffffffff , 0 ) + +[50,3]: + int 1ffffffffffff8 <- ( fffffffffffff , 0 ) + +[50,2]: + int 0ffffffffffffc <- ( fffffffffffff , 0 ) + +[50,1]: + int 7fffffffffffe <- ( fffffffffffff , 0 ) + +[49,64]: + int 1ffffffffffff0000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[49,63]: + int 0ffffffffffff8000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[49,62]: + int 7fffffffffffc000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[49,61]: + int 3fffffffffffe000000000000000 <- ( fffffffffffff , 0000000000000000 ) + +[49,60]: + int 1ffffffffffff000000000000000 <- ( fffffffffffff , 000000000000000 ) + +[49,59]: + int 0ffffffffffff800000000000000 <- ( fffffffffffff , 000000000000000 ) + +[49,58]: + int 7fffffffffffc00000000000000 <- ( fffffffffffff , 000000000000000 ) + +[49,57]: + int 3fffffffffffe00000000000000 <- ( fffffffffffff , 000000000000000 ) + +[49,56]: + int 1ffffffffffff00000000000000 <- ( fffffffffffff , 00000000000000 ) + +[49,55]: + int 0ffffffffffff80000000000000 <- ( fffffffffffff , 00000000000000 ) + +[49,54]: + int 7fffffffffffc0000000000000 <- ( fffffffffffff , 00000000000000 ) + +[49,53]: + int 3fffffffffffe0000000000000 <- ( fffffffffffff , 00000000000000 ) + +[49,52]: + int 1ffffffffffff0000000000000 <- ( fffffffffffff , 0000000000000 ) + +[49,51]: + int 0ffffffffffff8000000000000 <- ( fffffffffffff , 0000000000000 ) + +[49,50]: + int 7fffffffffffc000000000000 <- ( fffffffffffff , 0000000000000 ) + +[49,49]: + int 3fffffffffffe000000000000 <- ( fffffffffffff , 0000000000000 ) + +[49,48]: + int 1ffffffffffff000000000000 <- ( fffffffffffff , 000000000000 ) + +[49,47]: + int 0ffffffffffff800000000000 <- ( fffffffffffff , 000000000000 ) + +[49,46]: + int 7fffffffffffc00000000000 <- ( fffffffffffff , 000000000000 ) + +[49,45]: + int 3fffffffffffe00000000000 <- ( fffffffffffff , 000000000000 ) + +[49,44]: + int 1ffffffffffff00000000000 <- ( fffffffffffff , 00000000000 ) + +[49,43]: + int 0ffffffffffff80000000000 <- ( fffffffffffff , 00000000000 ) + +[49,42]: + int 7fffffffffffc0000000000 <- ( fffffffffffff , 00000000000 ) + +[49,41]: + int 3fffffffffffe0000000000 <- ( fffffffffffff , 00000000000 ) + +[49,40]: + int 1ffffffffffff0000000000 <- ( fffffffffffff , 0000000000 ) + +[49,39]: + int 0ffffffffffff8000000000 <- ( fffffffffffff , 0000000000 ) + +[49,38]: + int 7fffffffffffc000000000 <- ( fffffffffffff , 0000000000 ) + +[49,37]: + int 3fffffffffffe000000000 <- ( fffffffffffff , 0000000000 ) + +[49,36]: + int 1ffffffffffff000000000 <- ( fffffffffffff , 000000000 ) + +[49,35]: + int 0ffffffffffff800000000 <- ( fffffffffffff , 000000000 ) + +[49,34]: + int 7fffffffffffc00000000 <- ( fffffffffffff , 000000000 ) + +[49,33]: + int 3fffffffffffe00000000 <- ( fffffffffffff , 000000000 ) + +[49,32]: + int 1ffffffffffff00000000 <- ( fffffffffffff , 00000000 ) + +[49,31]: + int 0ffffffffffff80000000 <- ( fffffffffffff , 00000000 ) + +[49,30]: + int 7fffffffffffc0000000 <- ( fffffffffffff , 00000000 ) + +[49,29]: + int 3fffffffffffe0000000 <- ( fffffffffffff , 00000000 ) + +[49,28]: + int 1ffffffffffff0000000 <- ( fffffffffffff , 0000000 ) + +[49,27]: + int 0ffffffffffff8000000 <- ( fffffffffffff , 0000000 ) + +[49,26]: + int 7fffffffffffc000000 <- ( fffffffffffff , 0000000 ) + +[49,25]: + int 3fffffffffffe000000 <- ( fffffffffffff , 0000000 ) + +[49,24]: + int 1ffffffffffff000000 <- ( fffffffffffff , 000000 ) + +[49,23]: + int 0ffffffffffff800000 <- ( fffffffffffff , 000000 ) + +[49,22]: + int 7fffffffffffc00000 <- ( fffffffffffff , 000000 ) + +[49,21]: + int 3fffffffffffe00000 <- ( fffffffffffff , 000000 ) + +[49,20]: + int 1ffffffffffff00000 <- ( fffffffffffff , 00000 ) + +[49,19]: + int 0ffffffffffff80000 <- ( fffffffffffff , 00000 ) + +[49,18]: + int 7fffffffffffc0000 <- ( fffffffffffff , 00000 ) + +[49,17]: + int 3fffffffffffe0000 <- ( fffffffffffff , 00000 ) + +[49,16]: + int 1ffffffffffff0000 <- ( fffffffffffff , 0000 ) + +[49,15]: + int 0ffffffffffff8000 <- ( fffffffffffff , 0000 ) + +[49,14]: + int 7fffffffffffc000 <- ( fffffffffffff , 0000 ) + +[49,13]: + int 3fffffffffffe000 <- ( fffffffffffff , 0000 ) + +[49,12]: + int 1ffffffffffff000 <- ( fffffffffffff , 000 ) + +[49,11]: + int 0ffffffffffff800 <- ( fffffffffffff , 000 ) + +[49,10]: + int 7fffffffffffc00 <- ( fffffffffffff , 000 ) + +[49,9]: + int 3fffffffffffe00 <- ( fffffffffffff , 000 ) + +[49,8]: + int 1ffffffffffff00 <- ( fffffffffffff , 00 ) + +[49,7]: + int 0ffffffffffff80 <- ( fffffffffffff , 00 ) + +[49,6]: + int 7fffffffffffc0 <- ( fffffffffffff , 00 ) + +[49,5]: + int 3fffffffffffe0 <- ( fffffffffffff , 00 ) + +[49,4]: + int 1ffffffffffff0 <- ( fffffffffffff , 0 ) + +[49,3]: + int 0ffffffffffff8 <- ( fffffffffffff , 0 ) + +[49,2]: + int 7fffffffffffc <- ( fffffffffffff , 0 ) + +[49,1]: + int 3fffffffffffe <- ( fffffffffffff , 0 ) + +[48,64]: + int 0ffffffffffff0000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[48,63]: + int 7fffffffffff8000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[48,62]: + int 3fffffffffffc000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[48,61]: + int 1fffffffffffe000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[48,60]: + int 0ffffffffffff000000000000000 <- ( ffffffffffff , 000000000000000 ) + +[48,59]: + int 7fffffffffff800000000000000 <- ( ffffffffffff , 000000000000000 ) + +[48,58]: + int 3fffffffffffc00000000000000 <- ( ffffffffffff , 000000000000000 ) + +[48,57]: + int 1fffffffffffe00000000000000 <- ( ffffffffffff , 000000000000000 ) + +[48,56]: + int 0ffffffffffff00000000000000 <- ( ffffffffffff , 00000000000000 ) + +[48,55]: + int 7fffffffffff80000000000000 <- ( ffffffffffff , 00000000000000 ) + +[48,54]: + int 3fffffffffffc0000000000000 <- ( ffffffffffff , 00000000000000 ) + +[48,53]: + int 1fffffffffffe0000000000000 <- ( ffffffffffff , 00000000000000 ) + +[48,52]: + int 0ffffffffffff0000000000000 <- ( ffffffffffff , 0000000000000 ) + +[48,51]: + int 7fffffffffff8000000000000 <- ( ffffffffffff , 0000000000000 ) + +[48,50]: + int 3fffffffffffc000000000000 <- ( ffffffffffff , 0000000000000 ) + +[48,49]: + int 1fffffffffffe000000000000 <- ( ffffffffffff , 0000000000000 ) + +[48,48]: + int 0ffffffffffff000000000000 <- ( ffffffffffff , 000000000000 ) + +[48,47]: + int 7fffffffffff800000000000 <- ( ffffffffffff , 000000000000 ) + +[48,46]: + int 3fffffffffffc00000000000 <- ( ffffffffffff , 000000000000 ) + +[48,45]: + int 1fffffffffffe00000000000 <- ( ffffffffffff , 000000000000 ) + +[48,44]: + int 0ffffffffffff00000000000 <- ( ffffffffffff , 00000000000 ) + +[48,43]: + int 7fffffffffff80000000000 <- ( ffffffffffff , 00000000000 ) + +[48,42]: + int 3fffffffffffc0000000000 <- ( ffffffffffff , 00000000000 ) + +[48,41]: + int 1fffffffffffe0000000000 <- ( ffffffffffff , 00000000000 ) + +[48,40]: + int 0ffffffffffff0000000000 <- ( ffffffffffff , 0000000000 ) + +[48,39]: + int 7fffffffffff8000000000 <- ( ffffffffffff , 0000000000 ) + +[48,38]: + int 3fffffffffffc000000000 <- ( ffffffffffff , 0000000000 ) + +[48,37]: + int 1fffffffffffe000000000 <- ( ffffffffffff , 0000000000 ) + +[48,36]: + int 0ffffffffffff000000000 <- ( ffffffffffff , 000000000 ) + +[48,35]: + int 7fffffffffff800000000 <- ( ffffffffffff , 000000000 ) + +[48,34]: + int 3fffffffffffc00000000 <- ( ffffffffffff , 000000000 ) + +[48,33]: + int 1fffffffffffe00000000 <- ( ffffffffffff , 000000000 ) + +[48,32]: + int 0ffffffffffff00000000 <- ( ffffffffffff , 00000000 ) + +[48,31]: + int 7fffffffffff80000000 <- ( ffffffffffff , 00000000 ) + +[48,30]: + int 3fffffffffffc0000000 <- ( ffffffffffff , 00000000 ) + +[48,29]: + int 1fffffffffffe0000000 <- ( ffffffffffff , 00000000 ) + +[48,28]: + int 0ffffffffffff0000000 <- ( ffffffffffff , 0000000 ) + +[48,27]: + int 7fffffffffff8000000 <- ( ffffffffffff , 0000000 ) + +[48,26]: + int 3fffffffffffc000000 <- ( ffffffffffff , 0000000 ) + +[48,25]: + int 1fffffffffffe000000 <- ( ffffffffffff , 0000000 ) + +[48,24]: + int 0ffffffffffff000000 <- ( ffffffffffff , 000000 ) + +[48,23]: + int 7fffffffffff800000 <- ( ffffffffffff , 000000 ) + +[48,22]: + int 3fffffffffffc00000 <- ( ffffffffffff , 000000 ) + +[48,21]: + int 1fffffffffffe00000 <- ( ffffffffffff , 000000 ) + +[48,20]: + int 0ffffffffffff00000 <- ( ffffffffffff , 00000 ) + +[48,19]: + int 7fffffffffff80000 <- ( ffffffffffff , 00000 ) + +[48,18]: + int 3fffffffffffc0000 <- ( ffffffffffff , 00000 ) + +[48,17]: + int 1fffffffffffe0000 <- ( ffffffffffff , 00000 ) + +[48,16]: + int 0ffffffffffff0000 <- ( ffffffffffff , 0000 ) + +[48,15]: + int 7fffffffffff8000 <- ( ffffffffffff , 0000 ) + +[48,14]: + int 3fffffffffffc000 <- ( ffffffffffff , 0000 ) + +[48,13]: + int 1fffffffffffe000 <- ( ffffffffffff , 0000 ) + +[48,12]: + int 0ffffffffffff000 <- ( ffffffffffff , 000 ) + +[48,11]: + int 7fffffffffff800 <- ( ffffffffffff , 000 ) + +[48,10]: + int 3fffffffffffc00 <- ( ffffffffffff , 000 ) + +[48,9]: + int 1fffffffffffe00 <- ( ffffffffffff , 000 ) + +[48,8]: + int 0ffffffffffff00 <- ( ffffffffffff , 00 ) + +[48,7]: + int 7fffffffffff80 <- ( ffffffffffff , 00 ) + +[48,6]: + int 3fffffffffffc0 <- ( ffffffffffff , 00 ) + +[48,5]: + int 1fffffffffffe0 <- ( ffffffffffff , 00 ) + +[48,4]: + int 0ffffffffffff0 <- ( ffffffffffff , 0 ) + +[48,3]: + int 7fffffffffff8 <- ( ffffffffffff , 0 ) + +[48,2]: + int 3fffffffffffc <- ( ffffffffffff , 0 ) + +[48,1]: + int 1fffffffffffe <- ( ffffffffffff , 0 ) + +[47,64]: + int 7fffffffffff0000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[47,63]: + int 3fffffffffff8000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[47,62]: + int 1fffffffffffc000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[47,61]: + int 0fffffffffffe000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[47,60]: + int 7fffffffffff000000000000000 <- ( ffffffffffff , 000000000000000 ) + +[47,59]: + int 3fffffffffff800000000000000 <- ( ffffffffffff , 000000000000000 ) + +[47,58]: + int 1fffffffffffc00000000000000 <- ( ffffffffffff , 000000000000000 ) + +[47,57]: + int 0fffffffffffe00000000000000 <- ( ffffffffffff , 000000000000000 ) + +[47,56]: + int 7fffffffffff00000000000000 <- ( ffffffffffff , 00000000000000 ) + +[47,55]: + int 3fffffffffff80000000000000 <- ( ffffffffffff , 00000000000000 ) + +[47,54]: + int 1fffffffffffc0000000000000 <- ( ffffffffffff , 00000000000000 ) + +[47,53]: + int 0fffffffffffe0000000000000 <- ( ffffffffffff , 00000000000000 ) + +[47,52]: + int 7fffffffffff0000000000000 <- ( ffffffffffff , 0000000000000 ) + +[47,51]: + int 3fffffffffff8000000000000 <- ( ffffffffffff , 0000000000000 ) + +[47,50]: + int 1fffffffffffc000000000000 <- ( ffffffffffff , 0000000000000 ) + +[47,49]: + int 0fffffffffffe000000000000 <- ( ffffffffffff , 0000000000000 ) + +[47,48]: + int 7fffffffffff000000000000 <- ( ffffffffffff , 000000000000 ) + +[47,47]: + int 3fffffffffff800000000000 <- ( ffffffffffff , 000000000000 ) + +[47,46]: + int 1fffffffffffc00000000000 <- ( ffffffffffff , 000000000000 ) + +[47,45]: + int 0fffffffffffe00000000000 <- ( ffffffffffff , 000000000000 ) + +[47,44]: + int 7fffffffffff00000000000 <- ( ffffffffffff , 00000000000 ) + +[47,43]: + int 3fffffffffff80000000000 <- ( ffffffffffff , 00000000000 ) + +[47,42]: + int 1fffffffffffc0000000000 <- ( ffffffffffff , 00000000000 ) + +[47,41]: + int 0fffffffffffe0000000000 <- ( ffffffffffff , 00000000000 ) + +[47,40]: + int 7fffffffffff0000000000 <- ( ffffffffffff , 0000000000 ) + +[47,39]: + int 3fffffffffff8000000000 <- ( ffffffffffff , 0000000000 ) + +[47,38]: + int 1fffffffffffc000000000 <- ( ffffffffffff , 0000000000 ) + +[47,37]: + int 0fffffffffffe000000000 <- ( ffffffffffff , 0000000000 ) + +[47,36]: + int 7fffffffffff000000000 <- ( ffffffffffff , 000000000 ) + +[47,35]: + int 3fffffffffff800000000 <- ( ffffffffffff , 000000000 ) + +[47,34]: + int 1fffffffffffc00000000 <- ( ffffffffffff , 000000000 ) + +[47,33]: + int 0fffffffffffe00000000 <- ( ffffffffffff , 000000000 ) + +[47,32]: + int 7fffffffffff00000000 <- ( ffffffffffff , 00000000 ) + +[47,31]: + int 3fffffffffff80000000 <- ( ffffffffffff , 00000000 ) + +[47,30]: + int 1fffffffffffc0000000 <- ( ffffffffffff , 00000000 ) + +[47,29]: + int 0fffffffffffe0000000 <- ( ffffffffffff , 00000000 ) + +[47,28]: + int 7fffffffffff0000000 <- ( ffffffffffff , 0000000 ) + +[47,27]: + int 3fffffffffff8000000 <- ( ffffffffffff , 0000000 ) + +[47,26]: + int 1fffffffffffc000000 <- ( ffffffffffff , 0000000 ) + +[47,25]: + int 0fffffffffffe000000 <- ( ffffffffffff , 0000000 ) + +[47,24]: + int 7fffffffffff000000 <- ( ffffffffffff , 000000 ) + +[47,23]: + int 3fffffffffff800000 <- ( ffffffffffff , 000000 ) + +[47,22]: + int 1fffffffffffc00000 <- ( ffffffffffff , 000000 ) + +[47,21]: + int 0fffffffffffe00000 <- ( ffffffffffff , 000000 ) + +[47,20]: + int 7fffffffffff00000 <- ( ffffffffffff , 00000 ) + +[47,19]: + int 3fffffffffff80000 <- ( ffffffffffff , 00000 ) + +[47,18]: + int 1fffffffffffc0000 <- ( ffffffffffff , 00000 ) + +[47,17]: + int 0fffffffffffe0000 <- ( ffffffffffff , 00000 ) + +[47,16]: + int 7fffffffffff0000 <- ( ffffffffffff , 0000 ) + +[47,15]: + int 3fffffffffff8000 <- ( ffffffffffff , 0000 ) + +[47,14]: + int 1fffffffffffc000 <- ( ffffffffffff , 0000 ) + +[47,13]: + int 0fffffffffffe000 <- ( ffffffffffff , 0000 ) + +[47,12]: + int 7fffffffffff000 <- ( ffffffffffff , 000 ) + +[47,11]: + int 3fffffffffff800 <- ( ffffffffffff , 000 ) + +[47,10]: + int 1fffffffffffc00 <- ( ffffffffffff , 000 ) + +[47,9]: + int 0fffffffffffe00 <- ( ffffffffffff , 000 ) + +[47,8]: + int 7fffffffffff00 <- ( ffffffffffff , 00 ) + +[47,7]: + int 3fffffffffff80 <- ( ffffffffffff , 00 ) + +[47,6]: + int 1fffffffffffc0 <- ( ffffffffffff , 00 ) + +[47,5]: + int 0fffffffffffe0 <- ( ffffffffffff , 00 ) + +[47,4]: + int 7fffffffffff0 <- ( ffffffffffff , 0 ) + +[47,3]: + int 3fffffffffff8 <- ( ffffffffffff , 0 ) + +[47,2]: + int 1fffffffffffc <- ( ffffffffffff , 0 ) + +[47,1]: + int 0fffffffffffe <- ( ffffffffffff , 0 ) + +[46,64]: + int 3fffffffffff0000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[46,63]: + int 1fffffffffff8000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[46,62]: + int 0fffffffffffc000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[46,61]: + int 7ffffffffffe000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[46,60]: + int 3fffffffffff000000000000000 <- ( ffffffffffff , 000000000000000 ) + +[46,59]: + int 1fffffffffff800000000000000 <- ( ffffffffffff , 000000000000000 ) + +[46,58]: + int 0fffffffffffc00000000000000 <- ( ffffffffffff , 000000000000000 ) + +[46,57]: + int 7ffffffffffe00000000000000 <- ( ffffffffffff , 000000000000000 ) + +[46,56]: + int 3fffffffffff00000000000000 <- ( ffffffffffff , 00000000000000 ) + +[46,55]: + int 1fffffffffff80000000000000 <- ( ffffffffffff , 00000000000000 ) + +[46,54]: + int 0fffffffffffc0000000000000 <- ( ffffffffffff , 00000000000000 ) + +[46,53]: + int 7ffffffffffe0000000000000 <- ( ffffffffffff , 00000000000000 ) + +[46,52]: + int 3fffffffffff0000000000000 <- ( ffffffffffff , 0000000000000 ) + +[46,51]: + int 1fffffffffff8000000000000 <- ( ffffffffffff , 0000000000000 ) + +[46,50]: + int 0fffffffffffc000000000000 <- ( ffffffffffff , 0000000000000 ) + +[46,49]: + int 7ffffffffffe000000000000 <- ( ffffffffffff , 0000000000000 ) + +[46,48]: + int 3fffffffffff000000000000 <- ( ffffffffffff , 000000000000 ) + +[46,47]: + int 1fffffffffff800000000000 <- ( ffffffffffff , 000000000000 ) + +[46,46]: + int 0fffffffffffc00000000000 <- ( ffffffffffff , 000000000000 ) + +[46,45]: + int 7ffffffffffe00000000000 <- ( ffffffffffff , 000000000000 ) + +[46,44]: + int 3fffffffffff00000000000 <- ( ffffffffffff , 00000000000 ) + +[46,43]: + int 1fffffffffff80000000000 <- ( ffffffffffff , 00000000000 ) + +[46,42]: + int 0fffffffffffc0000000000 <- ( ffffffffffff , 00000000000 ) + +[46,41]: + int 7ffffffffffe0000000000 <- ( ffffffffffff , 00000000000 ) + +[46,40]: + int 3fffffffffff0000000000 <- ( ffffffffffff , 0000000000 ) + +[46,39]: + int 1fffffffffff8000000000 <- ( ffffffffffff , 0000000000 ) + +[46,38]: + int 0fffffffffffc000000000 <- ( ffffffffffff , 0000000000 ) + +[46,37]: + int 7ffffffffffe000000000 <- ( ffffffffffff , 0000000000 ) + +[46,36]: + int 3fffffffffff000000000 <- ( ffffffffffff , 000000000 ) + +[46,35]: + int 1fffffffffff800000000 <- ( ffffffffffff , 000000000 ) + +[46,34]: + int 0fffffffffffc00000000 <- ( ffffffffffff , 000000000 ) + +[46,33]: + int 7ffffffffffe00000000 <- ( ffffffffffff , 000000000 ) + +[46,32]: + int 3fffffffffff00000000 <- ( ffffffffffff , 00000000 ) + +[46,31]: + int 1fffffffffff80000000 <- ( ffffffffffff , 00000000 ) + +[46,30]: + int 0fffffffffffc0000000 <- ( ffffffffffff , 00000000 ) + +[46,29]: + int 7ffffffffffe0000000 <- ( ffffffffffff , 00000000 ) + +[46,28]: + int 3fffffffffff0000000 <- ( ffffffffffff , 0000000 ) + +[46,27]: + int 1fffffffffff8000000 <- ( ffffffffffff , 0000000 ) + +[46,26]: + int 0fffffffffffc000000 <- ( ffffffffffff , 0000000 ) + +[46,25]: + int 7ffffffffffe000000 <- ( ffffffffffff , 0000000 ) + +[46,24]: + int 3fffffffffff000000 <- ( ffffffffffff , 000000 ) + +[46,23]: + int 1fffffffffff800000 <- ( ffffffffffff , 000000 ) + +[46,22]: + int 0fffffffffffc00000 <- ( ffffffffffff , 000000 ) + +[46,21]: + int 7ffffffffffe00000 <- ( ffffffffffff , 000000 ) + +[46,20]: + int 3fffffffffff00000 <- ( ffffffffffff , 00000 ) + +[46,19]: + int 1fffffffffff80000 <- ( ffffffffffff , 00000 ) + +[46,18]: + int 0fffffffffffc0000 <- ( ffffffffffff , 00000 ) + +[46,17]: + int 7ffffffffffe0000 <- ( ffffffffffff , 00000 ) + +[46,16]: + int 3fffffffffff0000 <- ( ffffffffffff , 0000 ) + +[46,15]: + int 1fffffffffff8000 <- ( ffffffffffff , 0000 ) + +[46,14]: + int 0fffffffffffc000 <- ( ffffffffffff , 0000 ) + +[46,13]: + int 7ffffffffffe000 <- ( ffffffffffff , 0000 ) + +[46,12]: + int 3fffffffffff000 <- ( ffffffffffff , 000 ) + +[46,11]: + int 1fffffffffff800 <- ( ffffffffffff , 000 ) + +[46,10]: + int 0fffffffffffc00 <- ( ffffffffffff , 000 ) + +[46,9]: + int 7ffffffffffe00 <- ( ffffffffffff , 000 ) + +[46,8]: + int 3fffffffffff00 <- ( ffffffffffff , 00 ) + +[46,7]: + int 1fffffffffff80 <- ( ffffffffffff , 00 ) + +[46,6]: + int 0fffffffffffc0 <- ( ffffffffffff , 00 ) + +[46,5]: + int 7ffffffffffe0 <- ( ffffffffffff , 00 ) + +[46,4]: + int 3fffffffffff0 <- ( ffffffffffff , 0 ) + +[46,3]: + int 1fffffffffff8 <- ( ffffffffffff , 0 ) + +[46,2]: + int 0fffffffffffc <- ( ffffffffffff , 0 ) + +[46,1]: + int 7ffffffffffe <- ( ffffffffffff , 0 ) + +[45,64]: + int 1fffffffffff0000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[45,63]: + int 0fffffffffff8000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[45,62]: + int 7ffffffffffc000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[45,61]: + int 3ffffffffffe000000000000000 <- ( ffffffffffff , 0000000000000000 ) + +[45,60]: + int 1fffffffffff000000000000000 <- ( ffffffffffff , 000000000000000 ) + +[45,59]: + int 0fffffffffff800000000000000 <- ( ffffffffffff , 000000000000000 ) + +[45,58]: + int 7ffffffffffc00000000000000 <- ( ffffffffffff , 000000000000000 ) + +[45,57]: + int 3ffffffffffe00000000000000 <- ( ffffffffffff , 000000000000000 ) + +[45,56]: + int 1fffffffffff00000000000000 <- ( ffffffffffff , 00000000000000 ) + +[45,55]: + int 0fffffffffff80000000000000 <- ( ffffffffffff , 00000000000000 ) + +[45,54]: + int 7ffffffffffc0000000000000 <- ( ffffffffffff , 00000000000000 ) + +[45,53]: + int 3ffffffffffe0000000000000 <- ( ffffffffffff , 00000000000000 ) + +[45,52]: + int 1fffffffffff0000000000000 <- ( ffffffffffff , 0000000000000 ) + +[45,51]: + int 0fffffffffff8000000000000 <- ( ffffffffffff , 0000000000000 ) + +[45,50]: + int 7ffffffffffc000000000000 <- ( ffffffffffff , 0000000000000 ) + +[45,49]: + int 3ffffffffffe000000000000 <- ( ffffffffffff , 0000000000000 ) + +[45,48]: + int 1fffffffffff000000000000 <- ( ffffffffffff , 000000000000 ) + +[45,47]: + int 0fffffffffff800000000000 <- ( ffffffffffff , 000000000000 ) + +[45,46]: + int 7ffffffffffc00000000000 <- ( ffffffffffff , 000000000000 ) + +[45,45]: + int 3ffffffffffe00000000000 <- ( ffffffffffff , 000000000000 ) + +[45,44]: + int 1fffffffffff00000000000 <- ( ffffffffffff , 00000000000 ) + +[45,43]: + int 0fffffffffff80000000000 <- ( ffffffffffff , 00000000000 ) + +[45,42]: + int 7ffffffffffc0000000000 <- ( ffffffffffff , 00000000000 ) + +[45,41]: + int 3ffffffffffe0000000000 <- ( ffffffffffff , 00000000000 ) + +[45,40]: + int 1fffffffffff0000000000 <- ( ffffffffffff , 0000000000 ) + +[45,39]: + int 0fffffffffff8000000000 <- ( ffffffffffff , 0000000000 ) + +[45,38]: + int 7ffffffffffc000000000 <- ( ffffffffffff , 0000000000 ) + +[45,37]: + int 3ffffffffffe000000000 <- ( ffffffffffff , 0000000000 ) + +[45,36]: + int 1fffffffffff000000000 <- ( ffffffffffff , 000000000 ) + +[45,35]: + int 0fffffffffff800000000 <- ( ffffffffffff , 000000000 ) + +[45,34]: + int 7ffffffffffc00000000 <- ( ffffffffffff , 000000000 ) + +[45,33]: + int 3ffffffffffe00000000 <- ( ffffffffffff , 000000000 ) + +[45,32]: + int 1fffffffffff00000000 <- ( ffffffffffff , 00000000 ) + +[45,31]: + int 0fffffffffff80000000 <- ( ffffffffffff , 00000000 ) + +[45,30]: + int 7ffffffffffc0000000 <- ( ffffffffffff , 00000000 ) + +[45,29]: + int 3ffffffffffe0000000 <- ( ffffffffffff , 00000000 ) + +[45,28]: + int 1fffffffffff0000000 <- ( ffffffffffff , 0000000 ) + +[45,27]: + int 0fffffffffff8000000 <- ( ffffffffffff , 0000000 ) + +[45,26]: + int 7ffffffffffc000000 <- ( ffffffffffff , 0000000 ) + +[45,25]: + int 3ffffffffffe000000 <- ( ffffffffffff , 0000000 ) + +[45,24]: + int 1fffffffffff000000 <- ( ffffffffffff , 000000 ) + +[45,23]: + int 0fffffffffff800000 <- ( ffffffffffff , 000000 ) + +[45,22]: + int 7ffffffffffc00000 <- ( ffffffffffff , 000000 ) + +[45,21]: + int 3ffffffffffe00000 <- ( ffffffffffff , 000000 ) + +[45,20]: + int 1fffffffffff00000 <- ( ffffffffffff , 00000 ) + +[45,19]: + int 0fffffffffff80000 <- ( ffffffffffff , 00000 ) + +[45,18]: + int 7ffffffffffc0000 <- ( ffffffffffff , 00000 ) + +[45,17]: + int 3ffffffffffe0000 <- ( ffffffffffff , 00000 ) + +[45,16]: + int 1fffffffffff0000 <- ( ffffffffffff , 0000 ) + +[45,15]: + int 0fffffffffff8000 <- ( ffffffffffff , 0000 ) + +[45,14]: + int 7ffffffffffc000 <- ( ffffffffffff , 0000 ) + +[45,13]: + int 3ffffffffffe000 <- ( ffffffffffff , 0000 ) + +[45,12]: + int 1fffffffffff000 <- ( ffffffffffff , 000 ) + +[45,11]: + int 0fffffffffff800 <- ( ffffffffffff , 000 ) + +[45,10]: + int 7ffffffffffc00 <- ( ffffffffffff , 000 ) + +[45,9]: + int 3ffffffffffe00 <- ( ffffffffffff , 000 ) + +[45,8]: + int 1fffffffffff00 <- ( ffffffffffff , 00 ) + +[45,7]: + int 0fffffffffff80 <- ( ffffffffffff , 00 ) + +[45,6]: + int 7ffffffffffc0 <- ( ffffffffffff , 00 ) + +[45,5]: + int 3ffffffffffe0 <- ( ffffffffffff , 00 ) + +[45,4]: + int 1fffffffffff0 <- ( ffffffffffff , 0 ) + +[45,3]: + int 0fffffffffff8 <- ( ffffffffffff , 0 ) + +[45,2]: + int 7ffffffffffc <- ( ffffffffffff , 0 ) + +[45,1]: + int 3ffffffffffe <- ( ffffffffffff , 0 ) + +[44,64]: + int 0fffffffffff0000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[44,63]: + int 7ffffffffff8000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[44,62]: + int 3ffffffffffc000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[44,61]: + int 1ffffffffffe000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[44,60]: + int 0fffffffffff000000000000000 <- ( fffffffffff , 000000000000000 ) + +[44,59]: + int 7ffffffffff800000000000000 <- ( fffffffffff , 000000000000000 ) + +[44,58]: + int 3ffffffffffc00000000000000 <- ( fffffffffff , 000000000000000 ) + +[44,57]: + int 1ffffffffffe00000000000000 <- ( fffffffffff , 000000000000000 ) + +[44,56]: + int 0fffffffffff00000000000000 <- ( fffffffffff , 00000000000000 ) + +[44,55]: + int 7ffffffffff80000000000000 <- ( fffffffffff , 00000000000000 ) + +[44,54]: + int 3ffffffffffc0000000000000 <- ( fffffffffff , 00000000000000 ) + +[44,53]: + int 1ffffffffffe0000000000000 <- ( fffffffffff , 00000000000000 ) + +[44,52]: + int 0fffffffffff0000000000000 <- ( fffffffffff , 0000000000000 ) + +[44,51]: + int 7ffffffffff8000000000000 <- ( fffffffffff , 0000000000000 ) + +[44,50]: + int 3ffffffffffc000000000000 <- ( fffffffffff , 0000000000000 ) + +[44,49]: + int 1ffffffffffe000000000000 <- ( fffffffffff , 0000000000000 ) + +[44,48]: + int 0fffffffffff000000000000 <- ( fffffffffff , 000000000000 ) + +[44,47]: + int 7ffffffffff800000000000 <- ( fffffffffff , 000000000000 ) + +[44,46]: + int 3ffffffffffc00000000000 <- ( fffffffffff , 000000000000 ) + +[44,45]: + int 1ffffffffffe00000000000 <- ( fffffffffff , 000000000000 ) + +[44,44]: + int 0fffffffffff00000000000 <- ( fffffffffff , 00000000000 ) + +[44,43]: + int 7ffffffffff80000000000 <- ( fffffffffff , 00000000000 ) + +[44,42]: + int 3ffffffffffc0000000000 <- ( fffffffffff , 00000000000 ) + +[44,41]: + int 1ffffffffffe0000000000 <- ( fffffffffff , 00000000000 ) + +[44,40]: + int 0fffffffffff0000000000 <- ( fffffffffff , 0000000000 ) + +[44,39]: + int 7ffffffffff8000000000 <- ( fffffffffff , 0000000000 ) + +[44,38]: + int 3ffffffffffc000000000 <- ( fffffffffff , 0000000000 ) + +[44,37]: + int 1ffffffffffe000000000 <- ( fffffffffff , 0000000000 ) + +[44,36]: + int 0fffffffffff000000000 <- ( fffffffffff , 000000000 ) + +[44,35]: + int 7ffffffffff800000000 <- ( fffffffffff , 000000000 ) + +[44,34]: + int 3ffffffffffc00000000 <- ( fffffffffff , 000000000 ) + +[44,33]: + int 1ffffffffffe00000000 <- ( fffffffffff , 000000000 ) + +[44,32]: + int 0fffffffffff00000000 <- ( fffffffffff , 00000000 ) + +[44,31]: + int 7ffffffffff80000000 <- ( fffffffffff , 00000000 ) + +[44,30]: + int 3ffffffffffc0000000 <- ( fffffffffff , 00000000 ) + +[44,29]: + int 1ffffffffffe0000000 <- ( fffffffffff , 00000000 ) + +[44,28]: + int 0fffffffffff0000000 <- ( fffffffffff , 0000000 ) + +[44,27]: + int 7ffffffffff8000000 <- ( fffffffffff , 0000000 ) + +[44,26]: + int 3ffffffffffc000000 <- ( fffffffffff , 0000000 ) + +[44,25]: + int 1ffffffffffe000000 <- ( fffffffffff , 0000000 ) + +[44,24]: + int 0fffffffffff000000 <- ( fffffffffff , 000000 ) + +[44,23]: + int 7ffffffffff800000 <- ( fffffffffff , 000000 ) + +[44,22]: + int 3ffffffffffc00000 <- ( fffffffffff , 000000 ) + +[44,21]: + int 1ffffffffffe00000 <- ( fffffffffff , 000000 ) + +[44,20]: + int 0fffffffffff00000 <- ( fffffffffff , 00000 ) + +[44,19]: + int 7ffffffffff80000 <- ( fffffffffff , 00000 ) + +[44,18]: + int 3ffffffffffc0000 <- ( fffffffffff , 00000 ) + +[44,17]: + int 1ffffffffffe0000 <- ( fffffffffff , 00000 ) + +[44,16]: + int 0fffffffffff0000 <- ( fffffffffff , 0000 ) + +[44,15]: + int 7ffffffffff8000 <- ( fffffffffff , 0000 ) + +[44,14]: + int 3ffffffffffc000 <- ( fffffffffff , 0000 ) + +[44,13]: + int 1ffffffffffe000 <- ( fffffffffff , 0000 ) + +[44,12]: + int 0fffffffffff000 <- ( fffffffffff , 000 ) + +[44,11]: + int 7ffffffffff800 <- ( fffffffffff , 000 ) + +[44,10]: + int 3ffffffffffc00 <- ( fffffffffff , 000 ) + +[44,9]: + int 1ffffffffffe00 <- ( fffffffffff , 000 ) + +[44,8]: + int 0fffffffffff00 <- ( fffffffffff , 00 ) + +[44,7]: + int 7ffffffffff80 <- ( fffffffffff , 00 ) + +[44,6]: + int 3ffffffffffc0 <- ( fffffffffff , 00 ) + +[44,5]: + int 1ffffffffffe0 <- ( fffffffffff , 00 ) + +[44,4]: + int 0fffffffffff0 <- ( fffffffffff , 0 ) + +[44,3]: + int 7ffffffffff8 <- ( fffffffffff , 0 ) + +[44,2]: + int 3ffffffffffc <- ( fffffffffff , 0 ) + +[44,1]: + int 1ffffffffffe <- ( fffffffffff , 0 ) + +[43,64]: + int 7ffffffffff0000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[43,63]: + int 3ffffffffff8000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[43,62]: + int 1ffffffffffc000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[43,61]: + int 0ffffffffffe000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[43,60]: + int 7ffffffffff000000000000000 <- ( fffffffffff , 000000000000000 ) + +[43,59]: + int 3ffffffffff800000000000000 <- ( fffffffffff , 000000000000000 ) + +[43,58]: + int 1ffffffffffc00000000000000 <- ( fffffffffff , 000000000000000 ) + +[43,57]: + int 0ffffffffffe00000000000000 <- ( fffffffffff , 000000000000000 ) + +[43,56]: + int 7ffffffffff00000000000000 <- ( fffffffffff , 00000000000000 ) + +[43,55]: + int 3ffffffffff80000000000000 <- ( fffffffffff , 00000000000000 ) + +[43,54]: + int 1ffffffffffc0000000000000 <- ( fffffffffff , 00000000000000 ) + +[43,53]: + int 0ffffffffffe0000000000000 <- ( fffffffffff , 00000000000000 ) + +[43,52]: + int 7ffffffffff0000000000000 <- ( fffffffffff , 0000000000000 ) + +[43,51]: + int 3ffffffffff8000000000000 <- ( fffffffffff , 0000000000000 ) + +[43,50]: + int 1ffffffffffc000000000000 <- ( fffffffffff , 0000000000000 ) + +[43,49]: + int 0ffffffffffe000000000000 <- ( fffffffffff , 0000000000000 ) + +[43,48]: + int 7ffffffffff000000000000 <- ( fffffffffff , 000000000000 ) + +[43,47]: + int 3ffffffffff800000000000 <- ( fffffffffff , 000000000000 ) + +[43,46]: + int 1ffffffffffc00000000000 <- ( fffffffffff , 000000000000 ) + +[43,45]: + int 0ffffffffffe00000000000 <- ( fffffffffff , 000000000000 ) + +[43,44]: + int 7ffffffffff00000000000 <- ( fffffffffff , 00000000000 ) + +[43,43]: + int 3ffffffffff80000000000 <- ( fffffffffff , 00000000000 ) + +[43,42]: + int 1ffffffffffc0000000000 <- ( fffffffffff , 00000000000 ) + +[43,41]: + int 0ffffffffffe0000000000 <- ( fffffffffff , 00000000000 ) + +[43,40]: + int 7ffffffffff0000000000 <- ( fffffffffff , 0000000000 ) + +[43,39]: + int 3ffffffffff8000000000 <- ( fffffffffff , 0000000000 ) + +[43,38]: + int 1ffffffffffc000000000 <- ( fffffffffff , 0000000000 ) + +[43,37]: + int 0ffffffffffe000000000 <- ( fffffffffff , 0000000000 ) + +[43,36]: + int 7ffffffffff000000000 <- ( fffffffffff , 000000000 ) + +[43,35]: + int 3ffffffffff800000000 <- ( fffffffffff , 000000000 ) + +[43,34]: + int 1ffffffffffc00000000 <- ( fffffffffff , 000000000 ) + +[43,33]: + int 0ffffffffffe00000000 <- ( fffffffffff , 000000000 ) + +[43,32]: + int 7ffffffffff00000000 <- ( fffffffffff , 00000000 ) + +[43,31]: + int 3ffffffffff80000000 <- ( fffffffffff , 00000000 ) + +[43,30]: + int 1ffffffffffc0000000 <- ( fffffffffff , 00000000 ) + +[43,29]: + int 0ffffffffffe0000000 <- ( fffffffffff , 00000000 ) + +[43,28]: + int 7ffffffffff0000000 <- ( fffffffffff , 0000000 ) + +[43,27]: + int 3ffffffffff8000000 <- ( fffffffffff , 0000000 ) + +[43,26]: + int 1ffffffffffc000000 <- ( fffffffffff , 0000000 ) + +[43,25]: + int 0ffffffffffe000000 <- ( fffffffffff , 0000000 ) + +[43,24]: + int 7ffffffffff000000 <- ( fffffffffff , 000000 ) + +[43,23]: + int 3ffffffffff800000 <- ( fffffffffff , 000000 ) + +[43,22]: + int 1ffffffffffc00000 <- ( fffffffffff , 000000 ) + +[43,21]: + int 0ffffffffffe00000 <- ( fffffffffff , 000000 ) + +[43,20]: + int 7ffffffffff00000 <- ( fffffffffff , 00000 ) + +[43,19]: + int 3ffffffffff80000 <- ( fffffffffff , 00000 ) + +[43,18]: + int 1ffffffffffc0000 <- ( fffffffffff , 00000 ) + +[43,17]: + int 0ffffffffffe0000 <- ( fffffffffff , 00000 ) + +[43,16]: + int 7ffffffffff0000 <- ( fffffffffff , 0000 ) + +[43,15]: + int 3ffffffffff8000 <- ( fffffffffff , 0000 ) + +[43,14]: + int 1ffffffffffc000 <- ( fffffffffff , 0000 ) + +[43,13]: + int 0ffffffffffe000 <- ( fffffffffff , 0000 ) + +[43,12]: + int 7ffffffffff000 <- ( fffffffffff , 000 ) + +[43,11]: + int 3ffffffffff800 <- ( fffffffffff , 000 ) + +[43,10]: + int 1ffffffffffc00 <- ( fffffffffff , 000 ) + +[43,9]: + int 0ffffffffffe00 <- ( fffffffffff , 000 ) + +[43,8]: + int 7ffffffffff00 <- ( fffffffffff , 00 ) + +[43,7]: + int 3ffffffffff80 <- ( fffffffffff , 00 ) + +[43,6]: + int 1ffffffffffc0 <- ( fffffffffff , 00 ) + +[43,5]: + int 0ffffffffffe0 <- ( fffffffffff , 00 ) + +[43,4]: + int 7ffffffffff0 <- ( fffffffffff , 0 ) + +[43,3]: + int 3ffffffffff8 <- ( fffffffffff , 0 ) + +[43,2]: + int 1ffffffffffc <- ( fffffffffff , 0 ) + +[43,1]: + int 0ffffffffffe <- ( fffffffffff , 0 ) + +[42,64]: + int 3ffffffffff0000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[42,63]: + int 1ffffffffff8000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[42,62]: + int 0ffffffffffc000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[42,61]: + int 7fffffffffe000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[42,60]: + int 3ffffffffff000000000000000 <- ( fffffffffff , 000000000000000 ) + +[42,59]: + int 1ffffffffff800000000000000 <- ( fffffffffff , 000000000000000 ) + +[42,58]: + int 0ffffffffffc00000000000000 <- ( fffffffffff , 000000000000000 ) + +[42,57]: + int 7fffffffffe00000000000000 <- ( fffffffffff , 000000000000000 ) + +[42,56]: + int 3ffffffffff00000000000000 <- ( fffffffffff , 00000000000000 ) + +[42,55]: + int 1ffffffffff80000000000000 <- ( fffffffffff , 00000000000000 ) + +[42,54]: + int 0ffffffffffc0000000000000 <- ( fffffffffff , 00000000000000 ) + +[42,53]: + int 7fffffffffe0000000000000 <- ( fffffffffff , 00000000000000 ) + +[42,52]: + int 3ffffffffff0000000000000 <- ( fffffffffff , 0000000000000 ) + +[42,51]: + int 1ffffffffff8000000000000 <- ( fffffffffff , 0000000000000 ) + +[42,50]: + int 0ffffffffffc000000000000 <- ( fffffffffff , 0000000000000 ) + +[42,49]: + int 7fffffffffe000000000000 <- ( fffffffffff , 0000000000000 ) + +[42,48]: + int 3ffffffffff000000000000 <- ( fffffffffff , 000000000000 ) + +[42,47]: + int 1ffffffffff800000000000 <- ( fffffffffff , 000000000000 ) + +[42,46]: + int 0ffffffffffc00000000000 <- ( fffffffffff , 000000000000 ) + +[42,45]: + int 7fffffffffe00000000000 <- ( fffffffffff , 000000000000 ) + +[42,44]: + int 3ffffffffff00000000000 <- ( fffffffffff , 00000000000 ) + +[42,43]: + int 1ffffffffff80000000000 <- ( fffffffffff , 00000000000 ) + +[42,42]: + int 0ffffffffffc0000000000 <- ( fffffffffff , 00000000000 ) + +[42,41]: + int 7fffffffffe0000000000 <- ( fffffffffff , 00000000000 ) + +[42,40]: + int 3ffffffffff0000000000 <- ( fffffffffff , 0000000000 ) + +[42,39]: + int 1ffffffffff8000000000 <- ( fffffffffff , 0000000000 ) + +[42,38]: + int 0ffffffffffc000000000 <- ( fffffffffff , 0000000000 ) + +[42,37]: + int 7fffffffffe000000000 <- ( fffffffffff , 0000000000 ) + +[42,36]: + int 3ffffffffff000000000 <- ( fffffffffff , 000000000 ) + +[42,35]: + int 1ffffffffff800000000 <- ( fffffffffff , 000000000 ) + +[42,34]: + int 0ffffffffffc00000000 <- ( fffffffffff , 000000000 ) + +[42,33]: + int 7fffffffffe00000000 <- ( fffffffffff , 000000000 ) + +[42,32]: + int 3ffffffffff00000000 <- ( fffffffffff , 00000000 ) + +[42,31]: + int 1ffffffffff80000000 <- ( fffffffffff , 00000000 ) + +[42,30]: + int 0ffffffffffc0000000 <- ( fffffffffff , 00000000 ) + +[42,29]: + int 7fffffffffe0000000 <- ( fffffffffff , 00000000 ) + +[42,28]: + int 3ffffffffff0000000 <- ( fffffffffff , 0000000 ) + +[42,27]: + int 1ffffffffff8000000 <- ( fffffffffff , 0000000 ) + +[42,26]: + int 0ffffffffffc000000 <- ( fffffffffff , 0000000 ) + +[42,25]: + int 7fffffffffe000000 <- ( fffffffffff , 0000000 ) + +[42,24]: + int 3ffffffffff000000 <- ( fffffffffff , 000000 ) + +[42,23]: + int 1ffffffffff800000 <- ( fffffffffff , 000000 ) + +[42,22]: + int 0ffffffffffc00000 <- ( fffffffffff , 000000 ) + +[42,21]: + int 7fffffffffe00000 <- ( fffffffffff , 000000 ) + +[42,20]: + int 3ffffffffff00000 <- ( fffffffffff , 00000 ) + +[42,19]: + int 1ffffffffff80000 <- ( fffffffffff , 00000 ) + +[42,18]: + int 0ffffffffffc0000 <- ( fffffffffff , 00000 ) + +[42,17]: + int 7fffffffffe0000 <- ( fffffffffff , 00000 ) + +[42,16]: + int 3ffffffffff0000 <- ( fffffffffff , 0000 ) + +[42,15]: + int 1ffffffffff8000 <- ( fffffffffff , 0000 ) + +[42,14]: + int 0ffffffffffc000 <- ( fffffffffff , 0000 ) + +[42,13]: + int 7fffffffffe000 <- ( fffffffffff , 0000 ) + +[42,12]: + int 3ffffffffff000 <- ( fffffffffff , 000 ) + +[42,11]: + int 1ffffffffff800 <- ( fffffffffff , 000 ) + +[42,10]: + int 0ffffffffffc00 <- ( fffffffffff , 000 ) + +[42,9]: + int 7fffffffffe00 <- ( fffffffffff , 000 ) + +[42,8]: + int 3ffffffffff00 <- ( fffffffffff , 00 ) + +[42,7]: + int 1ffffffffff80 <- ( fffffffffff , 00 ) + +[42,6]: + int 0ffffffffffc0 <- ( fffffffffff , 00 ) + +[42,5]: + int 7fffffffffe0 <- ( fffffffffff , 00 ) + +[42,4]: + int 3ffffffffff0 <- ( fffffffffff , 0 ) + +[42,3]: + int 1ffffffffff8 <- ( fffffffffff , 0 ) + +[42,2]: + int 0ffffffffffc <- ( fffffffffff , 0 ) + +[42,1]: + int 7fffffffffe <- ( fffffffffff , 0 ) + +[41,64]: + int 1ffffffffff0000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[41,63]: + int 0ffffffffff8000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[41,62]: + int 7fffffffffc000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[41,61]: + int 3fffffffffe000000000000000 <- ( fffffffffff , 0000000000000000 ) + +[41,60]: + int 1ffffffffff000000000000000 <- ( fffffffffff , 000000000000000 ) + +[41,59]: + int 0ffffffffff800000000000000 <- ( fffffffffff , 000000000000000 ) + +[41,58]: + int 7fffffffffc00000000000000 <- ( fffffffffff , 000000000000000 ) + +[41,57]: + int 3fffffffffe00000000000000 <- ( fffffffffff , 000000000000000 ) + +[41,56]: + int 1ffffffffff00000000000000 <- ( fffffffffff , 00000000000000 ) + +[41,55]: + int 0ffffffffff80000000000000 <- ( fffffffffff , 00000000000000 ) + +[41,54]: + int 7fffffffffc0000000000000 <- ( fffffffffff , 00000000000000 ) + +[41,53]: + int 3fffffffffe0000000000000 <- ( fffffffffff , 00000000000000 ) + +[41,52]: + int 1ffffffffff0000000000000 <- ( fffffffffff , 0000000000000 ) + +[41,51]: + int 0ffffffffff8000000000000 <- ( fffffffffff , 0000000000000 ) + +[41,50]: + int 7fffffffffc000000000000 <- ( fffffffffff , 0000000000000 ) + +[41,49]: + int 3fffffffffe000000000000 <- ( fffffffffff , 0000000000000 ) + +[41,48]: + int 1ffffffffff000000000000 <- ( fffffffffff , 000000000000 ) + +[41,47]: + int 0ffffffffff800000000000 <- ( fffffffffff , 000000000000 ) + +[41,46]: + int 7fffffffffc00000000000 <- ( fffffffffff , 000000000000 ) + +[41,45]: + int 3fffffffffe00000000000 <- ( fffffffffff , 000000000000 ) + +[41,44]: + int 1ffffffffff00000000000 <- ( fffffffffff , 00000000000 ) + +[41,43]: + int 0ffffffffff80000000000 <- ( fffffffffff , 00000000000 ) + +[41,42]: + int 7fffffffffc0000000000 <- ( fffffffffff , 00000000000 ) + +[41,41]: + int 3fffffffffe0000000000 <- ( fffffffffff , 00000000000 ) + +[41,40]: + int 1ffffffffff0000000000 <- ( fffffffffff , 0000000000 ) + +[41,39]: + int 0ffffffffff8000000000 <- ( fffffffffff , 0000000000 ) + +[41,38]: + int 7fffffffffc000000000 <- ( fffffffffff , 0000000000 ) + +[41,37]: + int 3fffffffffe000000000 <- ( fffffffffff , 0000000000 ) + +[41,36]: + int 1ffffffffff000000000 <- ( fffffffffff , 000000000 ) + +[41,35]: + int 0ffffffffff800000000 <- ( fffffffffff , 000000000 ) + +[41,34]: + int 7fffffffffc00000000 <- ( fffffffffff , 000000000 ) + +[41,33]: + int 3fffffffffe00000000 <- ( fffffffffff , 000000000 ) + +[41,32]: + int 1ffffffffff00000000 <- ( fffffffffff , 00000000 ) + +[41,31]: + int 0ffffffffff80000000 <- ( fffffffffff , 00000000 ) + +[41,30]: + int 7fffffffffc0000000 <- ( fffffffffff , 00000000 ) + +[41,29]: + int 3fffffffffe0000000 <- ( fffffffffff , 00000000 ) + +[41,28]: + int 1ffffffffff0000000 <- ( fffffffffff , 0000000 ) + +[41,27]: + int 0ffffffffff8000000 <- ( fffffffffff , 0000000 ) + +[41,26]: + int 7fffffffffc000000 <- ( fffffffffff , 0000000 ) + +[41,25]: + int 3fffffffffe000000 <- ( fffffffffff , 0000000 ) + +[41,24]: + int 1ffffffffff000000 <- ( fffffffffff , 000000 ) + +[41,23]: + int 0ffffffffff800000 <- ( fffffffffff , 000000 ) + +[41,22]: + int 7fffffffffc00000 <- ( fffffffffff , 000000 ) + +[41,21]: + int 3fffffffffe00000 <- ( fffffffffff , 000000 ) + +[41,20]: + int 1ffffffffff00000 <- ( fffffffffff , 00000 ) + +[41,19]: + int 0ffffffffff80000 <- ( fffffffffff , 00000 ) + +[41,18]: + int 7fffffffffc0000 <- ( fffffffffff , 00000 ) + +[41,17]: + int 3fffffffffe0000 <- ( fffffffffff , 00000 ) + +[41,16]: + int 1ffffffffff0000 <- ( fffffffffff , 0000 ) + +[41,15]: + int 0ffffffffff8000 <- ( fffffffffff , 0000 ) + +[41,14]: + int 7fffffffffc000 <- ( fffffffffff , 0000 ) + +[41,13]: + int 3fffffffffe000 <- ( fffffffffff , 0000 ) + +[41,12]: + int 1ffffffffff000 <- ( fffffffffff , 000 ) + +[41,11]: + int 0ffffffffff800 <- ( fffffffffff , 000 ) + +[41,10]: + int 7fffffffffc00 <- ( fffffffffff , 000 ) + +[41,9]: + int 3fffffffffe00 <- ( fffffffffff , 000 ) + +[41,8]: + int 1ffffffffff00 <- ( fffffffffff , 00 ) + +[41,7]: + int 0ffffffffff80 <- ( fffffffffff , 00 ) + +[41,6]: + int 7fffffffffc0 <- ( fffffffffff , 00 ) + +[41,5]: + int 3fffffffffe0 <- ( fffffffffff , 00 ) + +[41,4]: + int 1ffffffffff0 <- ( fffffffffff , 0 ) + +[41,3]: + int 0ffffffffff8 <- ( fffffffffff , 0 ) + +[41,2]: + int 7fffffffffc <- ( fffffffffff , 0 ) + +[41,1]: + int 3fffffffffe <- ( fffffffffff , 0 ) + +[40,64]: + int 0ffffffffff0000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[40,63]: + int 7fffffffff8000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[40,62]: + int 3fffffffffc000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[40,61]: + int 1fffffffffe000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[40,60]: + int 0ffffffffff000000000000000 <- ( ffffffffff , 000000000000000 ) + +[40,59]: + int 7fffffffff800000000000000 <- ( ffffffffff , 000000000000000 ) + +[40,58]: + int 3fffffffffc00000000000000 <- ( ffffffffff , 000000000000000 ) + +[40,57]: + int 1fffffffffe00000000000000 <- ( ffffffffff , 000000000000000 ) + +[40,56]: + int 0ffffffffff00000000000000 <- ( ffffffffff , 00000000000000 ) + +[40,55]: + int 7fffffffff80000000000000 <- ( ffffffffff , 00000000000000 ) + +[40,54]: + int 3fffffffffc0000000000000 <- ( ffffffffff , 00000000000000 ) + +[40,53]: + int 1fffffffffe0000000000000 <- ( ffffffffff , 00000000000000 ) + +[40,52]: + int 0ffffffffff0000000000000 <- ( ffffffffff , 0000000000000 ) + +[40,51]: + int 7fffffffff8000000000000 <- ( ffffffffff , 0000000000000 ) + +[40,50]: + int 3fffffffffc000000000000 <- ( ffffffffff , 0000000000000 ) + +[40,49]: + int 1fffffffffe000000000000 <- ( ffffffffff , 0000000000000 ) + +[40,48]: + int 0ffffffffff000000000000 <- ( ffffffffff , 000000000000 ) + +[40,47]: + int 7fffffffff800000000000 <- ( ffffffffff , 000000000000 ) + +[40,46]: + int 3fffffffffc00000000000 <- ( ffffffffff , 000000000000 ) + +[40,45]: + int 1fffffffffe00000000000 <- ( ffffffffff , 000000000000 ) + +[40,44]: + int 0ffffffffff00000000000 <- ( ffffffffff , 00000000000 ) + +[40,43]: + int 7fffffffff80000000000 <- ( ffffffffff , 00000000000 ) + +[40,42]: + int 3fffffffffc0000000000 <- ( ffffffffff , 00000000000 ) + +[40,41]: + int 1fffffffffe0000000000 <- ( ffffffffff , 00000000000 ) + +[40,40]: + int 0ffffffffff0000000000 <- ( ffffffffff , 0000000000 ) + +[40,39]: + int 7fffffffff8000000000 <- ( ffffffffff , 0000000000 ) + +[40,38]: + int 3fffffffffc000000000 <- ( ffffffffff , 0000000000 ) + +[40,37]: + int 1fffffffffe000000000 <- ( ffffffffff , 0000000000 ) + +[40,36]: + int 0ffffffffff000000000 <- ( ffffffffff , 000000000 ) + +[40,35]: + int 7fffffffff800000000 <- ( ffffffffff , 000000000 ) + +[40,34]: + int 3fffffffffc00000000 <- ( ffffffffff , 000000000 ) + +[40,33]: + int 1fffffffffe00000000 <- ( ffffffffff , 000000000 ) + +[40,32]: + int 0ffffffffff00000000 <- ( ffffffffff , 00000000 ) + +[40,31]: + int 7fffffffff80000000 <- ( ffffffffff , 00000000 ) + +[40,30]: + int 3fffffffffc0000000 <- ( ffffffffff , 00000000 ) + +[40,29]: + int 1fffffffffe0000000 <- ( ffffffffff , 00000000 ) + +[40,28]: + int 0ffffffffff0000000 <- ( ffffffffff , 0000000 ) + +[40,27]: + int 7fffffffff8000000 <- ( ffffffffff , 0000000 ) + +[40,26]: + int 3fffffffffc000000 <- ( ffffffffff , 0000000 ) + +[40,25]: + int 1fffffffffe000000 <- ( ffffffffff , 0000000 ) + +[40,24]: + int 0ffffffffff000000 <- ( ffffffffff , 000000 ) + +[40,23]: + int 7fffffffff800000 <- ( ffffffffff , 000000 ) + +[40,22]: + int 3fffffffffc00000 <- ( ffffffffff , 000000 ) + +[40,21]: + int 1fffffffffe00000 <- ( ffffffffff , 000000 ) + +[40,20]: + int 0ffffffffff00000 <- ( ffffffffff , 00000 ) + +[40,19]: + int 7fffffffff80000 <- ( ffffffffff , 00000 ) + +[40,18]: + int 3fffffffffc0000 <- ( ffffffffff , 00000 ) + +[40,17]: + int 1fffffffffe0000 <- ( ffffffffff , 00000 ) + +[40,16]: + int 0ffffffffff0000 <- ( ffffffffff , 0000 ) + +[40,15]: + int 7fffffffff8000 <- ( ffffffffff , 0000 ) + +[40,14]: + int 3fffffffffc000 <- ( ffffffffff , 0000 ) + +[40,13]: + int 1fffffffffe000 <- ( ffffffffff , 0000 ) + +[40,12]: + int 0ffffffffff000 <- ( ffffffffff , 000 ) + +[40,11]: + int 7fffffffff800 <- ( ffffffffff , 000 ) + +[40,10]: + int 3fffffffffc00 <- ( ffffffffff , 000 ) + +[40,9]: + int 1fffffffffe00 <- ( ffffffffff , 000 ) + +[40,8]: + int 0ffffffffff00 <- ( ffffffffff , 00 ) + +[40,7]: + int 7fffffffff80 <- ( ffffffffff , 00 ) + +[40,6]: + int 3fffffffffc0 <- ( ffffffffff , 00 ) + +[40,5]: + int 1fffffffffe0 <- ( ffffffffff , 00 ) + +[40,4]: + int 0ffffffffff0 <- ( ffffffffff , 0 ) + +[40,3]: + int 7fffffffff8 <- ( ffffffffff , 0 ) + +[40,2]: + int 3fffffffffc <- ( ffffffffff , 0 ) + +[40,1]: + int 1fffffffffe <- ( ffffffffff , 0 ) + +[39,64]: + int 7fffffffff0000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[39,63]: + int 3fffffffff8000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[39,62]: + int 1fffffffffc000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[39,61]: + int 0fffffffffe000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[39,60]: + int 7fffffffff000000000000000 <- ( ffffffffff , 000000000000000 ) + +[39,59]: + int 3fffffffff800000000000000 <- ( ffffffffff , 000000000000000 ) + +[39,58]: + int 1fffffffffc00000000000000 <- ( ffffffffff , 000000000000000 ) + +[39,57]: + int 0fffffffffe00000000000000 <- ( ffffffffff , 000000000000000 ) + +[39,56]: + int 7fffffffff00000000000000 <- ( ffffffffff , 00000000000000 ) + +[39,55]: + int 3fffffffff80000000000000 <- ( ffffffffff , 00000000000000 ) + +[39,54]: + int 1fffffffffc0000000000000 <- ( ffffffffff , 00000000000000 ) + +[39,53]: + int 0fffffffffe0000000000000 <- ( ffffffffff , 00000000000000 ) + +[39,52]: + int 7fffffffff0000000000000 <- ( ffffffffff , 0000000000000 ) + +[39,51]: + int 3fffffffff8000000000000 <- ( ffffffffff , 0000000000000 ) + +[39,50]: + int 1fffffffffc000000000000 <- ( ffffffffff , 0000000000000 ) + +[39,49]: + int 0fffffffffe000000000000 <- ( ffffffffff , 0000000000000 ) + +[39,48]: + int 7fffffffff000000000000 <- ( ffffffffff , 000000000000 ) + +[39,47]: + int 3fffffffff800000000000 <- ( ffffffffff , 000000000000 ) + +[39,46]: + int 1fffffffffc00000000000 <- ( ffffffffff , 000000000000 ) + +[39,45]: + int 0fffffffffe00000000000 <- ( ffffffffff , 000000000000 ) + +[39,44]: + int 7fffffffff00000000000 <- ( ffffffffff , 00000000000 ) + +[39,43]: + int 3fffffffff80000000000 <- ( ffffffffff , 00000000000 ) + +[39,42]: + int 1fffffffffc0000000000 <- ( ffffffffff , 00000000000 ) + +[39,41]: + int 0fffffffffe0000000000 <- ( ffffffffff , 00000000000 ) + +[39,40]: + int 7fffffffff0000000000 <- ( ffffffffff , 0000000000 ) + +[39,39]: + int 3fffffffff8000000000 <- ( ffffffffff , 0000000000 ) + +[39,38]: + int 1fffffffffc000000000 <- ( ffffffffff , 0000000000 ) + +[39,37]: + int 0fffffffffe000000000 <- ( ffffffffff , 0000000000 ) + +[39,36]: + int 7fffffffff000000000 <- ( ffffffffff , 000000000 ) + +[39,35]: + int 3fffffffff800000000 <- ( ffffffffff , 000000000 ) + +[39,34]: + int 1fffffffffc00000000 <- ( ffffffffff , 000000000 ) + +[39,33]: + int 0fffffffffe00000000 <- ( ffffffffff , 000000000 ) + +[39,32]: + int 7fffffffff00000000 <- ( ffffffffff , 00000000 ) + +[39,31]: + int 3fffffffff80000000 <- ( ffffffffff , 00000000 ) + +[39,30]: + int 1fffffffffc0000000 <- ( ffffffffff , 00000000 ) + +[39,29]: + int 0fffffffffe0000000 <- ( ffffffffff , 00000000 ) + +[39,28]: + int 7fffffffff0000000 <- ( ffffffffff , 0000000 ) + +[39,27]: + int 3fffffffff8000000 <- ( ffffffffff , 0000000 ) + +[39,26]: + int 1fffffffffc000000 <- ( ffffffffff , 0000000 ) + +[39,25]: + int 0fffffffffe000000 <- ( ffffffffff , 0000000 ) + +[39,24]: + int 7fffffffff000000 <- ( ffffffffff , 000000 ) + +[39,23]: + int 3fffffffff800000 <- ( ffffffffff , 000000 ) + +[39,22]: + int 1fffffffffc00000 <- ( ffffffffff , 000000 ) + +[39,21]: + int 0fffffffffe00000 <- ( ffffffffff , 000000 ) + +[39,20]: + int 7fffffffff00000 <- ( ffffffffff , 00000 ) + +[39,19]: + int 3fffffffff80000 <- ( ffffffffff , 00000 ) + +[39,18]: + int 1fffffffffc0000 <- ( ffffffffff , 00000 ) + +[39,17]: + int 0fffffffffe0000 <- ( ffffffffff , 00000 ) + +[39,16]: + int 7fffffffff0000 <- ( ffffffffff , 0000 ) + +[39,15]: + int 3fffffffff8000 <- ( ffffffffff , 0000 ) + +[39,14]: + int 1fffffffffc000 <- ( ffffffffff , 0000 ) + +[39,13]: + int 0fffffffffe000 <- ( ffffffffff , 0000 ) + +[39,12]: + int 7fffffffff000 <- ( ffffffffff , 000 ) + +[39,11]: + int 3fffffffff800 <- ( ffffffffff , 000 ) + +[39,10]: + int 1fffffffffc00 <- ( ffffffffff , 000 ) + +[39,9]: + int 0fffffffffe00 <- ( ffffffffff , 000 ) + +[39,8]: + int 7fffffffff00 <- ( ffffffffff , 00 ) + +[39,7]: + int 3fffffffff80 <- ( ffffffffff , 00 ) + +[39,6]: + int 1fffffffffc0 <- ( ffffffffff , 00 ) + +[39,5]: + int 0fffffffffe0 <- ( ffffffffff , 00 ) + +[39,4]: + int 7fffffffff0 <- ( ffffffffff , 0 ) + +[39,3]: + int 3fffffffff8 <- ( ffffffffff , 0 ) + +[39,2]: + int 1fffffffffc <- ( ffffffffff , 0 ) + +[39,1]: + int 0fffffffffe <- ( ffffffffff , 0 ) + +[38,64]: + int 3fffffffff0000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[38,63]: + int 1fffffffff8000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[38,62]: + int 0fffffffffc000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[38,61]: + int 7ffffffffe000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[38,60]: + int 3fffffffff000000000000000 <- ( ffffffffff , 000000000000000 ) + +[38,59]: + int 1fffffffff800000000000000 <- ( ffffffffff , 000000000000000 ) + +[38,58]: + int 0fffffffffc00000000000000 <- ( ffffffffff , 000000000000000 ) + +[38,57]: + int 7ffffffffe00000000000000 <- ( ffffffffff , 000000000000000 ) + +[38,56]: + int 3fffffffff00000000000000 <- ( ffffffffff , 00000000000000 ) + +[38,55]: + int 1fffffffff80000000000000 <- ( ffffffffff , 00000000000000 ) + +[38,54]: + int 0fffffffffc0000000000000 <- ( ffffffffff , 00000000000000 ) + +[38,53]: + int 7ffffffffe0000000000000 <- ( ffffffffff , 00000000000000 ) + +[38,52]: + int 3fffffffff0000000000000 <- ( ffffffffff , 0000000000000 ) + +[38,51]: + int 1fffffffff8000000000000 <- ( ffffffffff , 0000000000000 ) + +[38,50]: + int 0fffffffffc000000000000 <- ( ffffffffff , 0000000000000 ) + +[38,49]: + int 7ffffffffe000000000000 <- ( ffffffffff , 0000000000000 ) + +[38,48]: + int 3fffffffff000000000000 <- ( ffffffffff , 000000000000 ) + +[38,47]: + int 1fffffffff800000000000 <- ( ffffffffff , 000000000000 ) + +[38,46]: + int 0fffffffffc00000000000 <- ( ffffffffff , 000000000000 ) + +[38,45]: + int 7ffffffffe00000000000 <- ( ffffffffff , 000000000000 ) + +[38,44]: + int 3fffffffff00000000000 <- ( ffffffffff , 00000000000 ) + +[38,43]: + int 1fffffffff80000000000 <- ( ffffffffff , 00000000000 ) + +[38,42]: + int 0fffffffffc0000000000 <- ( ffffffffff , 00000000000 ) + +[38,41]: + int 7ffffffffe0000000000 <- ( ffffffffff , 00000000000 ) + +[38,40]: + int 3fffffffff0000000000 <- ( ffffffffff , 0000000000 ) + +[38,39]: + int 1fffffffff8000000000 <- ( ffffffffff , 0000000000 ) + +[38,38]: + int 0fffffffffc000000000 <- ( ffffffffff , 0000000000 ) + +[38,37]: + int 7ffffffffe000000000 <- ( ffffffffff , 0000000000 ) + +[38,36]: + int 3fffffffff000000000 <- ( ffffffffff , 000000000 ) + +[38,35]: + int 1fffffffff800000000 <- ( ffffffffff , 000000000 ) + +[38,34]: + int 0fffffffffc00000000 <- ( ffffffffff , 000000000 ) + +[38,33]: + int 7ffffffffe00000000 <- ( ffffffffff , 000000000 ) + +[38,32]: + int 3fffffffff00000000 <- ( ffffffffff , 00000000 ) + +[38,31]: + int 1fffffffff80000000 <- ( ffffffffff , 00000000 ) + +[38,30]: + int 0fffffffffc0000000 <- ( ffffffffff , 00000000 ) + +[38,29]: + int 7ffffffffe0000000 <- ( ffffffffff , 00000000 ) + +[38,28]: + int 3fffffffff0000000 <- ( ffffffffff , 0000000 ) + +[38,27]: + int 1fffffffff8000000 <- ( ffffffffff , 0000000 ) + +[38,26]: + int 0fffffffffc000000 <- ( ffffffffff , 0000000 ) + +[38,25]: + int 7ffffffffe000000 <- ( ffffffffff , 0000000 ) + +[38,24]: + int 3fffffffff000000 <- ( ffffffffff , 000000 ) + +[38,23]: + int 1fffffffff800000 <- ( ffffffffff , 000000 ) + +[38,22]: + int 0fffffffffc00000 <- ( ffffffffff , 000000 ) + +[38,21]: + int 7ffffffffe00000 <- ( ffffffffff , 000000 ) + +[38,20]: + int 3fffffffff00000 <- ( ffffffffff , 00000 ) + +[38,19]: + int 1fffffffff80000 <- ( ffffffffff , 00000 ) + +[38,18]: + int 0fffffffffc0000 <- ( ffffffffff , 00000 ) + +[38,17]: + int 7ffffffffe0000 <- ( ffffffffff , 00000 ) + +[38,16]: + int 3fffffffff0000 <- ( ffffffffff , 0000 ) + +[38,15]: + int 1fffffffff8000 <- ( ffffffffff , 0000 ) + +[38,14]: + int 0fffffffffc000 <- ( ffffffffff , 0000 ) + +[38,13]: + int 7ffffffffe000 <- ( ffffffffff , 0000 ) + +[38,12]: + int 3fffffffff000 <- ( ffffffffff , 000 ) + +[38,11]: + int 1fffffffff800 <- ( ffffffffff , 000 ) + +[38,10]: + int 0fffffffffc00 <- ( ffffffffff , 000 ) + +[38,9]: + int 7ffffffffe00 <- ( ffffffffff , 000 ) + +[38,8]: + int 3fffffffff00 <- ( ffffffffff , 00 ) + +[38,7]: + int 1fffffffff80 <- ( ffffffffff , 00 ) + +[38,6]: + int 0fffffffffc0 <- ( ffffffffff , 00 ) + +[38,5]: + int 7ffffffffe0 <- ( ffffffffff , 00 ) + +[38,4]: + int 3fffffffff0 <- ( ffffffffff , 0 ) + +[38,3]: + int 1fffffffff8 <- ( ffffffffff , 0 ) + +[38,2]: + int 0fffffffffc <- ( ffffffffff , 0 ) + +[38,1]: + int 7ffffffffe <- ( ffffffffff , 0 ) + +[37,64]: + int 1fffffffff0000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[37,63]: + int 0fffffffff8000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[37,62]: + int 7ffffffffc000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[37,61]: + int 3ffffffffe000000000000000 <- ( ffffffffff , 0000000000000000 ) + +[37,60]: + int 1fffffffff000000000000000 <- ( ffffffffff , 000000000000000 ) + +[37,59]: + int 0fffffffff800000000000000 <- ( ffffffffff , 000000000000000 ) + +[37,58]: + int 7ffffffffc00000000000000 <- ( ffffffffff , 000000000000000 ) + +[37,57]: + int 3ffffffffe00000000000000 <- ( ffffffffff , 000000000000000 ) + +[37,56]: + int 1fffffffff00000000000000 <- ( ffffffffff , 00000000000000 ) + +[37,55]: + int 0fffffffff80000000000000 <- ( ffffffffff , 00000000000000 ) + +[37,54]: + int 7ffffffffc0000000000000 <- ( ffffffffff , 00000000000000 ) + +[37,53]: + int 3ffffffffe0000000000000 <- ( ffffffffff , 00000000000000 ) + +[37,52]: + int 1fffffffff0000000000000 <- ( ffffffffff , 0000000000000 ) + +[37,51]: + int 0fffffffff8000000000000 <- ( ffffffffff , 0000000000000 ) + +[37,50]: + int 7ffffffffc000000000000 <- ( ffffffffff , 0000000000000 ) + +[37,49]: + int 3ffffffffe000000000000 <- ( ffffffffff , 0000000000000 ) + +[37,48]: + int 1fffffffff000000000000 <- ( ffffffffff , 000000000000 ) + +[37,47]: + int 0fffffffff800000000000 <- ( ffffffffff , 000000000000 ) + +[37,46]: + int 7ffffffffc00000000000 <- ( ffffffffff , 000000000000 ) + +[37,45]: + int 3ffffffffe00000000000 <- ( ffffffffff , 000000000000 ) + +[37,44]: + int 1fffffffff00000000000 <- ( ffffffffff , 00000000000 ) + +[37,43]: + int 0fffffffff80000000000 <- ( ffffffffff , 00000000000 ) + +[37,42]: + int 7ffffffffc0000000000 <- ( ffffffffff , 00000000000 ) + +[37,41]: + int 3ffffffffe0000000000 <- ( ffffffffff , 00000000000 ) + +[37,40]: + int 1fffffffff0000000000 <- ( ffffffffff , 0000000000 ) + +[37,39]: + int 0fffffffff8000000000 <- ( ffffffffff , 0000000000 ) + +[37,38]: + int 7ffffffffc000000000 <- ( ffffffffff , 0000000000 ) + +[37,37]: + int 3ffffffffe000000000 <- ( ffffffffff , 0000000000 ) + +[37,36]: + int 1fffffffff000000000 <- ( ffffffffff , 000000000 ) + +[37,35]: + int 0fffffffff800000000 <- ( ffffffffff , 000000000 ) + +[37,34]: + int 7ffffffffc00000000 <- ( ffffffffff , 000000000 ) + +[37,33]: + int 3ffffffffe00000000 <- ( ffffffffff , 000000000 ) + +[37,32]: + int 1fffffffff00000000 <- ( ffffffffff , 00000000 ) + +[37,31]: + int 0fffffffff80000000 <- ( ffffffffff , 00000000 ) + +[37,30]: + int 7ffffffffc0000000 <- ( ffffffffff , 00000000 ) + +[37,29]: + int 3ffffffffe0000000 <- ( ffffffffff , 00000000 ) + +[37,28]: + int 1fffffffff0000000 <- ( ffffffffff , 0000000 ) + +[37,27]: + int 0fffffffff8000000 <- ( ffffffffff , 0000000 ) + +[37,26]: + int 7ffffffffc000000 <- ( ffffffffff , 0000000 ) + +[37,25]: + int 3ffffffffe000000 <- ( ffffffffff , 0000000 ) + +[37,24]: + int 1fffffffff000000 <- ( ffffffffff , 000000 ) + +[37,23]: + int 0fffffffff800000 <- ( ffffffffff , 000000 ) + +[37,22]: + int 7ffffffffc00000 <- ( ffffffffff , 000000 ) + +[37,21]: + int 3ffffffffe00000 <- ( ffffffffff , 000000 ) + +[37,20]: + int 1fffffffff00000 <- ( ffffffffff , 00000 ) + +[37,19]: + int 0fffffffff80000 <- ( ffffffffff , 00000 ) + +[37,18]: + int 7ffffffffc0000 <- ( ffffffffff , 00000 ) + +[37,17]: + int 3ffffffffe0000 <- ( ffffffffff , 00000 ) + +[37,16]: + int 1fffffffff0000 <- ( ffffffffff , 0000 ) + +[37,15]: + int 0fffffffff8000 <- ( ffffffffff , 0000 ) + +[37,14]: + int 7ffffffffc000 <- ( ffffffffff , 0000 ) + +[37,13]: + int 3ffffffffe000 <- ( ffffffffff , 0000 ) + +[37,12]: + int 1fffffffff000 <- ( ffffffffff , 000 ) + +[37,11]: + int 0fffffffff800 <- ( ffffffffff , 000 ) + +[37,10]: + int 7ffffffffc00 <- ( ffffffffff , 000 ) + +[37,9]: + int 3ffffffffe00 <- ( ffffffffff , 000 ) + +[37,8]: + int 1fffffffff00 <- ( ffffffffff , 00 ) + +[37,7]: + int 0fffffffff80 <- ( ffffffffff , 00 ) + +[37,6]: + int 7ffffffffc0 <- ( ffffffffff , 00 ) + +[37,5]: + int 3ffffffffe0 <- ( ffffffffff , 00 ) + +[37,4]: + int 1fffffffff0 <- ( ffffffffff , 0 ) + +[37,3]: + int 0fffffffff8 <- ( ffffffffff , 0 ) + +[37,2]: + int 7ffffffffc <- ( ffffffffff , 0 ) + +[37,1]: + int 3ffffffffe <- ( ffffffffff , 0 ) + +[36,64]: + int 0fffffffff0000000000000000 <- ( fffffffff , 0000000000000000 ) + +[36,63]: + int 7ffffffff8000000000000000 <- ( fffffffff , 0000000000000000 ) + +[36,62]: + int 3ffffffffc000000000000000 <- ( fffffffff , 0000000000000000 ) + +[36,61]: + int 1ffffffffe000000000000000 <- ( fffffffff , 0000000000000000 ) + +[36,60]: + int 0fffffffff000000000000000 <- ( fffffffff , 000000000000000 ) + +[36,59]: + int 7ffffffff800000000000000 <- ( fffffffff , 000000000000000 ) + +[36,58]: + int 3ffffffffc00000000000000 <- ( fffffffff , 000000000000000 ) + +[36,57]: + int 1ffffffffe00000000000000 <- ( fffffffff , 000000000000000 ) + +[36,56]: + int 0fffffffff00000000000000 <- ( fffffffff , 00000000000000 ) + +[36,55]: + int 7ffffffff80000000000000 <- ( fffffffff , 00000000000000 ) + +[36,54]: + int 3ffffffffc0000000000000 <- ( fffffffff , 00000000000000 ) + +[36,53]: + int 1ffffffffe0000000000000 <- ( fffffffff , 00000000000000 ) + +[36,52]: + int 0fffffffff0000000000000 <- ( fffffffff , 0000000000000 ) + +[36,51]: + int 7ffffffff8000000000000 <- ( fffffffff , 0000000000000 ) + +[36,50]: + int 3ffffffffc000000000000 <- ( fffffffff , 0000000000000 ) + +[36,49]: + int 1ffffffffe000000000000 <- ( fffffffff , 0000000000000 ) + +[36,48]: + int 0fffffffff000000000000 <- ( fffffffff , 000000000000 ) + +[36,47]: + int 7ffffffff800000000000 <- ( fffffffff , 000000000000 ) + +[36,46]: + int 3ffffffffc00000000000 <- ( fffffffff , 000000000000 ) + +[36,45]: + int 1ffffffffe00000000000 <- ( fffffffff , 000000000000 ) + +[36,44]: + int 0fffffffff00000000000 <- ( fffffffff , 00000000000 ) + +[36,43]: + int 7ffffffff80000000000 <- ( fffffffff , 00000000000 ) + +[36,42]: + int 3ffffffffc0000000000 <- ( fffffffff , 00000000000 ) + +[36,41]: + int 1ffffffffe0000000000 <- ( fffffffff , 00000000000 ) + +[36,40]: + int 0fffffffff0000000000 <- ( fffffffff , 0000000000 ) + +[36,39]: + int 7ffffffff8000000000 <- ( fffffffff , 0000000000 ) + +[36,38]: + int 3ffffffffc000000000 <- ( fffffffff , 0000000000 ) + +[36,37]: + int 1ffffffffe000000000 <- ( fffffffff , 0000000000 ) + +[36,36]: + int 0fffffffff000000000 <- ( fffffffff , 000000000 ) + +[36,35]: + int 7ffffffff800000000 <- ( fffffffff , 000000000 ) + +[36,34]: + int 3ffffffffc00000000 <- ( fffffffff , 000000000 ) + +[36,33]: + int 1ffffffffe00000000 <- ( fffffffff , 000000000 ) + +[36,32]: + int 0fffffffff00000000 <- ( fffffffff , 00000000 ) + +[36,31]: + int 7ffffffff80000000 <- ( fffffffff , 00000000 ) + +[36,30]: + int 3ffffffffc0000000 <- ( fffffffff , 00000000 ) + +[36,29]: + int 1ffffffffe0000000 <- ( fffffffff , 00000000 ) + +[36,28]: + int 0fffffffff0000000 <- ( fffffffff , 0000000 ) + +[36,27]: + int 7ffffffff8000000 <- ( fffffffff , 0000000 ) + +[36,26]: + int 3ffffffffc000000 <- ( fffffffff , 0000000 ) + +[36,25]: + int 1ffffffffe000000 <- ( fffffffff , 0000000 ) + +[36,24]: + int 0fffffffff000000 <- ( fffffffff , 000000 ) + +[36,23]: + int 7ffffffff800000 <- ( fffffffff , 000000 ) + +[36,22]: + int 3ffffffffc00000 <- ( fffffffff , 000000 ) + +[36,21]: + int 1ffffffffe00000 <- ( fffffffff , 000000 ) + +[36,20]: + int 0fffffffff00000 <- ( fffffffff , 00000 ) + +[36,19]: + int 7ffffffff80000 <- ( fffffffff , 00000 ) + +[36,18]: + int 3ffffffffc0000 <- ( fffffffff , 00000 ) + +[36,17]: + int 1ffffffffe0000 <- ( fffffffff , 00000 ) + +[36,16]: + int 0fffffffff0000 <- ( fffffffff , 0000 ) + +[36,15]: + int 7ffffffff8000 <- ( fffffffff , 0000 ) + +[36,14]: + int 3ffffffffc000 <- ( fffffffff , 0000 ) + +[36,13]: + int 1ffffffffe000 <- ( fffffffff , 0000 ) + +[36,12]: + int 0fffffffff000 <- ( fffffffff , 000 ) + +[36,11]: + int 7ffffffff800 <- ( fffffffff , 000 ) + +[36,10]: + int 3ffffffffc00 <- ( fffffffff , 000 ) + +[36,9]: + int 1ffffffffe00 <- ( fffffffff , 000 ) + +[36,8]: + int 0fffffffff00 <- ( fffffffff , 00 ) + +[36,7]: + int 7ffffffff80 <- ( fffffffff , 00 ) + +[36,6]: + int 3ffffffffc0 <- ( fffffffff , 00 ) + +[36,5]: + int 1ffffffffe0 <- ( fffffffff , 00 ) + +[36,4]: + int 0fffffffff0 <- ( fffffffff , 0 ) + +[36,3]: + int 7ffffffff8 <- ( fffffffff , 0 ) + +[36,2]: + int 3ffffffffc <- ( fffffffff , 0 ) + +[36,1]: + int 1ffffffffe <- ( fffffffff , 0 ) + +[35,64]: + int 7ffffffff0000000000000000 <- ( fffffffff , 0000000000000000 ) + +[35,63]: + int 3ffffffff8000000000000000 <- ( fffffffff , 0000000000000000 ) + +[35,62]: + int 1ffffffffc000000000000000 <- ( fffffffff , 0000000000000000 ) + +[35,61]: + int 0ffffffffe000000000000000 <- ( fffffffff , 0000000000000000 ) + +[35,60]: + int 7ffffffff000000000000000 <- ( fffffffff , 000000000000000 ) + +[35,59]: + int 3ffffffff800000000000000 <- ( fffffffff , 000000000000000 ) + +[35,58]: + int 1ffffffffc00000000000000 <- ( fffffffff , 000000000000000 ) + +[35,57]: + int 0ffffffffe00000000000000 <- ( fffffffff , 000000000000000 ) + +[35,56]: + int 7ffffffff00000000000000 <- ( fffffffff , 00000000000000 ) + +[35,55]: + int 3ffffffff80000000000000 <- ( fffffffff , 00000000000000 ) + +[35,54]: + int 1ffffffffc0000000000000 <- ( fffffffff , 00000000000000 ) + +[35,53]: + int 0ffffffffe0000000000000 <- ( fffffffff , 00000000000000 ) + +[35,52]: + int 7ffffffff0000000000000 <- ( fffffffff , 0000000000000 ) + +[35,51]: + int 3ffffffff8000000000000 <- ( fffffffff , 0000000000000 ) + +[35,50]: + int 1ffffffffc000000000000 <- ( fffffffff , 0000000000000 ) + +[35,49]: + int 0ffffffffe000000000000 <- ( fffffffff , 0000000000000 ) + +[35,48]: + int 7ffffffff000000000000 <- ( fffffffff , 000000000000 ) + +[35,47]: + int 3ffffffff800000000000 <- ( fffffffff , 000000000000 ) + +[35,46]: + int 1ffffffffc00000000000 <- ( fffffffff , 000000000000 ) + +[35,45]: + int 0ffffffffe00000000000 <- ( fffffffff , 000000000000 ) + +[35,44]: + int 7ffffffff00000000000 <- ( fffffffff , 00000000000 ) + +[35,43]: + int 3ffffffff80000000000 <- ( fffffffff , 00000000000 ) + +[35,42]: + int 1ffffffffc0000000000 <- ( fffffffff , 00000000000 ) + +[35,41]: + int 0ffffffffe0000000000 <- ( fffffffff , 00000000000 ) + +[35,40]: + int 7ffffffff0000000000 <- ( fffffffff , 0000000000 ) + +[35,39]: + int 3ffffffff8000000000 <- ( fffffffff , 0000000000 ) + +[35,38]: + int 1ffffffffc000000000 <- ( fffffffff , 0000000000 ) + +[35,37]: + int 0ffffffffe000000000 <- ( fffffffff , 0000000000 ) + +[35,36]: + int 7ffffffff000000000 <- ( fffffffff , 000000000 ) + +[35,35]: + int 3ffffffff800000000 <- ( fffffffff , 000000000 ) + +[35,34]: + int 1ffffffffc00000000 <- ( fffffffff , 000000000 ) + +[35,33]: + int 0ffffffffe00000000 <- ( fffffffff , 000000000 ) + +[35,32]: + int 7ffffffff00000000 <- ( fffffffff , 00000000 ) + +[35,31]: + int 3ffffffff80000000 <- ( fffffffff , 00000000 ) + +[35,30]: + int 1ffffffffc0000000 <- ( fffffffff , 00000000 ) + +[35,29]: + int 0ffffffffe0000000 <- ( fffffffff , 00000000 ) + +[35,28]: + int 7ffffffff0000000 <- ( fffffffff , 0000000 ) + +[35,27]: + int 3ffffffff8000000 <- ( fffffffff , 0000000 ) + +[35,26]: + int 1ffffffffc000000 <- ( fffffffff , 0000000 ) + +[35,25]: + int 0ffffffffe000000 <- ( fffffffff , 0000000 ) + +[35,24]: + int 7ffffffff000000 <- ( fffffffff , 000000 ) + +[35,23]: + int 3ffffffff800000 <- ( fffffffff , 000000 ) + +[35,22]: + int 1ffffffffc00000 <- ( fffffffff , 000000 ) + +[35,21]: + int 0ffffffffe00000 <- ( fffffffff , 000000 ) + +[35,20]: + int 7ffffffff00000 <- ( fffffffff , 00000 ) + +[35,19]: + int 3ffffffff80000 <- ( fffffffff , 00000 ) + +[35,18]: + int 1ffffffffc0000 <- ( fffffffff , 00000 ) + +[35,17]: + int 0ffffffffe0000 <- ( fffffffff , 00000 ) + +[35,16]: + int 7ffffffff0000 <- ( fffffffff , 0000 ) + +[35,15]: + int 3ffffffff8000 <- ( fffffffff , 0000 ) + +[35,14]: + int 1ffffffffc000 <- ( fffffffff , 0000 ) + +[35,13]: + int 0ffffffffe000 <- ( fffffffff , 0000 ) + +[35,12]: + int 7ffffffff000 <- ( fffffffff , 000 ) + +[35,11]: + int 3ffffffff800 <- ( fffffffff , 000 ) + +[35,10]: + int 1ffffffffc00 <- ( fffffffff , 000 ) + +[35,9]: + int 0ffffffffe00 <- ( fffffffff , 000 ) + +[35,8]: + int 7ffffffff00 <- ( fffffffff , 00 ) + +[35,7]: + int 3ffffffff80 <- ( fffffffff , 00 ) + +[35,6]: + int 1ffffffffc0 <- ( fffffffff , 00 ) + +[35,5]: + int 0ffffffffe0 <- ( fffffffff , 00 ) + +[35,4]: + int 7ffffffff0 <- ( fffffffff , 0 ) + +[35,3]: + int 3ffffffff8 <- ( fffffffff , 0 ) + +[35,2]: + int 1ffffffffc <- ( fffffffff , 0 ) + +[35,1]: + int 0ffffffffe <- ( fffffffff , 0 ) + +[34,64]: + int 3ffffffff0000000000000000 <- ( fffffffff , 0000000000000000 ) + +[34,63]: + int 1ffffffff8000000000000000 <- ( fffffffff , 0000000000000000 ) + +[34,62]: + int 0ffffffffc000000000000000 <- ( fffffffff , 0000000000000000 ) + +[34,61]: + int 7fffffffe000000000000000 <- ( fffffffff , 0000000000000000 ) + +[34,60]: + int 3ffffffff000000000000000 <- ( fffffffff , 000000000000000 ) + +[34,59]: + int 1ffffffff800000000000000 <- ( fffffffff , 000000000000000 ) + +[34,58]: + int 0ffffffffc00000000000000 <- ( fffffffff , 000000000000000 ) + +[34,57]: + int 7fffffffe00000000000000 <- ( fffffffff , 000000000000000 ) + +[34,56]: + int 3ffffffff00000000000000 <- ( fffffffff , 00000000000000 ) + +[34,55]: + int 1ffffffff80000000000000 <- ( fffffffff , 00000000000000 ) + +[34,54]: + int 0ffffffffc0000000000000 <- ( fffffffff , 00000000000000 ) + +[34,53]: + int 7fffffffe0000000000000 <- ( fffffffff , 00000000000000 ) + +[34,52]: + int 3ffffffff0000000000000 <- ( fffffffff , 0000000000000 ) + +[34,51]: + int 1ffffffff8000000000000 <- ( fffffffff , 0000000000000 ) + +[34,50]: + int 0ffffffffc000000000000 <- ( fffffffff , 0000000000000 ) + +[34,49]: + int 7fffffffe000000000000 <- ( fffffffff , 0000000000000 ) + +[34,48]: + int 3ffffffff000000000000 <- ( fffffffff , 000000000000 ) + +[34,47]: + int 1ffffffff800000000000 <- ( fffffffff , 000000000000 ) + +[34,46]: + int 0ffffffffc00000000000 <- ( fffffffff , 000000000000 ) + +[34,45]: + int 7fffffffe00000000000 <- ( fffffffff , 000000000000 ) + +[34,44]: + int 3ffffffff00000000000 <- ( fffffffff , 00000000000 ) + +[34,43]: + int 1ffffffff80000000000 <- ( fffffffff , 00000000000 ) + +[34,42]: + int 0ffffffffc0000000000 <- ( fffffffff , 00000000000 ) + +[34,41]: + int 7fffffffe0000000000 <- ( fffffffff , 00000000000 ) + +[34,40]: + int 3ffffffff0000000000 <- ( fffffffff , 0000000000 ) + +[34,39]: + int 1ffffffff8000000000 <- ( fffffffff , 0000000000 ) + +[34,38]: + int 0ffffffffc000000000 <- ( fffffffff , 0000000000 ) + +[34,37]: + int 7fffffffe000000000 <- ( fffffffff , 0000000000 ) + +[34,36]: + int 3ffffffff000000000 <- ( fffffffff , 000000000 ) + +[34,35]: + int 1ffffffff800000000 <- ( fffffffff , 000000000 ) + +[34,34]: + int 0ffffffffc00000000 <- ( fffffffff , 000000000 ) + +[34,33]: + int 7fffffffe00000000 <- ( fffffffff , 000000000 ) + +[34,32]: + int 3ffffffff00000000 <- ( fffffffff , 00000000 ) + +[34,31]: + int 1ffffffff80000000 <- ( fffffffff , 00000000 ) + +[34,30]: + int 0ffffffffc0000000 <- ( fffffffff , 00000000 ) + +[34,29]: + int 7fffffffe0000000 <- ( fffffffff , 00000000 ) + +[34,28]: + int 3ffffffff0000000 <- ( fffffffff , 0000000 ) + +[34,27]: + int 1ffffffff8000000 <- ( fffffffff , 0000000 ) + +[34,26]: + int 0ffffffffc000000 <- ( fffffffff , 0000000 ) + +[34,25]: + int 7fffffffe000000 <- ( fffffffff , 0000000 ) + +[34,24]: + int 3ffffffff000000 <- ( fffffffff , 000000 ) + +[34,23]: + int 1ffffffff800000 <- ( fffffffff , 000000 ) + +[34,22]: + int 0ffffffffc00000 <- ( fffffffff , 000000 ) + +[34,21]: + int 7fffffffe00000 <- ( fffffffff , 000000 ) + +[34,20]: + int 3ffffffff00000 <- ( fffffffff , 00000 ) + +[34,19]: + int 1ffffffff80000 <- ( fffffffff , 00000 ) + +[34,18]: + int 0ffffffffc0000 <- ( fffffffff , 00000 ) + +[34,17]: + int 7fffffffe0000 <- ( fffffffff , 00000 ) + +[34,16]: + int 3ffffffff0000 <- ( fffffffff , 0000 ) + +[34,15]: + int 1ffffffff8000 <- ( fffffffff , 0000 ) + +[34,14]: + int 0ffffffffc000 <- ( fffffffff , 0000 ) + +[34,13]: + int 7fffffffe000 <- ( fffffffff , 0000 ) + +[34,12]: + int 3ffffffff000 <- ( fffffffff , 000 ) + +[34,11]: + int 1ffffffff800 <- ( fffffffff , 000 ) + +[34,10]: + int 0ffffffffc00 <- ( fffffffff , 000 ) + +[34,9]: + int 7fffffffe00 <- ( fffffffff , 000 ) + +[34,8]: + int 3ffffffff00 <- ( fffffffff , 00 ) + +[34,7]: + int 1ffffffff80 <- ( fffffffff , 00 ) + +[34,6]: + int 0ffffffffc0 <- ( fffffffff , 00 ) + +[34,5]: + int 7fffffffe0 <- ( fffffffff , 00 ) + +[34,4]: + int 3ffffffff0 <- ( fffffffff , 0 ) + +[34,3]: + int 1ffffffff8 <- ( fffffffff , 0 ) + +[34,2]: + int 0ffffffffc <- ( fffffffff , 0 ) + +[34,1]: + int 7fffffffe <- ( fffffffff , 0 ) + +[33,64]: + int 1ffffffff0000000000000000 <- ( fffffffff , 0000000000000000 ) + +[33,63]: + int 0ffffffff8000000000000000 <- ( fffffffff , 0000000000000000 ) + +[33,62]: + int 7fffffffc000000000000000 <- ( fffffffff , 0000000000000000 ) + +[33,61]: + int 3fffffffe000000000000000 <- ( fffffffff , 0000000000000000 ) + +[33,60]: + int 1ffffffff000000000000000 <- ( fffffffff , 000000000000000 ) + +[33,59]: + int 0ffffffff800000000000000 <- ( fffffffff , 000000000000000 ) + +[33,58]: + int 7fffffffc00000000000000 <- ( fffffffff , 000000000000000 ) + +[33,57]: + int 3fffffffe00000000000000 <- ( fffffffff , 000000000000000 ) + +[33,56]: + int 1ffffffff00000000000000 <- ( fffffffff , 00000000000000 ) + +[33,55]: + int 0ffffffff80000000000000 <- ( fffffffff , 00000000000000 ) + +[33,54]: + int 7fffffffc0000000000000 <- ( fffffffff , 00000000000000 ) + +[33,53]: + int 3fffffffe0000000000000 <- ( fffffffff , 00000000000000 ) + +[33,52]: + int 1ffffffff0000000000000 <- ( fffffffff , 0000000000000 ) + +[33,51]: + int 0ffffffff8000000000000 <- ( fffffffff , 0000000000000 ) + +[33,50]: + int 7fffffffc000000000000 <- ( fffffffff , 0000000000000 ) + +[33,49]: + int 3fffffffe000000000000 <- ( fffffffff , 0000000000000 ) + +[33,48]: + int 1ffffffff000000000000 <- ( fffffffff , 000000000000 ) + +[33,47]: + int 0ffffffff800000000000 <- ( fffffffff , 000000000000 ) + +[33,46]: + int 7fffffffc00000000000 <- ( fffffffff , 000000000000 ) + +[33,45]: + int 3fffffffe00000000000 <- ( fffffffff , 000000000000 ) + +[33,44]: + int 1ffffffff00000000000 <- ( fffffffff , 00000000000 ) + +[33,43]: + int 0ffffffff80000000000 <- ( fffffffff , 00000000000 ) + +[33,42]: + int 7fffffffc0000000000 <- ( fffffffff , 00000000000 ) + +[33,41]: + int 3fffffffe0000000000 <- ( fffffffff , 00000000000 ) + +[33,40]: + int 1ffffffff0000000000 <- ( fffffffff , 0000000000 ) + +[33,39]: + int 0ffffffff8000000000 <- ( fffffffff , 0000000000 ) + +[33,38]: + int 7fffffffc000000000 <- ( fffffffff , 0000000000 ) + +[33,37]: + int 3fffffffe000000000 <- ( fffffffff , 0000000000 ) + +[33,36]: + int 1ffffffff000000000 <- ( fffffffff , 000000000 ) + +[33,35]: + int 0ffffffff800000000 <- ( fffffffff , 000000000 ) + +[33,34]: + int 7fffffffc00000000 <- ( fffffffff , 000000000 ) + +[33,33]: + int 3fffffffe00000000 <- ( fffffffff , 000000000 ) + +[33,32]: + int 1ffffffff00000000 <- ( fffffffff , 00000000 ) + +[33,31]: + int 0ffffffff80000000 <- ( fffffffff , 00000000 ) + +[33,30]: + int 7fffffffc0000000 <- ( fffffffff , 00000000 ) + +[33,29]: + int 3fffffffe0000000 <- ( fffffffff , 00000000 ) + +[33,28]: + int 1ffffffff0000000 <- ( fffffffff , 0000000 ) + +[33,27]: + int 0ffffffff8000000 <- ( fffffffff , 0000000 ) + +[33,26]: + int 7fffffffc000000 <- ( fffffffff , 0000000 ) + +[33,25]: + int 3fffffffe000000 <- ( fffffffff , 0000000 ) + +[33,24]: + int 1ffffffff000000 <- ( fffffffff , 000000 ) + +[33,23]: + int 0ffffffff800000 <- ( fffffffff , 000000 ) + +[33,22]: + int 7fffffffc00000 <- ( fffffffff , 000000 ) + +[33,21]: + int 3fffffffe00000 <- ( fffffffff , 000000 ) + +[33,20]: + int 1ffffffff00000 <- ( fffffffff , 00000 ) + +[33,19]: + int 0ffffffff80000 <- ( fffffffff , 00000 ) + +[33,18]: + int 7fffffffc0000 <- ( fffffffff , 00000 ) + +[33,17]: + int 3fffffffe0000 <- ( fffffffff , 00000 ) + +[33,16]: + int 1ffffffff0000 <- ( fffffffff , 0000 ) + +[33,15]: + int 0ffffffff8000 <- ( fffffffff , 0000 ) + +[33,14]: + int 7fffffffc000 <- ( fffffffff , 0000 ) + +[33,13]: + int 3fffffffe000 <- ( fffffffff , 0000 ) + +[33,12]: + int 1ffffffff000 <- ( fffffffff , 000 ) + +[33,11]: + int 0ffffffff800 <- ( fffffffff , 000 ) + +[33,10]: + int 7fffffffc00 <- ( fffffffff , 000 ) + +[33,9]: + int 3fffffffe00 <- ( fffffffff , 000 ) + +[33,8]: + int 1ffffffff00 <- ( fffffffff , 00 ) + +[33,7]: + int 0ffffffff80 <- ( fffffffff , 00 ) + +[33,6]: + int 7fffffffc0 <- ( fffffffff , 00 ) + +[33,5]: + int 3fffffffe0 <- ( fffffffff , 00 ) + +[33,4]: + int 1ffffffff0 <- ( fffffffff , 0 ) + +[33,3]: + int 0ffffffff8 <- ( fffffffff , 0 ) + +[33,2]: + int 7fffffffc <- ( fffffffff , 0 ) + +[33,1]: + int 3fffffffe <- ( fffffffff , 0 ) + +[32,64]: + int 0ffffffff0000000000000000 <- ( ffffffff , 0000000000000000 ) + +[32,63]: + int 7fffffff8000000000000000 <- ( ffffffff , 0000000000000000 ) + +[32,62]: + int 3fffffffc000000000000000 <- ( ffffffff , 0000000000000000 ) + +[32,61]: + int 1fffffffe000000000000000 <- ( ffffffff , 0000000000000000 ) + +[32,60]: + int 0ffffffff000000000000000 <- ( ffffffff , 000000000000000 ) + +[32,59]: + int 7fffffff800000000000000 <- ( ffffffff , 000000000000000 ) + +[32,58]: + int 3fffffffc00000000000000 <- ( ffffffff , 000000000000000 ) + +[32,57]: + int 1fffffffe00000000000000 <- ( ffffffff , 000000000000000 ) + +[32,56]: + int 0ffffffff00000000000000 <- ( ffffffff , 00000000000000 ) + +[32,55]: + int 7fffffff80000000000000 <- ( ffffffff , 00000000000000 ) + +[32,54]: + int 3fffffffc0000000000000 <- ( ffffffff , 00000000000000 ) + +[32,53]: + int 1fffffffe0000000000000 <- ( ffffffff , 00000000000000 ) + +[32,52]: + int 0ffffffff0000000000000 <- ( ffffffff , 0000000000000 ) + +[32,51]: + int 7fffffff8000000000000 <- ( ffffffff , 0000000000000 ) + +[32,50]: + int 3fffffffc000000000000 <- ( ffffffff , 0000000000000 ) + +[32,49]: + int 1fffffffe000000000000 <- ( ffffffff , 0000000000000 ) + +[32,48]: + int 0ffffffff000000000000 <- ( ffffffff , 000000000000 ) + +[32,47]: + int 7fffffff800000000000 <- ( ffffffff , 000000000000 ) + +[32,46]: + int 3fffffffc00000000000 <- ( ffffffff , 000000000000 ) + +[32,45]: + int 1fffffffe00000000000 <- ( ffffffff , 000000000000 ) + +[32,44]: + int 0ffffffff00000000000 <- ( ffffffff , 00000000000 ) + +[32,43]: + int 7fffffff80000000000 <- ( ffffffff , 00000000000 ) + +[32,42]: + int 3fffffffc0000000000 <- ( ffffffff , 00000000000 ) + +[32,41]: + int 1fffffffe0000000000 <- ( ffffffff , 00000000000 ) + +[32,40]: + int 0ffffffff0000000000 <- ( ffffffff , 0000000000 ) + +[32,39]: + int 7fffffff8000000000 <- ( ffffffff , 0000000000 ) + +[32,38]: + int 3fffffffc000000000 <- ( ffffffff , 0000000000 ) + +[32,37]: + int 1fffffffe000000000 <- ( ffffffff , 0000000000 ) + +[32,36]: + int 0ffffffff000000000 <- ( ffffffff , 000000000 ) + +[32,35]: + int 7fffffff800000000 <- ( ffffffff , 000000000 ) + +[32,34]: + int 3fffffffc00000000 <- ( ffffffff , 000000000 ) + +[32,33]: + int 1fffffffe00000000 <- ( ffffffff , 000000000 ) + +[32,32]: + int 0ffffffff00000000 <- ( ffffffff , 00000000 ) + +[32,31]: + int 7fffffff80000000 <- ( ffffffff , 00000000 ) + +[32,30]: + int 3fffffffc0000000 <- ( ffffffff , 00000000 ) + +[32,29]: + int 1fffffffe0000000 <- ( ffffffff , 00000000 ) + +[32,28]: + int 0ffffffff0000000 <- ( ffffffff , 0000000 ) + +[32,27]: + int 7fffffff8000000 <- ( ffffffff , 0000000 ) + +[32,26]: + int 3fffffffc000000 <- ( ffffffff , 0000000 ) + +[32,25]: + int 1fffffffe000000 <- ( ffffffff , 0000000 ) + +[32,24]: + int 0ffffffff000000 <- ( ffffffff , 000000 ) + +[32,23]: + int 7fffffff800000 <- ( ffffffff , 000000 ) + +[32,22]: + int 3fffffffc00000 <- ( ffffffff , 000000 ) + +[32,21]: + int 1fffffffe00000 <- ( ffffffff , 000000 ) + +[32,20]: + int 0ffffffff00000 <- ( ffffffff , 00000 ) + +[32,19]: + int 7fffffff80000 <- ( ffffffff , 00000 ) + +[32,18]: + int 3fffffffc0000 <- ( ffffffff , 00000 ) + +[32,17]: + int 1fffffffe0000 <- ( ffffffff , 00000 ) + +[32,16]: + int 0ffffffff0000 <- ( ffffffff , 0000 ) + +[32,15]: + int 7fffffff8000 <- ( ffffffff , 0000 ) + +[32,14]: + int 3fffffffc000 <- ( ffffffff , 0000 ) + +[32,13]: + int 1fffffffe000 <- ( ffffffff , 0000 ) + +[32,12]: + int 0ffffffff000 <- ( ffffffff , 000 ) + +[32,11]: + int 7fffffff800 <- ( ffffffff , 000 ) + +[32,10]: + int 3fffffffc00 <- ( ffffffff , 000 ) + +[32,9]: + int 1fffffffe00 <- ( ffffffff , 000 ) + +[32,8]: + int 0ffffffff00 <- ( ffffffff , 00 ) + +[32,7]: + int 7fffffff80 <- ( ffffffff , 00 ) + +[32,6]: + int 3fffffffc0 <- ( ffffffff , 00 ) + +[32,5]: + int 1fffffffe0 <- ( ffffffff , 00 ) + +[32,4]: + int 0ffffffff0 <- ( ffffffff , 0 ) + +[32,3]: + int 7fffffff8 <- ( ffffffff , 0 ) + +[32,2]: + int 3fffffffc <- ( ffffffff , 0 ) + +[32,1]: + int 1fffffffe <- ( ffffffff , 0 ) + +[31,64]: + int 7fffffff0000000000000000 <- ( ffffffff , 0000000000000000 ) + +[31,63]: + int 3fffffff8000000000000000 <- ( ffffffff , 0000000000000000 ) + +[31,62]: + int 1fffffffc000000000000000 <- ( ffffffff , 0000000000000000 ) + +[31,61]: + int 0fffffffe000000000000000 <- ( ffffffff , 0000000000000000 ) + +[31,60]: + int 7fffffff000000000000000 <- ( ffffffff , 000000000000000 ) + +[31,59]: + int 3fffffff800000000000000 <- ( ffffffff , 000000000000000 ) + +[31,58]: + int 1fffffffc00000000000000 <- ( ffffffff , 000000000000000 ) + +[31,57]: + int 0fffffffe00000000000000 <- ( ffffffff , 000000000000000 ) + +[31,56]: + int 7fffffff00000000000000 <- ( ffffffff , 00000000000000 ) + +[31,55]: + int 3fffffff80000000000000 <- ( ffffffff , 00000000000000 ) + +[31,54]: + int 1fffffffc0000000000000 <- ( ffffffff , 00000000000000 ) + +[31,53]: + int 0fffffffe0000000000000 <- ( ffffffff , 00000000000000 ) + +[31,52]: + int 7fffffff0000000000000 <- ( ffffffff , 0000000000000 ) + +[31,51]: + int 3fffffff8000000000000 <- ( ffffffff , 0000000000000 ) + +[31,50]: + int 1fffffffc000000000000 <- ( ffffffff , 0000000000000 ) + +[31,49]: + int 0fffffffe000000000000 <- ( ffffffff , 0000000000000 ) + +[31,48]: + int 7fffffff000000000000 <- ( ffffffff , 000000000000 ) + +[31,47]: + int 3fffffff800000000000 <- ( ffffffff , 000000000000 ) + +[31,46]: + int 1fffffffc00000000000 <- ( ffffffff , 000000000000 ) + +[31,45]: + int 0fffffffe00000000000 <- ( ffffffff , 000000000000 ) + +[31,44]: + int 7fffffff00000000000 <- ( ffffffff , 00000000000 ) + +[31,43]: + int 3fffffff80000000000 <- ( ffffffff , 00000000000 ) + +[31,42]: + int 1fffffffc0000000000 <- ( ffffffff , 00000000000 ) + +[31,41]: + int 0fffffffe0000000000 <- ( ffffffff , 00000000000 ) + +[31,40]: + int 7fffffff0000000000 <- ( ffffffff , 0000000000 ) + +[31,39]: + int 3fffffff8000000000 <- ( ffffffff , 0000000000 ) + +[31,38]: + int 1fffffffc000000000 <- ( ffffffff , 0000000000 ) + +[31,37]: + int 0fffffffe000000000 <- ( ffffffff , 0000000000 ) + +[31,36]: + int 7fffffff000000000 <- ( ffffffff , 000000000 ) + +[31,35]: + int 3fffffff800000000 <- ( ffffffff , 000000000 ) + +[31,34]: + int 1fffffffc00000000 <- ( ffffffff , 000000000 ) + +[31,33]: + int 0fffffffe00000000 <- ( ffffffff , 000000000 ) + +[31,32]: + int 7fffffff00000000 <- ( ffffffff , 00000000 ) + +[31,31]: + int 3fffffff80000000 <- ( ffffffff , 00000000 ) + +[31,30]: + int 1fffffffc0000000 <- ( ffffffff , 00000000 ) + +[31,29]: + int 0fffffffe0000000 <- ( ffffffff , 00000000 ) + +[31,28]: + int 7fffffff0000000 <- ( ffffffff , 0000000 ) + +[31,27]: + int 3fffffff8000000 <- ( ffffffff , 0000000 ) + +[31,26]: + int 1fffffffc000000 <- ( ffffffff , 0000000 ) + +[31,25]: + int 0fffffffe000000 <- ( ffffffff , 0000000 ) + +[31,24]: + int 7fffffff000000 <- ( ffffffff , 000000 ) + +[31,23]: + int 3fffffff800000 <- ( ffffffff , 000000 ) + +[31,22]: + int 1fffffffc00000 <- ( ffffffff , 000000 ) + +[31,21]: + int 0fffffffe00000 <- ( ffffffff , 000000 ) + +[31,20]: + int 7fffffff00000 <- ( ffffffff , 00000 ) + +[31,19]: + int 3fffffff80000 <- ( ffffffff , 00000 ) + +[31,18]: + int 1fffffffc0000 <- ( ffffffff , 00000 ) + +[31,17]: + int 0fffffffe0000 <- ( ffffffff , 00000 ) + +[31,16]: + int 7fffffff0000 <- ( ffffffff , 0000 ) + +[31,15]: + int 3fffffff8000 <- ( ffffffff , 0000 ) + +[31,14]: + int 1fffffffc000 <- ( ffffffff , 0000 ) + +[31,13]: + int 0fffffffe000 <- ( ffffffff , 0000 ) + +[31,12]: + int 7fffffff000 <- ( ffffffff , 000 ) + +[31,11]: + int 3fffffff800 <- ( ffffffff , 000 ) + +[31,10]: + int 1fffffffc00 <- ( ffffffff , 000 ) + +[31,9]: + int 0fffffffe00 <- ( ffffffff , 000 ) + +[31,8]: + int 7fffffff00 <- ( ffffffff , 00 ) + +[31,7]: + int 3fffffff80 <- ( ffffffff , 00 ) + +[31,6]: + int 1fffffffc0 <- ( ffffffff , 00 ) + +[31,5]: + int 0fffffffe0 <- ( ffffffff , 00 ) + +[31,4]: + int 7fffffff0 <- ( ffffffff , 0 ) + +[31,3]: + int 3fffffff8 <- ( ffffffff , 0 ) + +[31,2]: + int 1fffffffc <- ( ffffffff , 0 ) + +[31,1]: + int 0fffffffe <- ( ffffffff , 0 ) + +[30,64]: + int 3fffffff0000000000000000 <- ( ffffffff , 0000000000000000 ) + +[30,63]: + int 1fffffff8000000000000000 <- ( ffffffff , 0000000000000000 ) + +[30,62]: + int 0fffffffc000000000000000 <- ( ffffffff , 0000000000000000 ) + +[30,61]: + int 7ffffffe000000000000000 <- ( ffffffff , 0000000000000000 ) + +[30,60]: + int 3fffffff000000000000000 <- ( ffffffff , 000000000000000 ) + +[30,59]: + int 1fffffff800000000000000 <- ( ffffffff , 000000000000000 ) + +[30,58]: + int 0fffffffc00000000000000 <- ( ffffffff , 000000000000000 ) + +[30,57]: + int 7ffffffe00000000000000 <- ( ffffffff , 000000000000000 ) + +[30,56]: + int 3fffffff00000000000000 <- ( ffffffff , 00000000000000 ) + +[30,55]: + int 1fffffff80000000000000 <- ( ffffffff , 00000000000000 ) + +[30,54]: + int 0fffffffc0000000000000 <- ( ffffffff , 00000000000000 ) + +[30,53]: + int 7ffffffe0000000000000 <- ( ffffffff , 00000000000000 ) + +[30,52]: + int 3fffffff0000000000000 <- ( ffffffff , 0000000000000 ) + +[30,51]: + int 1fffffff8000000000000 <- ( ffffffff , 0000000000000 ) + +[30,50]: + int 0fffffffc000000000000 <- ( ffffffff , 0000000000000 ) + +[30,49]: + int 7ffffffe000000000000 <- ( ffffffff , 0000000000000 ) + +[30,48]: + int 3fffffff000000000000 <- ( ffffffff , 000000000000 ) + +[30,47]: + int 1fffffff800000000000 <- ( ffffffff , 000000000000 ) + +[30,46]: + int 0fffffffc00000000000 <- ( ffffffff , 000000000000 ) + +[30,45]: + int 7ffffffe00000000000 <- ( ffffffff , 000000000000 ) + +[30,44]: + int 3fffffff00000000000 <- ( ffffffff , 00000000000 ) + +[30,43]: + int 1fffffff80000000000 <- ( ffffffff , 00000000000 ) + +[30,42]: + int 0fffffffc0000000000 <- ( ffffffff , 00000000000 ) + +[30,41]: + int 7ffffffe0000000000 <- ( ffffffff , 00000000000 ) + +[30,40]: + int 3fffffff0000000000 <- ( ffffffff , 0000000000 ) + +[30,39]: + int 1fffffff8000000000 <- ( ffffffff , 0000000000 ) + +[30,38]: + int 0fffffffc000000000 <- ( ffffffff , 0000000000 ) + +[30,37]: + int 7ffffffe000000000 <- ( ffffffff , 0000000000 ) + +[30,36]: + int 3fffffff000000000 <- ( ffffffff , 000000000 ) + +[30,35]: + int 1fffffff800000000 <- ( ffffffff , 000000000 ) + +[30,34]: + int 0fffffffc00000000 <- ( ffffffff , 000000000 ) + +[30,33]: + int 7ffffffe00000000 <- ( ffffffff , 000000000 ) + +[30,32]: + int 3fffffff00000000 <- ( ffffffff , 00000000 ) + +[30,31]: + int 1fffffff80000000 <- ( ffffffff , 00000000 ) + +[30,30]: + int 0fffffffc0000000 <- ( ffffffff , 00000000 ) + +[30,29]: + int 7ffffffe0000000 <- ( ffffffff , 00000000 ) + +[30,28]: + int 3fffffff0000000 <- ( ffffffff , 0000000 ) + +[30,27]: + int 1fffffff8000000 <- ( ffffffff , 0000000 ) + +[30,26]: + int 0fffffffc000000 <- ( ffffffff , 0000000 ) + +[30,25]: + int 7ffffffe000000 <- ( ffffffff , 0000000 ) + +[30,24]: + int 3fffffff000000 <- ( ffffffff , 000000 ) + +[30,23]: + int 1fffffff800000 <- ( ffffffff , 000000 ) + +[30,22]: + int 0fffffffc00000 <- ( ffffffff , 000000 ) + +[30,21]: + int 7ffffffe00000 <- ( ffffffff , 000000 ) + +[30,20]: + int 3fffffff00000 <- ( ffffffff , 00000 ) + +[30,19]: + int 1fffffff80000 <- ( ffffffff , 00000 ) + +[30,18]: + int 0fffffffc0000 <- ( ffffffff , 00000 ) + +[30,17]: + int 7ffffffe0000 <- ( ffffffff , 00000 ) + +[30,16]: + int 3fffffff0000 <- ( ffffffff , 0000 ) + +[30,15]: + int 1fffffff8000 <- ( ffffffff , 0000 ) + +[30,14]: + int 0fffffffc000 <- ( ffffffff , 0000 ) + +[30,13]: + int 7ffffffe000 <- ( ffffffff , 0000 ) + +[30,12]: + int 3fffffff000 <- ( ffffffff , 000 ) + +[30,11]: + int 1fffffff800 <- ( ffffffff , 000 ) + +[30,10]: + int 0fffffffc00 <- ( ffffffff , 000 ) + +[30,9]: + int 7ffffffe00 <- ( ffffffff , 000 ) + +[30,8]: + int 3fffffff00 <- ( ffffffff , 00 ) + +[30,7]: + int 1fffffff80 <- ( ffffffff , 00 ) + +[30,6]: + int 0fffffffc0 <- ( ffffffff , 00 ) + +[30,5]: + int 7ffffffe0 <- ( ffffffff , 00 ) + +[30,4]: + int 3fffffff0 <- ( ffffffff , 0 ) + +[30,3]: + int 1fffffff8 <- ( ffffffff , 0 ) + +[30,2]: + int 0fffffffc <- ( ffffffff , 0 ) + +[30,1]: + int 7ffffffe <- ( ffffffff , 0 ) + +[29,64]: + int 1fffffff0000000000000000 <- ( ffffffff , 0000000000000000 ) + +[29,63]: + int 0fffffff8000000000000000 <- ( ffffffff , 0000000000000000 ) + +[29,62]: + int 7ffffffc000000000000000 <- ( ffffffff , 0000000000000000 ) + +[29,61]: + int 3ffffffe000000000000000 <- ( ffffffff , 0000000000000000 ) + +[29,60]: + int 1fffffff000000000000000 <- ( ffffffff , 000000000000000 ) + +[29,59]: + int 0fffffff800000000000000 <- ( ffffffff , 000000000000000 ) + +[29,58]: + int 7ffffffc00000000000000 <- ( ffffffff , 000000000000000 ) + +[29,57]: + int 3ffffffe00000000000000 <- ( ffffffff , 000000000000000 ) + +[29,56]: + int 1fffffff00000000000000 <- ( ffffffff , 00000000000000 ) + +[29,55]: + int 0fffffff80000000000000 <- ( ffffffff , 00000000000000 ) + +[29,54]: + int 7ffffffc0000000000000 <- ( ffffffff , 00000000000000 ) + +[29,53]: + int 3ffffffe0000000000000 <- ( ffffffff , 00000000000000 ) + +[29,52]: + int 1fffffff0000000000000 <- ( ffffffff , 0000000000000 ) + +[29,51]: + int 0fffffff8000000000000 <- ( ffffffff , 0000000000000 ) + +[29,50]: + int 7ffffffc000000000000 <- ( ffffffff , 0000000000000 ) + +[29,49]: + int 3ffffffe000000000000 <- ( ffffffff , 0000000000000 ) + +[29,48]: + int 1fffffff000000000000 <- ( ffffffff , 000000000000 ) + +[29,47]: + int 0fffffff800000000000 <- ( ffffffff , 000000000000 ) + +[29,46]: + int 7ffffffc00000000000 <- ( ffffffff , 000000000000 ) + +[29,45]: + int 3ffffffe00000000000 <- ( ffffffff , 000000000000 ) + +[29,44]: + int 1fffffff00000000000 <- ( ffffffff , 00000000000 ) + +[29,43]: + int 0fffffff80000000000 <- ( ffffffff , 00000000000 ) + +[29,42]: + int 7ffffffc0000000000 <- ( ffffffff , 00000000000 ) + +[29,41]: + int 3ffffffe0000000000 <- ( ffffffff , 00000000000 ) + +[29,40]: + int 1fffffff0000000000 <- ( ffffffff , 0000000000 ) + +[29,39]: + int 0fffffff8000000000 <- ( ffffffff , 0000000000 ) + +[29,38]: + int 7ffffffc000000000 <- ( ffffffff , 0000000000 ) + +[29,37]: + int 3ffffffe000000000 <- ( ffffffff , 0000000000 ) + +[29,36]: + int 1fffffff000000000 <- ( ffffffff , 000000000 ) + +[29,35]: + int 0fffffff800000000 <- ( ffffffff , 000000000 ) + +[29,34]: + int 7ffffffc00000000 <- ( ffffffff , 000000000 ) + +[29,33]: + int 3ffffffe00000000 <- ( ffffffff , 000000000 ) + +[29,32]: + int 1fffffff00000000 <- ( ffffffff , 00000000 ) + +[29,31]: + int 0fffffff80000000 <- ( ffffffff , 00000000 ) + +[29,30]: + int 7ffffffc0000000 <- ( ffffffff , 00000000 ) + +[29,29]: + int 3ffffffe0000000 <- ( ffffffff , 00000000 ) + +[29,28]: + int 1fffffff0000000 <- ( ffffffff , 0000000 ) + +[29,27]: + int 0fffffff8000000 <- ( ffffffff , 0000000 ) + +[29,26]: + int 7ffffffc000000 <- ( ffffffff , 0000000 ) + +[29,25]: + int 3ffffffe000000 <- ( ffffffff , 0000000 ) + +[29,24]: + int 1fffffff000000 <- ( ffffffff , 000000 ) + +[29,23]: + int 0fffffff800000 <- ( ffffffff , 000000 ) + +[29,22]: + int 7ffffffc00000 <- ( ffffffff , 000000 ) + +[29,21]: + int 3ffffffe00000 <- ( ffffffff , 000000 ) + +[29,20]: + int 1fffffff00000 <- ( ffffffff , 00000 ) + +[29,19]: + int 0fffffff80000 <- ( ffffffff , 00000 ) + +[29,18]: + int 7ffffffc0000 <- ( ffffffff , 00000 ) + +[29,17]: + int 3ffffffe0000 <- ( ffffffff , 00000 ) + +[29,16]: + int 1fffffff0000 <- ( ffffffff , 0000 ) + +[29,15]: + int 0fffffff8000 <- ( ffffffff , 0000 ) + +[29,14]: + int 7ffffffc000 <- ( ffffffff , 0000 ) + +[29,13]: + int 3ffffffe000 <- ( ffffffff , 0000 ) + +[29,12]: + int 1fffffff000 <- ( ffffffff , 000 ) + +[29,11]: + int 0fffffff800 <- ( ffffffff , 000 ) + +[29,10]: + int 7ffffffc00 <- ( ffffffff , 000 ) + +[29,9]: + int 3ffffffe00 <- ( ffffffff , 000 ) + +[29,8]: + int 1fffffff00 <- ( ffffffff , 00 ) + +[29,7]: + int 0fffffff80 <- ( ffffffff , 00 ) + +[29,6]: + int 7ffffffc0 <- ( ffffffff , 00 ) + +[29,5]: + int 3ffffffe0 <- ( ffffffff , 00 ) + +[29,4]: + int 1fffffff0 <- ( ffffffff , 0 ) + +[29,3]: + int 0fffffff8 <- ( ffffffff , 0 ) + +[29,2]: + int 7ffffffc <- ( ffffffff , 0 ) + +[29,1]: + int 3ffffffe <- ( ffffffff , 0 ) + +[28,64]: + int 0fffffff0000000000000000 <- ( fffffff , 0000000000000000 ) + +[28,63]: + int 7ffffff8000000000000000 <- ( fffffff , 0000000000000000 ) + +[28,62]: + int 3ffffffc000000000000000 <- ( fffffff , 0000000000000000 ) + +[28,61]: + int 1ffffffe000000000000000 <- ( fffffff , 0000000000000000 ) + +[28,60]: + int 0fffffff000000000000000 <- ( fffffff , 000000000000000 ) + +[28,59]: + int 7ffffff800000000000000 <- ( fffffff , 000000000000000 ) + +[28,58]: + int 3ffffffc00000000000000 <- ( fffffff , 000000000000000 ) + +[28,57]: + int 1ffffffe00000000000000 <- ( fffffff , 000000000000000 ) + +[28,56]: + int 0fffffff00000000000000 <- ( fffffff , 00000000000000 ) + +[28,55]: + int 7ffffff80000000000000 <- ( fffffff , 00000000000000 ) + +[28,54]: + int 3ffffffc0000000000000 <- ( fffffff , 00000000000000 ) + +[28,53]: + int 1ffffffe0000000000000 <- ( fffffff , 00000000000000 ) + +[28,52]: + int 0fffffff0000000000000 <- ( fffffff , 0000000000000 ) + +[28,51]: + int 7ffffff8000000000000 <- ( fffffff , 0000000000000 ) + +[28,50]: + int 3ffffffc000000000000 <- ( fffffff , 0000000000000 ) + +[28,49]: + int 1ffffffe000000000000 <- ( fffffff , 0000000000000 ) + +[28,48]: + int 0fffffff000000000000 <- ( fffffff , 000000000000 ) + +[28,47]: + int 7ffffff800000000000 <- ( fffffff , 000000000000 ) + +[28,46]: + int 3ffffffc00000000000 <- ( fffffff , 000000000000 ) + +[28,45]: + int 1ffffffe00000000000 <- ( fffffff , 000000000000 ) + +[28,44]: + int 0fffffff00000000000 <- ( fffffff , 00000000000 ) + +[28,43]: + int 7ffffff80000000000 <- ( fffffff , 00000000000 ) + +[28,42]: + int 3ffffffc0000000000 <- ( fffffff , 00000000000 ) + +[28,41]: + int 1ffffffe0000000000 <- ( fffffff , 00000000000 ) + +[28,40]: + int 0fffffff0000000000 <- ( fffffff , 0000000000 ) + +[28,39]: + int 7ffffff8000000000 <- ( fffffff , 0000000000 ) + +[28,38]: + int 3ffffffc000000000 <- ( fffffff , 0000000000 ) + +[28,37]: + int 1ffffffe000000000 <- ( fffffff , 0000000000 ) + +[28,36]: + int 0fffffff000000000 <- ( fffffff , 000000000 ) + +[28,35]: + int 7ffffff800000000 <- ( fffffff , 000000000 ) + +[28,34]: + int 3ffffffc00000000 <- ( fffffff , 000000000 ) + +[28,33]: + int 1ffffffe00000000 <- ( fffffff , 000000000 ) + +[28,32]: + int 0fffffff00000000 <- ( fffffff , 00000000 ) + +[28,31]: + int 7ffffff80000000 <- ( fffffff , 00000000 ) + +[28,30]: + int 3ffffffc0000000 <- ( fffffff , 00000000 ) + +[28,29]: + int 1ffffffe0000000 <- ( fffffff , 00000000 ) + +[28,28]: + int 0fffffff0000000 <- ( fffffff , 0000000 ) + +[28,27]: + int 7ffffff8000000 <- ( fffffff , 0000000 ) + +[28,26]: + int 3ffffffc000000 <- ( fffffff , 0000000 ) + +[28,25]: + int 1ffffffe000000 <- ( fffffff , 0000000 ) + +[28,24]: + int 0fffffff000000 <- ( fffffff , 000000 ) + +[28,23]: + int 7ffffff800000 <- ( fffffff , 000000 ) + +[28,22]: + int 3ffffffc00000 <- ( fffffff , 000000 ) + +[28,21]: + int 1ffffffe00000 <- ( fffffff , 000000 ) + +[28,20]: + int 0fffffff00000 <- ( fffffff , 00000 ) + +[28,19]: + int 7ffffff80000 <- ( fffffff , 00000 ) + +[28,18]: + int 3ffffffc0000 <- ( fffffff , 00000 ) + +[28,17]: + int 1ffffffe0000 <- ( fffffff , 00000 ) + +[28,16]: + int 0fffffff0000 <- ( fffffff , 0000 ) + +[28,15]: + int 7ffffff8000 <- ( fffffff , 0000 ) + +[28,14]: + int 3ffffffc000 <- ( fffffff , 0000 ) + +[28,13]: + int 1ffffffe000 <- ( fffffff , 0000 ) + +[28,12]: + int 0fffffff000 <- ( fffffff , 000 ) + +[28,11]: + int 7ffffff800 <- ( fffffff , 000 ) + +[28,10]: + int 3ffffffc00 <- ( fffffff , 000 ) + +[28,9]: + int 1ffffffe00 <- ( fffffff , 000 ) + +[28,8]: + int 0fffffff00 <- ( fffffff , 00 ) + +[28,7]: + int 7ffffff80 <- ( fffffff , 00 ) + +[28,6]: + int 3ffffffc0 <- ( fffffff , 00 ) + +[28,5]: + int 1ffffffe0 <- ( fffffff , 00 ) + +[28,4]: + int 0fffffff0 <- ( fffffff , 0 ) + +[28,3]: + int 7ffffff8 <- ( fffffff , 0 ) + +[28,2]: + int 3ffffffc <- ( fffffff , 0 ) + +[28,1]: + int 1ffffffe <- ( fffffff , 0 ) + +[27,64]: + int 7ffffff0000000000000000 <- ( fffffff , 0000000000000000 ) + +[27,63]: + int 3ffffff8000000000000000 <- ( fffffff , 0000000000000000 ) + +[27,62]: + int 1ffffffc000000000000000 <- ( fffffff , 0000000000000000 ) + +[27,61]: + int 0ffffffe000000000000000 <- ( fffffff , 0000000000000000 ) + +[27,60]: + int 7ffffff000000000000000 <- ( fffffff , 000000000000000 ) + +[27,59]: + int 3ffffff800000000000000 <- ( fffffff , 000000000000000 ) + +[27,58]: + int 1ffffffc00000000000000 <- ( fffffff , 000000000000000 ) + +[27,57]: + int 0ffffffe00000000000000 <- ( fffffff , 000000000000000 ) + +[27,56]: + int 7ffffff00000000000000 <- ( fffffff , 00000000000000 ) + +[27,55]: + int 3ffffff80000000000000 <- ( fffffff , 00000000000000 ) + +[27,54]: + int 1ffffffc0000000000000 <- ( fffffff , 00000000000000 ) + +[27,53]: + int 0ffffffe0000000000000 <- ( fffffff , 00000000000000 ) + +[27,52]: + int 7ffffff0000000000000 <- ( fffffff , 0000000000000 ) + +[27,51]: + int 3ffffff8000000000000 <- ( fffffff , 0000000000000 ) + +[27,50]: + int 1ffffffc000000000000 <- ( fffffff , 0000000000000 ) + +[27,49]: + int 0ffffffe000000000000 <- ( fffffff , 0000000000000 ) + +[27,48]: + int 7ffffff000000000000 <- ( fffffff , 000000000000 ) + +[27,47]: + int 3ffffff800000000000 <- ( fffffff , 000000000000 ) + +[27,46]: + int 1ffffffc00000000000 <- ( fffffff , 000000000000 ) + +[27,45]: + int 0ffffffe00000000000 <- ( fffffff , 000000000000 ) + +[27,44]: + int 7ffffff00000000000 <- ( fffffff , 00000000000 ) + +[27,43]: + int 3ffffff80000000000 <- ( fffffff , 00000000000 ) + +[27,42]: + int 1ffffffc0000000000 <- ( fffffff , 00000000000 ) + +[27,41]: + int 0ffffffe0000000000 <- ( fffffff , 00000000000 ) + +[27,40]: + int 7ffffff0000000000 <- ( fffffff , 0000000000 ) + +[27,39]: + int 3ffffff8000000000 <- ( fffffff , 0000000000 ) + +[27,38]: + int 1ffffffc000000000 <- ( fffffff , 0000000000 ) + +[27,37]: + int 0ffffffe000000000 <- ( fffffff , 0000000000 ) + +[27,36]: + int 7ffffff000000000 <- ( fffffff , 000000000 ) + +[27,35]: + int 3ffffff800000000 <- ( fffffff , 000000000 ) + +[27,34]: + int 1ffffffc00000000 <- ( fffffff , 000000000 ) + +[27,33]: + int 0ffffffe00000000 <- ( fffffff , 000000000 ) + +[27,32]: + int 7ffffff00000000 <- ( fffffff , 00000000 ) + +[27,31]: + int 3ffffff80000000 <- ( fffffff , 00000000 ) + +[27,30]: + int 1ffffffc0000000 <- ( fffffff , 00000000 ) + +[27,29]: + int 0ffffffe0000000 <- ( fffffff , 00000000 ) + +[27,28]: + int 7ffffff0000000 <- ( fffffff , 0000000 ) + +[27,27]: + int 3ffffff8000000 <- ( fffffff , 0000000 ) + +[27,26]: + int 1ffffffc000000 <- ( fffffff , 0000000 ) + +[27,25]: + int 0ffffffe000000 <- ( fffffff , 0000000 ) + +[27,24]: + int 7ffffff000000 <- ( fffffff , 000000 ) + +[27,23]: + int 3ffffff800000 <- ( fffffff , 000000 ) + +[27,22]: + int 1ffffffc00000 <- ( fffffff , 000000 ) + +[27,21]: + int 0ffffffe00000 <- ( fffffff , 000000 ) + +[27,20]: + int 7ffffff00000 <- ( fffffff , 00000 ) + +[27,19]: + int 3ffffff80000 <- ( fffffff , 00000 ) + +[27,18]: + int 1ffffffc0000 <- ( fffffff , 00000 ) + +[27,17]: + int 0ffffffe0000 <- ( fffffff , 00000 ) + +[27,16]: + int 7ffffff0000 <- ( fffffff , 0000 ) + +[27,15]: + int 3ffffff8000 <- ( fffffff , 0000 ) + +[27,14]: + int 1ffffffc000 <- ( fffffff , 0000 ) + +[27,13]: + int 0ffffffe000 <- ( fffffff , 0000 ) + +[27,12]: + int 7ffffff000 <- ( fffffff , 000 ) + +[27,11]: + int 3ffffff800 <- ( fffffff , 000 ) + +[27,10]: + int 1ffffffc00 <- ( fffffff , 000 ) + +[27,9]: + int 0ffffffe00 <- ( fffffff , 000 ) + +[27,8]: + int 7ffffff00 <- ( fffffff , 00 ) + +[27,7]: + int 3ffffff80 <- ( fffffff , 00 ) + +[27,6]: + int 1ffffffc0 <- ( fffffff , 00 ) + +[27,5]: + int 0ffffffe0 <- ( fffffff , 00 ) + +[27,4]: + int 7ffffff0 <- ( fffffff , 0 ) + +[27,3]: + int 3ffffff8 <- ( fffffff , 0 ) + +[27,2]: + int 1ffffffc <- ( fffffff , 0 ) + +[27,1]: + int 0ffffffe <- ( fffffff , 0 ) + +[26,64]: + int 3ffffff0000000000000000 <- ( fffffff , 0000000000000000 ) + +[26,63]: + int 1ffffff8000000000000000 <- ( fffffff , 0000000000000000 ) + +[26,62]: + int 0ffffffc000000000000000 <- ( fffffff , 0000000000000000 ) + +[26,61]: + int 7fffffe000000000000000 <- ( fffffff , 0000000000000000 ) + +[26,60]: + int 3ffffff000000000000000 <- ( fffffff , 000000000000000 ) + +[26,59]: + int 1ffffff800000000000000 <- ( fffffff , 000000000000000 ) + +[26,58]: + int 0ffffffc00000000000000 <- ( fffffff , 000000000000000 ) + +[26,57]: + int 7fffffe00000000000000 <- ( fffffff , 000000000000000 ) + +[26,56]: + int 3ffffff00000000000000 <- ( fffffff , 00000000000000 ) + +[26,55]: + int 1ffffff80000000000000 <- ( fffffff , 00000000000000 ) + +[26,54]: + int 0ffffffc0000000000000 <- ( fffffff , 00000000000000 ) + +[26,53]: + int 7fffffe0000000000000 <- ( fffffff , 00000000000000 ) + +[26,52]: + int 3ffffff0000000000000 <- ( fffffff , 0000000000000 ) + +[26,51]: + int 1ffffff8000000000000 <- ( fffffff , 0000000000000 ) + +[26,50]: + int 0ffffffc000000000000 <- ( fffffff , 0000000000000 ) + +[26,49]: + int 7fffffe000000000000 <- ( fffffff , 0000000000000 ) + +[26,48]: + int 3ffffff000000000000 <- ( fffffff , 000000000000 ) + +[26,47]: + int 1ffffff800000000000 <- ( fffffff , 000000000000 ) + +[26,46]: + int 0ffffffc00000000000 <- ( fffffff , 000000000000 ) + +[26,45]: + int 7fffffe00000000000 <- ( fffffff , 000000000000 ) + +[26,44]: + int 3ffffff00000000000 <- ( fffffff , 00000000000 ) + +[26,43]: + int 1ffffff80000000000 <- ( fffffff , 00000000000 ) + +[26,42]: + int 0ffffffc0000000000 <- ( fffffff , 00000000000 ) + +[26,41]: + int 7fffffe0000000000 <- ( fffffff , 00000000000 ) + +[26,40]: + int 3ffffff0000000000 <- ( fffffff , 0000000000 ) + +[26,39]: + int 1ffffff8000000000 <- ( fffffff , 0000000000 ) + +[26,38]: + int 0ffffffc000000000 <- ( fffffff , 0000000000 ) + +[26,37]: + int 7fffffe000000000 <- ( fffffff , 0000000000 ) + +[26,36]: + int 3ffffff000000000 <- ( fffffff , 000000000 ) + +[26,35]: + int 1ffffff800000000 <- ( fffffff , 000000000 ) + +[26,34]: + int 0ffffffc00000000 <- ( fffffff , 000000000 ) + +[26,33]: + int 7fffffe00000000 <- ( fffffff , 000000000 ) + +[26,32]: + int 3ffffff00000000 <- ( fffffff , 00000000 ) + +[26,31]: + int 1ffffff80000000 <- ( fffffff , 00000000 ) + +[26,30]: + int 0ffffffc0000000 <- ( fffffff , 00000000 ) + +[26,29]: + int 7fffffe0000000 <- ( fffffff , 00000000 ) + +[26,28]: + int 3ffffff0000000 <- ( fffffff , 0000000 ) + +[26,27]: + int 1ffffff8000000 <- ( fffffff , 0000000 ) + +[26,26]: + int 0ffffffc000000 <- ( fffffff , 0000000 ) + +[26,25]: + int 7fffffe000000 <- ( fffffff , 0000000 ) + +[26,24]: + int 3ffffff000000 <- ( fffffff , 000000 ) + +[26,23]: + int 1ffffff800000 <- ( fffffff , 000000 ) + +[26,22]: + int 0ffffffc00000 <- ( fffffff , 000000 ) + +[26,21]: + int 7fffffe00000 <- ( fffffff , 000000 ) + +[26,20]: + int 3ffffff00000 <- ( fffffff , 00000 ) + +[26,19]: + int 1ffffff80000 <- ( fffffff , 00000 ) + +[26,18]: + int 0ffffffc0000 <- ( fffffff , 00000 ) + +[26,17]: + int 7fffffe0000 <- ( fffffff , 00000 ) + +[26,16]: + int 3ffffff0000 <- ( fffffff , 0000 ) + +[26,15]: + int 1ffffff8000 <- ( fffffff , 0000 ) + +[26,14]: + int 0ffffffc000 <- ( fffffff , 0000 ) + +[26,13]: + int 7fffffe000 <- ( fffffff , 0000 ) + +[26,12]: + int 3ffffff000 <- ( fffffff , 000 ) + +[26,11]: + int 1ffffff800 <- ( fffffff , 000 ) + +[26,10]: + int 0ffffffc00 <- ( fffffff , 000 ) + +[26,9]: + int 7fffffe00 <- ( fffffff , 000 ) + +[26,8]: + int 3ffffff00 <- ( fffffff , 00 ) + +[26,7]: + int 1ffffff80 <- ( fffffff , 00 ) + +[26,6]: + int 0ffffffc0 <- ( fffffff , 00 ) + +[26,5]: + int 7fffffe0 <- ( fffffff , 00 ) + +[26,4]: + int 3ffffff0 <- ( fffffff , 0 ) + +[26,3]: + int 1ffffff8 <- ( fffffff , 0 ) + +[26,2]: + int 0ffffffc <- ( fffffff , 0 ) + +[26,1]: + int 7fffffe <- ( fffffff , 0 ) + +[25,64]: + int 1ffffff0000000000000000 <- ( fffffff , 0000000000000000 ) + +[25,63]: + int 0ffffff8000000000000000 <- ( fffffff , 0000000000000000 ) + +[25,62]: + int 7fffffc000000000000000 <- ( fffffff , 0000000000000000 ) + +[25,61]: + int 3fffffe000000000000000 <- ( fffffff , 0000000000000000 ) + +[25,60]: + int 1ffffff000000000000000 <- ( fffffff , 000000000000000 ) + +[25,59]: + int 0ffffff800000000000000 <- ( fffffff , 000000000000000 ) + +[25,58]: + int 7fffffc00000000000000 <- ( fffffff , 000000000000000 ) + +[25,57]: + int 3fffffe00000000000000 <- ( fffffff , 000000000000000 ) + +[25,56]: + int 1ffffff00000000000000 <- ( fffffff , 00000000000000 ) + +[25,55]: + int 0ffffff80000000000000 <- ( fffffff , 00000000000000 ) + +[25,54]: + int 7fffffc0000000000000 <- ( fffffff , 00000000000000 ) + +[25,53]: + int 3fffffe0000000000000 <- ( fffffff , 00000000000000 ) + +[25,52]: + int 1ffffff0000000000000 <- ( fffffff , 0000000000000 ) + +[25,51]: + int 0ffffff8000000000000 <- ( fffffff , 0000000000000 ) + +[25,50]: + int 7fffffc000000000000 <- ( fffffff , 0000000000000 ) + +[25,49]: + int 3fffffe000000000000 <- ( fffffff , 0000000000000 ) + +[25,48]: + int 1ffffff000000000000 <- ( fffffff , 000000000000 ) + +[25,47]: + int 0ffffff800000000000 <- ( fffffff , 000000000000 ) + +[25,46]: + int 7fffffc00000000000 <- ( fffffff , 000000000000 ) + +[25,45]: + int 3fffffe00000000000 <- ( fffffff , 000000000000 ) + +[25,44]: + int 1ffffff00000000000 <- ( fffffff , 00000000000 ) + +[25,43]: + int 0ffffff80000000000 <- ( fffffff , 00000000000 ) + +[25,42]: + int 7fffffc0000000000 <- ( fffffff , 00000000000 ) + +[25,41]: + int 3fffffe0000000000 <- ( fffffff , 00000000000 ) + +[25,40]: + int 1ffffff0000000000 <- ( fffffff , 0000000000 ) + +[25,39]: + int 0ffffff8000000000 <- ( fffffff , 0000000000 ) + +[25,38]: + int 7fffffc000000000 <- ( fffffff , 0000000000 ) + +[25,37]: + int 3fffffe000000000 <- ( fffffff , 0000000000 ) + +[25,36]: + int 1ffffff000000000 <- ( fffffff , 000000000 ) + +[25,35]: + int 0ffffff800000000 <- ( fffffff , 000000000 ) + +[25,34]: + int 7fffffc00000000 <- ( fffffff , 000000000 ) + +[25,33]: + int 3fffffe00000000 <- ( fffffff , 000000000 ) + +[25,32]: + int 1ffffff00000000 <- ( fffffff , 00000000 ) + +[25,31]: + int 0ffffff80000000 <- ( fffffff , 00000000 ) + +[25,30]: + int 7fffffc0000000 <- ( fffffff , 00000000 ) + +[25,29]: + int 3fffffe0000000 <- ( fffffff , 00000000 ) + +[25,28]: + int 1ffffff0000000 <- ( fffffff , 0000000 ) + +[25,27]: + int 0ffffff8000000 <- ( fffffff , 0000000 ) + +[25,26]: + int 7fffffc000000 <- ( fffffff , 0000000 ) + +[25,25]: + int 3fffffe000000 <- ( fffffff , 0000000 ) + +[25,24]: + int 1ffffff000000 <- ( fffffff , 000000 ) + +[25,23]: + int 0ffffff800000 <- ( fffffff , 000000 ) + +[25,22]: + int 7fffffc00000 <- ( fffffff , 000000 ) + +[25,21]: + int 3fffffe00000 <- ( fffffff , 000000 ) + +[25,20]: + int 1ffffff00000 <- ( fffffff , 00000 ) + +[25,19]: + int 0ffffff80000 <- ( fffffff , 00000 ) + +[25,18]: + int 7fffffc0000 <- ( fffffff , 00000 ) + +[25,17]: + int 3fffffe0000 <- ( fffffff , 00000 ) + +[25,16]: + int 1ffffff0000 <- ( fffffff , 0000 ) + +[25,15]: + int 0ffffff8000 <- ( fffffff , 0000 ) + +[25,14]: + int 7fffffc000 <- ( fffffff , 0000 ) + +[25,13]: + int 3fffffe000 <- ( fffffff , 0000 ) + +[25,12]: + int 1ffffff000 <- ( fffffff , 000 ) + +[25,11]: + int 0ffffff800 <- ( fffffff , 000 ) + +[25,10]: + int 7fffffc00 <- ( fffffff , 000 ) + +[25,9]: + int 3fffffe00 <- ( fffffff , 000 ) + +[25,8]: + int 1ffffff00 <- ( fffffff , 00 ) + +[25,7]: + int 0ffffff80 <- ( fffffff , 00 ) + +[25,6]: + int 7fffffc0 <- ( fffffff , 00 ) + +[25,5]: + int 3fffffe0 <- ( fffffff , 00 ) + +[25,4]: + int 1ffffff0 <- ( fffffff , 0 ) + +[25,3]: + int 0ffffff8 <- ( fffffff , 0 ) + +[25,2]: + int 7fffffc <- ( fffffff , 0 ) + +[25,1]: + int 3fffffe <- ( fffffff , 0 ) + +[24,64]: + int 0ffffff0000000000000000 <- ( ffffff , 0000000000000000 ) + +[24,63]: + int 7fffff8000000000000000 <- ( ffffff , 0000000000000000 ) + +[24,62]: + int 3fffffc000000000000000 <- ( ffffff , 0000000000000000 ) + +[24,61]: + int 1fffffe000000000000000 <- ( ffffff , 0000000000000000 ) + +[24,60]: + int 0ffffff000000000000000 <- ( ffffff , 000000000000000 ) + +[24,59]: + int 7fffff800000000000000 <- ( ffffff , 000000000000000 ) + +[24,58]: + int 3fffffc00000000000000 <- ( ffffff , 000000000000000 ) + +[24,57]: + int 1fffffe00000000000000 <- ( ffffff , 000000000000000 ) + +[24,56]: + int 0ffffff00000000000000 <- ( ffffff , 00000000000000 ) + +[24,55]: + int 7fffff80000000000000 <- ( ffffff , 00000000000000 ) + +[24,54]: + int 3fffffc0000000000000 <- ( ffffff , 00000000000000 ) + +[24,53]: + int 1fffffe0000000000000 <- ( ffffff , 00000000000000 ) + +[24,52]: + int 0ffffff0000000000000 <- ( ffffff , 0000000000000 ) + +[24,51]: + int 7fffff8000000000000 <- ( ffffff , 0000000000000 ) + +[24,50]: + int 3fffffc000000000000 <- ( ffffff , 0000000000000 ) + +[24,49]: + int 1fffffe000000000000 <- ( ffffff , 0000000000000 ) + +[24,48]: + int 0ffffff000000000000 <- ( ffffff , 000000000000 ) + +[24,47]: + int 7fffff800000000000 <- ( ffffff , 000000000000 ) + +[24,46]: + int 3fffffc00000000000 <- ( ffffff , 000000000000 ) + +[24,45]: + int 1fffffe00000000000 <- ( ffffff , 000000000000 ) + +[24,44]: + int 0ffffff00000000000 <- ( ffffff , 00000000000 ) + +[24,43]: + int 7fffff80000000000 <- ( ffffff , 00000000000 ) + +[24,42]: + int 3fffffc0000000000 <- ( ffffff , 00000000000 ) + +[24,41]: + int 1fffffe0000000000 <- ( ffffff , 00000000000 ) + +[24,40]: + int 0ffffff0000000000 <- ( ffffff , 0000000000 ) + +[24,39]: + int 7fffff8000000000 <- ( ffffff , 0000000000 ) + +[24,38]: + int 3fffffc000000000 <- ( ffffff , 0000000000 ) + +[24,37]: + int 1fffffe000000000 <- ( ffffff , 0000000000 ) + +[24,36]: + int 0ffffff000000000 <- ( ffffff , 000000000 ) + +[24,35]: + int 7fffff800000000 <- ( ffffff , 000000000 ) + +[24,34]: + int 3fffffc00000000 <- ( ffffff , 000000000 ) + +[24,33]: + int 1fffffe00000000 <- ( ffffff , 000000000 ) + +[24,32]: + int 0ffffff00000000 <- ( ffffff , 00000000 ) + +[24,31]: + int 7fffff80000000 <- ( ffffff , 00000000 ) + +[24,30]: + int 3fffffc0000000 <- ( ffffff , 00000000 ) + +[24,29]: + int 1fffffe0000000 <- ( ffffff , 00000000 ) + +[24,28]: + int 0ffffff0000000 <- ( ffffff , 0000000 ) + +[24,27]: + int 7fffff8000000 <- ( ffffff , 0000000 ) + +[24,26]: + int 3fffffc000000 <- ( ffffff , 0000000 ) + +[24,25]: + int 1fffffe000000 <- ( ffffff , 0000000 ) + +[24,24]: + int 0ffffff000000 <- ( ffffff , 000000 ) + +[24,23]: + int 7fffff800000 <- ( ffffff , 000000 ) + +[24,22]: + int 3fffffc00000 <- ( ffffff , 000000 ) + +[24,21]: + int 1fffffe00000 <- ( ffffff , 000000 ) + +[24,20]: + int 0ffffff00000 <- ( ffffff , 00000 ) + +[24,19]: + int 7fffff80000 <- ( ffffff , 00000 ) + +[24,18]: + int 3fffffc0000 <- ( ffffff , 00000 ) + +[24,17]: + int 1fffffe0000 <- ( ffffff , 00000 ) + +[24,16]: + int 0ffffff0000 <- ( ffffff , 0000 ) + +[24,15]: + int 7fffff8000 <- ( ffffff , 0000 ) + +[24,14]: + int 3fffffc000 <- ( ffffff , 0000 ) + +[24,13]: + int 1fffffe000 <- ( ffffff , 0000 ) + +[24,12]: + int 0ffffff000 <- ( ffffff , 000 ) + +[24,11]: + int 7fffff800 <- ( ffffff , 000 ) + +[24,10]: + int 3fffffc00 <- ( ffffff , 000 ) + +[24,9]: + int 1fffffe00 <- ( ffffff , 000 ) + +[24,8]: + int 0ffffff00 <- ( ffffff , 00 ) + +[24,7]: + int 7fffff80 <- ( ffffff , 00 ) + +[24,6]: + int 3fffffc0 <- ( ffffff , 00 ) + +[24,5]: + int 1fffffe0 <- ( ffffff , 00 ) + +[24,4]: + int 0ffffff0 <- ( ffffff , 0 ) + +[24,3]: + int 7fffff8 <- ( ffffff , 0 ) + +[24,2]: + int 3fffffc <- ( ffffff , 0 ) + +[24,1]: + int 1fffffe <- ( ffffff , 0 ) + +[23,64]: + int 7fffff0000000000000000 <- ( ffffff , 0000000000000000 ) + +[23,63]: + int 3fffff8000000000000000 <- ( ffffff , 0000000000000000 ) + +[23,62]: + int 1fffffc000000000000000 <- ( ffffff , 0000000000000000 ) + +[23,61]: + int 0fffffe000000000000000 <- ( ffffff , 0000000000000000 ) + +[23,60]: + int 7fffff000000000000000 <- ( ffffff , 000000000000000 ) + +[23,59]: + int 3fffff800000000000000 <- ( ffffff , 000000000000000 ) + +[23,58]: + int 1fffffc00000000000000 <- ( ffffff , 000000000000000 ) + +[23,57]: + int 0fffffe00000000000000 <- ( ffffff , 000000000000000 ) + +[23,56]: + int 7fffff00000000000000 <- ( ffffff , 00000000000000 ) + +[23,55]: + int 3fffff80000000000000 <- ( ffffff , 00000000000000 ) + +[23,54]: + int 1fffffc0000000000000 <- ( ffffff , 00000000000000 ) + +[23,53]: + int 0fffffe0000000000000 <- ( ffffff , 00000000000000 ) + +[23,52]: + int 7fffff0000000000000 <- ( ffffff , 0000000000000 ) + +[23,51]: + int 3fffff8000000000000 <- ( ffffff , 0000000000000 ) + +[23,50]: + int 1fffffc000000000000 <- ( ffffff , 0000000000000 ) + +[23,49]: + int 0fffffe000000000000 <- ( ffffff , 0000000000000 ) + +[23,48]: + int 7fffff000000000000 <- ( ffffff , 000000000000 ) + +[23,47]: + int 3fffff800000000000 <- ( ffffff , 000000000000 ) + +[23,46]: + int 1fffffc00000000000 <- ( ffffff , 000000000000 ) + +[23,45]: + int 0fffffe00000000000 <- ( ffffff , 000000000000 ) + +[23,44]: + int 7fffff00000000000 <- ( ffffff , 00000000000 ) + +[23,43]: + int 3fffff80000000000 <- ( ffffff , 00000000000 ) + +[23,42]: + int 1fffffc0000000000 <- ( ffffff , 00000000000 ) + +[23,41]: + int 0fffffe0000000000 <- ( ffffff , 00000000000 ) + +[23,40]: + int 7fffff0000000000 <- ( ffffff , 0000000000 ) + +[23,39]: + int 3fffff8000000000 <- ( ffffff , 0000000000 ) + +[23,38]: + int 1fffffc000000000 <- ( ffffff , 0000000000 ) + +[23,37]: + int 0fffffe000000000 <- ( ffffff , 0000000000 ) + +[23,36]: + int 7fffff000000000 <- ( ffffff , 000000000 ) + +[23,35]: + int 3fffff800000000 <- ( ffffff , 000000000 ) + +[23,34]: + int 1fffffc00000000 <- ( ffffff , 000000000 ) + +[23,33]: + int 0fffffe00000000 <- ( ffffff , 000000000 ) + +[23,32]: + int 7fffff00000000 <- ( ffffff , 00000000 ) + +[23,31]: + int 3fffff80000000 <- ( ffffff , 00000000 ) + +[23,30]: + int 1fffffc0000000 <- ( ffffff , 00000000 ) + +[23,29]: + int 0fffffe0000000 <- ( ffffff , 00000000 ) + +[23,28]: + int 7fffff0000000 <- ( ffffff , 0000000 ) + +[23,27]: + int 3fffff8000000 <- ( ffffff , 0000000 ) + +[23,26]: + int 1fffffc000000 <- ( ffffff , 0000000 ) + +[23,25]: + int 0fffffe000000 <- ( ffffff , 0000000 ) + +[23,24]: + int 7fffff000000 <- ( ffffff , 000000 ) + +[23,23]: + int 3fffff800000 <- ( ffffff , 000000 ) + +[23,22]: + int 1fffffc00000 <- ( ffffff , 000000 ) + +[23,21]: + int 0fffffe00000 <- ( ffffff , 000000 ) + +[23,20]: + int 7fffff00000 <- ( ffffff , 00000 ) + +[23,19]: + int 3fffff80000 <- ( ffffff , 00000 ) + +[23,18]: + int 1fffffc0000 <- ( ffffff , 00000 ) + +[23,17]: + int 0fffffe0000 <- ( ffffff , 00000 ) + +[23,16]: + int 7fffff0000 <- ( ffffff , 0000 ) + +[23,15]: + int 3fffff8000 <- ( ffffff , 0000 ) + +[23,14]: + int 1fffffc000 <- ( ffffff , 0000 ) + +[23,13]: + int 0fffffe000 <- ( ffffff , 0000 ) + +[23,12]: + int 7fffff000 <- ( ffffff , 000 ) + +[23,11]: + int 3fffff800 <- ( ffffff , 000 ) + +[23,10]: + int 1fffffc00 <- ( ffffff , 000 ) + +[23,9]: + int 0fffffe00 <- ( ffffff , 000 ) + +[23,8]: + int 7fffff00 <- ( ffffff , 00 ) + +[23,7]: + int 3fffff80 <- ( ffffff , 00 ) + +[23,6]: + int 1fffffc0 <- ( ffffff , 00 ) + +[23,5]: + int 0fffffe0 <- ( ffffff , 00 ) + +[23,4]: + int 7fffff0 <- ( ffffff , 0 ) + +[23,3]: + int 3fffff8 <- ( ffffff , 0 ) + +[23,2]: + int 1fffffc <- ( ffffff , 0 ) + +[23,1]: + int 0fffffe <- ( ffffff , 0 ) + +[22,64]: + int 3fffff0000000000000000 <- ( ffffff , 0000000000000000 ) + +[22,63]: + int 1fffff8000000000000000 <- ( ffffff , 0000000000000000 ) + +[22,62]: + int 0fffffc000000000000000 <- ( ffffff , 0000000000000000 ) + +[22,61]: + int 7ffffe000000000000000 <- ( ffffff , 0000000000000000 ) + +[22,60]: + int 3fffff000000000000000 <- ( ffffff , 000000000000000 ) + +[22,59]: + int 1fffff800000000000000 <- ( ffffff , 000000000000000 ) + +[22,58]: + int 0fffffc00000000000000 <- ( ffffff , 000000000000000 ) + +[22,57]: + int 7ffffe00000000000000 <- ( ffffff , 000000000000000 ) + +[22,56]: + int 3fffff00000000000000 <- ( ffffff , 00000000000000 ) + +[22,55]: + int 1fffff80000000000000 <- ( ffffff , 00000000000000 ) + +[22,54]: + int 0fffffc0000000000000 <- ( ffffff , 00000000000000 ) + +[22,53]: + int 7ffffe0000000000000 <- ( ffffff , 00000000000000 ) + +[22,52]: + int 3fffff0000000000000 <- ( ffffff , 0000000000000 ) + +[22,51]: + int 1fffff8000000000000 <- ( ffffff , 0000000000000 ) + +[22,50]: + int 0fffffc000000000000 <- ( ffffff , 0000000000000 ) + +[22,49]: + int 7ffffe000000000000 <- ( ffffff , 0000000000000 ) + +[22,48]: + int 3fffff000000000000 <- ( ffffff , 000000000000 ) + +[22,47]: + int 1fffff800000000000 <- ( ffffff , 000000000000 ) + +[22,46]: + int 0fffffc00000000000 <- ( ffffff , 000000000000 ) + +[22,45]: + int 7ffffe00000000000 <- ( ffffff , 000000000000 ) + +[22,44]: + int 3fffff00000000000 <- ( ffffff , 00000000000 ) + +[22,43]: + int 1fffff80000000000 <- ( ffffff , 00000000000 ) + +[22,42]: + int 0fffffc0000000000 <- ( ffffff , 00000000000 ) + +[22,41]: + int 7ffffe0000000000 <- ( ffffff , 00000000000 ) + +[22,40]: + int 3fffff0000000000 <- ( ffffff , 0000000000 ) + +[22,39]: + int 1fffff8000000000 <- ( ffffff , 0000000000 ) + +[22,38]: + int 0fffffc000000000 <- ( ffffff , 0000000000 ) + +[22,37]: + int 7ffffe000000000 <- ( ffffff , 0000000000 ) + +[22,36]: + int 3fffff000000000 <- ( ffffff , 000000000 ) + +[22,35]: + int 1fffff800000000 <- ( ffffff , 000000000 ) + +[22,34]: + int 0fffffc00000000 <- ( ffffff , 000000000 ) + +[22,33]: + int 7ffffe00000000 <- ( ffffff , 000000000 ) + +[22,32]: + int 3fffff00000000 <- ( ffffff , 00000000 ) + +[22,31]: + int 1fffff80000000 <- ( ffffff , 00000000 ) + +[22,30]: + int 0fffffc0000000 <- ( ffffff , 00000000 ) + +[22,29]: + int 7ffffe0000000 <- ( ffffff , 00000000 ) + +[22,28]: + int 3fffff0000000 <- ( ffffff , 0000000 ) + +[22,27]: + int 1fffff8000000 <- ( ffffff , 0000000 ) + +[22,26]: + int 0fffffc000000 <- ( ffffff , 0000000 ) + +[22,25]: + int 7ffffe000000 <- ( ffffff , 0000000 ) + +[22,24]: + int 3fffff000000 <- ( ffffff , 000000 ) + +[22,23]: + int 1fffff800000 <- ( ffffff , 000000 ) + +[22,22]: + int 0fffffc00000 <- ( ffffff , 000000 ) + +[22,21]: + int 7ffffe00000 <- ( ffffff , 000000 ) + +[22,20]: + int 3fffff00000 <- ( ffffff , 00000 ) + +[22,19]: + int 1fffff80000 <- ( ffffff , 00000 ) + +[22,18]: + int 0fffffc0000 <- ( ffffff , 00000 ) + +[22,17]: + int 7ffffe0000 <- ( ffffff , 00000 ) + +[22,16]: + int 3fffff0000 <- ( ffffff , 0000 ) + +[22,15]: + int 1fffff8000 <- ( ffffff , 0000 ) + +[22,14]: + int 0fffffc000 <- ( ffffff , 0000 ) + +[22,13]: + int 7ffffe000 <- ( ffffff , 0000 ) + +[22,12]: + int 3fffff000 <- ( ffffff , 000 ) + +[22,11]: + int 1fffff800 <- ( ffffff , 000 ) + +[22,10]: + int 0fffffc00 <- ( ffffff , 000 ) + +[22,9]: + int 7ffffe00 <- ( ffffff , 000 ) + +[22,8]: + int 3fffff00 <- ( ffffff , 00 ) + +[22,7]: + int 1fffff80 <- ( ffffff , 00 ) + +[22,6]: + int 0fffffc0 <- ( ffffff , 00 ) + +[22,5]: + int 7ffffe0 <- ( ffffff , 00 ) + +[22,4]: + int 3fffff0 <- ( ffffff , 0 ) + +[22,3]: + int 1fffff8 <- ( ffffff , 0 ) + +[22,2]: + int 0fffffc <- ( ffffff , 0 ) + +[22,1]: + int 7ffffe <- ( ffffff , 0 ) + +[21,64]: + int 1fffff0000000000000000 <- ( ffffff , 0000000000000000 ) + +[21,63]: + int 0fffff8000000000000000 <- ( ffffff , 0000000000000000 ) + +[21,62]: + int 7ffffc000000000000000 <- ( ffffff , 0000000000000000 ) + +[21,61]: + int 3ffffe000000000000000 <- ( ffffff , 0000000000000000 ) + +[21,60]: + int 1fffff000000000000000 <- ( ffffff , 000000000000000 ) + +[21,59]: + int 0fffff800000000000000 <- ( ffffff , 000000000000000 ) + +[21,58]: + int 7ffffc00000000000000 <- ( ffffff , 000000000000000 ) + +[21,57]: + int 3ffffe00000000000000 <- ( ffffff , 000000000000000 ) + +[21,56]: + int 1fffff00000000000000 <- ( ffffff , 00000000000000 ) + +[21,55]: + int 0fffff80000000000000 <- ( ffffff , 00000000000000 ) + +[21,54]: + int 7ffffc0000000000000 <- ( ffffff , 00000000000000 ) + +[21,53]: + int 3ffffe0000000000000 <- ( ffffff , 00000000000000 ) + +[21,52]: + int 1fffff0000000000000 <- ( ffffff , 0000000000000 ) + +[21,51]: + int 0fffff8000000000000 <- ( ffffff , 0000000000000 ) + +[21,50]: + int 7ffffc000000000000 <- ( ffffff , 0000000000000 ) + +[21,49]: + int 3ffffe000000000000 <- ( ffffff , 0000000000000 ) + +[21,48]: + int 1fffff000000000000 <- ( ffffff , 000000000000 ) + +[21,47]: + int 0fffff800000000000 <- ( ffffff , 000000000000 ) + +[21,46]: + int 7ffffc00000000000 <- ( ffffff , 000000000000 ) + +[21,45]: + int 3ffffe00000000000 <- ( ffffff , 000000000000 ) + +[21,44]: + int 1fffff00000000000 <- ( ffffff , 00000000000 ) + +[21,43]: + int 0fffff80000000000 <- ( ffffff , 00000000000 ) + +[21,42]: + int 7ffffc0000000000 <- ( ffffff , 00000000000 ) + +[21,41]: + int 3ffffe0000000000 <- ( ffffff , 00000000000 ) + +[21,40]: + int 1fffff0000000000 <- ( ffffff , 0000000000 ) + +[21,39]: + int 0fffff8000000000 <- ( ffffff , 0000000000 ) + +[21,38]: + int 7ffffc000000000 <- ( ffffff , 0000000000 ) + +[21,37]: + int 3ffffe000000000 <- ( ffffff , 0000000000 ) + +[21,36]: + int 1fffff000000000 <- ( ffffff , 000000000 ) + +[21,35]: + int 0fffff800000000 <- ( ffffff , 000000000 ) + +[21,34]: + int 7ffffc00000000 <- ( ffffff , 000000000 ) + +[21,33]: + int 3ffffe00000000 <- ( ffffff , 000000000 ) + +[21,32]: + int 1fffff00000000 <- ( ffffff , 00000000 ) + +[21,31]: + int 0fffff80000000 <- ( ffffff , 00000000 ) + +[21,30]: + int 7ffffc0000000 <- ( ffffff , 00000000 ) + +[21,29]: + int 3ffffe0000000 <- ( ffffff , 00000000 ) + +[21,28]: + int 1fffff0000000 <- ( ffffff , 0000000 ) + +[21,27]: + int 0fffff8000000 <- ( ffffff , 0000000 ) + +[21,26]: + int 7ffffc000000 <- ( ffffff , 0000000 ) + +[21,25]: + int 3ffffe000000 <- ( ffffff , 0000000 ) + +[21,24]: + int 1fffff000000 <- ( ffffff , 000000 ) + +[21,23]: + int 0fffff800000 <- ( ffffff , 000000 ) + +[21,22]: + int 7ffffc00000 <- ( ffffff , 000000 ) + +[21,21]: + int 3ffffe00000 <- ( ffffff , 000000 ) + +[21,20]: + int 1fffff00000 <- ( ffffff , 00000 ) + +[21,19]: + int 0fffff80000 <- ( ffffff , 00000 ) + +[21,18]: + int 7ffffc0000 <- ( ffffff , 00000 ) + +[21,17]: + int 3ffffe0000 <- ( ffffff , 00000 ) + +[21,16]: + int 1fffff0000 <- ( ffffff , 0000 ) + +[21,15]: + int 0fffff8000 <- ( ffffff , 0000 ) + +[21,14]: + int 7ffffc000 <- ( ffffff , 0000 ) + +[21,13]: + int 3ffffe000 <- ( ffffff , 0000 ) + +[21,12]: + int 1fffff000 <- ( ffffff , 000 ) + +[21,11]: + int 0fffff800 <- ( ffffff , 000 ) + +[21,10]: + int 7ffffc00 <- ( ffffff , 000 ) + +[21,9]: + int 3ffffe00 <- ( ffffff , 000 ) + +[21,8]: + int 1fffff00 <- ( ffffff , 00 ) + +[21,7]: + int 0fffff80 <- ( ffffff , 00 ) + +[21,6]: + int 7ffffc0 <- ( ffffff , 00 ) + +[21,5]: + int 3ffffe0 <- ( ffffff , 00 ) + +[21,4]: + int 1fffff0 <- ( ffffff , 0 ) + +[21,3]: + int 0fffff8 <- ( ffffff , 0 ) + +[21,2]: + int 7ffffc <- ( ffffff , 0 ) + +[21,1]: + int 3ffffe <- ( ffffff , 0 ) + +[20,64]: + int 0fffff0000000000000000 <- ( fffff , 0000000000000000 ) + +[20,63]: + int 7ffff8000000000000000 <- ( fffff , 0000000000000000 ) + +[20,62]: + int 3ffffc000000000000000 <- ( fffff , 0000000000000000 ) + +[20,61]: + int 1ffffe000000000000000 <- ( fffff , 0000000000000000 ) + +[20,60]: + int 0fffff000000000000000 <- ( fffff , 000000000000000 ) + +[20,59]: + int 7ffff800000000000000 <- ( fffff , 000000000000000 ) + +[20,58]: + int 3ffffc00000000000000 <- ( fffff , 000000000000000 ) + +[20,57]: + int 1ffffe00000000000000 <- ( fffff , 000000000000000 ) + +[20,56]: + int 0fffff00000000000000 <- ( fffff , 00000000000000 ) + +[20,55]: + int 7ffff80000000000000 <- ( fffff , 00000000000000 ) + +[20,54]: + int 3ffffc0000000000000 <- ( fffff , 00000000000000 ) + +[20,53]: + int 1ffffe0000000000000 <- ( fffff , 00000000000000 ) + +[20,52]: + int 0fffff0000000000000 <- ( fffff , 0000000000000 ) + +[20,51]: + int 7ffff8000000000000 <- ( fffff , 0000000000000 ) + +[20,50]: + int 3ffffc000000000000 <- ( fffff , 0000000000000 ) + +[20,49]: + int 1ffffe000000000000 <- ( fffff , 0000000000000 ) + +[20,48]: + int 0fffff000000000000 <- ( fffff , 000000000000 ) + +[20,47]: + int 7ffff800000000000 <- ( fffff , 000000000000 ) + +[20,46]: + int 3ffffc00000000000 <- ( fffff , 000000000000 ) + +[20,45]: + int 1ffffe00000000000 <- ( fffff , 000000000000 ) + +[20,44]: + int 0fffff00000000000 <- ( fffff , 00000000000 ) + +[20,43]: + int 7ffff80000000000 <- ( fffff , 00000000000 ) + +[20,42]: + int 3ffffc0000000000 <- ( fffff , 00000000000 ) + +[20,41]: + int 1ffffe0000000000 <- ( fffff , 00000000000 ) + +[20,40]: + int 0fffff0000000000 <- ( fffff , 0000000000 ) + +[20,39]: + int 7ffff8000000000 <- ( fffff , 0000000000 ) + +[20,38]: + int 3ffffc000000000 <- ( fffff , 0000000000 ) + +[20,37]: + int 1ffffe000000000 <- ( fffff , 0000000000 ) + +[20,36]: + int 0fffff000000000 <- ( fffff , 000000000 ) + +[20,35]: + int 7ffff800000000 <- ( fffff , 000000000 ) + +[20,34]: + int 3ffffc00000000 <- ( fffff , 000000000 ) + +[20,33]: + int 1ffffe00000000 <- ( fffff , 000000000 ) + +[20,32]: + int 0fffff00000000 <- ( fffff , 00000000 ) + +[20,31]: + int 7ffff80000000 <- ( fffff , 00000000 ) + +[20,30]: + int 3ffffc0000000 <- ( fffff , 00000000 ) + +[20,29]: + int 1ffffe0000000 <- ( fffff , 00000000 ) + +[20,28]: + int 0fffff0000000 <- ( fffff , 0000000 ) + +[20,27]: + int 7ffff8000000 <- ( fffff , 0000000 ) + +[20,26]: + int 3ffffc000000 <- ( fffff , 0000000 ) + +[20,25]: + int 1ffffe000000 <- ( fffff , 0000000 ) + +[20,24]: + int 0fffff000000 <- ( fffff , 000000 ) + +[20,23]: + int 7ffff800000 <- ( fffff , 000000 ) + +[20,22]: + int 3ffffc00000 <- ( fffff , 000000 ) + +[20,21]: + int 1ffffe00000 <- ( fffff , 000000 ) + +[20,20]: + int 0fffff00000 <- ( fffff , 00000 ) + +[20,19]: + int 7ffff80000 <- ( fffff , 00000 ) + +[20,18]: + int 3ffffc0000 <- ( fffff , 00000 ) + +[20,17]: + int 1ffffe0000 <- ( fffff , 00000 ) + +[20,16]: + int 0fffff0000 <- ( fffff , 0000 ) + +[20,15]: + int 7ffff8000 <- ( fffff , 0000 ) + +[20,14]: + int 3ffffc000 <- ( fffff , 0000 ) + +[20,13]: + int 1ffffe000 <- ( fffff , 0000 ) + +[20,12]: + int 0fffff000 <- ( fffff , 000 ) + +[20,11]: + int 7ffff800 <- ( fffff , 000 ) + +[20,10]: + int 3ffffc00 <- ( fffff , 000 ) + +[20,9]: + int 1ffffe00 <- ( fffff , 000 ) + +[20,8]: + int 0fffff00 <- ( fffff , 00 ) + +[20,7]: + int 7ffff80 <- ( fffff , 00 ) + +[20,6]: + int 3ffffc0 <- ( fffff , 00 ) + +[20,5]: + int 1ffffe0 <- ( fffff , 00 ) + +[20,4]: + int 0fffff0 <- ( fffff , 0 ) + +[20,3]: + int 7ffff8 <- ( fffff , 0 ) + +[20,2]: + int 3ffffc <- ( fffff , 0 ) + +[20,1]: + int 1ffffe <- ( fffff , 0 ) + +[19,64]: + int 7ffff0000000000000000 <- ( fffff , 0000000000000000 ) + +[19,63]: + int 3ffff8000000000000000 <- ( fffff , 0000000000000000 ) + +[19,62]: + int 1ffffc000000000000000 <- ( fffff , 0000000000000000 ) + +[19,61]: + int 0ffffe000000000000000 <- ( fffff , 0000000000000000 ) + +[19,60]: + int 7ffff000000000000000 <- ( fffff , 000000000000000 ) + +[19,59]: + int 3ffff800000000000000 <- ( fffff , 000000000000000 ) + +[19,58]: + int 1ffffc00000000000000 <- ( fffff , 000000000000000 ) + +[19,57]: + int 0ffffe00000000000000 <- ( fffff , 000000000000000 ) + +[19,56]: + int 7ffff00000000000000 <- ( fffff , 00000000000000 ) + +[19,55]: + int 3ffff80000000000000 <- ( fffff , 00000000000000 ) + +[19,54]: + int 1ffffc0000000000000 <- ( fffff , 00000000000000 ) + +[19,53]: + int 0ffffe0000000000000 <- ( fffff , 00000000000000 ) + +[19,52]: + int 7ffff0000000000000 <- ( fffff , 0000000000000 ) + +[19,51]: + int 3ffff8000000000000 <- ( fffff , 0000000000000 ) + +[19,50]: + int 1ffffc000000000000 <- ( fffff , 0000000000000 ) + +[19,49]: + int 0ffffe000000000000 <- ( fffff , 0000000000000 ) + +[19,48]: + int 7ffff000000000000 <- ( fffff , 000000000000 ) + +[19,47]: + int 3ffff800000000000 <- ( fffff , 000000000000 ) + +[19,46]: + int 1ffffc00000000000 <- ( fffff , 000000000000 ) + +[19,45]: + int 0ffffe00000000000 <- ( fffff , 000000000000 ) + +[19,44]: + int 7ffff00000000000 <- ( fffff , 00000000000 ) + +[19,43]: + int 3ffff80000000000 <- ( fffff , 00000000000 ) + +[19,42]: + int 1ffffc0000000000 <- ( fffff , 00000000000 ) + +[19,41]: + int 0ffffe0000000000 <- ( fffff , 00000000000 ) + +[19,40]: + int 7ffff0000000000 <- ( fffff , 0000000000 ) + +[19,39]: + int 3ffff8000000000 <- ( fffff , 0000000000 ) + +[19,38]: + int 1ffffc000000000 <- ( fffff , 0000000000 ) + +[19,37]: + int 0ffffe000000000 <- ( fffff , 0000000000 ) + +[19,36]: + int 7ffff000000000 <- ( fffff , 000000000 ) + +[19,35]: + int 3ffff800000000 <- ( fffff , 000000000 ) + +[19,34]: + int 1ffffc00000000 <- ( fffff , 000000000 ) + +[19,33]: + int 0ffffe00000000 <- ( fffff , 000000000 ) + +[19,32]: + int 7ffff00000000 <- ( fffff , 00000000 ) + +[19,31]: + int 3ffff80000000 <- ( fffff , 00000000 ) + +[19,30]: + int 1ffffc0000000 <- ( fffff , 00000000 ) + +[19,29]: + int 0ffffe0000000 <- ( fffff , 00000000 ) + +[19,28]: + int 7ffff0000000 <- ( fffff , 0000000 ) + +[19,27]: + int 3ffff8000000 <- ( fffff , 0000000 ) + +[19,26]: + int 1ffffc000000 <- ( fffff , 0000000 ) + +[19,25]: + int 0ffffe000000 <- ( fffff , 0000000 ) + +[19,24]: + int 7ffff000000 <- ( fffff , 000000 ) + +[19,23]: + int 3ffff800000 <- ( fffff , 000000 ) + +[19,22]: + int 1ffffc00000 <- ( fffff , 000000 ) + +[19,21]: + int 0ffffe00000 <- ( fffff , 000000 ) + +[19,20]: + int 7ffff00000 <- ( fffff , 00000 ) + +[19,19]: + int 3ffff80000 <- ( fffff , 00000 ) + +[19,18]: + int 1ffffc0000 <- ( fffff , 00000 ) + +[19,17]: + int 0ffffe0000 <- ( fffff , 00000 ) + +[19,16]: + int 7ffff0000 <- ( fffff , 0000 ) + +[19,15]: + int 3ffff8000 <- ( fffff , 0000 ) + +[19,14]: + int 1ffffc000 <- ( fffff , 0000 ) + +[19,13]: + int 0ffffe000 <- ( fffff , 0000 ) + +[19,12]: + int 7ffff000 <- ( fffff , 000 ) + +[19,11]: + int 3ffff800 <- ( fffff , 000 ) + +[19,10]: + int 1ffffc00 <- ( fffff , 000 ) + +[19,9]: + int 0ffffe00 <- ( fffff , 000 ) + +[19,8]: + int 7ffff00 <- ( fffff , 00 ) + +[19,7]: + int 3ffff80 <- ( fffff , 00 ) + +[19,6]: + int 1ffffc0 <- ( fffff , 00 ) + +[19,5]: + int 0ffffe0 <- ( fffff , 00 ) + +[19,4]: + int 7ffff0 <- ( fffff , 0 ) + +[19,3]: + int 3ffff8 <- ( fffff , 0 ) + +[19,2]: + int 1ffffc <- ( fffff , 0 ) + +[19,1]: + int 0ffffe <- ( fffff , 0 ) + +[18,64]: + int 3ffff0000000000000000 <- ( fffff , 0000000000000000 ) + +[18,63]: + int 1ffff8000000000000000 <- ( fffff , 0000000000000000 ) + +[18,62]: + int 0ffffc000000000000000 <- ( fffff , 0000000000000000 ) + +[18,61]: + int 7fffe000000000000000 <- ( fffff , 0000000000000000 ) + +[18,60]: + int 3ffff000000000000000 <- ( fffff , 000000000000000 ) + +[18,59]: + int 1ffff800000000000000 <- ( fffff , 000000000000000 ) + +[18,58]: + int 0ffffc00000000000000 <- ( fffff , 000000000000000 ) + +[18,57]: + int 7fffe00000000000000 <- ( fffff , 000000000000000 ) + +[18,56]: + int 3ffff00000000000000 <- ( fffff , 00000000000000 ) + +[18,55]: + int 1ffff80000000000000 <- ( fffff , 00000000000000 ) + +[18,54]: + int 0ffffc0000000000000 <- ( fffff , 00000000000000 ) + +[18,53]: + int 7fffe0000000000000 <- ( fffff , 00000000000000 ) + +[18,52]: + int 3ffff0000000000000 <- ( fffff , 0000000000000 ) + +[18,51]: + int 1ffff8000000000000 <- ( fffff , 0000000000000 ) + +[18,50]: + int 0ffffc000000000000 <- ( fffff , 0000000000000 ) + +[18,49]: + int 7fffe000000000000 <- ( fffff , 0000000000000 ) + +[18,48]: + int 3ffff000000000000 <- ( fffff , 000000000000 ) + +[18,47]: + int 1ffff800000000000 <- ( fffff , 000000000000 ) + +[18,46]: + int 0ffffc00000000000 <- ( fffff , 000000000000 ) + +[18,45]: + int 7fffe00000000000 <- ( fffff , 000000000000 ) + +[18,44]: + int 3ffff00000000000 <- ( fffff , 00000000000 ) + +[18,43]: + int 1ffff80000000000 <- ( fffff , 00000000000 ) + +[18,42]: + int 0ffffc0000000000 <- ( fffff , 00000000000 ) + +[18,41]: + int 7fffe0000000000 <- ( fffff , 00000000000 ) + +[18,40]: + int 3ffff0000000000 <- ( fffff , 0000000000 ) + +[18,39]: + int 1ffff8000000000 <- ( fffff , 0000000000 ) + +[18,38]: + int 0ffffc000000000 <- ( fffff , 0000000000 ) + +[18,37]: + int 7fffe000000000 <- ( fffff , 0000000000 ) + +[18,36]: + int 3ffff000000000 <- ( fffff , 000000000 ) + +[18,35]: + int 1ffff800000000 <- ( fffff , 000000000 ) + +[18,34]: + int 0ffffc00000000 <- ( fffff , 000000000 ) + +[18,33]: + int 7fffe00000000 <- ( fffff , 000000000 ) + +[18,32]: + int 3ffff00000000 <- ( fffff , 00000000 ) + +[18,31]: + int 1ffff80000000 <- ( fffff , 00000000 ) + +[18,30]: + int 0ffffc0000000 <- ( fffff , 00000000 ) + +[18,29]: + int 7fffe0000000 <- ( fffff , 00000000 ) + +[18,28]: + int 3ffff0000000 <- ( fffff , 0000000 ) + +[18,27]: + int 1ffff8000000 <- ( fffff , 0000000 ) + +[18,26]: + int 0ffffc000000 <- ( fffff , 0000000 ) + +[18,25]: + int 7fffe000000 <- ( fffff , 0000000 ) + +[18,24]: + int 3ffff000000 <- ( fffff , 000000 ) + +[18,23]: + int 1ffff800000 <- ( fffff , 000000 ) + +[18,22]: + int 0ffffc00000 <- ( fffff , 000000 ) + +[18,21]: + int 7fffe00000 <- ( fffff , 000000 ) + +[18,20]: + int 3ffff00000 <- ( fffff , 00000 ) + +[18,19]: + int 1ffff80000 <- ( fffff , 00000 ) + +[18,18]: + int 0ffffc0000 <- ( fffff , 00000 ) + +[18,17]: + int 7fffe0000 <- ( fffff , 00000 ) + +[18,16]: + int 3ffff0000 <- ( fffff , 0000 ) + +[18,15]: + int 1ffff8000 <- ( fffff , 0000 ) + +[18,14]: + int 0ffffc000 <- ( fffff , 0000 ) + +[18,13]: + int 7fffe000 <- ( fffff , 0000 ) + +[18,12]: + int 3ffff000 <- ( fffff , 000 ) + +[18,11]: + int 1ffff800 <- ( fffff , 000 ) + +[18,10]: + int 0ffffc00 <- ( fffff , 000 ) + +[18,9]: + int 7fffe00 <- ( fffff , 000 ) + +[18,8]: + int 3ffff00 <- ( fffff , 00 ) + +[18,7]: + int 1ffff80 <- ( fffff , 00 ) + +[18,6]: + int 0ffffc0 <- ( fffff , 00 ) + +[18,5]: + int 7fffe0 <- ( fffff , 00 ) + +[18,4]: + int 3ffff0 <- ( fffff , 0 ) + +[18,3]: + int 1ffff8 <- ( fffff , 0 ) + +[18,2]: + int 0ffffc <- ( fffff , 0 ) + +[18,1]: + int 7fffe <- ( fffff , 0 ) + +[17,64]: + int 1ffff0000000000000000 <- ( fffff , 0000000000000000 ) + +[17,63]: + int 0ffff8000000000000000 <- ( fffff , 0000000000000000 ) + +[17,62]: + int 7fffc000000000000000 <- ( fffff , 0000000000000000 ) + +[17,61]: + int 3fffe000000000000000 <- ( fffff , 0000000000000000 ) + +[17,60]: + int 1ffff000000000000000 <- ( fffff , 000000000000000 ) + +[17,59]: + int 0ffff800000000000000 <- ( fffff , 000000000000000 ) + +[17,58]: + int 7fffc00000000000000 <- ( fffff , 000000000000000 ) + +[17,57]: + int 3fffe00000000000000 <- ( fffff , 000000000000000 ) + +[17,56]: + int 1ffff00000000000000 <- ( fffff , 00000000000000 ) + +[17,55]: + int 0ffff80000000000000 <- ( fffff , 00000000000000 ) + +[17,54]: + int 7fffc0000000000000 <- ( fffff , 00000000000000 ) + +[17,53]: + int 3fffe0000000000000 <- ( fffff , 00000000000000 ) + +[17,52]: + int 1ffff0000000000000 <- ( fffff , 0000000000000 ) + +[17,51]: + int 0ffff8000000000000 <- ( fffff , 0000000000000 ) + +[17,50]: + int 7fffc000000000000 <- ( fffff , 0000000000000 ) + +[17,49]: + int 3fffe000000000000 <- ( fffff , 0000000000000 ) + +[17,48]: + int 1ffff000000000000 <- ( fffff , 000000000000 ) + +[17,47]: + int 0ffff800000000000 <- ( fffff , 000000000000 ) + +[17,46]: + int 7fffc00000000000 <- ( fffff , 000000000000 ) + +[17,45]: + int 3fffe00000000000 <- ( fffff , 000000000000 ) + +[17,44]: + int 1ffff00000000000 <- ( fffff , 00000000000 ) + +[17,43]: + int 0ffff80000000000 <- ( fffff , 00000000000 ) + +[17,42]: + int 7fffc0000000000 <- ( fffff , 00000000000 ) + +[17,41]: + int 3fffe0000000000 <- ( fffff , 00000000000 ) + +[17,40]: + int 1ffff0000000000 <- ( fffff , 0000000000 ) + +[17,39]: + int 0ffff8000000000 <- ( fffff , 0000000000 ) + +[17,38]: + int 7fffc000000000 <- ( fffff , 0000000000 ) + +[17,37]: + int 3fffe000000000 <- ( fffff , 0000000000 ) + +[17,36]: + int 1ffff000000000 <- ( fffff , 000000000 ) + +[17,35]: + int 0ffff800000000 <- ( fffff , 000000000 ) + +[17,34]: + int 7fffc00000000 <- ( fffff , 000000000 ) + +[17,33]: + int 3fffe00000000 <- ( fffff , 000000000 ) + +[17,32]: + int 1ffff00000000 <- ( fffff , 00000000 ) + +[17,31]: + int 0ffff80000000 <- ( fffff , 00000000 ) + +[17,30]: + int 7fffc0000000 <- ( fffff , 00000000 ) + +[17,29]: + int 3fffe0000000 <- ( fffff , 00000000 ) + +[17,28]: + int 1ffff0000000 <- ( fffff , 0000000 ) + +[17,27]: + int 0ffff8000000 <- ( fffff , 0000000 ) + +[17,26]: + int 7fffc000000 <- ( fffff , 0000000 ) + +[17,25]: + int 3fffe000000 <- ( fffff , 0000000 ) + +[17,24]: + int 1ffff000000 <- ( fffff , 000000 ) + +[17,23]: + int 0ffff800000 <- ( fffff , 000000 ) + +[17,22]: + int 7fffc00000 <- ( fffff , 000000 ) + +[17,21]: + int 3fffe00000 <- ( fffff , 000000 ) + +[17,20]: + int 1ffff00000 <- ( fffff , 00000 ) + +[17,19]: + int 0ffff80000 <- ( fffff , 00000 ) + +[17,18]: + int 7fffc0000 <- ( fffff , 00000 ) + +[17,17]: + int 3fffe0000 <- ( fffff , 00000 ) + +[17,16]: + int 1ffff0000 <- ( fffff , 0000 ) + +[17,15]: + int 0ffff8000 <- ( fffff , 0000 ) + +[17,14]: + int 7fffc000 <- ( fffff , 0000 ) + +[17,13]: + int 3fffe000 <- ( fffff , 0000 ) + +[17,12]: + int 1ffff000 <- ( fffff , 000 ) + +[17,11]: + int 0ffff800 <- ( fffff , 000 ) + +[17,10]: + int 7fffc00 <- ( fffff , 000 ) + +[17,9]: + int 3fffe00 <- ( fffff , 000 ) + +[17,8]: + int 1ffff00 <- ( fffff , 00 ) + +[17,7]: + int 0ffff80 <- ( fffff , 00 ) + +[17,6]: + int 7fffc0 <- ( fffff , 00 ) + +[17,5]: + int 3fffe0 <- ( fffff , 00 ) + +[17,4]: + int 1ffff0 <- ( fffff , 0 ) + +[17,3]: + int 0ffff8 <- ( fffff , 0 ) + +[17,2]: + int 7fffc <- ( fffff , 0 ) + +[17,1]: + int 3fffe <- ( fffff , 0 ) + +[16,64]: + int 0ffff0000000000000000 <- ( ffff , 0000000000000000 ) + +[16,63]: + int 7fff8000000000000000 <- ( ffff , 0000000000000000 ) + +[16,62]: + int 3fffc000000000000000 <- ( ffff , 0000000000000000 ) + +[16,61]: + int 1fffe000000000000000 <- ( ffff , 0000000000000000 ) + +[16,60]: + int 0ffff000000000000000 <- ( ffff , 000000000000000 ) + +[16,59]: + int 7fff800000000000000 <- ( ffff , 000000000000000 ) + +[16,58]: + int 3fffc00000000000000 <- ( ffff , 000000000000000 ) + +[16,57]: + int 1fffe00000000000000 <- ( ffff , 000000000000000 ) + +[16,56]: + int 0ffff00000000000000 <- ( ffff , 00000000000000 ) + +[16,55]: + int 7fff80000000000000 <- ( ffff , 00000000000000 ) + +[16,54]: + int 3fffc0000000000000 <- ( ffff , 00000000000000 ) + +[16,53]: + int 1fffe0000000000000 <- ( ffff , 00000000000000 ) + +[16,52]: + int 0ffff0000000000000 <- ( ffff , 0000000000000 ) + +[16,51]: + int 7fff8000000000000 <- ( ffff , 0000000000000 ) + +[16,50]: + int 3fffc000000000000 <- ( ffff , 0000000000000 ) + +[16,49]: + int 1fffe000000000000 <- ( ffff , 0000000000000 ) + +[16,48]: + int 0ffff000000000000 <- ( ffff , 000000000000 ) + +[16,47]: + int 7fff800000000000 <- ( ffff , 000000000000 ) + +[16,46]: + int 3fffc00000000000 <- ( ffff , 000000000000 ) + +[16,45]: + int 1fffe00000000000 <- ( ffff , 000000000000 ) + +[16,44]: + int 0ffff00000000000 <- ( ffff , 00000000000 ) + +[16,43]: + int 7fff80000000000 <- ( ffff , 00000000000 ) + +[16,42]: + int 3fffc0000000000 <- ( ffff , 00000000000 ) + +[16,41]: + int 1fffe0000000000 <- ( ffff , 00000000000 ) + +[16,40]: + int 0ffff0000000000 <- ( ffff , 0000000000 ) + +[16,39]: + int 7fff8000000000 <- ( ffff , 0000000000 ) + +[16,38]: + int 3fffc000000000 <- ( ffff , 0000000000 ) + +[16,37]: + int 1fffe000000000 <- ( ffff , 0000000000 ) + +[16,36]: + int 0ffff000000000 <- ( ffff , 000000000 ) + +[16,35]: + int 7fff800000000 <- ( ffff , 000000000 ) + +[16,34]: + int 3fffc00000000 <- ( ffff , 000000000 ) + +[16,33]: + int 1fffe00000000 <- ( ffff , 000000000 ) + +[16,32]: + int 0ffff00000000 <- ( ffff , 00000000 ) + +[16,31]: + int 7fff80000000 <- ( ffff , 00000000 ) + +[16,30]: + int 3fffc0000000 <- ( ffff , 00000000 ) + +[16,29]: + int 1fffe0000000 <- ( ffff , 00000000 ) + +[16,28]: + int 0ffff0000000 <- ( ffff , 0000000 ) + +[16,27]: + int 7fff8000000 <- ( ffff , 0000000 ) + +[16,26]: + int 3fffc000000 <- ( ffff , 0000000 ) + +[16,25]: + int 1fffe000000 <- ( ffff , 0000000 ) + +[16,24]: + int 0ffff000000 <- ( ffff , 000000 ) + +[16,23]: + int 7fff800000 <- ( ffff , 000000 ) + +[16,22]: + int 3fffc00000 <- ( ffff , 000000 ) + +[16,21]: + int 1fffe00000 <- ( ffff , 000000 ) + +[16,20]: + int 0ffff00000 <- ( ffff , 00000 ) + +[16,19]: + int 7fff80000 <- ( ffff , 00000 ) + +[16,18]: + int 3fffc0000 <- ( ffff , 00000 ) + +[16,17]: + int 1fffe0000 <- ( ffff , 00000 ) + +[16,16]: + int 0ffff0000 <- ( ffff , 0000 ) + +[16,15]: + int 7fff8000 <- ( ffff , 0000 ) + +[16,14]: + int 3fffc000 <- ( ffff , 0000 ) + +[16,13]: + int 1fffe000 <- ( ffff , 0000 ) + +[16,12]: + int 0ffff000 <- ( ffff , 000 ) + +[16,11]: + int 7fff800 <- ( ffff , 000 ) + +[16,10]: + int 3fffc00 <- ( ffff , 000 ) + +[16,9]: + int 1fffe00 <- ( ffff , 000 ) + +[16,8]: + int 0ffff00 <- ( ffff , 00 ) + +[16,7]: + int 7fff80 <- ( ffff , 00 ) + +[16,6]: + int 3fffc0 <- ( ffff , 00 ) + +[16,5]: + int 1fffe0 <- ( ffff , 00 ) + +[16,4]: + int 0ffff0 <- ( ffff , 0 ) + +[16,3]: + int 7fff8 <- ( ffff , 0 ) + +[16,2]: + int 3fffc <- ( ffff , 0 ) + +[16,1]: + int 1fffe <- ( ffff , 0 ) + +[15,64]: + int 7fff0000000000000000 <- ( ffff , 0000000000000000 ) + +[15,63]: + int 3fff8000000000000000 <- ( ffff , 0000000000000000 ) + +[15,62]: + int 1fffc000000000000000 <- ( ffff , 0000000000000000 ) + +[15,61]: + int 0fffe000000000000000 <- ( ffff , 0000000000000000 ) + +[15,60]: + int 7fff000000000000000 <- ( ffff , 000000000000000 ) + +[15,59]: + int 3fff800000000000000 <- ( ffff , 000000000000000 ) + +[15,58]: + int 1fffc00000000000000 <- ( ffff , 000000000000000 ) + +[15,57]: + int 0fffe00000000000000 <- ( ffff , 000000000000000 ) + +[15,56]: + int 7fff00000000000000 <- ( ffff , 00000000000000 ) + +[15,55]: + int 3fff80000000000000 <- ( ffff , 00000000000000 ) + +[15,54]: + int 1fffc0000000000000 <- ( ffff , 00000000000000 ) + +[15,53]: + int 0fffe0000000000000 <- ( ffff , 00000000000000 ) + +[15,52]: + int 7fff0000000000000 <- ( ffff , 0000000000000 ) + +[15,51]: + int 3fff8000000000000 <- ( ffff , 0000000000000 ) + +[15,50]: + int 1fffc000000000000 <- ( ffff , 0000000000000 ) + +[15,49]: + int 0fffe000000000000 <- ( ffff , 0000000000000 ) + +[15,48]: + int 7fff000000000000 <- ( ffff , 000000000000 ) + +[15,47]: + int 3fff800000000000 <- ( ffff , 000000000000 ) + +[15,46]: + int 1fffc00000000000 <- ( ffff , 000000000000 ) + +[15,45]: + int 0fffe00000000000 <- ( ffff , 000000000000 ) + +[15,44]: + int 7fff00000000000 <- ( ffff , 00000000000 ) + +[15,43]: + int 3fff80000000000 <- ( ffff , 00000000000 ) + +[15,42]: + int 1fffc0000000000 <- ( ffff , 00000000000 ) + +[15,41]: + int 0fffe0000000000 <- ( ffff , 00000000000 ) + +[15,40]: + int 7fff0000000000 <- ( ffff , 0000000000 ) + +[15,39]: + int 3fff8000000000 <- ( ffff , 0000000000 ) + +[15,38]: + int 1fffc000000000 <- ( ffff , 0000000000 ) + +[15,37]: + int 0fffe000000000 <- ( ffff , 0000000000 ) + +[15,36]: + int 7fff000000000 <- ( ffff , 000000000 ) + +[15,35]: + int 3fff800000000 <- ( ffff , 000000000 ) + +[15,34]: + int 1fffc00000000 <- ( ffff , 000000000 ) + +[15,33]: + int 0fffe00000000 <- ( ffff , 000000000 ) + +[15,32]: + int 7fff00000000 <- ( ffff , 00000000 ) + +[15,31]: + int 3fff80000000 <- ( ffff , 00000000 ) + +[15,30]: + int 1fffc0000000 <- ( ffff , 00000000 ) + +[15,29]: + int 0fffe0000000 <- ( ffff , 00000000 ) + +[15,28]: + int 7fff0000000 <- ( ffff , 0000000 ) + +[15,27]: + int 3fff8000000 <- ( ffff , 0000000 ) + +[15,26]: + int 1fffc000000 <- ( ffff , 0000000 ) + +[15,25]: + int 0fffe000000 <- ( ffff , 0000000 ) + +[15,24]: + int 7fff000000 <- ( ffff , 000000 ) + +[15,23]: + int 3fff800000 <- ( ffff , 000000 ) + +[15,22]: + int 1fffc00000 <- ( ffff , 000000 ) + +[15,21]: + int 0fffe00000 <- ( ffff , 000000 ) + +[15,20]: + int 7fff00000 <- ( ffff , 00000 ) + +[15,19]: + int 3fff80000 <- ( ffff , 00000 ) + +[15,18]: + int 1fffc0000 <- ( ffff , 00000 ) + +[15,17]: + int 0fffe0000 <- ( ffff , 00000 ) + +[15,16]: + int 7fff0000 <- ( ffff , 0000 ) + +[15,15]: + int 3fff8000 <- ( ffff , 0000 ) + +[15,14]: + int 1fffc000 <- ( ffff , 0000 ) + +[15,13]: + int 0fffe000 <- ( ffff , 0000 ) + +[15,12]: + int 7fff000 <- ( ffff , 000 ) + +[15,11]: + int 3fff800 <- ( ffff , 000 ) + +[15,10]: + int 1fffc00 <- ( ffff , 000 ) + +[15,9]: + int 0fffe00 <- ( ffff , 000 ) + +[15,8]: + int 7fff00 <- ( ffff , 00 ) + +[15,7]: + int 3fff80 <- ( ffff , 00 ) + +[15,6]: + int 1fffc0 <- ( ffff , 00 ) + +[15,5]: + int 0fffe0 <- ( ffff , 00 ) + +[15,4]: + int 7fff0 <- ( ffff , 0 ) + +[15,3]: + int 3fff8 <- ( ffff , 0 ) + +[15,2]: + int 1fffc <- ( ffff , 0 ) + +[15,1]: + int 0fffe <- ( ffff , 0 ) + +[14,64]: + int 3fff0000000000000000 <- ( ffff , 0000000000000000 ) + +[14,63]: + int 1fff8000000000000000 <- ( ffff , 0000000000000000 ) + +[14,62]: + int 0fffc000000000000000 <- ( ffff , 0000000000000000 ) + +[14,61]: + int 7ffe000000000000000 <- ( ffff , 0000000000000000 ) + +[14,60]: + int 3fff000000000000000 <- ( ffff , 000000000000000 ) + +[14,59]: + int 1fff800000000000000 <- ( ffff , 000000000000000 ) + +[14,58]: + int 0fffc00000000000000 <- ( ffff , 000000000000000 ) + +[14,57]: + int 7ffe00000000000000 <- ( ffff , 000000000000000 ) + +[14,56]: + int 3fff00000000000000 <- ( ffff , 00000000000000 ) + +[14,55]: + int 1fff80000000000000 <- ( ffff , 00000000000000 ) + +[14,54]: + int 0fffc0000000000000 <- ( ffff , 00000000000000 ) + +[14,53]: + int 7ffe0000000000000 <- ( ffff , 00000000000000 ) + +[14,52]: + int 3fff0000000000000 <- ( ffff , 0000000000000 ) + +[14,51]: + int 1fff8000000000000 <- ( ffff , 0000000000000 ) + +[14,50]: + int 0fffc000000000000 <- ( ffff , 0000000000000 ) + +[14,49]: + int 7ffe000000000000 <- ( ffff , 0000000000000 ) + +[14,48]: + int 3fff000000000000 <- ( ffff , 000000000000 ) + +[14,47]: + int 1fff800000000000 <- ( ffff , 000000000000 ) + +[14,46]: + int 0fffc00000000000 <- ( ffff , 000000000000 ) + +[14,45]: + int 7ffe00000000000 <- ( ffff , 000000000000 ) + +[14,44]: + int 3fff00000000000 <- ( ffff , 00000000000 ) + +[14,43]: + int 1fff80000000000 <- ( ffff , 00000000000 ) + +[14,42]: + int 0fffc0000000000 <- ( ffff , 00000000000 ) + +[14,41]: + int 7ffe0000000000 <- ( ffff , 00000000000 ) + +[14,40]: + int 3fff0000000000 <- ( ffff , 0000000000 ) + +[14,39]: + int 1fff8000000000 <- ( ffff , 0000000000 ) + +[14,38]: + int 0fffc000000000 <- ( ffff , 0000000000 ) + +[14,37]: + int 7ffe000000000 <- ( ffff , 0000000000 ) + +[14,36]: + int 3fff000000000 <- ( ffff , 000000000 ) + +[14,35]: + int 1fff800000000 <- ( ffff , 000000000 ) + +[14,34]: + int 0fffc00000000 <- ( ffff , 000000000 ) + +[14,33]: + int 7ffe00000000 <- ( ffff , 000000000 ) + +[14,32]: + int 3fff00000000 <- ( ffff , 00000000 ) + +[14,31]: + int 1fff80000000 <- ( ffff , 00000000 ) + +[14,30]: + int 0fffc0000000 <- ( ffff , 00000000 ) + +[14,29]: + int 7ffe0000000 <- ( ffff , 00000000 ) + +[14,28]: + int 3fff0000000 <- ( ffff , 0000000 ) + +[14,27]: + int 1fff8000000 <- ( ffff , 0000000 ) + +[14,26]: + int 0fffc000000 <- ( ffff , 0000000 ) + +[14,25]: + int 7ffe000000 <- ( ffff , 0000000 ) + +[14,24]: + int 3fff000000 <- ( ffff , 000000 ) + +[14,23]: + int 1fff800000 <- ( ffff , 000000 ) + +[14,22]: + int 0fffc00000 <- ( ffff , 000000 ) + +[14,21]: + int 7ffe00000 <- ( ffff , 000000 ) + +[14,20]: + int 3fff00000 <- ( ffff , 00000 ) + +[14,19]: + int 1fff80000 <- ( ffff , 00000 ) + +[14,18]: + int 0fffc0000 <- ( ffff , 00000 ) + +[14,17]: + int 7ffe0000 <- ( ffff , 00000 ) + +[14,16]: + int 3fff0000 <- ( ffff , 0000 ) + +[14,15]: + int 1fff8000 <- ( ffff , 0000 ) + +[14,14]: + int 0fffc000 <- ( ffff , 0000 ) + +[14,13]: + int 7ffe000 <- ( ffff , 0000 ) + +[14,12]: + int 3fff000 <- ( ffff , 000 ) + +[14,11]: + int 1fff800 <- ( ffff , 000 ) + +[14,10]: + int 0fffc00 <- ( ffff , 000 ) + +[14,9]: + int 7ffe00 <- ( ffff , 000 ) + +[14,8]: + int 3fff00 <- ( ffff , 00 ) + +[14,7]: + int 1fff80 <- ( ffff , 00 ) + +[14,6]: + int 0fffc0 <- ( ffff , 00 ) + +[14,5]: + int 7ffe0 <- ( ffff , 00 ) + +[14,4]: + int 3fff0 <- ( ffff , 0 ) + +[14,3]: + int 1fff8 <- ( ffff , 0 ) + +[14,2]: + int 0fffc <- ( ffff , 0 ) + +[14,1]: + int 7ffe <- ( ffff , 0 ) + +[13,64]: + int 1fff0000000000000000 <- ( ffff , 0000000000000000 ) + +[13,63]: + int 0fff8000000000000000 <- ( ffff , 0000000000000000 ) + +[13,62]: + int 7ffc000000000000000 <- ( ffff , 0000000000000000 ) + +[13,61]: + int 3ffe000000000000000 <- ( ffff , 0000000000000000 ) + +[13,60]: + int 1fff000000000000000 <- ( ffff , 000000000000000 ) + +[13,59]: + int 0fff800000000000000 <- ( ffff , 000000000000000 ) + +[13,58]: + int 7ffc00000000000000 <- ( ffff , 000000000000000 ) + +[13,57]: + int 3ffe00000000000000 <- ( ffff , 000000000000000 ) + +[13,56]: + int 1fff00000000000000 <- ( ffff , 00000000000000 ) + +[13,55]: + int 0fff80000000000000 <- ( ffff , 00000000000000 ) + +[13,54]: + int 7ffc0000000000000 <- ( ffff , 00000000000000 ) + +[13,53]: + int 3ffe0000000000000 <- ( ffff , 00000000000000 ) + +[13,52]: + int 1fff0000000000000 <- ( ffff , 0000000000000 ) + +[13,51]: + int 0fff8000000000000 <- ( ffff , 0000000000000 ) + +[13,50]: + int 7ffc000000000000 <- ( ffff , 0000000000000 ) + +[13,49]: + int 3ffe000000000000 <- ( ffff , 0000000000000 ) + +[13,48]: + int 1fff000000000000 <- ( ffff , 000000000000 ) + +[13,47]: + int 0fff800000000000 <- ( ffff , 000000000000 ) + +[13,46]: + int 7ffc00000000000 <- ( ffff , 000000000000 ) + +[13,45]: + int 3ffe00000000000 <- ( ffff , 000000000000 ) + +[13,44]: + int 1fff00000000000 <- ( ffff , 00000000000 ) + +[13,43]: + int 0fff80000000000 <- ( ffff , 00000000000 ) + +[13,42]: + int 7ffc0000000000 <- ( ffff , 00000000000 ) + +[13,41]: + int 3ffe0000000000 <- ( ffff , 00000000000 ) + +[13,40]: + int 1fff0000000000 <- ( ffff , 0000000000 ) + +[13,39]: + int 0fff8000000000 <- ( ffff , 0000000000 ) + +[13,38]: + int 7ffc000000000 <- ( ffff , 0000000000 ) + +[13,37]: + int 3ffe000000000 <- ( ffff , 0000000000 ) + +[13,36]: + int 1fff000000000 <- ( ffff , 000000000 ) + +[13,35]: + int 0fff800000000 <- ( ffff , 000000000 ) + +[13,34]: + int 7ffc00000000 <- ( ffff , 000000000 ) + +[13,33]: + int 3ffe00000000 <- ( ffff , 000000000 ) + +[13,32]: + int 1fff00000000 <- ( ffff , 00000000 ) + +[13,31]: + int 0fff80000000 <- ( ffff , 00000000 ) + +[13,30]: + int 7ffc0000000 <- ( ffff , 00000000 ) + +[13,29]: + int 3ffe0000000 <- ( ffff , 00000000 ) + +[13,28]: + int 1fff0000000 <- ( ffff , 0000000 ) + +[13,27]: + int 0fff8000000 <- ( ffff , 0000000 ) + +[13,26]: + int 7ffc000000 <- ( ffff , 0000000 ) + +[13,25]: + int 3ffe000000 <- ( ffff , 0000000 ) + +[13,24]: + int 1fff000000 <- ( ffff , 000000 ) + +[13,23]: + int 0fff800000 <- ( ffff , 000000 ) + +[13,22]: + int 7ffc00000 <- ( ffff , 000000 ) + +[13,21]: + int 3ffe00000 <- ( ffff , 000000 ) + +[13,20]: + int 1fff00000 <- ( ffff , 00000 ) + +[13,19]: + int 0fff80000 <- ( ffff , 00000 ) + +[13,18]: + int 7ffc0000 <- ( ffff , 00000 ) + +[13,17]: + int 3ffe0000 <- ( ffff , 00000 ) + +[13,16]: + int 1fff0000 <- ( ffff , 0000 ) + +[13,15]: + int 0fff8000 <- ( ffff , 0000 ) + +[13,14]: + int 7ffc000 <- ( ffff , 0000 ) + +[13,13]: + int 3ffe000 <- ( ffff , 0000 ) + +[13,12]: + int 1fff000 <- ( ffff , 000 ) + +[13,11]: + int 0fff800 <- ( ffff , 000 ) + +[13,10]: + int 7ffc00 <- ( ffff , 000 ) + +[13,9]: + int 3ffe00 <- ( ffff , 000 ) + +[13,8]: + int 1fff00 <- ( ffff , 00 ) + +[13,7]: + int 0fff80 <- ( ffff , 00 ) + +[13,6]: + int 7ffc0 <- ( ffff , 00 ) + +[13,5]: + int 3ffe0 <- ( ffff , 00 ) + +[13,4]: + int 1fff0 <- ( ffff , 0 ) + +[13,3]: + int 0fff8 <- ( ffff , 0 ) + +[13,2]: + int 7ffc <- ( ffff , 0 ) + +[13,1]: + int 3ffe <- ( ffff , 0 ) + +[12,64]: + int 0fff0000000000000000 <- ( fff , 0000000000000000 ) + +[12,63]: + int 7ff8000000000000000 <- ( fff , 0000000000000000 ) + +[12,62]: + int 3ffc000000000000000 <- ( fff , 0000000000000000 ) + +[12,61]: + int 1ffe000000000000000 <- ( fff , 0000000000000000 ) + +[12,60]: + int 0fff000000000000000 <- ( fff , 000000000000000 ) + +[12,59]: + int 7ff800000000000000 <- ( fff , 000000000000000 ) + +[12,58]: + int 3ffc00000000000000 <- ( fff , 000000000000000 ) + +[12,57]: + int 1ffe00000000000000 <- ( fff , 000000000000000 ) + +[12,56]: + int 0fff00000000000000 <- ( fff , 00000000000000 ) + +[12,55]: + int 7ff80000000000000 <- ( fff , 00000000000000 ) + +[12,54]: + int 3ffc0000000000000 <- ( fff , 00000000000000 ) + +[12,53]: + int 1ffe0000000000000 <- ( fff , 00000000000000 ) + +[12,52]: + int 0fff0000000000000 <- ( fff , 0000000000000 ) + +[12,51]: + int 7ff8000000000000 <- ( fff , 0000000000000 ) + +[12,50]: + int 3ffc000000000000 <- ( fff , 0000000000000 ) + +[12,49]: + int 1ffe000000000000 <- ( fff , 0000000000000 ) + +[12,48]: + int 0fff000000000000 <- ( fff , 000000000000 ) + +[12,47]: + int 7ff800000000000 <- ( fff , 000000000000 ) + +[12,46]: + int 3ffc00000000000 <- ( fff , 000000000000 ) + +[12,45]: + int 1ffe00000000000 <- ( fff , 000000000000 ) + +[12,44]: + int 0fff00000000000 <- ( fff , 00000000000 ) + +[12,43]: + int 7ff80000000000 <- ( fff , 00000000000 ) + +[12,42]: + int 3ffc0000000000 <- ( fff , 00000000000 ) + +[12,41]: + int 1ffe0000000000 <- ( fff , 00000000000 ) + +[12,40]: + int 0fff0000000000 <- ( fff , 0000000000 ) + +[12,39]: + int 7ff8000000000 <- ( fff , 0000000000 ) + +[12,38]: + int 3ffc000000000 <- ( fff , 0000000000 ) + +[12,37]: + int 1ffe000000000 <- ( fff , 0000000000 ) + +[12,36]: + int 0fff000000000 <- ( fff , 000000000 ) + +[12,35]: + int 7ff800000000 <- ( fff , 000000000 ) + +[12,34]: + int 3ffc00000000 <- ( fff , 000000000 ) + +[12,33]: + int 1ffe00000000 <- ( fff , 000000000 ) + +[12,32]: + int 0fff00000000 <- ( fff , 00000000 ) + +[12,31]: + int 7ff80000000 <- ( fff , 00000000 ) + +[12,30]: + int 3ffc0000000 <- ( fff , 00000000 ) + +[12,29]: + int 1ffe0000000 <- ( fff , 00000000 ) + +[12,28]: + int 0fff0000000 <- ( fff , 0000000 ) + +[12,27]: + int 7ff8000000 <- ( fff , 0000000 ) + +[12,26]: + int 3ffc000000 <- ( fff , 0000000 ) + +[12,25]: + int 1ffe000000 <- ( fff , 0000000 ) + +[12,24]: + int 0fff000000 <- ( fff , 000000 ) + +[12,23]: + int 7ff800000 <- ( fff , 000000 ) + +[12,22]: + int 3ffc00000 <- ( fff , 000000 ) + +[12,21]: + int 1ffe00000 <- ( fff , 000000 ) + +[12,20]: + int 0fff00000 <- ( fff , 00000 ) + +[12,19]: + int 7ff80000 <- ( fff , 00000 ) + +[12,18]: + int 3ffc0000 <- ( fff , 00000 ) + +[12,17]: + int 1ffe0000 <- ( fff , 00000 ) + +[12,16]: + int 0fff0000 <- ( fff , 0000 ) + +[12,15]: + int 7ff8000 <- ( fff , 0000 ) + +[12,14]: + int 3ffc000 <- ( fff , 0000 ) + +[12,13]: + int 1ffe000 <- ( fff , 0000 ) + +[12,12]: + int 0fff000 <- ( fff , 000 ) + +[12,11]: + int 7ff800 <- ( fff , 000 ) + +[12,10]: + int 3ffc00 <- ( fff , 000 ) + +[12,9]: + int 1ffe00 <- ( fff , 000 ) + +[12,8]: + int 0fff00 <- ( fff , 00 ) + +[12,7]: + int 7ff80 <- ( fff , 00 ) + +[12,6]: + int 3ffc0 <- ( fff , 00 ) + +[12,5]: + int 1ffe0 <- ( fff , 00 ) + +[12,4]: + int 0fff0 <- ( fff , 0 ) + +[12,3]: + int 7ff8 <- ( fff , 0 ) + +[12,2]: + int 3ffc <- ( fff , 0 ) + +[12,1]: + int 1ffe <- ( fff , 0 ) + +[11,64]: + int 7ff0000000000000000 <- ( fff , 0000000000000000 ) + +[11,63]: + int 3ff8000000000000000 <- ( fff , 0000000000000000 ) + +[11,62]: + int 1ffc000000000000000 <- ( fff , 0000000000000000 ) + +[11,61]: + int 0ffe000000000000000 <- ( fff , 0000000000000000 ) + +[11,60]: + int 7ff000000000000000 <- ( fff , 000000000000000 ) + +[11,59]: + int 3ff800000000000000 <- ( fff , 000000000000000 ) + +[11,58]: + int 1ffc00000000000000 <- ( fff , 000000000000000 ) + +[11,57]: + int 0ffe00000000000000 <- ( fff , 000000000000000 ) + +[11,56]: + int 7ff00000000000000 <- ( fff , 00000000000000 ) + +[11,55]: + int 3ff80000000000000 <- ( fff , 00000000000000 ) + +[11,54]: + int 1ffc0000000000000 <- ( fff , 00000000000000 ) + +[11,53]: + int 0ffe0000000000000 <- ( fff , 00000000000000 ) + +[11,52]: + int 7ff0000000000000 <- ( fff , 0000000000000 ) + +[11,51]: + int 3ff8000000000000 <- ( fff , 0000000000000 ) + +[11,50]: + int 1ffc000000000000 <- ( fff , 0000000000000 ) + +[11,49]: + int 0ffe000000000000 <- ( fff , 0000000000000 ) + +[11,48]: + int 7ff000000000000 <- ( fff , 000000000000 ) + +[11,47]: + int 3ff800000000000 <- ( fff , 000000000000 ) + +[11,46]: + int 1ffc00000000000 <- ( fff , 000000000000 ) + +[11,45]: + int 0ffe00000000000 <- ( fff , 000000000000 ) + +[11,44]: + int 7ff00000000000 <- ( fff , 00000000000 ) + +[11,43]: + int 3ff80000000000 <- ( fff , 00000000000 ) + +[11,42]: + int 1ffc0000000000 <- ( fff , 00000000000 ) + +[11,41]: + int 0ffe0000000000 <- ( fff , 00000000000 ) + +[11,40]: + int 7ff0000000000 <- ( fff , 0000000000 ) + +[11,39]: + int 3ff8000000000 <- ( fff , 0000000000 ) + +[11,38]: + int 1ffc000000000 <- ( fff , 0000000000 ) + +[11,37]: + int 0ffe000000000 <- ( fff , 0000000000 ) + +[11,36]: + int 7ff000000000 <- ( fff , 000000000 ) + +[11,35]: + int 3ff800000000 <- ( fff , 000000000 ) + +[11,34]: + int 1ffc00000000 <- ( fff , 000000000 ) + +[11,33]: + int 0ffe00000000 <- ( fff , 000000000 ) + +[11,32]: + int 7ff00000000 <- ( fff , 00000000 ) + +[11,31]: + int 3ff80000000 <- ( fff , 00000000 ) + +[11,30]: + int 1ffc0000000 <- ( fff , 00000000 ) + +[11,29]: + int 0ffe0000000 <- ( fff , 00000000 ) + +[11,28]: + int 7ff0000000 <- ( fff , 0000000 ) + +[11,27]: + int 3ff8000000 <- ( fff , 0000000 ) + +[11,26]: + int 1ffc000000 <- ( fff , 0000000 ) + +[11,25]: + int 0ffe000000 <- ( fff , 0000000 ) + +[11,24]: + int 7ff000000 <- ( fff , 000000 ) + +[11,23]: + int 3ff800000 <- ( fff , 000000 ) + +[11,22]: + int 1ffc00000 <- ( fff , 000000 ) + +[11,21]: + int 0ffe00000 <- ( fff , 000000 ) + +[11,20]: + int 7ff00000 <- ( fff , 00000 ) + +[11,19]: + int 3ff80000 <- ( fff , 00000 ) + +[11,18]: + int 1ffc0000 <- ( fff , 00000 ) + +[11,17]: + int 0ffe0000 <- ( fff , 00000 ) + +[11,16]: + int 7ff0000 <- ( fff , 0000 ) + +[11,15]: + int 3ff8000 <- ( fff , 0000 ) + +[11,14]: + int 1ffc000 <- ( fff , 0000 ) + +[11,13]: + int 0ffe000 <- ( fff , 0000 ) + +[11,12]: + int 7ff000 <- ( fff , 000 ) + +[11,11]: + int 3ff800 <- ( fff , 000 ) + +[11,10]: + int 1ffc00 <- ( fff , 000 ) + +[11,9]: + int 0ffe00 <- ( fff , 000 ) + +[11,8]: + int 7ff00 <- ( fff , 00 ) + +[11,7]: + int 3ff80 <- ( fff , 00 ) + +[11,6]: + int 1ffc0 <- ( fff , 00 ) + +[11,5]: + int 0ffe0 <- ( fff , 00 ) + +[11,4]: + int 7ff0 <- ( fff , 0 ) + +[11,3]: + int 3ff8 <- ( fff , 0 ) + +[11,2]: + int 1ffc <- ( fff , 0 ) + +[11,1]: + int 0ffe <- ( fff , 0 ) + +[10,64]: + int 3ff0000000000000000 <- ( fff , 0000000000000000 ) + +[10,63]: + int 1ff8000000000000000 <- ( fff , 0000000000000000 ) + +[10,62]: + int 0ffc000000000000000 <- ( fff , 0000000000000000 ) + +[10,61]: + int 7fe000000000000000 <- ( fff , 0000000000000000 ) + +[10,60]: + int 3ff000000000000000 <- ( fff , 000000000000000 ) + +[10,59]: + int 1ff800000000000000 <- ( fff , 000000000000000 ) + +[10,58]: + int 0ffc00000000000000 <- ( fff , 000000000000000 ) + +[10,57]: + int 7fe00000000000000 <- ( fff , 000000000000000 ) + +[10,56]: + int 3ff00000000000000 <- ( fff , 00000000000000 ) + +[10,55]: + int 1ff80000000000000 <- ( fff , 00000000000000 ) + +[10,54]: + int 0ffc0000000000000 <- ( fff , 00000000000000 ) + +[10,53]: + int 7fe0000000000000 <- ( fff , 00000000000000 ) + +[10,52]: + int 3ff0000000000000 <- ( fff , 0000000000000 ) + +[10,51]: + int 1ff8000000000000 <- ( fff , 0000000000000 ) + +[10,50]: + int 0ffc000000000000 <- ( fff , 0000000000000 ) + +[10,49]: + int 7fe000000000000 <- ( fff , 0000000000000 ) + +[10,48]: + int 3ff000000000000 <- ( fff , 000000000000 ) + +[10,47]: + int 1ff800000000000 <- ( fff , 000000000000 ) + +[10,46]: + int 0ffc00000000000 <- ( fff , 000000000000 ) + +[10,45]: + int 7fe00000000000 <- ( fff , 000000000000 ) + +[10,44]: + int 3ff00000000000 <- ( fff , 00000000000 ) + +[10,43]: + int 1ff80000000000 <- ( fff , 00000000000 ) + +[10,42]: + int 0ffc0000000000 <- ( fff , 00000000000 ) + +[10,41]: + int 7fe0000000000 <- ( fff , 00000000000 ) + +[10,40]: + int 3ff0000000000 <- ( fff , 0000000000 ) + +[10,39]: + int 1ff8000000000 <- ( fff , 0000000000 ) + +[10,38]: + int 0ffc000000000 <- ( fff , 0000000000 ) + +[10,37]: + int 7fe000000000 <- ( fff , 0000000000 ) + +[10,36]: + int 3ff000000000 <- ( fff , 000000000 ) + +[10,35]: + int 1ff800000000 <- ( fff , 000000000 ) + +[10,34]: + int 0ffc00000000 <- ( fff , 000000000 ) + +[10,33]: + int 7fe00000000 <- ( fff , 000000000 ) + +[10,32]: + int 3ff00000000 <- ( fff , 00000000 ) + +[10,31]: + int 1ff80000000 <- ( fff , 00000000 ) + +[10,30]: + int 0ffc0000000 <- ( fff , 00000000 ) + +[10,29]: + int 7fe0000000 <- ( fff , 00000000 ) + +[10,28]: + int 3ff0000000 <- ( fff , 0000000 ) + +[10,27]: + int 1ff8000000 <- ( fff , 0000000 ) + +[10,26]: + int 0ffc000000 <- ( fff , 0000000 ) + +[10,25]: + int 7fe000000 <- ( fff , 0000000 ) + +[10,24]: + int 3ff000000 <- ( fff , 000000 ) + +[10,23]: + int 1ff800000 <- ( fff , 000000 ) + +[10,22]: + int 0ffc00000 <- ( fff , 000000 ) + +[10,21]: + int 7fe00000 <- ( fff , 000000 ) + +[10,20]: + int 3ff00000 <- ( fff , 00000 ) + +[10,19]: + int 1ff80000 <- ( fff , 00000 ) + +[10,18]: + int 0ffc0000 <- ( fff , 00000 ) + +[10,17]: + int 7fe0000 <- ( fff , 00000 ) + +[10,16]: + int 3ff0000 <- ( fff , 0000 ) + +[10,15]: + int 1ff8000 <- ( fff , 0000 ) + +[10,14]: + int 0ffc000 <- ( fff , 0000 ) + +[10,13]: + int 7fe000 <- ( fff , 0000 ) + +[10,12]: + int 3ff000 <- ( fff , 000 ) + +[10,11]: + int 1ff800 <- ( fff , 000 ) + +[10,10]: + int 0ffc00 <- ( fff , 000 ) + +[10,9]: + int 7fe00 <- ( fff , 000 ) + +[10,8]: + int 3ff00 <- ( fff , 00 ) + +[10,7]: + int 1ff80 <- ( fff , 00 ) + +[10,6]: + int 0ffc0 <- ( fff , 00 ) + +[10,5]: + int 7fe0 <- ( fff , 00 ) + +[10,4]: + int 3ff0 <- ( fff , 0 ) + +[10,3]: + int 1ff8 <- ( fff , 0 ) + +[10,2]: + int 0ffc <- ( fff , 0 ) + +[10,1]: + int 7fe <- ( fff , 0 ) + +[9,64]: + int 1ff0000000000000000 <- ( fff , 0000000000000000 ) + +[9,63]: + int 0ff8000000000000000 <- ( fff , 0000000000000000 ) + +[9,62]: + int 7fc000000000000000 <- ( fff , 0000000000000000 ) + +[9,61]: + int 3fe000000000000000 <- ( fff , 0000000000000000 ) + +[9,60]: + int 1ff000000000000000 <- ( fff , 000000000000000 ) + +[9,59]: + int 0ff800000000000000 <- ( fff , 000000000000000 ) + +[9,58]: + int 7fc00000000000000 <- ( fff , 000000000000000 ) + +[9,57]: + int 3fe00000000000000 <- ( fff , 000000000000000 ) + +[9,56]: + int 1ff00000000000000 <- ( fff , 00000000000000 ) + +[9,55]: + int 0ff80000000000000 <- ( fff , 00000000000000 ) + +[9,54]: + int 7fc0000000000000 <- ( fff , 00000000000000 ) + +[9,53]: + int 3fe0000000000000 <- ( fff , 00000000000000 ) + +[9,52]: + int 1ff0000000000000 <- ( fff , 0000000000000 ) + +[9,51]: + int 0ff8000000000000 <- ( fff , 0000000000000 ) + +[9,50]: + int 7fc000000000000 <- ( fff , 0000000000000 ) + +[9,49]: + int 3fe000000000000 <- ( fff , 0000000000000 ) + +[9,48]: + int 1ff000000000000 <- ( fff , 000000000000 ) + +[9,47]: + int 0ff800000000000 <- ( fff , 000000000000 ) + +[9,46]: + int 7fc00000000000 <- ( fff , 000000000000 ) + +[9,45]: + int 3fe00000000000 <- ( fff , 000000000000 ) + +[9,44]: + int 1ff00000000000 <- ( fff , 00000000000 ) + +[9,43]: + int 0ff80000000000 <- ( fff , 00000000000 ) + +[9,42]: + int 7fc0000000000 <- ( fff , 00000000000 ) + +[9,41]: + int 3fe0000000000 <- ( fff , 00000000000 ) + +[9,40]: + int 1ff0000000000 <- ( fff , 0000000000 ) + +[9,39]: + int 0ff8000000000 <- ( fff , 0000000000 ) + +[9,38]: + int 7fc000000000 <- ( fff , 0000000000 ) + +[9,37]: + int 3fe000000000 <- ( fff , 0000000000 ) + +[9,36]: + int 1ff000000000 <- ( fff , 000000000 ) + +[9,35]: + int 0ff800000000 <- ( fff , 000000000 ) + +[9,34]: + int 7fc00000000 <- ( fff , 000000000 ) + +[9,33]: + int 3fe00000000 <- ( fff , 000000000 ) + +[9,32]: + int 1ff00000000 <- ( fff , 00000000 ) + +[9,31]: + int 0ff80000000 <- ( fff , 00000000 ) + +[9,30]: + int 7fc0000000 <- ( fff , 00000000 ) + +[9,29]: + int 3fe0000000 <- ( fff , 00000000 ) + +[9,28]: + int 1ff0000000 <- ( fff , 0000000 ) + +[9,27]: + int 0ff8000000 <- ( fff , 0000000 ) + +[9,26]: + int 7fc000000 <- ( fff , 0000000 ) + +[9,25]: + int 3fe000000 <- ( fff , 0000000 ) + +[9,24]: + int 1ff000000 <- ( fff , 000000 ) + +[9,23]: + int 0ff800000 <- ( fff , 000000 ) + +[9,22]: + int 7fc00000 <- ( fff , 000000 ) + +[9,21]: + int 3fe00000 <- ( fff , 000000 ) + +[9,20]: + int 1ff00000 <- ( fff , 00000 ) + +[9,19]: + int 0ff80000 <- ( fff , 00000 ) + +[9,18]: + int 7fc0000 <- ( fff , 00000 ) + +[9,17]: + int 3fe0000 <- ( fff , 00000 ) + +[9,16]: + int 1ff0000 <- ( fff , 0000 ) + +[9,15]: + int 0ff8000 <- ( fff , 0000 ) + +[9,14]: + int 7fc000 <- ( fff , 0000 ) + +[9,13]: + int 3fe000 <- ( fff , 0000 ) + +[9,12]: + int 1ff000 <- ( fff , 000 ) + +[9,11]: + int 0ff800 <- ( fff , 000 ) + +[9,10]: + int 7fc00 <- ( fff , 000 ) + +[9,9]: + int 3fe00 <- ( fff , 000 ) + +[9,8]: + int 1ff00 <- ( fff , 00 ) + +[9,7]: + int 0ff80 <- ( fff , 00 ) + +[9,6]: + int 7fc0 <- ( fff , 00 ) + +[9,5]: + int 3fe0 <- ( fff , 00 ) + +[9,4]: + int 1ff0 <- ( fff , 0 ) + +[9,3]: + int 0ff8 <- ( fff , 0 ) + +[9,2]: + int 7fc <- ( fff , 0 ) + +[9,1]: + int 3fe <- ( fff , 0 ) + +[8,64]: + int 0ff0000000000000000 <- ( ff , 0000000000000000 ) + +[8,63]: + int 7f8000000000000000 <- ( ff , 0000000000000000 ) + +[8,62]: + int 3fc000000000000000 <- ( ff , 0000000000000000 ) + +[8,61]: + int 1fe000000000000000 <- ( ff , 0000000000000000 ) + +[8,60]: + int 0ff000000000000000 <- ( ff , 000000000000000 ) + +[8,59]: + int 7f800000000000000 <- ( ff , 000000000000000 ) + +[8,58]: + int 3fc00000000000000 <- ( ff , 000000000000000 ) + +[8,57]: + int 1fe00000000000000 <- ( ff , 000000000000000 ) + +[8,56]: + int 0ff00000000000000 <- ( ff , 00000000000000 ) + +[8,55]: + int 7f80000000000000 <- ( ff , 00000000000000 ) + +[8,54]: + int 3fc0000000000000 <- ( ff , 00000000000000 ) + +[8,53]: + int 1fe0000000000000 <- ( ff , 00000000000000 ) + +[8,52]: + int 0ff0000000000000 <- ( ff , 0000000000000 ) + +[8,51]: + int 7f8000000000000 <- ( ff , 0000000000000 ) + +[8,50]: + int 3fc000000000000 <- ( ff , 0000000000000 ) + +[8,49]: + int 1fe000000000000 <- ( ff , 0000000000000 ) + +[8,48]: + int 0ff000000000000 <- ( ff , 000000000000 ) + +[8,47]: + int 7f800000000000 <- ( ff , 000000000000 ) + +[8,46]: + int 3fc00000000000 <- ( ff , 000000000000 ) + +[8,45]: + int 1fe00000000000 <- ( ff , 000000000000 ) + +[8,44]: + int 0ff00000000000 <- ( ff , 00000000000 ) + +[8,43]: + int 7f80000000000 <- ( ff , 00000000000 ) + +[8,42]: + int 3fc0000000000 <- ( ff , 00000000000 ) + +[8,41]: + int 1fe0000000000 <- ( ff , 00000000000 ) + +[8,40]: + int 0ff0000000000 <- ( ff , 0000000000 ) + +[8,39]: + int 7f8000000000 <- ( ff , 0000000000 ) + +[8,38]: + int 3fc000000000 <- ( ff , 0000000000 ) + +[8,37]: + int 1fe000000000 <- ( ff , 0000000000 ) + +[8,36]: + int 0ff000000000 <- ( ff , 000000000 ) + +[8,35]: + int 7f800000000 <- ( ff , 000000000 ) + +[8,34]: + int 3fc00000000 <- ( ff , 000000000 ) + +[8,33]: + int 1fe00000000 <- ( ff , 000000000 ) + +[8,32]: + int 0ff00000000 <- ( ff , 00000000 ) + +[8,31]: + int 7f80000000 <- ( ff , 00000000 ) + +[8,30]: + int 3fc0000000 <- ( ff , 00000000 ) + +[8,29]: + int 1fe0000000 <- ( ff , 00000000 ) + +[8,28]: + int 0ff0000000 <- ( ff , 0000000 ) + +[8,27]: + int 7f8000000 <- ( ff , 0000000 ) + +[8,26]: + int 3fc000000 <- ( ff , 0000000 ) + +[8,25]: + int 1fe000000 <- ( ff , 0000000 ) + +[8,24]: + int 0ff000000 <- ( ff , 000000 ) + +[8,23]: + int 7f800000 <- ( ff , 000000 ) + +[8,22]: + int 3fc00000 <- ( ff , 000000 ) + +[8,21]: + int 1fe00000 <- ( ff , 000000 ) + +[8,20]: + int 0ff00000 <- ( ff , 00000 ) + +[8,19]: + int 7f80000 <- ( ff , 00000 ) + +[8,18]: + int 3fc0000 <- ( ff , 00000 ) + +[8,17]: + int 1fe0000 <- ( ff , 00000 ) + +[8,16]: + int 0ff0000 <- ( ff , 0000 ) + +[8,15]: + int 7f8000 <- ( ff , 0000 ) + +[8,14]: + int 3fc000 <- ( ff , 0000 ) + +[8,13]: + int 1fe000 <- ( ff , 0000 ) + +[8,12]: + int 0ff000 <- ( ff , 000 ) + +[8,11]: + int 7f800 <- ( ff , 000 ) + +[8,10]: + int 3fc00 <- ( ff , 000 ) + +[8,9]: + int 1fe00 <- ( ff , 000 ) + +[8,8]: + int 0ff00 <- ( ff , 00 ) + +[8,7]: + int 7f80 <- ( ff , 00 ) + +[8,6]: + int 3fc0 <- ( ff , 00 ) + +[8,5]: + int 1fe0 <- ( ff , 00 ) + +[8,4]: + int 0ff0 <- ( ff , 0 ) + +[8,3]: + int 7f8 <- ( ff , 0 ) + +[8,2]: + int 3fc <- ( ff , 0 ) + +[8,1]: + int 1fe <- ( ff , 0 ) + +[7,64]: + int 7f0000000000000000 <- ( ff , 0000000000000000 ) + +[7,63]: + int 3f8000000000000000 <- ( ff , 0000000000000000 ) + +[7,62]: + int 1fc000000000000000 <- ( ff , 0000000000000000 ) + +[7,61]: + int 0fe000000000000000 <- ( ff , 0000000000000000 ) + +[7,60]: + int 7f000000000000000 <- ( ff , 000000000000000 ) + +[7,59]: + int 3f800000000000000 <- ( ff , 000000000000000 ) + +[7,58]: + int 1fc00000000000000 <- ( ff , 000000000000000 ) + +[7,57]: + int 0fe00000000000000 <- ( ff , 000000000000000 ) + +[7,56]: + int 7f00000000000000 <- ( ff , 00000000000000 ) + +[7,55]: + int 3f80000000000000 <- ( ff , 00000000000000 ) + +[7,54]: + int 1fc0000000000000 <- ( ff , 00000000000000 ) + +[7,53]: + int 0fe0000000000000 <- ( ff , 00000000000000 ) + +[7,52]: + int 7f0000000000000 <- ( ff , 0000000000000 ) + +[7,51]: + int 3f8000000000000 <- ( ff , 0000000000000 ) + +[7,50]: + int 1fc000000000000 <- ( ff , 0000000000000 ) + +[7,49]: + int 0fe000000000000 <- ( ff , 0000000000000 ) + +[7,48]: + int 7f000000000000 <- ( ff , 000000000000 ) + +[7,47]: + int 3f800000000000 <- ( ff , 000000000000 ) + +[7,46]: + int 1fc00000000000 <- ( ff , 000000000000 ) + +[7,45]: + int 0fe00000000000 <- ( ff , 000000000000 ) + +[7,44]: + int 7f00000000000 <- ( ff , 00000000000 ) + +[7,43]: + int 3f80000000000 <- ( ff , 00000000000 ) + +[7,42]: + int 1fc0000000000 <- ( ff , 00000000000 ) + +[7,41]: + int 0fe0000000000 <- ( ff , 00000000000 ) + +[7,40]: + int 7f0000000000 <- ( ff , 0000000000 ) + +[7,39]: + int 3f8000000000 <- ( ff , 0000000000 ) + +[7,38]: + int 1fc000000000 <- ( ff , 0000000000 ) + +[7,37]: + int 0fe000000000 <- ( ff , 0000000000 ) + +[7,36]: + int 7f000000000 <- ( ff , 000000000 ) + +[7,35]: + int 3f800000000 <- ( ff , 000000000 ) + +[7,34]: + int 1fc00000000 <- ( ff , 000000000 ) + +[7,33]: + int 0fe00000000 <- ( ff , 000000000 ) + +[7,32]: + int 7f00000000 <- ( ff , 00000000 ) + +[7,31]: + int 3f80000000 <- ( ff , 00000000 ) + +[7,30]: + int 1fc0000000 <- ( ff , 00000000 ) + +[7,29]: + int 0fe0000000 <- ( ff , 00000000 ) + +[7,28]: + int 7f0000000 <- ( ff , 0000000 ) + +[7,27]: + int 3f8000000 <- ( ff , 0000000 ) + +[7,26]: + int 1fc000000 <- ( ff , 0000000 ) + +[7,25]: + int 0fe000000 <- ( ff , 0000000 ) + +[7,24]: + int 7f000000 <- ( ff , 000000 ) + +[7,23]: + int 3f800000 <- ( ff , 000000 ) + +[7,22]: + int 1fc00000 <- ( ff , 000000 ) + +[7,21]: + int 0fe00000 <- ( ff , 000000 ) + +[7,20]: + int 7f00000 <- ( ff , 00000 ) + +[7,19]: + int 3f80000 <- ( ff , 00000 ) + +[7,18]: + int 1fc0000 <- ( ff , 00000 ) + +[7,17]: + int 0fe0000 <- ( ff , 00000 ) + +[7,16]: + int 7f0000 <- ( ff , 0000 ) + +[7,15]: + int 3f8000 <- ( ff , 0000 ) + +[7,14]: + int 1fc000 <- ( ff , 0000 ) + +[7,13]: + int 0fe000 <- ( ff , 0000 ) + +[7,12]: + int 7f000 <- ( ff , 000 ) + +[7,11]: + int 3f800 <- ( ff , 000 ) + +[7,10]: + int 1fc00 <- ( ff , 000 ) + +[7,9]: + int 0fe00 <- ( ff , 000 ) + +[7,8]: + int 7f00 <- ( ff , 00 ) + +[7,7]: + int 3f80 <- ( ff , 00 ) + +[7,6]: + int 1fc0 <- ( ff , 00 ) + +[7,5]: + int 0fe0 <- ( ff , 00 ) + +[7,4]: + int 7f0 <- ( ff , 0 ) + +[7,3]: + int 3f8 <- ( ff , 0 ) + +[7,2]: + int 1fc <- ( ff , 0 ) + +[7,1]: + int 0fe <- ( ff , 0 ) + +[6,64]: + int 3f0000000000000000 <- ( ff , 0000000000000000 ) + +[6,63]: + int 1f8000000000000000 <- ( ff , 0000000000000000 ) + +[6,62]: + int 0fc000000000000000 <- ( ff , 0000000000000000 ) + +[6,61]: + int 7e000000000000000 <- ( ff , 0000000000000000 ) + +[6,60]: + int 3f000000000000000 <- ( ff , 000000000000000 ) + +[6,59]: + int 1f800000000000000 <- ( ff , 000000000000000 ) + +[6,58]: + int 0fc00000000000000 <- ( ff , 000000000000000 ) + +[6,57]: + int 7e00000000000000 <- ( ff , 000000000000000 ) + +[6,56]: + int 3f00000000000000 <- ( ff , 00000000000000 ) + +[6,55]: + int 1f80000000000000 <- ( ff , 00000000000000 ) + +[6,54]: + int 0fc0000000000000 <- ( ff , 00000000000000 ) + +[6,53]: + int 7e0000000000000 <- ( ff , 00000000000000 ) + +[6,52]: + int 3f0000000000000 <- ( ff , 0000000000000 ) + +[6,51]: + int 1f8000000000000 <- ( ff , 0000000000000 ) + +[6,50]: + int 0fc000000000000 <- ( ff , 0000000000000 ) + +[6,49]: + int 7e000000000000 <- ( ff , 0000000000000 ) + +[6,48]: + int 3f000000000000 <- ( ff , 000000000000 ) + +[6,47]: + int 1f800000000000 <- ( ff , 000000000000 ) + +[6,46]: + int 0fc00000000000 <- ( ff , 000000000000 ) + +[6,45]: + int 7e00000000000 <- ( ff , 000000000000 ) + +[6,44]: + int 3f00000000000 <- ( ff , 00000000000 ) + +[6,43]: + int 1f80000000000 <- ( ff , 00000000000 ) + +[6,42]: + int 0fc0000000000 <- ( ff , 00000000000 ) + +[6,41]: + int 7e0000000000 <- ( ff , 00000000000 ) + +[6,40]: + int 3f0000000000 <- ( ff , 0000000000 ) + +[6,39]: + int 1f8000000000 <- ( ff , 0000000000 ) + +[6,38]: + int 0fc000000000 <- ( ff , 0000000000 ) + +[6,37]: + int 7e000000000 <- ( ff , 0000000000 ) + +[6,36]: + int 3f000000000 <- ( ff , 000000000 ) + +[6,35]: + int 1f800000000 <- ( ff , 000000000 ) + +[6,34]: + int 0fc00000000 <- ( ff , 000000000 ) + +[6,33]: + int 7e00000000 <- ( ff , 000000000 ) + +[6,32]: + int 3f00000000 <- ( ff , 00000000 ) + +[6,31]: + int 1f80000000 <- ( ff , 00000000 ) + +[6,30]: + int 0fc0000000 <- ( ff , 00000000 ) + +[6,29]: + int 7e0000000 <- ( ff , 00000000 ) + +[6,28]: + int 3f0000000 <- ( ff , 0000000 ) + +[6,27]: + int 1f8000000 <- ( ff , 0000000 ) + +[6,26]: + int 0fc000000 <- ( ff , 0000000 ) + +[6,25]: + int 7e000000 <- ( ff , 0000000 ) + +[6,24]: + int 3f000000 <- ( ff , 000000 ) + +[6,23]: + int 1f800000 <- ( ff , 000000 ) + +[6,22]: + int 0fc00000 <- ( ff , 000000 ) + +[6,21]: + int 7e00000 <- ( ff , 000000 ) + +[6,20]: + int 3f00000 <- ( ff , 00000 ) + +[6,19]: + int 1f80000 <- ( ff , 00000 ) + +[6,18]: + int 0fc0000 <- ( ff , 00000 ) + +[6,17]: + int 7e0000 <- ( ff , 00000 ) + +[6,16]: + int 3f0000 <- ( ff , 0000 ) + +[6,15]: + int 1f8000 <- ( ff , 0000 ) + +[6,14]: + int 0fc000 <- ( ff , 0000 ) + +[6,13]: + int 7e000 <- ( ff , 0000 ) + +[6,12]: + int 3f000 <- ( ff , 000 ) + +[6,11]: + int 1f800 <- ( ff , 000 ) + +[6,10]: + int 0fc00 <- ( ff , 000 ) + +[6,9]: + int 7e00 <- ( ff , 000 ) + +[6,8]: + int 3f00 <- ( ff , 00 ) + +[6,7]: + int 1f80 <- ( ff , 00 ) + +[6,6]: + int 0fc0 <- ( ff , 00 ) + +[6,5]: + int 7e0 <- ( ff , 00 ) + +[6,4]: + int 3f0 <- ( ff , 0 ) + +[6,3]: + int 1f8 <- ( ff , 0 ) + +[6,2]: + int 0fc <- ( ff , 0 ) + +[6,1]: + int 7e <- ( ff , 0 ) + +[5,64]: + int 1f0000000000000000 <- ( ff , 0000000000000000 ) + +[5,63]: + int 0f8000000000000000 <- ( ff , 0000000000000000 ) + +[5,62]: + int 7c000000000000000 <- ( ff , 0000000000000000 ) + +[5,61]: + int 3e000000000000000 <- ( ff , 0000000000000000 ) + +[5,60]: + int 1f000000000000000 <- ( ff , 000000000000000 ) + +[5,59]: + int 0f800000000000000 <- ( ff , 000000000000000 ) + +[5,58]: + int 7c00000000000000 <- ( ff , 000000000000000 ) + +[5,57]: + int 3e00000000000000 <- ( ff , 000000000000000 ) + +[5,56]: + int 1f00000000000000 <- ( ff , 00000000000000 ) + +[5,55]: + int 0f80000000000000 <- ( ff , 00000000000000 ) + +[5,54]: + int 7c0000000000000 <- ( ff , 00000000000000 ) + +[5,53]: + int 3e0000000000000 <- ( ff , 00000000000000 ) + +[5,52]: + int 1f0000000000000 <- ( ff , 0000000000000 ) + +[5,51]: + int 0f8000000000000 <- ( ff , 0000000000000 ) + +[5,50]: + int 7c000000000000 <- ( ff , 0000000000000 ) + +[5,49]: + int 3e000000000000 <- ( ff , 0000000000000 ) + +[5,48]: + int 1f000000000000 <- ( ff , 000000000000 ) + +[5,47]: + int 0f800000000000 <- ( ff , 000000000000 ) + +[5,46]: + int 7c00000000000 <- ( ff , 000000000000 ) + +[5,45]: + int 3e00000000000 <- ( ff , 000000000000 ) + +[5,44]: + int 1f00000000000 <- ( ff , 00000000000 ) + +[5,43]: + int 0f80000000000 <- ( ff , 00000000000 ) + +[5,42]: + int 7c0000000000 <- ( ff , 00000000000 ) + +[5,41]: + int 3e0000000000 <- ( ff , 00000000000 ) + +[5,40]: + int 1f0000000000 <- ( ff , 0000000000 ) + +[5,39]: + int 0f8000000000 <- ( ff , 0000000000 ) + +[5,38]: + int 7c000000000 <- ( ff , 0000000000 ) + +[5,37]: + int 3e000000000 <- ( ff , 0000000000 ) + +[5,36]: + int 1f000000000 <- ( ff , 000000000 ) + +[5,35]: + int 0f800000000 <- ( ff , 000000000 ) + +[5,34]: + int 7c00000000 <- ( ff , 000000000 ) + +[5,33]: + int 3e00000000 <- ( ff , 000000000 ) + +[5,32]: + int 1f00000000 <- ( ff , 00000000 ) + +[5,31]: + int 0f80000000 <- ( ff , 00000000 ) + +[5,30]: + int 7c0000000 <- ( ff , 00000000 ) + +[5,29]: + int 3e0000000 <- ( ff , 00000000 ) + +[5,28]: + int 1f0000000 <- ( ff , 0000000 ) + +[5,27]: + int 0f8000000 <- ( ff , 0000000 ) + +[5,26]: + int 7c000000 <- ( ff , 0000000 ) + +[5,25]: + int 3e000000 <- ( ff , 0000000 ) + +[5,24]: + int 1f000000 <- ( ff , 000000 ) + +[5,23]: + int 0f800000 <- ( ff , 000000 ) + +[5,22]: + int 7c00000 <- ( ff , 000000 ) + +[5,21]: + int 3e00000 <- ( ff , 000000 ) + +[5,20]: + int 1f00000 <- ( ff , 00000 ) + +[5,19]: + int 0f80000 <- ( ff , 00000 ) + +[5,18]: + int 7c0000 <- ( ff , 00000 ) + +[5,17]: + int 3e0000 <- ( ff , 00000 ) + +[5,16]: + int 1f0000 <- ( ff , 0000 ) + +[5,15]: + int 0f8000 <- ( ff , 0000 ) + +[5,14]: + int 7c000 <- ( ff , 0000 ) + +[5,13]: + int 3e000 <- ( ff , 0000 ) + +[5,12]: + int 1f000 <- ( ff , 000 ) + +[5,11]: + int 0f800 <- ( ff , 000 ) + +[5,10]: + int 7c00 <- ( ff , 000 ) + +[5,9]: + int 3e00 <- ( ff , 000 ) + +[5,8]: + int 1f00 <- ( ff , 00 ) + +[5,7]: + int 0f80 <- ( ff , 00 ) + +[5,6]: + int 7c0 <- ( ff , 00 ) + +[5,5]: + int 3e0 <- ( ff , 00 ) + +[5,4]: + int 1f0 <- ( ff , 0 ) + +[5,3]: + int 0f8 <- ( ff , 0 ) + +[5,2]: + int 7c <- ( ff , 0 ) + +[5,1]: + int 3e <- ( ff , 0 ) + +[4,64]: + int 0f0000000000000000 <- ( f , 0000000000000000 ) + +[4,63]: + int 78000000000000000 <- ( f , 0000000000000000 ) + +[4,62]: + int 3c000000000000000 <- ( f , 0000000000000000 ) + +[4,61]: + int 1e000000000000000 <- ( f , 0000000000000000 ) + +[4,60]: + int 0f000000000000000 <- ( f , 000000000000000 ) + +[4,59]: + int 7800000000000000 <- ( f , 000000000000000 ) + +[4,58]: + int 3c00000000000000 <- ( f , 000000000000000 ) + +[4,57]: + int 1e00000000000000 <- ( f , 000000000000000 ) + +[4,56]: + int 0f00000000000000 <- ( f , 00000000000000 ) + +[4,55]: + int 780000000000000 <- ( f , 00000000000000 ) + +[4,54]: + int 3c0000000000000 <- ( f , 00000000000000 ) + +[4,53]: + int 1e0000000000000 <- ( f , 00000000000000 ) + +[4,52]: + int 0f0000000000000 <- ( f , 0000000000000 ) + +[4,51]: + int 78000000000000 <- ( f , 0000000000000 ) + +[4,50]: + int 3c000000000000 <- ( f , 0000000000000 ) + +[4,49]: + int 1e000000000000 <- ( f , 0000000000000 ) + +[4,48]: + int 0f000000000000 <- ( f , 000000000000 ) + +[4,47]: + int 7800000000000 <- ( f , 000000000000 ) + +[4,46]: + int 3c00000000000 <- ( f , 000000000000 ) + +[4,45]: + int 1e00000000000 <- ( f , 000000000000 ) + +[4,44]: + int 0f00000000000 <- ( f , 00000000000 ) + +[4,43]: + int 780000000000 <- ( f , 00000000000 ) + +[4,42]: + int 3c0000000000 <- ( f , 00000000000 ) + +[4,41]: + int 1e0000000000 <- ( f , 00000000000 ) + +[4,40]: + int 0f0000000000 <- ( f , 0000000000 ) + +[4,39]: + int 78000000000 <- ( f , 0000000000 ) + +[4,38]: + int 3c000000000 <- ( f , 0000000000 ) + +[4,37]: + int 1e000000000 <- ( f , 0000000000 ) + +[4,36]: + int 0f000000000 <- ( f , 000000000 ) + +[4,35]: + int 7800000000 <- ( f , 000000000 ) + +[4,34]: + int 3c00000000 <- ( f , 000000000 ) + +[4,33]: + int 1e00000000 <- ( f , 000000000 ) + +[4,32]: + int 0f00000000 <- ( f , 00000000 ) + +[4,31]: + int 780000000 <- ( f , 00000000 ) + +[4,30]: + int 3c0000000 <- ( f , 00000000 ) + +[4,29]: + int 1e0000000 <- ( f , 00000000 ) + +[4,28]: + int 0f0000000 <- ( f , 0000000 ) + +[4,27]: + int 78000000 <- ( f , 0000000 ) + +[4,26]: + int 3c000000 <- ( f , 0000000 ) + +[4,25]: + int 1e000000 <- ( f , 0000000 ) + +[4,24]: + int 0f000000 <- ( f , 000000 ) + +[4,23]: + int 7800000 <- ( f , 000000 ) + +[4,22]: + int 3c00000 <- ( f , 000000 ) + +[4,21]: + int 1e00000 <- ( f , 000000 ) + +[4,20]: + int 0f00000 <- ( f , 00000 ) + +[4,19]: + int 780000 <- ( f , 00000 ) + +[4,18]: + int 3c0000 <- ( f , 00000 ) + +[4,17]: + int 1e0000 <- ( f , 00000 ) + +[4,16]: + int 0f0000 <- ( f , 0000 ) + +[4,15]: + int 78000 <- ( f , 0000 ) + +[4,14]: + int 3c000 <- ( f , 0000 ) + +[4,13]: + int 1e000 <- ( f , 0000 ) + +[4,12]: + int 0f000 <- ( f , 000 ) + +[4,11]: + int 7800 <- ( f , 000 ) + +[4,10]: + int 3c00 <- ( f , 000 ) + +[4,9]: + int 1e00 <- ( f , 000 ) + +[4,8]: + int 0f00 <- ( f , 00 ) + +[4,7]: + int 780 <- ( f , 00 ) + +[4,6]: + int 3c0 <- ( f , 00 ) + +[4,5]: + int 1e0 <- ( f , 00 ) + +[4,4]: + int 0f0 <- ( f , 0 ) + +[4,3]: + int 78 <- ( f , 0 ) + +[4,2]: + int 3c <- ( f , 0 ) + +[4,1]: + int 1e <- ( f , 0 ) + +[3,64]: + int 70000000000000000 <- ( f , 0000000000000000 ) + +[3,63]: + int 38000000000000000 <- ( f , 0000000000000000 ) + +[3,62]: + int 1c000000000000000 <- ( f , 0000000000000000 ) + +[3,61]: + int 0e000000000000000 <- ( f , 0000000000000000 ) + +[3,60]: + int 7000000000000000 <- ( f , 000000000000000 ) + +[3,59]: + int 3800000000000000 <- ( f , 000000000000000 ) + +[3,58]: + int 1c00000000000000 <- ( f , 000000000000000 ) + +[3,57]: + int 0e00000000000000 <- ( f , 000000000000000 ) + +[3,56]: + int 700000000000000 <- ( f , 00000000000000 ) + +[3,55]: + int 380000000000000 <- ( f , 00000000000000 ) + +[3,54]: + int 1c0000000000000 <- ( f , 00000000000000 ) + +[3,53]: + int 0e0000000000000 <- ( f , 00000000000000 ) + +[3,52]: + int 70000000000000 <- ( f , 0000000000000 ) + +[3,51]: + int 38000000000000 <- ( f , 0000000000000 ) + +[3,50]: + int 1c000000000000 <- ( f , 0000000000000 ) + +[3,49]: + int 0e000000000000 <- ( f , 0000000000000 ) + +[3,48]: + int 7000000000000 <- ( f , 000000000000 ) + +[3,47]: + int 3800000000000 <- ( f , 000000000000 ) + +[3,46]: + int 1c00000000000 <- ( f , 000000000000 ) + +[3,45]: + int 0e00000000000 <- ( f , 000000000000 ) + +[3,44]: + int 700000000000 <- ( f , 00000000000 ) + +[3,43]: + int 380000000000 <- ( f , 00000000000 ) + +[3,42]: + int 1c0000000000 <- ( f , 00000000000 ) + +[3,41]: + int 0e0000000000 <- ( f , 00000000000 ) + +[3,40]: + int 70000000000 <- ( f , 0000000000 ) + +[3,39]: + int 38000000000 <- ( f , 0000000000 ) + +[3,38]: + int 1c000000000 <- ( f , 0000000000 ) + +[3,37]: + int 0e000000000 <- ( f , 0000000000 ) + +[3,36]: + int 7000000000 <- ( f , 000000000 ) + +[3,35]: + int 3800000000 <- ( f , 000000000 ) + +[3,34]: + int 1c00000000 <- ( f , 000000000 ) + +[3,33]: + int 0e00000000 <- ( f , 000000000 ) + +[3,32]: + int 700000000 <- ( f , 00000000 ) + +[3,31]: + int 380000000 <- ( f , 00000000 ) + +[3,30]: + int 1c0000000 <- ( f , 00000000 ) + +[3,29]: + int 0e0000000 <- ( f , 00000000 ) + +[3,28]: + int 70000000 <- ( f , 0000000 ) + +[3,27]: + int 38000000 <- ( f , 0000000 ) + +[3,26]: + int 1c000000 <- ( f , 0000000 ) + +[3,25]: + int 0e000000 <- ( f , 0000000 ) + +[3,24]: + int 7000000 <- ( f , 000000 ) + +[3,23]: + int 3800000 <- ( f , 000000 ) + +[3,22]: + int 1c00000 <- ( f , 000000 ) + +[3,21]: + int 0e00000 <- ( f , 000000 ) + +[3,20]: + int 700000 <- ( f , 00000 ) + +[3,19]: + int 380000 <- ( f , 00000 ) + +[3,18]: + int 1c0000 <- ( f , 00000 ) + +[3,17]: + int 0e0000 <- ( f , 00000 ) + +[3,16]: + int 70000 <- ( f , 0000 ) + +[3,15]: + int 38000 <- ( f , 0000 ) + +[3,14]: + int 1c000 <- ( f , 0000 ) + +[3,13]: + int 0e000 <- ( f , 0000 ) + +[3,12]: + int 7000 <- ( f , 000 ) + +[3,11]: + int 3800 <- ( f , 000 ) + +[3,10]: + int 1c00 <- ( f , 000 ) + +[3,9]: + int 0e00 <- ( f , 000 ) + +[3,8]: + int 700 <- ( f , 00 ) + +[3,7]: + int 380 <- ( f , 00 ) + +[3,6]: + int 1c0 <- ( f , 00 ) + +[3,5]: + int 0e0 <- ( f , 00 ) + +[3,4]: + int 70 <- ( f , 0 ) + +[3,3]: + int 38 <- ( f , 0 ) + +[3,2]: + int 1c <- ( f , 0 ) + +[3,1]: + int 0e <- ( f , 0 ) + +[2,64]: + int 30000000000000000 <- ( f , 0000000000000000 ) + +[2,63]: + int 18000000000000000 <- ( f , 0000000000000000 ) + +[2,62]: + int 0c000000000000000 <- ( f , 0000000000000000 ) + +[2,61]: + int 6000000000000000 <- ( f , 0000000000000000 ) + +[2,60]: + int 3000000000000000 <- ( f , 000000000000000 ) + +[2,59]: + int 1800000000000000 <- ( f , 000000000000000 ) + +[2,58]: + int 0c00000000000000 <- ( f , 000000000000000 ) + +[2,57]: + int 600000000000000 <- ( f , 000000000000000 ) + +[2,56]: + int 300000000000000 <- ( f , 00000000000000 ) + +[2,55]: + int 180000000000000 <- ( f , 00000000000000 ) + +[2,54]: + int 0c0000000000000 <- ( f , 00000000000000 ) + +[2,53]: + int 60000000000000 <- ( f , 00000000000000 ) + +[2,52]: + int 30000000000000 <- ( f , 0000000000000 ) + +[2,51]: + int 18000000000000 <- ( f , 0000000000000 ) + +[2,50]: + int 0c000000000000 <- ( f , 0000000000000 ) + +[2,49]: + int 6000000000000 <- ( f , 0000000000000 ) + +[2,48]: + int 3000000000000 <- ( f , 000000000000 ) + +[2,47]: + int 1800000000000 <- ( f , 000000000000 ) + +[2,46]: + int 0c00000000000 <- ( f , 000000000000 ) + +[2,45]: + int 600000000000 <- ( f , 000000000000 ) + +[2,44]: + int 300000000000 <- ( f , 00000000000 ) + +[2,43]: + int 180000000000 <- ( f , 00000000000 ) + +[2,42]: + int 0c0000000000 <- ( f , 00000000000 ) + +[2,41]: + int 60000000000 <- ( f , 00000000000 ) + +[2,40]: + int 30000000000 <- ( f , 0000000000 ) + +[2,39]: + int 18000000000 <- ( f , 0000000000 ) + +[2,38]: + int 0c000000000 <- ( f , 0000000000 ) + +[2,37]: + int 6000000000 <- ( f , 0000000000 ) + +[2,36]: + int 3000000000 <- ( f , 000000000 ) + +[2,35]: + int 1800000000 <- ( f , 000000000 ) + +[2,34]: + int 0c00000000 <- ( f , 000000000 ) + +[2,33]: + int 600000000 <- ( f , 000000000 ) + +[2,32]: + int 300000000 <- ( f , 00000000 ) + +[2,31]: + int 180000000 <- ( f , 00000000 ) + +[2,30]: + int 0c0000000 <- ( f , 00000000 ) + +[2,29]: + int 60000000 <- ( f , 00000000 ) + +[2,28]: + int 30000000 <- ( f , 0000000 ) + +[2,27]: + int 18000000 <- ( f , 0000000 ) + +[2,26]: + int 0c000000 <- ( f , 0000000 ) + +[2,25]: + int 6000000 <- ( f , 0000000 ) + +[2,24]: + int 3000000 <- ( f , 000000 ) + +[2,23]: + int 1800000 <- ( f , 000000 ) + +[2,22]: + int 0c00000 <- ( f , 000000 ) + +[2,21]: + int 600000 <- ( f , 000000 ) + +[2,20]: + int 300000 <- ( f , 00000 ) + +[2,19]: + int 180000 <- ( f , 00000 ) + +[2,18]: + int 0c0000 <- ( f , 00000 ) + +[2,17]: + int 60000 <- ( f , 00000 ) + +[2,16]: + int 30000 <- ( f , 0000 ) + +[2,15]: + int 18000 <- ( f , 0000 ) + +[2,14]: + int 0c000 <- ( f , 0000 ) + +[2,13]: + int 6000 <- ( f , 0000 ) + +[2,12]: + int 3000 <- ( f , 000 ) + +[2,11]: + int 1800 <- ( f , 000 ) + +[2,10]: + int 0c00 <- ( f , 000 ) + +[2,9]: + int 600 <- ( f , 000 ) + +[2,8]: + int 300 <- ( f , 00 ) + +[2,7]: + int 180 <- ( f , 00 ) + +[2,6]: + int 0c0 <- ( f , 00 ) + +[2,5]: + int 60 <- ( f , 00 ) + +[2,4]: + int 30 <- ( f , 0 ) + +[2,3]: + int 18 <- ( f , 0 ) + +[2,2]: + int 0c <- ( f , 0 ) + +[2,1]: + int 6 <- ( f , 0 ) + +[1,64]: + int 10000000000000000 <- ( f , 0000000000000000 ) + +[1,63]: + int 08000000000000000 <- ( f , 0000000000000000 ) + +[1,62]: + int 4000000000000000 <- ( f , 0000000000000000 ) + +[1,61]: + int 2000000000000000 <- ( f , 0000000000000000 ) + +[1,60]: + int 1000000000000000 <- ( f , 000000000000000 ) + +[1,59]: + int 0800000000000000 <- ( f , 000000000000000 ) + +[1,58]: + int 400000000000000 <- ( f , 000000000000000 ) + +[1,57]: + int 200000000000000 <- ( f , 000000000000000 ) + +[1,56]: + int 100000000000000 <- ( f , 00000000000000 ) + +[1,55]: + int 080000000000000 <- ( f , 00000000000000 ) + +[1,54]: + int 40000000000000 <- ( f , 00000000000000 ) + +[1,53]: + int 20000000000000 <- ( f , 00000000000000 ) + +[1,52]: + int 10000000000000 <- ( f , 0000000000000 ) + +[1,51]: + int 08000000000000 <- ( f , 0000000000000 ) + +[1,50]: + int 4000000000000 <- ( f , 0000000000000 ) + +[1,49]: + int 2000000000000 <- ( f , 0000000000000 ) + +[1,48]: + int 1000000000000 <- ( f , 000000000000 ) + +[1,47]: + int 0800000000000 <- ( f , 000000000000 ) + +[1,46]: + int 400000000000 <- ( f , 000000000000 ) + +[1,45]: + int 200000000000 <- ( f , 000000000000 ) + +[1,44]: + int 100000000000 <- ( f , 00000000000 ) + +[1,43]: + int 080000000000 <- ( f , 00000000000 ) + +[1,42]: + int 40000000000 <- ( f , 00000000000 ) + +[1,41]: + int 20000000000 <- ( f , 00000000000 ) + +[1,40]: + int 10000000000 <- ( f , 0000000000 ) + +[1,39]: + int 08000000000 <- ( f , 0000000000 ) + +[1,38]: + int 4000000000 <- ( f , 0000000000 ) + +[1,37]: + int 2000000000 <- ( f , 0000000000 ) + +[1,36]: + int 1000000000 <- ( f , 000000000 ) + +[1,35]: + int 0800000000 <- ( f , 000000000 ) + +[1,34]: + int 400000000 <- ( f , 000000000 ) + +[1,33]: + int 200000000 <- ( f , 000000000 ) + +[1,32]: + int 100000000 <- ( f , 00000000 ) + +[1,31]: + int 080000000 <- ( f , 00000000 ) + +[1,30]: + int 40000000 <- ( f , 00000000 ) + +[1,29]: + int 20000000 <- ( f , 00000000 ) + +[1,28]: + int 10000000 <- ( f , 0000000 ) + +[1,27]: + int 08000000 <- ( f , 0000000 ) + +[1,26]: + int 4000000 <- ( f , 0000000 ) + +[1,25]: + int 2000000 <- ( f , 0000000 ) + +[1,24]: + int 1000000 <- ( f , 000000 ) + +[1,23]: + int 0800000 <- ( f , 000000 ) + +[1,22]: + int 400000 <- ( f , 000000 ) + +[1,21]: + int 200000 <- ( f , 000000 ) + +[1,20]: + int 100000 <- ( f , 00000 ) + +[1,19]: + int 080000 <- ( f , 00000 ) + +[1,18]: + int 40000 <- ( f , 00000 ) + +[1,17]: + int 20000 <- ( f , 00000 ) + +[1,16]: + int 10000 <- ( f , 0000 ) + +[1,15]: + int 08000 <- ( f , 0000 ) + +[1,14]: + int 4000 <- ( f , 0000 ) + +[1,13]: + int 2000 <- ( f , 0000 ) + +[1,12]: + int 1000 <- ( f , 000 ) + +[1,11]: + int 0800 <- ( f , 000 ) + +[1,10]: + int 400 <- ( f , 000 ) + +[1,9]: + int 200 <- ( f , 000 ) + +[1,8]: + int 100 <- ( f , 00 ) + +[1,7]: + int 080 <- ( f , 00 ) + +[1,6]: + int 40 <- ( f , 00 ) + +[1,5]: + int 20 <- ( f , 00 ) + +[1,4]: + int 10 <- ( f , 0 ) + +[1,3]: + int 08 <- ( f , 0 ) + +[1,2]: + int 4 <- ( f , 0 ) + +[1,1]: + int 2 <- ( f , 0 ) + +[64,64]: + int 00000000000000000ffffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[64,63]: + int 00000000000000007fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[64,62]: + int 00000000000000003fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[64,61]: + int 00000000000000001fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[64,60]: + int 00000000000000000fffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[64,59]: + int 00000000000000007ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[64,58]: + int 00000000000000003ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[64,57]: + int 00000000000000001ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[64,56]: + int 00000000000000000ffffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[64,55]: + int 00000000000000007fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[64,54]: + int 00000000000000003fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[64,53]: + int 00000000000000001fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[64,52]: + int 00000000000000000fffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[64,51]: + int 00000000000000007ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[64,50]: + int 00000000000000003ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[64,49]: + int 00000000000000001ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[64,48]: + int 00000000000000000ffffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[64,47]: + int 00000000000000007fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[64,46]: + int 00000000000000003fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[64,45]: + int 00000000000000001fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[64,44]: + int 00000000000000000fffffffffff <- ( 0000000000000000 , fffffffffff ) + +[64,43]: + int 00000000000000007ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[64,42]: + int 00000000000000003ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[64,41]: + int 00000000000000001ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[64,40]: + int 00000000000000000ffffffffff <- ( 0000000000000000 , ffffffffff ) + +[64,39]: + int 00000000000000007fffffffff <- ( 0000000000000000 , ffffffffff ) + +[64,38]: + int 00000000000000003fffffffff <- ( 0000000000000000 , ffffffffff ) + +[64,37]: + int 00000000000000001fffffffff <- ( 0000000000000000 , ffffffffff ) + +[64,36]: + int 00000000000000000fffffffff <- ( 0000000000000000 , fffffffff ) + +[64,35]: + int 00000000000000007ffffffff <- ( 0000000000000000 , fffffffff ) + +[64,34]: + int 00000000000000003ffffffff <- ( 0000000000000000 , fffffffff ) + +[64,33]: + int 00000000000000001ffffffff <- ( 0000000000000000 , fffffffff ) + +[64,32]: + int 00000000000000000ffffffff <- ( 0000000000000000 , ffffffff ) + +[64,31]: + int 00000000000000007fffffff <- ( 0000000000000000 , ffffffff ) + +[64,30]: + int 00000000000000003fffffff <- ( 0000000000000000 , ffffffff ) + +[64,29]: + int 00000000000000001fffffff <- ( 0000000000000000 , ffffffff ) + +[64,28]: + int 00000000000000000fffffff <- ( 0000000000000000 , fffffff ) + +[64,27]: + int 00000000000000007ffffff <- ( 0000000000000000 , fffffff ) + +[64,26]: + int 00000000000000003ffffff <- ( 0000000000000000 , fffffff ) + +[64,25]: + int 00000000000000001ffffff <- ( 0000000000000000 , fffffff ) + +[64,24]: + int 00000000000000000ffffff <- ( 0000000000000000 , ffffff ) + +[64,23]: + int 00000000000000007fffff <- ( 0000000000000000 , ffffff ) + +[64,22]: + int 00000000000000003fffff <- ( 0000000000000000 , ffffff ) + +[64,21]: + int 00000000000000001fffff <- ( 0000000000000000 , ffffff ) + +[64,20]: + int 00000000000000000fffff <- ( 0000000000000000 , fffff ) + +[64,19]: + int 00000000000000007ffff <- ( 0000000000000000 , fffff ) + +[64,18]: + int 00000000000000003ffff <- ( 0000000000000000 , fffff ) + +[64,17]: + int 00000000000000001ffff <- ( 0000000000000000 , fffff ) + +[64,16]: + int 00000000000000000ffff <- ( 0000000000000000 , ffff ) + +[64,15]: + int 00000000000000007fff <- ( 0000000000000000 , ffff ) + +[64,14]: + int 00000000000000003fff <- ( 0000000000000000 , ffff ) + +[64,13]: + int 00000000000000001fff <- ( 0000000000000000 , ffff ) + +[64,12]: + int 00000000000000000fff <- ( 0000000000000000 , fff ) + +[64,11]: + int 00000000000000007ff <- ( 0000000000000000 , fff ) + +[64,10]: + int 00000000000000003ff <- ( 0000000000000000 , fff ) + +[64,9]: + int 00000000000000001ff <- ( 0000000000000000 , fff ) + +[64,8]: + int 00000000000000000ff <- ( 0000000000000000 , ff ) + +[64,7]: + int 00000000000000007f <- ( 0000000000000000 , ff ) + +[64,6]: + int 00000000000000003f <- ( 0000000000000000 , ff ) + +[64,5]: + int 00000000000000001f <- ( 0000000000000000 , ff ) + +[64,4]: + int 00000000000000000f <- ( 0000000000000000 , f ) + +[64,3]: + int 00000000000000007 <- ( 0000000000000000 , f ) + +[64,2]: + int 00000000000000003 <- ( 0000000000000000 , f ) + +[64,1]: + int 00000000000000001 <- ( 0000000000000000 , f ) + +[63,64]: + int 0000000000000000ffffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[63,63]: + int 00000000000000007fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[63,62]: + int 00000000000000003fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[63,61]: + int 00000000000000001fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[63,60]: + int 0000000000000000fffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[63,59]: + int 00000000000000007ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[63,58]: + int 00000000000000003ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[63,57]: + int 00000000000000001ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[63,56]: + int 0000000000000000ffffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[63,55]: + int 00000000000000007fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[63,54]: + int 00000000000000003fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[63,53]: + int 00000000000000001fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[63,52]: + int 0000000000000000fffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[63,51]: + int 00000000000000007ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[63,50]: + int 00000000000000003ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[63,49]: + int 00000000000000001ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[63,48]: + int 0000000000000000ffffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[63,47]: + int 00000000000000007fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[63,46]: + int 00000000000000003fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[63,45]: + int 00000000000000001fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[63,44]: + int 0000000000000000fffffffffff <- ( 0000000000000000 , fffffffffff ) + +[63,43]: + int 00000000000000007ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[63,42]: + int 00000000000000003ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[63,41]: + int 00000000000000001ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[63,40]: + int 0000000000000000ffffffffff <- ( 0000000000000000 , ffffffffff ) + +[63,39]: + int 00000000000000007fffffffff <- ( 0000000000000000 , ffffffffff ) + +[63,38]: + int 00000000000000003fffffffff <- ( 0000000000000000 , ffffffffff ) + +[63,37]: + int 00000000000000001fffffffff <- ( 0000000000000000 , ffffffffff ) + +[63,36]: + int 0000000000000000fffffffff <- ( 0000000000000000 , fffffffff ) + +[63,35]: + int 00000000000000007ffffffff <- ( 0000000000000000 , fffffffff ) + +[63,34]: + int 00000000000000003ffffffff <- ( 0000000000000000 , fffffffff ) + +[63,33]: + int 00000000000000001ffffffff <- ( 0000000000000000 , fffffffff ) + +[63,32]: + int 0000000000000000ffffffff <- ( 0000000000000000 , ffffffff ) + +[63,31]: + int 00000000000000007fffffff <- ( 0000000000000000 , ffffffff ) + +[63,30]: + int 00000000000000003fffffff <- ( 0000000000000000 , ffffffff ) + +[63,29]: + int 00000000000000001fffffff <- ( 0000000000000000 , ffffffff ) + +[63,28]: + int 0000000000000000fffffff <- ( 0000000000000000 , fffffff ) + +[63,27]: + int 00000000000000007ffffff <- ( 0000000000000000 , fffffff ) + +[63,26]: + int 00000000000000003ffffff <- ( 0000000000000000 , fffffff ) + +[63,25]: + int 00000000000000001ffffff <- ( 0000000000000000 , fffffff ) + +[63,24]: + int 0000000000000000ffffff <- ( 0000000000000000 , ffffff ) + +[63,23]: + int 00000000000000007fffff <- ( 0000000000000000 , ffffff ) + +[63,22]: + int 00000000000000003fffff <- ( 0000000000000000 , ffffff ) + +[63,21]: + int 00000000000000001fffff <- ( 0000000000000000 , ffffff ) + +[63,20]: + int 0000000000000000fffff <- ( 0000000000000000 , fffff ) + +[63,19]: + int 00000000000000007ffff <- ( 0000000000000000 , fffff ) + +[63,18]: + int 00000000000000003ffff <- ( 0000000000000000 , fffff ) + +[63,17]: + int 00000000000000001ffff <- ( 0000000000000000 , fffff ) + +[63,16]: + int 0000000000000000ffff <- ( 0000000000000000 , ffff ) + +[63,15]: + int 00000000000000007fff <- ( 0000000000000000 , ffff ) + +[63,14]: + int 00000000000000003fff <- ( 0000000000000000 , ffff ) + +[63,13]: + int 00000000000000001fff <- ( 0000000000000000 , ffff ) + +[63,12]: + int 0000000000000000fff <- ( 0000000000000000 , fff ) + +[63,11]: + int 00000000000000007ff <- ( 0000000000000000 , fff ) + +[63,10]: + int 00000000000000003ff <- ( 0000000000000000 , fff ) + +[63,9]: + int 00000000000000001ff <- ( 0000000000000000 , fff ) + +[63,8]: + int 0000000000000000ff <- ( 0000000000000000 , ff ) + +[63,7]: + int 00000000000000007f <- ( 0000000000000000 , ff ) + +[63,6]: + int 00000000000000003f <- ( 0000000000000000 , ff ) + +[63,5]: + int 00000000000000001f <- ( 0000000000000000 , ff ) + +[63,4]: + int 0000000000000000f <- ( 0000000000000000 , f ) + +[63,3]: + int 00000000000000007 <- ( 0000000000000000 , f ) + +[63,2]: + int 00000000000000003 <- ( 0000000000000000 , f ) + +[63,1]: + int 00000000000000001 <- ( 0000000000000000 , f ) + +[62,64]: + int 0000000000000000ffffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[62,63]: + int 00000000000000007fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[62,62]: + int 00000000000000003fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[62,61]: + int 0000000000000001fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[62,60]: + int 0000000000000000fffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[62,59]: + int 00000000000000007ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[62,58]: + int 00000000000000003ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[62,57]: + int 0000000000000001ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[62,56]: + int 0000000000000000ffffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[62,55]: + int 00000000000000007fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[62,54]: + int 00000000000000003fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[62,53]: + int 0000000000000001fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[62,52]: + int 0000000000000000fffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[62,51]: + int 00000000000000007ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[62,50]: + int 00000000000000003ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[62,49]: + int 0000000000000001ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[62,48]: + int 0000000000000000ffffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[62,47]: + int 00000000000000007fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[62,46]: + int 00000000000000003fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[62,45]: + int 0000000000000001fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[62,44]: + int 0000000000000000fffffffffff <- ( 0000000000000000 , fffffffffff ) + +[62,43]: + int 00000000000000007ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[62,42]: + int 00000000000000003ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[62,41]: + int 0000000000000001ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[62,40]: + int 0000000000000000ffffffffff <- ( 0000000000000000 , ffffffffff ) + +[62,39]: + int 00000000000000007fffffffff <- ( 0000000000000000 , ffffffffff ) + +[62,38]: + int 00000000000000003fffffffff <- ( 0000000000000000 , ffffffffff ) + +[62,37]: + int 0000000000000001fffffffff <- ( 0000000000000000 , ffffffffff ) + +[62,36]: + int 0000000000000000fffffffff <- ( 0000000000000000 , fffffffff ) + +[62,35]: + int 00000000000000007ffffffff <- ( 0000000000000000 , fffffffff ) + +[62,34]: + int 00000000000000003ffffffff <- ( 0000000000000000 , fffffffff ) + +[62,33]: + int 0000000000000001ffffffff <- ( 0000000000000000 , fffffffff ) + +[62,32]: + int 0000000000000000ffffffff <- ( 0000000000000000 , ffffffff ) + +[62,31]: + int 00000000000000007fffffff <- ( 0000000000000000 , ffffffff ) + +[62,30]: + int 00000000000000003fffffff <- ( 0000000000000000 , ffffffff ) + +[62,29]: + int 0000000000000001fffffff <- ( 0000000000000000 , ffffffff ) + +[62,28]: + int 0000000000000000fffffff <- ( 0000000000000000 , fffffff ) + +[62,27]: + int 00000000000000007ffffff <- ( 0000000000000000 , fffffff ) + +[62,26]: + int 00000000000000003ffffff <- ( 0000000000000000 , fffffff ) + +[62,25]: + int 0000000000000001ffffff <- ( 0000000000000000 , fffffff ) + +[62,24]: + int 0000000000000000ffffff <- ( 0000000000000000 , ffffff ) + +[62,23]: + int 00000000000000007fffff <- ( 0000000000000000 , ffffff ) + +[62,22]: + int 00000000000000003fffff <- ( 0000000000000000 , ffffff ) + +[62,21]: + int 0000000000000001fffff <- ( 0000000000000000 , ffffff ) + +[62,20]: + int 0000000000000000fffff <- ( 0000000000000000 , fffff ) + +[62,19]: + int 00000000000000007ffff <- ( 0000000000000000 , fffff ) + +[62,18]: + int 00000000000000003ffff <- ( 0000000000000000 , fffff ) + +[62,17]: + int 0000000000000001ffff <- ( 0000000000000000 , fffff ) + +[62,16]: + int 0000000000000000ffff <- ( 0000000000000000 , ffff ) + +[62,15]: + int 00000000000000007fff <- ( 0000000000000000 , ffff ) + +[62,14]: + int 00000000000000003fff <- ( 0000000000000000 , ffff ) + +[62,13]: + int 0000000000000001fff <- ( 0000000000000000 , ffff ) + +[62,12]: + int 0000000000000000fff <- ( 0000000000000000 , fff ) + +[62,11]: + int 00000000000000007ff <- ( 0000000000000000 , fff ) + +[62,10]: + int 00000000000000003ff <- ( 0000000000000000 , fff ) + +[62,9]: + int 0000000000000001ff <- ( 0000000000000000 , fff ) + +[62,8]: + int 0000000000000000ff <- ( 0000000000000000 , ff ) + +[62,7]: + int 00000000000000007f <- ( 0000000000000000 , ff ) + +[62,6]: + int 00000000000000003f <- ( 0000000000000000 , ff ) + +[62,5]: + int 0000000000000001f <- ( 0000000000000000 , ff ) + +[62,4]: + int 0000000000000000f <- ( 0000000000000000 , f ) + +[62,3]: + int 00000000000000007 <- ( 0000000000000000 , f ) + +[62,2]: + int 00000000000000003 <- ( 0000000000000000 , f ) + +[62,1]: + int 0000000000000001 <- ( 0000000000000000 , f ) + +[61,64]: + int 0000000000000000ffffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[61,63]: + int 00000000000000007fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[61,62]: + int 0000000000000003fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[61,61]: + int 0000000000000001fffffffffffffff <- ( 0000000000000000 , ffffffffffffffff ) + +[61,60]: + int 0000000000000000fffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[61,59]: + int 00000000000000007ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[61,58]: + int 0000000000000003ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[61,57]: + int 0000000000000001ffffffffffffff <- ( 0000000000000000 , fffffffffffffff ) + +[61,56]: + int 0000000000000000ffffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[61,55]: + int 00000000000000007fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[61,54]: + int 0000000000000003fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[61,53]: + int 0000000000000001fffffffffffff <- ( 0000000000000000 , ffffffffffffff ) + +[61,52]: + int 0000000000000000fffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[61,51]: + int 00000000000000007ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[61,50]: + int 0000000000000003ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[61,49]: + int 0000000000000001ffffffffffff <- ( 0000000000000000 , fffffffffffff ) + +[61,48]: + int 0000000000000000ffffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[61,47]: + int 00000000000000007fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[61,46]: + int 0000000000000003fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[61,45]: + int 0000000000000001fffffffffff <- ( 0000000000000000 , ffffffffffff ) + +[61,44]: + int 0000000000000000fffffffffff <- ( 0000000000000000 , fffffffffff ) + +[61,43]: + int 00000000000000007ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[61,42]: + int 0000000000000003ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[61,41]: + int 0000000000000001ffffffffff <- ( 0000000000000000 , fffffffffff ) + +[61,40]: + int 0000000000000000ffffffffff <- ( 0000000000000000 , ffffffffff ) + +[61,39]: + int 00000000000000007fffffffff <- ( 0000000000000000 , ffffffffff ) + +[61,38]: + int 0000000000000003fffffffff <- ( 0000000000000000 , ffffffffff ) + +[61,37]: + int 0000000000000001fffffffff <- ( 0000000000000000 , ffffffffff ) + +[61,36]: + int 0000000000000000fffffffff <- ( 0000000000000000 , fffffffff ) + +[61,35]: + int 00000000000000007ffffffff <- ( 0000000000000000 , fffffffff ) + +[61,34]: + int 0000000000000003ffffffff <- ( 0000000000000000 , fffffffff ) + +[61,33]: + int 0000000000000001ffffffff <- ( 0000000000000000 , fffffffff ) + +[61,32]: + int 0000000000000000ffffffff <- ( 0000000000000000 , ffffffff ) + +[61,31]: + int 00000000000000007fffffff <- ( 0000000000000000 , ffffffff ) + +[61,30]: + int 0000000000000003fffffff <- ( 0000000000000000 , ffffffff ) + +[61,29]: + int 0000000000000001fffffff <- ( 0000000000000000 , ffffffff ) + +[61,28]: + int 0000000000000000fffffff <- ( 0000000000000000 , fffffff ) + +[61,27]: + int 00000000000000007ffffff <- ( 0000000000000000 , fffffff ) + +[61,26]: + int 0000000000000003ffffff <- ( 0000000000000000 , fffffff ) + +[61,25]: + int 0000000000000001ffffff <- ( 0000000000000000 , fffffff ) + +[61,24]: + int 0000000000000000ffffff <- ( 0000000000000000 , ffffff ) + +[61,23]: + int 00000000000000007fffff <- ( 0000000000000000 , ffffff ) + +[61,22]: + int 0000000000000003fffff <- ( 0000000000000000 , ffffff ) + +[61,21]: + int 0000000000000001fffff <- ( 0000000000000000 , ffffff ) + +[61,20]: + int 0000000000000000fffff <- ( 0000000000000000 , fffff ) + +[61,19]: + int 00000000000000007ffff <- ( 0000000000000000 , fffff ) + +[61,18]: + int 0000000000000003ffff <- ( 0000000000000000 , fffff ) + +[61,17]: + int 0000000000000001ffff <- ( 0000000000000000 , fffff ) + +[61,16]: + int 0000000000000000ffff <- ( 0000000000000000 , ffff ) + +[61,15]: + int 00000000000000007fff <- ( 0000000000000000 , ffff ) + +[61,14]: + int 0000000000000003fff <- ( 0000000000000000 , ffff ) + +[61,13]: + int 0000000000000001fff <- ( 0000000000000000 , ffff ) + +[61,12]: + int 0000000000000000fff <- ( 0000000000000000 , fff ) + +[61,11]: + int 00000000000000007ff <- ( 0000000000000000 , fff ) + +[61,10]: + int 0000000000000003ff <- ( 0000000000000000 , fff ) + +[61,9]: + int 0000000000000001ff <- ( 0000000000000000 , fff ) + +[61,8]: + int 0000000000000000ff <- ( 0000000000000000 , ff ) + +[61,7]: + int 00000000000000007f <- ( 0000000000000000 , ff ) + +[61,6]: + int 0000000000000003f <- ( 0000000000000000 , ff ) + +[61,5]: + int 0000000000000001f <- ( 0000000000000000 , ff ) + +[61,4]: + int 0000000000000000f <- ( 0000000000000000 , f ) + +[61,3]: + int 00000000000000007 <- ( 0000000000000000 , f ) + +[61,2]: + int 0000000000000003 <- ( 0000000000000000 , f ) + +[61,1]: + int 0000000000000001 <- ( 0000000000000000 , f ) + +[60,64]: + int 0000000000000000ffffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[60,63]: + int 0000000000000007fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[60,62]: + int 0000000000000003fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[60,61]: + int 0000000000000001fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[60,60]: + int 0000000000000000fffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[60,59]: + int 0000000000000007ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[60,58]: + int 0000000000000003ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[60,57]: + int 0000000000000001ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[60,56]: + int 0000000000000000ffffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[60,55]: + int 0000000000000007fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[60,54]: + int 0000000000000003fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[60,53]: + int 0000000000000001fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[60,52]: + int 0000000000000000fffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[60,51]: + int 0000000000000007ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[60,50]: + int 0000000000000003ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[60,49]: + int 0000000000000001ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[60,48]: + int 0000000000000000ffffffffffff <- ( 000000000000000 , ffffffffffff ) + +[60,47]: + int 0000000000000007fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[60,46]: + int 0000000000000003fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[60,45]: + int 0000000000000001fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[60,44]: + int 0000000000000000fffffffffff <- ( 000000000000000 , fffffffffff ) + +[60,43]: + int 0000000000000007ffffffffff <- ( 000000000000000 , fffffffffff ) + +[60,42]: + int 0000000000000003ffffffffff <- ( 000000000000000 , fffffffffff ) + +[60,41]: + int 0000000000000001ffffffffff <- ( 000000000000000 , fffffffffff ) + +[60,40]: + int 0000000000000000ffffffffff <- ( 000000000000000 , ffffffffff ) + +[60,39]: + int 0000000000000007fffffffff <- ( 000000000000000 , ffffffffff ) + +[60,38]: + int 0000000000000003fffffffff <- ( 000000000000000 , ffffffffff ) + +[60,37]: + int 0000000000000001fffffffff <- ( 000000000000000 , ffffffffff ) + +[60,36]: + int 0000000000000000fffffffff <- ( 000000000000000 , fffffffff ) + +[60,35]: + int 0000000000000007ffffffff <- ( 000000000000000 , fffffffff ) + +[60,34]: + int 0000000000000003ffffffff <- ( 000000000000000 , fffffffff ) + +[60,33]: + int 0000000000000001ffffffff <- ( 000000000000000 , fffffffff ) + +[60,32]: + int 0000000000000000ffffffff <- ( 000000000000000 , ffffffff ) + +[60,31]: + int 0000000000000007fffffff <- ( 000000000000000 , ffffffff ) + +[60,30]: + int 0000000000000003fffffff <- ( 000000000000000 , ffffffff ) + +[60,29]: + int 0000000000000001fffffff <- ( 000000000000000 , ffffffff ) + +[60,28]: + int 0000000000000000fffffff <- ( 000000000000000 , fffffff ) + +[60,27]: + int 0000000000000007ffffff <- ( 000000000000000 , fffffff ) + +[60,26]: + int 0000000000000003ffffff <- ( 000000000000000 , fffffff ) + +[60,25]: + int 0000000000000001ffffff <- ( 000000000000000 , fffffff ) + +[60,24]: + int 0000000000000000ffffff <- ( 000000000000000 , ffffff ) + +[60,23]: + int 0000000000000007fffff <- ( 000000000000000 , ffffff ) + +[60,22]: + int 0000000000000003fffff <- ( 000000000000000 , ffffff ) + +[60,21]: + int 0000000000000001fffff <- ( 000000000000000 , ffffff ) + +[60,20]: + int 0000000000000000fffff <- ( 000000000000000 , fffff ) + +[60,19]: + int 0000000000000007ffff <- ( 000000000000000 , fffff ) + +[60,18]: + int 0000000000000003ffff <- ( 000000000000000 , fffff ) + +[60,17]: + int 0000000000000001ffff <- ( 000000000000000 , fffff ) + +[60,16]: + int 0000000000000000ffff <- ( 000000000000000 , ffff ) + +[60,15]: + int 0000000000000007fff <- ( 000000000000000 , ffff ) + +[60,14]: + int 0000000000000003fff <- ( 000000000000000 , ffff ) + +[60,13]: + int 0000000000000001fff <- ( 000000000000000 , ffff ) + +[60,12]: + int 0000000000000000fff <- ( 000000000000000 , fff ) + +[60,11]: + int 0000000000000007ff <- ( 000000000000000 , fff ) + +[60,10]: + int 0000000000000003ff <- ( 000000000000000 , fff ) + +[60,9]: + int 0000000000000001ff <- ( 000000000000000 , fff ) + +[60,8]: + int 0000000000000000ff <- ( 000000000000000 , ff ) + +[60,7]: + int 0000000000000007f <- ( 000000000000000 , ff ) + +[60,6]: + int 0000000000000003f <- ( 000000000000000 , ff ) + +[60,5]: + int 0000000000000001f <- ( 000000000000000 , ff ) + +[60,4]: + int 0000000000000000f <- ( 000000000000000 , f ) + +[60,3]: + int 0000000000000007 <- ( 000000000000000 , f ) + +[60,2]: + int 0000000000000003 <- ( 000000000000000 , f ) + +[60,1]: + int 0000000000000001 <- ( 000000000000000 , f ) + +[59,64]: + int 000000000000000ffffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[59,63]: + int 0000000000000007fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[59,62]: + int 0000000000000003fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[59,61]: + int 0000000000000001fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[59,60]: + int 000000000000000fffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[59,59]: + int 0000000000000007ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[59,58]: + int 0000000000000003ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[59,57]: + int 0000000000000001ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[59,56]: + int 000000000000000ffffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[59,55]: + int 0000000000000007fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[59,54]: + int 0000000000000003fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[59,53]: + int 0000000000000001fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[59,52]: + int 000000000000000fffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[59,51]: + int 0000000000000007ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[59,50]: + int 0000000000000003ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[59,49]: + int 0000000000000001ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[59,48]: + int 000000000000000ffffffffffff <- ( 000000000000000 , ffffffffffff ) + +[59,47]: + int 0000000000000007fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[59,46]: + int 0000000000000003fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[59,45]: + int 0000000000000001fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[59,44]: + int 000000000000000fffffffffff <- ( 000000000000000 , fffffffffff ) + +[59,43]: + int 0000000000000007ffffffffff <- ( 000000000000000 , fffffffffff ) + +[59,42]: + int 0000000000000003ffffffffff <- ( 000000000000000 , fffffffffff ) + +[59,41]: + int 0000000000000001ffffffffff <- ( 000000000000000 , fffffffffff ) + +[59,40]: + int 000000000000000ffffffffff <- ( 000000000000000 , ffffffffff ) + +[59,39]: + int 0000000000000007fffffffff <- ( 000000000000000 , ffffffffff ) + +[59,38]: + int 0000000000000003fffffffff <- ( 000000000000000 , ffffffffff ) + +[59,37]: + int 0000000000000001fffffffff <- ( 000000000000000 , ffffffffff ) + +[59,36]: + int 000000000000000fffffffff <- ( 000000000000000 , fffffffff ) + +[59,35]: + int 0000000000000007ffffffff <- ( 000000000000000 , fffffffff ) + +[59,34]: + int 0000000000000003ffffffff <- ( 000000000000000 , fffffffff ) + +[59,33]: + int 0000000000000001ffffffff <- ( 000000000000000 , fffffffff ) + +[59,32]: + int 000000000000000ffffffff <- ( 000000000000000 , ffffffff ) + +[59,31]: + int 0000000000000007fffffff <- ( 000000000000000 , ffffffff ) + +[59,30]: + int 0000000000000003fffffff <- ( 000000000000000 , ffffffff ) + +[59,29]: + int 0000000000000001fffffff <- ( 000000000000000 , ffffffff ) + +[59,28]: + int 000000000000000fffffff <- ( 000000000000000 , fffffff ) + +[59,27]: + int 0000000000000007ffffff <- ( 000000000000000 , fffffff ) + +[59,26]: + int 0000000000000003ffffff <- ( 000000000000000 , fffffff ) + +[59,25]: + int 0000000000000001ffffff <- ( 000000000000000 , fffffff ) + +[59,24]: + int 000000000000000ffffff <- ( 000000000000000 , ffffff ) + +[59,23]: + int 0000000000000007fffff <- ( 000000000000000 , ffffff ) + +[59,22]: + int 0000000000000003fffff <- ( 000000000000000 , ffffff ) + +[59,21]: + int 0000000000000001fffff <- ( 000000000000000 , ffffff ) + +[59,20]: + int 000000000000000fffff <- ( 000000000000000 , fffff ) + +[59,19]: + int 0000000000000007ffff <- ( 000000000000000 , fffff ) + +[59,18]: + int 0000000000000003ffff <- ( 000000000000000 , fffff ) + +[59,17]: + int 0000000000000001ffff <- ( 000000000000000 , fffff ) + +[59,16]: + int 000000000000000ffff <- ( 000000000000000 , ffff ) + +[59,15]: + int 0000000000000007fff <- ( 000000000000000 , ffff ) + +[59,14]: + int 0000000000000003fff <- ( 000000000000000 , ffff ) + +[59,13]: + int 0000000000000001fff <- ( 000000000000000 , ffff ) + +[59,12]: + int 000000000000000fff <- ( 000000000000000 , fff ) + +[59,11]: + int 0000000000000007ff <- ( 000000000000000 , fff ) + +[59,10]: + int 0000000000000003ff <- ( 000000000000000 , fff ) + +[59,9]: + int 0000000000000001ff <- ( 000000000000000 , fff ) + +[59,8]: + int 000000000000000ff <- ( 000000000000000 , ff ) + +[59,7]: + int 0000000000000007f <- ( 000000000000000 , ff ) + +[59,6]: + int 0000000000000003f <- ( 000000000000000 , ff ) + +[59,5]: + int 0000000000000001f <- ( 000000000000000 , ff ) + +[59,4]: + int 000000000000000f <- ( 000000000000000 , f ) + +[59,3]: + int 0000000000000007 <- ( 000000000000000 , f ) + +[59,2]: + int 0000000000000003 <- ( 000000000000000 , f ) + +[59,1]: + int 0000000000000001 <- ( 000000000000000 , f ) + +[58,64]: + int 000000000000000ffffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[58,63]: + int 0000000000000007fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[58,62]: + int 0000000000000003fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[58,61]: + int 000000000000001fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[58,60]: + int 000000000000000fffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[58,59]: + int 0000000000000007ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[58,58]: + int 0000000000000003ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[58,57]: + int 000000000000001ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[58,56]: + int 000000000000000ffffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[58,55]: + int 0000000000000007fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[58,54]: + int 0000000000000003fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[58,53]: + int 000000000000001fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[58,52]: + int 000000000000000fffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[58,51]: + int 0000000000000007ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[58,50]: + int 0000000000000003ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[58,49]: + int 000000000000001ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[58,48]: + int 000000000000000ffffffffffff <- ( 000000000000000 , ffffffffffff ) + +[58,47]: + int 0000000000000007fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[58,46]: + int 0000000000000003fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[58,45]: + int 000000000000001fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[58,44]: + int 000000000000000fffffffffff <- ( 000000000000000 , fffffffffff ) + +[58,43]: + int 0000000000000007ffffffffff <- ( 000000000000000 , fffffffffff ) + +[58,42]: + int 0000000000000003ffffffffff <- ( 000000000000000 , fffffffffff ) + +[58,41]: + int 000000000000001ffffffffff <- ( 000000000000000 , fffffffffff ) + +[58,40]: + int 000000000000000ffffffffff <- ( 000000000000000 , ffffffffff ) + +[58,39]: + int 0000000000000007fffffffff <- ( 000000000000000 , ffffffffff ) + +[58,38]: + int 0000000000000003fffffffff <- ( 000000000000000 , ffffffffff ) + +[58,37]: + int 000000000000001fffffffff <- ( 000000000000000 , ffffffffff ) + +[58,36]: + int 000000000000000fffffffff <- ( 000000000000000 , fffffffff ) + +[58,35]: + int 0000000000000007ffffffff <- ( 000000000000000 , fffffffff ) + +[58,34]: + int 0000000000000003ffffffff <- ( 000000000000000 , fffffffff ) + +[58,33]: + int 000000000000001ffffffff <- ( 000000000000000 , fffffffff ) + +[58,32]: + int 000000000000000ffffffff <- ( 000000000000000 , ffffffff ) + +[58,31]: + int 0000000000000007fffffff <- ( 000000000000000 , ffffffff ) + +[58,30]: + int 0000000000000003fffffff <- ( 000000000000000 , ffffffff ) + +[58,29]: + int 000000000000001fffffff <- ( 000000000000000 , ffffffff ) + +[58,28]: + int 000000000000000fffffff <- ( 000000000000000 , fffffff ) + +[58,27]: + int 0000000000000007ffffff <- ( 000000000000000 , fffffff ) + +[58,26]: + int 0000000000000003ffffff <- ( 000000000000000 , fffffff ) + +[58,25]: + int 000000000000001ffffff <- ( 000000000000000 , fffffff ) + +[58,24]: + int 000000000000000ffffff <- ( 000000000000000 , ffffff ) + +[58,23]: + int 0000000000000007fffff <- ( 000000000000000 , ffffff ) + +[58,22]: + int 0000000000000003fffff <- ( 000000000000000 , ffffff ) + +[58,21]: + int 000000000000001fffff <- ( 000000000000000 , ffffff ) + +[58,20]: + int 000000000000000fffff <- ( 000000000000000 , fffff ) + +[58,19]: + int 0000000000000007ffff <- ( 000000000000000 , fffff ) + +[58,18]: + int 0000000000000003ffff <- ( 000000000000000 , fffff ) + +[58,17]: + int 000000000000001ffff <- ( 000000000000000 , fffff ) + +[58,16]: + int 000000000000000ffff <- ( 000000000000000 , ffff ) + +[58,15]: + int 0000000000000007fff <- ( 000000000000000 , ffff ) + +[58,14]: + int 0000000000000003fff <- ( 000000000000000 , ffff ) + +[58,13]: + int 000000000000001fff <- ( 000000000000000 , ffff ) + +[58,12]: + int 000000000000000fff <- ( 000000000000000 , fff ) + +[58,11]: + int 0000000000000007ff <- ( 000000000000000 , fff ) + +[58,10]: + int 0000000000000003ff <- ( 000000000000000 , fff ) + +[58,9]: + int 000000000000001ff <- ( 000000000000000 , fff ) + +[58,8]: + int 000000000000000ff <- ( 000000000000000 , ff ) + +[58,7]: + int 0000000000000007f <- ( 000000000000000 , ff ) + +[58,6]: + int 0000000000000003f <- ( 000000000000000 , ff ) + +[58,5]: + int 000000000000001f <- ( 000000000000000 , ff ) + +[58,4]: + int 000000000000000f <- ( 000000000000000 , f ) + +[58,3]: + int 0000000000000007 <- ( 000000000000000 , f ) + +[58,2]: + int 0000000000000003 <- ( 000000000000000 , f ) + +[58,1]: + int 000000000000001 <- ( 000000000000000 , f ) + +[57,64]: + int 000000000000000ffffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[57,63]: + int 0000000000000007fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[57,62]: + int 000000000000003fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[57,61]: + int 000000000000001fffffffffffffff <- ( 000000000000000 , ffffffffffffffff ) + +[57,60]: + int 000000000000000fffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[57,59]: + int 0000000000000007ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[57,58]: + int 000000000000003ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[57,57]: + int 000000000000001ffffffffffffff <- ( 000000000000000 , fffffffffffffff ) + +[57,56]: + int 000000000000000ffffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[57,55]: + int 0000000000000007fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[57,54]: + int 000000000000003fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[57,53]: + int 000000000000001fffffffffffff <- ( 000000000000000 , ffffffffffffff ) + +[57,52]: + int 000000000000000fffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[57,51]: + int 0000000000000007ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[57,50]: + int 000000000000003ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[57,49]: + int 000000000000001ffffffffffff <- ( 000000000000000 , fffffffffffff ) + +[57,48]: + int 000000000000000ffffffffffff <- ( 000000000000000 , ffffffffffff ) + +[57,47]: + int 0000000000000007fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[57,46]: + int 000000000000003fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[57,45]: + int 000000000000001fffffffffff <- ( 000000000000000 , ffffffffffff ) + +[57,44]: + int 000000000000000fffffffffff <- ( 000000000000000 , fffffffffff ) + +[57,43]: + int 0000000000000007ffffffffff <- ( 000000000000000 , fffffffffff ) + +[57,42]: + int 000000000000003ffffffffff <- ( 000000000000000 , fffffffffff ) + +[57,41]: + int 000000000000001ffffffffff <- ( 000000000000000 , fffffffffff ) + +[57,40]: + int 000000000000000ffffffffff <- ( 000000000000000 , ffffffffff ) + +[57,39]: + int 0000000000000007fffffffff <- ( 000000000000000 , ffffffffff ) + +[57,38]: + int 000000000000003fffffffff <- ( 000000000000000 , ffffffffff ) + +[57,37]: + int 000000000000001fffffffff <- ( 000000000000000 , ffffffffff ) + +[57,36]: + int 000000000000000fffffffff <- ( 000000000000000 , fffffffff ) + +[57,35]: + int 0000000000000007ffffffff <- ( 000000000000000 , fffffffff ) + +[57,34]: + int 000000000000003ffffffff <- ( 000000000000000 , fffffffff ) + +[57,33]: + int 000000000000001ffffffff <- ( 000000000000000 , fffffffff ) + +[57,32]: + int 000000000000000ffffffff <- ( 000000000000000 , ffffffff ) + +[57,31]: + int 0000000000000007fffffff <- ( 000000000000000 , ffffffff ) + +[57,30]: + int 000000000000003fffffff <- ( 000000000000000 , ffffffff ) + +[57,29]: + int 000000000000001fffffff <- ( 000000000000000 , ffffffff ) + +[57,28]: + int 000000000000000fffffff <- ( 000000000000000 , fffffff ) + +[57,27]: + int 0000000000000007ffffff <- ( 000000000000000 , fffffff ) + +[57,26]: + int 000000000000003ffffff <- ( 000000000000000 , fffffff ) + +[57,25]: + int 000000000000001ffffff <- ( 000000000000000 , fffffff ) + +[57,24]: + int 000000000000000ffffff <- ( 000000000000000 , ffffff ) + +[57,23]: + int 0000000000000007fffff <- ( 000000000000000 , ffffff ) + +[57,22]: + int 000000000000003fffff <- ( 000000000000000 , ffffff ) + +[57,21]: + int 000000000000001fffff <- ( 000000000000000 , ffffff ) + +[57,20]: + int 000000000000000fffff <- ( 000000000000000 , fffff ) + +[57,19]: + int 0000000000000007ffff <- ( 000000000000000 , fffff ) + +[57,18]: + int 000000000000003ffff <- ( 000000000000000 , fffff ) + +[57,17]: + int 000000000000001ffff <- ( 000000000000000 , fffff ) + +[57,16]: + int 000000000000000ffff <- ( 000000000000000 , ffff ) + +[57,15]: + int 0000000000000007fff <- ( 000000000000000 , ffff ) + +[57,14]: + int 000000000000003fff <- ( 000000000000000 , ffff ) + +[57,13]: + int 000000000000001fff <- ( 000000000000000 , ffff ) + +[57,12]: + int 000000000000000fff <- ( 000000000000000 , fff ) + +[57,11]: + int 0000000000000007ff <- ( 000000000000000 , fff ) + +[57,10]: + int 000000000000003ff <- ( 000000000000000 , fff ) + +[57,9]: + int 000000000000001ff <- ( 000000000000000 , fff ) + +[57,8]: + int 000000000000000ff <- ( 000000000000000 , ff ) + +[57,7]: + int 0000000000000007f <- ( 000000000000000 , ff ) + +[57,6]: + int 000000000000003f <- ( 000000000000000 , ff ) + +[57,5]: + int 000000000000001f <- ( 000000000000000 , ff ) + +[57,4]: + int 000000000000000f <- ( 000000000000000 , f ) + +[57,3]: + int 0000000000000007 <- ( 000000000000000 , f ) + +[57,2]: + int 000000000000003 <- ( 000000000000000 , f ) + +[57,1]: + int 000000000000001 <- ( 000000000000000 , f ) + +[56,64]: + int 000000000000000ffffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[56,63]: + int 000000000000007fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[56,62]: + int 000000000000003fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[56,61]: + int 000000000000001fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[56,60]: + int 000000000000000fffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[56,59]: + int 000000000000007ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[56,58]: + int 000000000000003ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[56,57]: + int 000000000000001ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[56,56]: + int 000000000000000ffffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[56,55]: + int 000000000000007fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[56,54]: + int 000000000000003fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[56,53]: + int 000000000000001fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[56,52]: + int 000000000000000fffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[56,51]: + int 000000000000007ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[56,50]: + int 000000000000003ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[56,49]: + int 000000000000001ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[56,48]: + int 000000000000000ffffffffffff <- ( 00000000000000 , ffffffffffff ) + +[56,47]: + int 000000000000007fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[56,46]: + int 000000000000003fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[56,45]: + int 000000000000001fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[56,44]: + int 000000000000000fffffffffff <- ( 00000000000000 , fffffffffff ) + +[56,43]: + int 000000000000007ffffffffff <- ( 00000000000000 , fffffffffff ) + +[56,42]: + int 000000000000003ffffffffff <- ( 00000000000000 , fffffffffff ) + +[56,41]: + int 000000000000001ffffffffff <- ( 00000000000000 , fffffffffff ) + +[56,40]: + int 000000000000000ffffffffff <- ( 00000000000000 , ffffffffff ) + +[56,39]: + int 000000000000007fffffffff <- ( 00000000000000 , ffffffffff ) + +[56,38]: + int 000000000000003fffffffff <- ( 00000000000000 , ffffffffff ) + +[56,37]: + int 000000000000001fffffffff <- ( 00000000000000 , ffffffffff ) + +[56,36]: + int 000000000000000fffffffff <- ( 00000000000000 , fffffffff ) + +[56,35]: + int 000000000000007ffffffff <- ( 00000000000000 , fffffffff ) + +[56,34]: + int 000000000000003ffffffff <- ( 00000000000000 , fffffffff ) + +[56,33]: + int 000000000000001ffffffff <- ( 00000000000000 , fffffffff ) + +[56,32]: + int 000000000000000ffffffff <- ( 00000000000000 , ffffffff ) + +[56,31]: + int 000000000000007fffffff <- ( 00000000000000 , ffffffff ) + +[56,30]: + int 000000000000003fffffff <- ( 00000000000000 , ffffffff ) + +[56,29]: + int 000000000000001fffffff <- ( 00000000000000 , ffffffff ) + +[56,28]: + int 000000000000000fffffff <- ( 00000000000000 , fffffff ) + +[56,27]: + int 000000000000007ffffff <- ( 00000000000000 , fffffff ) + +[56,26]: + int 000000000000003ffffff <- ( 00000000000000 , fffffff ) + +[56,25]: + int 000000000000001ffffff <- ( 00000000000000 , fffffff ) + +[56,24]: + int 000000000000000ffffff <- ( 00000000000000 , ffffff ) + +[56,23]: + int 000000000000007fffff <- ( 00000000000000 , ffffff ) + +[56,22]: + int 000000000000003fffff <- ( 00000000000000 , ffffff ) + +[56,21]: + int 000000000000001fffff <- ( 00000000000000 , ffffff ) + +[56,20]: + int 000000000000000fffff <- ( 00000000000000 , fffff ) + +[56,19]: + int 000000000000007ffff <- ( 00000000000000 , fffff ) + +[56,18]: + int 000000000000003ffff <- ( 00000000000000 , fffff ) + +[56,17]: + int 000000000000001ffff <- ( 00000000000000 , fffff ) + +[56,16]: + int 000000000000000ffff <- ( 00000000000000 , ffff ) + +[56,15]: + int 000000000000007fff <- ( 00000000000000 , ffff ) + +[56,14]: + int 000000000000003fff <- ( 00000000000000 , ffff ) + +[56,13]: + int 000000000000001fff <- ( 00000000000000 , ffff ) + +[56,12]: + int 000000000000000fff <- ( 00000000000000 , fff ) + +[56,11]: + int 000000000000007ff <- ( 00000000000000 , fff ) + +[56,10]: + int 000000000000003ff <- ( 00000000000000 , fff ) + +[56,9]: + int 000000000000001ff <- ( 00000000000000 , fff ) + +[56,8]: + int 000000000000000ff <- ( 00000000000000 , ff ) + +[56,7]: + int 000000000000007f <- ( 00000000000000 , ff ) + +[56,6]: + int 000000000000003f <- ( 00000000000000 , ff ) + +[56,5]: + int 000000000000001f <- ( 00000000000000 , ff ) + +[56,4]: + int 000000000000000f <- ( 00000000000000 , f ) + +[56,3]: + int 000000000000007 <- ( 00000000000000 , f ) + +[56,2]: + int 000000000000003 <- ( 00000000000000 , f ) + +[56,1]: + int 000000000000001 <- ( 00000000000000 , f ) + +[55,64]: + int 00000000000000ffffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[55,63]: + int 000000000000007fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[55,62]: + int 000000000000003fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[55,61]: + int 000000000000001fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[55,60]: + int 00000000000000fffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[55,59]: + int 000000000000007ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[55,58]: + int 000000000000003ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[55,57]: + int 000000000000001ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[55,56]: + int 00000000000000ffffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[55,55]: + int 000000000000007fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[55,54]: + int 000000000000003fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[55,53]: + int 000000000000001fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[55,52]: + int 00000000000000fffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[55,51]: + int 000000000000007ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[55,50]: + int 000000000000003ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[55,49]: + int 000000000000001ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[55,48]: + int 00000000000000ffffffffffff <- ( 00000000000000 , ffffffffffff ) + +[55,47]: + int 000000000000007fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[55,46]: + int 000000000000003fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[55,45]: + int 000000000000001fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[55,44]: + int 00000000000000fffffffffff <- ( 00000000000000 , fffffffffff ) + +[55,43]: + int 000000000000007ffffffffff <- ( 00000000000000 , fffffffffff ) + +[55,42]: + int 000000000000003ffffffffff <- ( 00000000000000 , fffffffffff ) + +[55,41]: + int 000000000000001ffffffffff <- ( 00000000000000 , fffffffffff ) + +[55,40]: + int 00000000000000ffffffffff <- ( 00000000000000 , ffffffffff ) + +[55,39]: + int 000000000000007fffffffff <- ( 00000000000000 , ffffffffff ) + +[55,38]: + int 000000000000003fffffffff <- ( 00000000000000 , ffffffffff ) + +[55,37]: + int 000000000000001fffffffff <- ( 00000000000000 , ffffffffff ) + +[55,36]: + int 00000000000000fffffffff <- ( 00000000000000 , fffffffff ) + +[55,35]: + int 000000000000007ffffffff <- ( 00000000000000 , fffffffff ) + +[55,34]: + int 000000000000003ffffffff <- ( 00000000000000 , fffffffff ) + +[55,33]: + int 000000000000001ffffffff <- ( 00000000000000 , fffffffff ) + +[55,32]: + int 00000000000000ffffffff <- ( 00000000000000 , ffffffff ) + +[55,31]: + int 000000000000007fffffff <- ( 00000000000000 , ffffffff ) + +[55,30]: + int 000000000000003fffffff <- ( 00000000000000 , ffffffff ) + +[55,29]: + int 000000000000001fffffff <- ( 00000000000000 , ffffffff ) + +[55,28]: + int 00000000000000fffffff <- ( 00000000000000 , fffffff ) + +[55,27]: + int 000000000000007ffffff <- ( 00000000000000 , fffffff ) + +[55,26]: + int 000000000000003ffffff <- ( 00000000000000 , fffffff ) + +[55,25]: + int 000000000000001ffffff <- ( 00000000000000 , fffffff ) + +[55,24]: + int 00000000000000ffffff <- ( 00000000000000 , ffffff ) + +[55,23]: + int 000000000000007fffff <- ( 00000000000000 , ffffff ) + +[55,22]: + int 000000000000003fffff <- ( 00000000000000 , ffffff ) + +[55,21]: + int 000000000000001fffff <- ( 00000000000000 , ffffff ) + +[55,20]: + int 00000000000000fffff <- ( 00000000000000 , fffff ) + +[55,19]: + int 000000000000007ffff <- ( 00000000000000 , fffff ) + +[55,18]: + int 000000000000003ffff <- ( 00000000000000 , fffff ) + +[55,17]: + int 000000000000001ffff <- ( 00000000000000 , fffff ) + +[55,16]: + int 00000000000000ffff <- ( 00000000000000 , ffff ) + +[55,15]: + int 000000000000007fff <- ( 00000000000000 , ffff ) + +[55,14]: + int 000000000000003fff <- ( 00000000000000 , ffff ) + +[55,13]: + int 000000000000001fff <- ( 00000000000000 , ffff ) + +[55,12]: + int 00000000000000fff <- ( 00000000000000 , fff ) + +[55,11]: + int 000000000000007ff <- ( 00000000000000 , fff ) + +[55,10]: + int 000000000000003ff <- ( 00000000000000 , fff ) + +[55,9]: + int 000000000000001ff <- ( 00000000000000 , fff ) + +[55,8]: + int 00000000000000ff <- ( 00000000000000 , ff ) + +[55,7]: + int 000000000000007f <- ( 00000000000000 , ff ) + +[55,6]: + int 000000000000003f <- ( 00000000000000 , ff ) + +[55,5]: + int 000000000000001f <- ( 00000000000000 , ff ) + +[55,4]: + int 00000000000000f <- ( 00000000000000 , f ) + +[55,3]: + int 000000000000007 <- ( 00000000000000 , f ) + +[55,2]: + int 000000000000003 <- ( 00000000000000 , f ) + +[55,1]: + int 000000000000001 <- ( 00000000000000 , f ) + +[54,64]: + int 00000000000000ffffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[54,63]: + int 000000000000007fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[54,62]: + int 000000000000003fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[54,61]: + int 00000000000001fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[54,60]: + int 00000000000000fffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[54,59]: + int 000000000000007ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[54,58]: + int 000000000000003ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[54,57]: + int 00000000000001ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[54,56]: + int 00000000000000ffffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[54,55]: + int 000000000000007fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[54,54]: + int 000000000000003fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[54,53]: + int 00000000000001fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[54,52]: + int 00000000000000fffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[54,51]: + int 000000000000007ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[54,50]: + int 000000000000003ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[54,49]: + int 00000000000001ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[54,48]: + int 00000000000000ffffffffffff <- ( 00000000000000 , ffffffffffff ) + +[54,47]: + int 000000000000007fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[54,46]: + int 000000000000003fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[54,45]: + int 00000000000001fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[54,44]: + int 00000000000000fffffffffff <- ( 00000000000000 , fffffffffff ) + +[54,43]: + int 000000000000007ffffffffff <- ( 00000000000000 , fffffffffff ) + +[54,42]: + int 000000000000003ffffffffff <- ( 00000000000000 , fffffffffff ) + +[54,41]: + int 00000000000001ffffffffff <- ( 00000000000000 , fffffffffff ) + +[54,40]: + int 00000000000000ffffffffff <- ( 00000000000000 , ffffffffff ) + +[54,39]: + int 000000000000007fffffffff <- ( 00000000000000 , ffffffffff ) + +[54,38]: + int 000000000000003fffffffff <- ( 00000000000000 , ffffffffff ) + +[54,37]: + int 00000000000001fffffffff <- ( 00000000000000 , ffffffffff ) + +[54,36]: + int 00000000000000fffffffff <- ( 00000000000000 , fffffffff ) + +[54,35]: + int 000000000000007ffffffff <- ( 00000000000000 , fffffffff ) + +[54,34]: + int 000000000000003ffffffff <- ( 00000000000000 , fffffffff ) + +[54,33]: + int 00000000000001ffffffff <- ( 00000000000000 , fffffffff ) + +[54,32]: + int 00000000000000ffffffff <- ( 00000000000000 , ffffffff ) + +[54,31]: + int 000000000000007fffffff <- ( 00000000000000 , ffffffff ) + +[54,30]: + int 000000000000003fffffff <- ( 00000000000000 , ffffffff ) + +[54,29]: + int 00000000000001fffffff <- ( 00000000000000 , ffffffff ) + +[54,28]: + int 00000000000000fffffff <- ( 00000000000000 , fffffff ) + +[54,27]: + int 000000000000007ffffff <- ( 00000000000000 , fffffff ) + +[54,26]: + int 000000000000003ffffff <- ( 00000000000000 , fffffff ) + +[54,25]: + int 00000000000001ffffff <- ( 00000000000000 , fffffff ) + +[54,24]: + int 00000000000000ffffff <- ( 00000000000000 , ffffff ) + +[54,23]: + int 000000000000007fffff <- ( 00000000000000 , ffffff ) + +[54,22]: + int 000000000000003fffff <- ( 00000000000000 , ffffff ) + +[54,21]: + int 00000000000001fffff <- ( 00000000000000 , ffffff ) + +[54,20]: + int 00000000000000fffff <- ( 00000000000000 , fffff ) + +[54,19]: + int 000000000000007ffff <- ( 00000000000000 , fffff ) + +[54,18]: + int 000000000000003ffff <- ( 00000000000000 , fffff ) + +[54,17]: + int 00000000000001ffff <- ( 00000000000000 , fffff ) + +[54,16]: + int 00000000000000ffff <- ( 00000000000000 , ffff ) + +[54,15]: + int 000000000000007fff <- ( 00000000000000 , ffff ) + +[54,14]: + int 000000000000003fff <- ( 00000000000000 , ffff ) + +[54,13]: + int 00000000000001fff <- ( 00000000000000 , ffff ) + +[54,12]: + int 00000000000000fff <- ( 00000000000000 , fff ) + +[54,11]: + int 000000000000007ff <- ( 00000000000000 , fff ) + +[54,10]: + int 000000000000003ff <- ( 00000000000000 , fff ) + +[54,9]: + int 00000000000001ff <- ( 00000000000000 , fff ) + +[54,8]: + int 00000000000000ff <- ( 00000000000000 , ff ) + +[54,7]: + int 000000000000007f <- ( 00000000000000 , ff ) + +[54,6]: + int 000000000000003f <- ( 00000000000000 , ff ) + +[54,5]: + int 00000000000001f <- ( 00000000000000 , ff ) + +[54,4]: + int 00000000000000f <- ( 00000000000000 , f ) + +[54,3]: + int 000000000000007 <- ( 00000000000000 , f ) + +[54,2]: + int 000000000000003 <- ( 00000000000000 , f ) + +[54,1]: + int 00000000000001 <- ( 00000000000000 , f ) + +[53,64]: + int 00000000000000ffffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[53,63]: + int 000000000000007fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[53,62]: + int 00000000000003fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[53,61]: + int 00000000000001fffffffffffffff <- ( 00000000000000 , ffffffffffffffff ) + +[53,60]: + int 00000000000000fffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[53,59]: + int 000000000000007ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[53,58]: + int 00000000000003ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[53,57]: + int 00000000000001ffffffffffffff <- ( 00000000000000 , fffffffffffffff ) + +[53,56]: + int 00000000000000ffffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[53,55]: + int 000000000000007fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[53,54]: + int 00000000000003fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[53,53]: + int 00000000000001fffffffffffff <- ( 00000000000000 , ffffffffffffff ) + +[53,52]: + int 00000000000000fffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[53,51]: + int 000000000000007ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[53,50]: + int 00000000000003ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[53,49]: + int 00000000000001ffffffffffff <- ( 00000000000000 , fffffffffffff ) + +[53,48]: + int 00000000000000ffffffffffff <- ( 00000000000000 , ffffffffffff ) + +[53,47]: + int 000000000000007fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[53,46]: + int 00000000000003fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[53,45]: + int 00000000000001fffffffffff <- ( 00000000000000 , ffffffffffff ) + +[53,44]: + int 00000000000000fffffffffff <- ( 00000000000000 , fffffffffff ) + +[53,43]: + int 000000000000007ffffffffff <- ( 00000000000000 , fffffffffff ) + +[53,42]: + int 00000000000003ffffffffff <- ( 00000000000000 , fffffffffff ) + +[53,41]: + int 00000000000001ffffffffff <- ( 00000000000000 , fffffffffff ) + +[53,40]: + int 00000000000000ffffffffff <- ( 00000000000000 , ffffffffff ) + +[53,39]: + int 000000000000007fffffffff <- ( 00000000000000 , ffffffffff ) + +[53,38]: + int 00000000000003fffffffff <- ( 00000000000000 , ffffffffff ) + +[53,37]: + int 00000000000001fffffffff <- ( 00000000000000 , ffffffffff ) + +[53,36]: + int 00000000000000fffffffff <- ( 00000000000000 , fffffffff ) + +[53,35]: + int 000000000000007ffffffff <- ( 00000000000000 , fffffffff ) + +[53,34]: + int 00000000000003ffffffff <- ( 00000000000000 , fffffffff ) + +[53,33]: + int 00000000000001ffffffff <- ( 00000000000000 , fffffffff ) + +[53,32]: + int 00000000000000ffffffff <- ( 00000000000000 , ffffffff ) + +[53,31]: + int 000000000000007fffffff <- ( 00000000000000 , ffffffff ) + +[53,30]: + int 00000000000003fffffff <- ( 00000000000000 , ffffffff ) + +[53,29]: + int 00000000000001fffffff <- ( 00000000000000 , ffffffff ) + +[53,28]: + int 00000000000000fffffff <- ( 00000000000000 , fffffff ) + +[53,27]: + int 000000000000007ffffff <- ( 00000000000000 , fffffff ) + +[53,26]: + int 00000000000003ffffff <- ( 00000000000000 , fffffff ) + +[53,25]: + int 00000000000001ffffff <- ( 00000000000000 , fffffff ) + +[53,24]: + int 00000000000000ffffff <- ( 00000000000000 , ffffff ) + +[53,23]: + int 000000000000007fffff <- ( 00000000000000 , ffffff ) + +[53,22]: + int 00000000000003fffff <- ( 00000000000000 , ffffff ) + +[53,21]: + int 00000000000001fffff <- ( 00000000000000 , ffffff ) + +[53,20]: + int 00000000000000fffff <- ( 00000000000000 , fffff ) + +[53,19]: + int 000000000000007ffff <- ( 00000000000000 , fffff ) + +[53,18]: + int 00000000000003ffff <- ( 00000000000000 , fffff ) + +[53,17]: + int 00000000000001ffff <- ( 00000000000000 , fffff ) + +[53,16]: + int 00000000000000ffff <- ( 00000000000000 , ffff ) + +[53,15]: + int 000000000000007fff <- ( 00000000000000 , ffff ) + +[53,14]: + int 00000000000003fff <- ( 00000000000000 , ffff ) + +[53,13]: + int 00000000000001fff <- ( 00000000000000 , ffff ) + +[53,12]: + int 00000000000000fff <- ( 00000000000000 , fff ) + +[53,11]: + int 000000000000007ff <- ( 00000000000000 , fff ) + +[53,10]: + int 00000000000003ff <- ( 00000000000000 , fff ) + +[53,9]: + int 00000000000001ff <- ( 00000000000000 , fff ) + +[53,8]: + int 00000000000000ff <- ( 00000000000000 , ff ) + +[53,7]: + int 000000000000007f <- ( 00000000000000 , ff ) + +[53,6]: + int 00000000000003f <- ( 00000000000000 , ff ) + +[53,5]: + int 00000000000001f <- ( 00000000000000 , ff ) + +[53,4]: + int 00000000000000f <- ( 00000000000000 , f ) + +[53,3]: + int 000000000000007 <- ( 00000000000000 , f ) + +[53,2]: + int 00000000000003 <- ( 00000000000000 , f ) + +[53,1]: + int 00000000000001 <- ( 00000000000000 , f ) + +[52,64]: + int 00000000000000ffffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[52,63]: + int 00000000000007fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[52,62]: + int 00000000000003fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[52,61]: + int 00000000000001fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[52,60]: + int 00000000000000fffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[52,59]: + int 00000000000007ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[52,58]: + int 00000000000003ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[52,57]: + int 00000000000001ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[52,56]: + int 00000000000000ffffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[52,55]: + int 00000000000007fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[52,54]: + int 00000000000003fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[52,53]: + int 00000000000001fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[52,52]: + int 00000000000000fffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[52,51]: + int 00000000000007ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[52,50]: + int 00000000000003ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[52,49]: + int 00000000000001ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[52,48]: + int 00000000000000ffffffffffff <- ( 0000000000000 , ffffffffffff ) + +[52,47]: + int 00000000000007fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[52,46]: + int 00000000000003fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[52,45]: + int 00000000000001fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[52,44]: + int 00000000000000fffffffffff <- ( 0000000000000 , fffffffffff ) + +[52,43]: + int 00000000000007ffffffffff <- ( 0000000000000 , fffffffffff ) + +[52,42]: + int 00000000000003ffffffffff <- ( 0000000000000 , fffffffffff ) + +[52,41]: + int 00000000000001ffffffffff <- ( 0000000000000 , fffffffffff ) + +[52,40]: + int 00000000000000ffffffffff <- ( 0000000000000 , ffffffffff ) + +[52,39]: + int 00000000000007fffffffff <- ( 0000000000000 , ffffffffff ) + +[52,38]: + int 00000000000003fffffffff <- ( 0000000000000 , ffffffffff ) + +[52,37]: + int 00000000000001fffffffff <- ( 0000000000000 , ffffffffff ) + +[52,36]: + int 00000000000000fffffffff <- ( 0000000000000 , fffffffff ) + +[52,35]: + int 00000000000007ffffffff <- ( 0000000000000 , fffffffff ) + +[52,34]: + int 00000000000003ffffffff <- ( 0000000000000 , fffffffff ) + +[52,33]: + int 00000000000001ffffffff <- ( 0000000000000 , fffffffff ) + +[52,32]: + int 00000000000000ffffffff <- ( 0000000000000 , ffffffff ) + +[52,31]: + int 00000000000007fffffff <- ( 0000000000000 , ffffffff ) + +[52,30]: + int 00000000000003fffffff <- ( 0000000000000 , ffffffff ) + +[52,29]: + int 00000000000001fffffff <- ( 0000000000000 , ffffffff ) + +[52,28]: + int 00000000000000fffffff <- ( 0000000000000 , fffffff ) + +[52,27]: + int 00000000000007ffffff <- ( 0000000000000 , fffffff ) + +[52,26]: + int 00000000000003ffffff <- ( 0000000000000 , fffffff ) + +[52,25]: + int 00000000000001ffffff <- ( 0000000000000 , fffffff ) + +[52,24]: + int 00000000000000ffffff <- ( 0000000000000 , ffffff ) + +[52,23]: + int 00000000000007fffff <- ( 0000000000000 , ffffff ) + +[52,22]: + int 00000000000003fffff <- ( 0000000000000 , ffffff ) + +[52,21]: + int 00000000000001fffff <- ( 0000000000000 , ffffff ) + +[52,20]: + int 00000000000000fffff <- ( 0000000000000 , fffff ) + +[52,19]: + int 00000000000007ffff <- ( 0000000000000 , fffff ) + +[52,18]: + int 00000000000003ffff <- ( 0000000000000 , fffff ) + +[52,17]: + int 00000000000001ffff <- ( 0000000000000 , fffff ) + +[52,16]: + int 00000000000000ffff <- ( 0000000000000 , ffff ) + +[52,15]: + int 00000000000007fff <- ( 0000000000000 , ffff ) + +[52,14]: + int 00000000000003fff <- ( 0000000000000 , ffff ) + +[52,13]: + int 00000000000001fff <- ( 0000000000000 , ffff ) + +[52,12]: + int 00000000000000fff <- ( 0000000000000 , fff ) + +[52,11]: + int 00000000000007ff <- ( 0000000000000 , fff ) + +[52,10]: + int 00000000000003ff <- ( 0000000000000 , fff ) + +[52,9]: + int 00000000000001ff <- ( 0000000000000 , fff ) + +[52,8]: + int 00000000000000ff <- ( 0000000000000 , ff ) + +[52,7]: + int 00000000000007f <- ( 0000000000000 , ff ) + +[52,6]: + int 00000000000003f <- ( 0000000000000 , ff ) + +[52,5]: + int 00000000000001f <- ( 0000000000000 , ff ) + +[52,4]: + int 00000000000000f <- ( 0000000000000 , f ) + +[52,3]: + int 00000000000007 <- ( 0000000000000 , f ) + +[52,2]: + int 00000000000003 <- ( 0000000000000 , f ) + +[52,1]: + int 00000000000001 <- ( 0000000000000 , f ) + +[51,64]: + int 0000000000000ffffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[51,63]: + int 00000000000007fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[51,62]: + int 00000000000003fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[51,61]: + int 00000000000001fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[51,60]: + int 0000000000000fffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[51,59]: + int 00000000000007ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[51,58]: + int 00000000000003ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[51,57]: + int 00000000000001ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[51,56]: + int 0000000000000ffffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[51,55]: + int 00000000000007fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[51,54]: + int 00000000000003fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[51,53]: + int 00000000000001fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[51,52]: + int 0000000000000fffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[51,51]: + int 00000000000007ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[51,50]: + int 00000000000003ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[51,49]: + int 00000000000001ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[51,48]: + int 0000000000000ffffffffffff <- ( 0000000000000 , ffffffffffff ) + +[51,47]: + int 00000000000007fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[51,46]: + int 00000000000003fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[51,45]: + int 00000000000001fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[51,44]: + int 0000000000000fffffffffff <- ( 0000000000000 , fffffffffff ) + +[51,43]: + int 00000000000007ffffffffff <- ( 0000000000000 , fffffffffff ) + +[51,42]: + int 00000000000003ffffffffff <- ( 0000000000000 , fffffffffff ) + +[51,41]: + int 00000000000001ffffffffff <- ( 0000000000000 , fffffffffff ) + +[51,40]: + int 0000000000000ffffffffff <- ( 0000000000000 , ffffffffff ) + +[51,39]: + int 00000000000007fffffffff <- ( 0000000000000 , ffffffffff ) + +[51,38]: + int 00000000000003fffffffff <- ( 0000000000000 , ffffffffff ) + +[51,37]: + int 00000000000001fffffffff <- ( 0000000000000 , ffffffffff ) + +[51,36]: + int 0000000000000fffffffff <- ( 0000000000000 , fffffffff ) + +[51,35]: + int 00000000000007ffffffff <- ( 0000000000000 , fffffffff ) + +[51,34]: + int 00000000000003ffffffff <- ( 0000000000000 , fffffffff ) + +[51,33]: + int 00000000000001ffffffff <- ( 0000000000000 , fffffffff ) + +[51,32]: + int 0000000000000ffffffff <- ( 0000000000000 , ffffffff ) + +[51,31]: + int 00000000000007fffffff <- ( 0000000000000 , ffffffff ) + +[51,30]: + int 00000000000003fffffff <- ( 0000000000000 , ffffffff ) + +[51,29]: + int 00000000000001fffffff <- ( 0000000000000 , ffffffff ) + +[51,28]: + int 0000000000000fffffff <- ( 0000000000000 , fffffff ) + +[51,27]: + int 00000000000007ffffff <- ( 0000000000000 , fffffff ) + +[51,26]: + int 00000000000003ffffff <- ( 0000000000000 , fffffff ) + +[51,25]: + int 00000000000001ffffff <- ( 0000000000000 , fffffff ) + +[51,24]: + int 0000000000000ffffff <- ( 0000000000000 , ffffff ) + +[51,23]: + int 00000000000007fffff <- ( 0000000000000 , ffffff ) + +[51,22]: + int 00000000000003fffff <- ( 0000000000000 , ffffff ) + +[51,21]: + int 00000000000001fffff <- ( 0000000000000 , ffffff ) + +[51,20]: + int 0000000000000fffff <- ( 0000000000000 , fffff ) + +[51,19]: + int 00000000000007ffff <- ( 0000000000000 , fffff ) + +[51,18]: + int 00000000000003ffff <- ( 0000000000000 , fffff ) + +[51,17]: + int 00000000000001ffff <- ( 0000000000000 , fffff ) + +[51,16]: + int 0000000000000ffff <- ( 0000000000000 , ffff ) + +[51,15]: + int 00000000000007fff <- ( 0000000000000 , ffff ) + +[51,14]: + int 00000000000003fff <- ( 0000000000000 , ffff ) + +[51,13]: + int 00000000000001fff <- ( 0000000000000 , ffff ) + +[51,12]: + int 0000000000000fff <- ( 0000000000000 , fff ) + +[51,11]: + int 00000000000007ff <- ( 0000000000000 , fff ) + +[51,10]: + int 00000000000003ff <- ( 0000000000000 , fff ) + +[51,9]: + int 00000000000001ff <- ( 0000000000000 , fff ) + +[51,8]: + int 0000000000000ff <- ( 0000000000000 , ff ) + +[51,7]: + int 00000000000007f <- ( 0000000000000 , ff ) + +[51,6]: + int 00000000000003f <- ( 0000000000000 , ff ) + +[51,5]: + int 00000000000001f <- ( 0000000000000 , ff ) + +[51,4]: + int 0000000000000f <- ( 0000000000000 , f ) + +[51,3]: + int 00000000000007 <- ( 0000000000000 , f ) + +[51,2]: + int 00000000000003 <- ( 0000000000000 , f ) + +[51,1]: + int 00000000000001 <- ( 0000000000000 , f ) + +[50,64]: + int 0000000000000ffffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[50,63]: + int 00000000000007fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[50,62]: + int 00000000000003fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[50,61]: + int 0000000000001fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[50,60]: + int 0000000000000fffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[50,59]: + int 00000000000007ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[50,58]: + int 00000000000003ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[50,57]: + int 0000000000001ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[50,56]: + int 0000000000000ffffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[50,55]: + int 00000000000007fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[50,54]: + int 00000000000003fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[50,53]: + int 0000000000001fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[50,52]: + int 0000000000000fffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[50,51]: + int 00000000000007ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[50,50]: + int 00000000000003ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[50,49]: + int 0000000000001ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[50,48]: + int 0000000000000ffffffffffff <- ( 0000000000000 , ffffffffffff ) + +[50,47]: + int 00000000000007fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[50,46]: + int 00000000000003fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[50,45]: + int 0000000000001fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[50,44]: + int 0000000000000fffffffffff <- ( 0000000000000 , fffffffffff ) + +[50,43]: + int 00000000000007ffffffffff <- ( 0000000000000 , fffffffffff ) + +[50,42]: + int 00000000000003ffffffffff <- ( 0000000000000 , fffffffffff ) + +[50,41]: + int 0000000000001ffffffffff <- ( 0000000000000 , fffffffffff ) + +[50,40]: + int 0000000000000ffffffffff <- ( 0000000000000 , ffffffffff ) + +[50,39]: + int 00000000000007fffffffff <- ( 0000000000000 , ffffffffff ) + +[50,38]: + int 00000000000003fffffffff <- ( 0000000000000 , ffffffffff ) + +[50,37]: + int 0000000000001fffffffff <- ( 0000000000000 , ffffffffff ) + +[50,36]: + int 0000000000000fffffffff <- ( 0000000000000 , fffffffff ) + +[50,35]: + int 00000000000007ffffffff <- ( 0000000000000 , fffffffff ) + +[50,34]: + int 00000000000003ffffffff <- ( 0000000000000 , fffffffff ) + +[50,33]: + int 0000000000001ffffffff <- ( 0000000000000 , fffffffff ) + +[50,32]: + int 0000000000000ffffffff <- ( 0000000000000 , ffffffff ) + +[50,31]: + int 00000000000007fffffff <- ( 0000000000000 , ffffffff ) + +[50,30]: + int 00000000000003fffffff <- ( 0000000000000 , ffffffff ) + +[50,29]: + int 0000000000001fffffff <- ( 0000000000000 , ffffffff ) + +[50,28]: + int 0000000000000fffffff <- ( 0000000000000 , fffffff ) + +[50,27]: + int 00000000000007ffffff <- ( 0000000000000 , fffffff ) + +[50,26]: + int 00000000000003ffffff <- ( 0000000000000 , fffffff ) + +[50,25]: + int 0000000000001ffffff <- ( 0000000000000 , fffffff ) + +[50,24]: + int 0000000000000ffffff <- ( 0000000000000 , ffffff ) + +[50,23]: + int 00000000000007fffff <- ( 0000000000000 , ffffff ) + +[50,22]: + int 00000000000003fffff <- ( 0000000000000 , ffffff ) + +[50,21]: + int 0000000000001fffff <- ( 0000000000000 , ffffff ) + +[50,20]: + int 0000000000000fffff <- ( 0000000000000 , fffff ) + +[50,19]: + int 00000000000007ffff <- ( 0000000000000 , fffff ) + +[50,18]: + int 00000000000003ffff <- ( 0000000000000 , fffff ) + +[50,17]: + int 0000000000001ffff <- ( 0000000000000 , fffff ) + +[50,16]: + int 0000000000000ffff <- ( 0000000000000 , ffff ) + +[50,15]: + int 00000000000007fff <- ( 0000000000000 , ffff ) + +[50,14]: + int 00000000000003fff <- ( 0000000000000 , ffff ) + +[50,13]: + int 0000000000001fff <- ( 0000000000000 , ffff ) + +[50,12]: + int 0000000000000fff <- ( 0000000000000 , fff ) + +[50,11]: + int 00000000000007ff <- ( 0000000000000 , fff ) + +[50,10]: + int 00000000000003ff <- ( 0000000000000 , fff ) + +[50,9]: + int 0000000000001ff <- ( 0000000000000 , fff ) + +[50,8]: + int 0000000000000ff <- ( 0000000000000 , ff ) + +[50,7]: + int 00000000000007f <- ( 0000000000000 , ff ) + +[50,6]: + int 00000000000003f <- ( 0000000000000 , ff ) + +[50,5]: + int 0000000000001f <- ( 0000000000000 , ff ) + +[50,4]: + int 0000000000000f <- ( 0000000000000 , f ) + +[50,3]: + int 00000000000007 <- ( 0000000000000 , f ) + +[50,2]: + int 00000000000003 <- ( 0000000000000 , f ) + +[50,1]: + int 0000000000001 <- ( 0000000000000 , f ) + +[49,64]: + int 0000000000000ffffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[49,63]: + int 00000000000007fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[49,62]: + int 0000000000003fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[49,61]: + int 0000000000001fffffffffffffff <- ( 0000000000000 , ffffffffffffffff ) + +[49,60]: + int 0000000000000fffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[49,59]: + int 00000000000007ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[49,58]: + int 0000000000003ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[49,57]: + int 0000000000001ffffffffffffff <- ( 0000000000000 , fffffffffffffff ) + +[49,56]: + int 0000000000000ffffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[49,55]: + int 00000000000007fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[49,54]: + int 0000000000003fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[49,53]: + int 0000000000001fffffffffffff <- ( 0000000000000 , ffffffffffffff ) + +[49,52]: + int 0000000000000fffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[49,51]: + int 00000000000007ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[49,50]: + int 0000000000003ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[49,49]: + int 0000000000001ffffffffffff <- ( 0000000000000 , fffffffffffff ) + +[49,48]: + int 0000000000000ffffffffffff <- ( 0000000000000 , ffffffffffff ) + +[49,47]: + int 00000000000007fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[49,46]: + int 0000000000003fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[49,45]: + int 0000000000001fffffffffff <- ( 0000000000000 , ffffffffffff ) + +[49,44]: + int 0000000000000fffffffffff <- ( 0000000000000 , fffffffffff ) + +[49,43]: + int 00000000000007ffffffffff <- ( 0000000000000 , fffffffffff ) + +[49,42]: + int 0000000000003ffffffffff <- ( 0000000000000 , fffffffffff ) + +[49,41]: + int 0000000000001ffffffffff <- ( 0000000000000 , fffffffffff ) + +[49,40]: + int 0000000000000ffffffffff <- ( 0000000000000 , ffffffffff ) + +[49,39]: + int 00000000000007fffffffff <- ( 0000000000000 , ffffffffff ) + +[49,38]: + int 0000000000003fffffffff <- ( 0000000000000 , ffffffffff ) + +[49,37]: + int 0000000000001fffffffff <- ( 0000000000000 , ffffffffff ) + +[49,36]: + int 0000000000000fffffffff <- ( 0000000000000 , fffffffff ) + +[49,35]: + int 00000000000007ffffffff <- ( 0000000000000 , fffffffff ) + +[49,34]: + int 0000000000003ffffffff <- ( 0000000000000 , fffffffff ) + +[49,33]: + int 0000000000001ffffffff <- ( 0000000000000 , fffffffff ) + +[49,32]: + int 0000000000000ffffffff <- ( 0000000000000 , ffffffff ) + +[49,31]: + int 00000000000007fffffff <- ( 0000000000000 , ffffffff ) + +[49,30]: + int 0000000000003fffffff <- ( 0000000000000 , ffffffff ) + +[49,29]: + int 0000000000001fffffff <- ( 0000000000000 , ffffffff ) + +[49,28]: + int 0000000000000fffffff <- ( 0000000000000 , fffffff ) + +[49,27]: + int 00000000000007ffffff <- ( 0000000000000 , fffffff ) + +[49,26]: + int 0000000000003ffffff <- ( 0000000000000 , fffffff ) + +[49,25]: + int 0000000000001ffffff <- ( 0000000000000 , fffffff ) + +[49,24]: + int 0000000000000ffffff <- ( 0000000000000 , ffffff ) + +[49,23]: + int 00000000000007fffff <- ( 0000000000000 , ffffff ) + +[49,22]: + int 0000000000003fffff <- ( 0000000000000 , ffffff ) + +[49,21]: + int 0000000000001fffff <- ( 0000000000000 , ffffff ) + +[49,20]: + int 0000000000000fffff <- ( 0000000000000 , fffff ) + +[49,19]: + int 00000000000007ffff <- ( 0000000000000 , fffff ) + +[49,18]: + int 0000000000003ffff <- ( 0000000000000 , fffff ) + +[49,17]: + int 0000000000001ffff <- ( 0000000000000 , fffff ) + +[49,16]: + int 0000000000000ffff <- ( 0000000000000 , ffff ) + +[49,15]: + int 00000000000007fff <- ( 0000000000000 , ffff ) + +[49,14]: + int 0000000000003fff <- ( 0000000000000 , ffff ) + +[49,13]: + int 0000000000001fff <- ( 0000000000000 , ffff ) + +[49,12]: + int 0000000000000fff <- ( 0000000000000 , fff ) + +[49,11]: + int 00000000000007ff <- ( 0000000000000 , fff ) + +[49,10]: + int 0000000000003ff <- ( 0000000000000 , fff ) + +[49,9]: + int 0000000000001ff <- ( 0000000000000 , fff ) + +[49,8]: + int 0000000000000ff <- ( 0000000000000 , ff ) + +[49,7]: + int 00000000000007f <- ( 0000000000000 , ff ) + +[49,6]: + int 0000000000003f <- ( 0000000000000 , ff ) + +[49,5]: + int 0000000000001f <- ( 0000000000000 , ff ) + +[49,4]: + int 0000000000000f <- ( 0000000000000 , f ) + +[49,3]: + int 00000000000007 <- ( 0000000000000 , f ) + +[49,2]: + int 0000000000003 <- ( 0000000000000 , f ) + +[49,1]: + int 0000000000001 <- ( 0000000000000 , f ) + +[48,64]: + int 0000000000000ffffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[48,63]: + int 0000000000007fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[48,62]: + int 0000000000003fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[48,61]: + int 0000000000001fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[48,60]: + int 0000000000000fffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[48,59]: + int 0000000000007ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[48,58]: + int 0000000000003ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[48,57]: + int 0000000000001ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[48,56]: + int 0000000000000ffffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[48,55]: + int 0000000000007fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[48,54]: + int 0000000000003fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[48,53]: + int 0000000000001fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[48,52]: + int 0000000000000fffffffffffff <- ( 000000000000 , fffffffffffff ) + +[48,51]: + int 0000000000007ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[48,50]: + int 0000000000003ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[48,49]: + int 0000000000001ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[48,48]: + int 0000000000000ffffffffffff <- ( 000000000000 , ffffffffffff ) + +[48,47]: + int 0000000000007fffffffffff <- ( 000000000000 , ffffffffffff ) + +[48,46]: + int 0000000000003fffffffffff <- ( 000000000000 , ffffffffffff ) + +[48,45]: + int 0000000000001fffffffffff <- ( 000000000000 , ffffffffffff ) + +[48,44]: + int 0000000000000fffffffffff <- ( 000000000000 , fffffffffff ) + +[48,43]: + int 0000000000007ffffffffff <- ( 000000000000 , fffffffffff ) + +[48,42]: + int 0000000000003ffffffffff <- ( 000000000000 , fffffffffff ) + +[48,41]: + int 0000000000001ffffffffff <- ( 000000000000 , fffffffffff ) + +[48,40]: + int 0000000000000ffffffffff <- ( 000000000000 , ffffffffff ) + +[48,39]: + int 0000000000007fffffffff <- ( 000000000000 , ffffffffff ) + +[48,38]: + int 0000000000003fffffffff <- ( 000000000000 , ffffffffff ) + +[48,37]: + int 0000000000001fffffffff <- ( 000000000000 , ffffffffff ) + +[48,36]: + int 0000000000000fffffffff <- ( 000000000000 , fffffffff ) + +[48,35]: + int 0000000000007ffffffff <- ( 000000000000 , fffffffff ) + +[48,34]: + int 0000000000003ffffffff <- ( 000000000000 , fffffffff ) + +[48,33]: + int 0000000000001ffffffff <- ( 000000000000 , fffffffff ) + +[48,32]: + int 0000000000000ffffffff <- ( 000000000000 , ffffffff ) + +[48,31]: + int 0000000000007fffffff <- ( 000000000000 , ffffffff ) + +[48,30]: + int 0000000000003fffffff <- ( 000000000000 , ffffffff ) + +[48,29]: + int 0000000000001fffffff <- ( 000000000000 , ffffffff ) + +[48,28]: + int 0000000000000fffffff <- ( 000000000000 , fffffff ) + +[48,27]: + int 0000000000007ffffff <- ( 000000000000 , fffffff ) + +[48,26]: + int 0000000000003ffffff <- ( 000000000000 , fffffff ) + +[48,25]: + int 0000000000001ffffff <- ( 000000000000 , fffffff ) + +[48,24]: + int 0000000000000ffffff <- ( 000000000000 , ffffff ) + +[48,23]: + int 0000000000007fffff <- ( 000000000000 , ffffff ) + +[48,22]: + int 0000000000003fffff <- ( 000000000000 , ffffff ) + +[48,21]: + int 0000000000001fffff <- ( 000000000000 , ffffff ) + +[48,20]: + int 0000000000000fffff <- ( 000000000000 , fffff ) + +[48,19]: + int 0000000000007ffff <- ( 000000000000 , fffff ) + +[48,18]: + int 0000000000003ffff <- ( 000000000000 , fffff ) + +[48,17]: + int 0000000000001ffff <- ( 000000000000 , fffff ) + +[48,16]: + int 0000000000000ffff <- ( 000000000000 , ffff ) + +[48,15]: + int 0000000000007fff <- ( 000000000000 , ffff ) + +[48,14]: + int 0000000000003fff <- ( 000000000000 , ffff ) + +[48,13]: + int 0000000000001fff <- ( 000000000000 , ffff ) + +[48,12]: + int 0000000000000fff <- ( 000000000000 , fff ) + +[48,11]: + int 0000000000007ff <- ( 000000000000 , fff ) + +[48,10]: + int 0000000000003ff <- ( 000000000000 , fff ) + +[48,9]: + int 0000000000001ff <- ( 000000000000 , fff ) + +[48,8]: + int 0000000000000ff <- ( 000000000000 , ff ) + +[48,7]: + int 0000000000007f <- ( 000000000000 , ff ) + +[48,6]: + int 0000000000003f <- ( 000000000000 , ff ) + +[48,5]: + int 0000000000001f <- ( 000000000000 , ff ) + +[48,4]: + int 0000000000000f <- ( 000000000000 , f ) + +[48,3]: + int 0000000000007 <- ( 000000000000 , f ) + +[48,2]: + int 0000000000003 <- ( 000000000000 , f ) + +[48,1]: + int 0000000000001 <- ( 000000000000 , f ) + +[47,64]: + int 000000000000ffffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[47,63]: + int 0000000000007fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[47,62]: + int 0000000000003fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[47,61]: + int 0000000000001fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[47,60]: + int 000000000000fffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[47,59]: + int 0000000000007ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[47,58]: + int 0000000000003ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[47,57]: + int 0000000000001ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[47,56]: + int 000000000000ffffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[47,55]: + int 0000000000007fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[47,54]: + int 0000000000003fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[47,53]: + int 0000000000001fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[47,52]: + int 000000000000fffffffffffff <- ( 000000000000 , fffffffffffff ) + +[47,51]: + int 0000000000007ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[47,50]: + int 0000000000003ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[47,49]: + int 0000000000001ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[47,48]: + int 000000000000ffffffffffff <- ( 000000000000 , ffffffffffff ) + +[47,47]: + int 0000000000007fffffffffff <- ( 000000000000 , ffffffffffff ) + +[47,46]: + int 0000000000003fffffffffff <- ( 000000000000 , ffffffffffff ) + +[47,45]: + int 0000000000001fffffffffff <- ( 000000000000 , ffffffffffff ) + +[47,44]: + int 000000000000fffffffffff <- ( 000000000000 , fffffffffff ) + +[47,43]: + int 0000000000007ffffffffff <- ( 000000000000 , fffffffffff ) + +[47,42]: + int 0000000000003ffffffffff <- ( 000000000000 , fffffffffff ) + +[47,41]: + int 0000000000001ffffffffff <- ( 000000000000 , fffffffffff ) + +[47,40]: + int 000000000000ffffffffff <- ( 000000000000 , ffffffffff ) + +[47,39]: + int 0000000000007fffffffff <- ( 000000000000 , ffffffffff ) + +[47,38]: + int 0000000000003fffffffff <- ( 000000000000 , ffffffffff ) + +[47,37]: + int 0000000000001fffffffff <- ( 000000000000 , ffffffffff ) + +[47,36]: + int 000000000000fffffffff <- ( 000000000000 , fffffffff ) + +[47,35]: + int 0000000000007ffffffff <- ( 000000000000 , fffffffff ) + +[47,34]: + int 0000000000003ffffffff <- ( 000000000000 , fffffffff ) + +[47,33]: + int 0000000000001ffffffff <- ( 000000000000 , fffffffff ) + +[47,32]: + int 000000000000ffffffff <- ( 000000000000 , ffffffff ) + +[47,31]: + int 0000000000007fffffff <- ( 000000000000 , ffffffff ) + +[47,30]: + int 0000000000003fffffff <- ( 000000000000 , ffffffff ) + +[47,29]: + int 0000000000001fffffff <- ( 000000000000 , ffffffff ) + +[47,28]: + int 000000000000fffffff <- ( 000000000000 , fffffff ) + +[47,27]: + int 0000000000007ffffff <- ( 000000000000 , fffffff ) + +[47,26]: + int 0000000000003ffffff <- ( 000000000000 , fffffff ) + +[47,25]: + int 0000000000001ffffff <- ( 000000000000 , fffffff ) + +[47,24]: + int 000000000000ffffff <- ( 000000000000 , ffffff ) + +[47,23]: + int 0000000000007fffff <- ( 000000000000 , ffffff ) + +[47,22]: + int 0000000000003fffff <- ( 000000000000 , ffffff ) + +[47,21]: + int 0000000000001fffff <- ( 000000000000 , ffffff ) + +[47,20]: + int 000000000000fffff <- ( 000000000000 , fffff ) + +[47,19]: + int 0000000000007ffff <- ( 000000000000 , fffff ) + +[47,18]: + int 0000000000003ffff <- ( 000000000000 , fffff ) + +[47,17]: + int 0000000000001ffff <- ( 000000000000 , fffff ) + +[47,16]: + int 000000000000ffff <- ( 000000000000 , ffff ) + +[47,15]: + int 0000000000007fff <- ( 000000000000 , ffff ) + +[47,14]: + int 0000000000003fff <- ( 000000000000 , ffff ) + +[47,13]: + int 0000000000001fff <- ( 000000000000 , ffff ) + +[47,12]: + int 000000000000fff <- ( 000000000000 , fff ) + +[47,11]: + int 0000000000007ff <- ( 000000000000 , fff ) + +[47,10]: + int 0000000000003ff <- ( 000000000000 , fff ) + +[47,9]: + int 0000000000001ff <- ( 000000000000 , fff ) + +[47,8]: + int 000000000000ff <- ( 000000000000 , ff ) + +[47,7]: + int 0000000000007f <- ( 000000000000 , ff ) + +[47,6]: + int 0000000000003f <- ( 000000000000 , ff ) + +[47,5]: + int 0000000000001f <- ( 000000000000 , ff ) + +[47,4]: + int 000000000000f <- ( 000000000000 , f ) + +[47,3]: + int 0000000000007 <- ( 000000000000 , f ) + +[47,2]: + int 0000000000003 <- ( 000000000000 , f ) + +[47,1]: + int 0000000000001 <- ( 000000000000 , f ) + +[46,64]: + int 000000000000ffffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[46,63]: + int 0000000000007fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[46,62]: + int 0000000000003fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[46,61]: + int 000000000001fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[46,60]: + int 000000000000fffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[46,59]: + int 0000000000007ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[46,58]: + int 0000000000003ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[46,57]: + int 000000000001ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[46,56]: + int 000000000000ffffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[46,55]: + int 0000000000007fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[46,54]: + int 0000000000003fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[46,53]: + int 000000000001fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[46,52]: + int 000000000000fffffffffffff <- ( 000000000000 , fffffffffffff ) + +[46,51]: + int 0000000000007ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[46,50]: + int 0000000000003ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[46,49]: + int 000000000001ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[46,48]: + int 000000000000ffffffffffff <- ( 000000000000 , ffffffffffff ) + +[46,47]: + int 0000000000007fffffffffff <- ( 000000000000 , ffffffffffff ) + +[46,46]: + int 0000000000003fffffffffff <- ( 000000000000 , ffffffffffff ) + +[46,45]: + int 000000000001fffffffffff <- ( 000000000000 , ffffffffffff ) + +[46,44]: + int 000000000000fffffffffff <- ( 000000000000 , fffffffffff ) + +[46,43]: + int 0000000000007ffffffffff <- ( 000000000000 , fffffffffff ) + +[46,42]: + int 0000000000003ffffffffff <- ( 000000000000 , fffffffffff ) + +[46,41]: + int 000000000001ffffffffff <- ( 000000000000 , fffffffffff ) + +[46,40]: + int 000000000000ffffffffff <- ( 000000000000 , ffffffffff ) + +[46,39]: + int 0000000000007fffffffff <- ( 000000000000 , ffffffffff ) + +[46,38]: + int 0000000000003fffffffff <- ( 000000000000 , ffffffffff ) + +[46,37]: + int 000000000001fffffffff <- ( 000000000000 , ffffffffff ) + +[46,36]: + int 000000000000fffffffff <- ( 000000000000 , fffffffff ) + +[46,35]: + int 0000000000007ffffffff <- ( 000000000000 , fffffffff ) + +[46,34]: + int 0000000000003ffffffff <- ( 000000000000 , fffffffff ) + +[46,33]: + int 000000000001ffffffff <- ( 000000000000 , fffffffff ) + +[46,32]: + int 000000000000ffffffff <- ( 000000000000 , ffffffff ) + +[46,31]: + int 0000000000007fffffff <- ( 000000000000 , ffffffff ) + +[46,30]: + int 0000000000003fffffff <- ( 000000000000 , ffffffff ) + +[46,29]: + int 000000000001fffffff <- ( 000000000000 , ffffffff ) + +[46,28]: + int 000000000000fffffff <- ( 000000000000 , fffffff ) + +[46,27]: + int 0000000000007ffffff <- ( 000000000000 , fffffff ) + +[46,26]: + int 0000000000003ffffff <- ( 000000000000 , fffffff ) + +[46,25]: + int 000000000001ffffff <- ( 000000000000 , fffffff ) + +[46,24]: + int 000000000000ffffff <- ( 000000000000 , ffffff ) + +[46,23]: + int 0000000000007fffff <- ( 000000000000 , ffffff ) + +[46,22]: + int 0000000000003fffff <- ( 000000000000 , ffffff ) + +[46,21]: + int 000000000001fffff <- ( 000000000000 , ffffff ) + +[46,20]: + int 000000000000fffff <- ( 000000000000 , fffff ) + +[46,19]: + int 0000000000007ffff <- ( 000000000000 , fffff ) + +[46,18]: + int 0000000000003ffff <- ( 000000000000 , fffff ) + +[46,17]: + int 000000000001ffff <- ( 000000000000 , fffff ) + +[46,16]: + int 000000000000ffff <- ( 000000000000 , ffff ) + +[46,15]: + int 0000000000007fff <- ( 000000000000 , ffff ) + +[46,14]: + int 0000000000003fff <- ( 000000000000 , ffff ) + +[46,13]: + int 000000000001fff <- ( 000000000000 , ffff ) + +[46,12]: + int 000000000000fff <- ( 000000000000 , fff ) + +[46,11]: + int 0000000000007ff <- ( 000000000000 , fff ) + +[46,10]: + int 0000000000003ff <- ( 000000000000 , fff ) + +[46,9]: + int 000000000001ff <- ( 000000000000 , fff ) + +[46,8]: + int 000000000000ff <- ( 000000000000 , ff ) + +[46,7]: + int 0000000000007f <- ( 000000000000 , ff ) + +[46,6]: + int 0000000000003f <- ( 000000000000 , ff ) + +[46,5]: + int 000000000001f <- ( 000000000000 , ff ) + +[46,4]: + int 000000000000f <- ( 000000000000 , f ) + +[46,3]: + int 0000000000007 <- ( 000000000000 , f ) + +[46,2]: + int 0000000000003 <- ( 000000000000 , f ) + +[46,1]: + int 000000000001 <- ( 000000000000 , f ) + +[45,64]: + int 000000000000ffffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[45,63]: + int 0000000000007fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[45,62]: + int 000000000003fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[45,61]: + int 000000000001fffffffffffffff <- ( 000000000000 , ffffffffffffffff ) + +[45,60]: + int 000000000000fffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[45,59]: + int 0000000000007ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[45,58]: + int 000000000003ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[45,57]: + int 000000000001ffffffffffffff <- ( 000000000000 , fffffffffffffff ) + +[45,56]: + int 000000000000ffffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[45,55]: + int 0000000000007fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[45,54]: + int 000000000003fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[45,53]: + int 000000000001fffffffffffff <- ( 000000000000 , ffffffffffffff ) + +[45,52]: + int 000000000000fffffffffffff <- ( 000000000000 , fffffffffffff ) + +[45,51]: + int 0000000000007ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[45,50]: + int 000000000003ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[45,49]: + int 000000000001ffffffffffff <- ( 000000000000 , fffffffffffff ) + +[45,48]: + int 000000000000ffffffffffff <- ( 000000000000 , ffffffffffff ) + +[45,47]: + int 0000000000007fffffffffff <- ( 000000000000 , ffffffffffff ) + +[45,46]: + int 000000000003fffffffffff <- ( 000000000000 , ffffffffffff ) + +[45,45]: + int 000000000001fffffffffff <- ( 000000000000 , ffffffffffff ) + +[45,44]: + int 000000000000fffffffffff <- ( 000000000000 , fffffffffff ) + +[45,43]: + int 0000000000007ffffffffff <- ( 000000000000 , fffffffffff ) + +[45,42]: + int 000000000003ffffffffff <- ( 000000000000 , fffffffffff ) + +[45,41]: + int 000000000001ffffffffff <- ( 000000000000 , fffffffffff ) + +[45,40]: + int 000000000000ffffffffff <- ( 000000000000 , ffffffffff ) + +[45,39]: + int 0000000000007fffffffff <- ( 000000000000 , ffffffffff ) + +[45,38]: + int 000000000003fffffffff <- ( 000000000000 , ffffffffff ) + +[45,37]: + int 000000000001fffffffff <- ( 000000000000 , ffffffffff ) + +[45,36]: + int 000000000000fffffffff <- ( 000000000000 , fffffffff ) + +[45,35]: + int 0000000000007ffffffff <- ( 000000000000 , fffffffff ) + +[45,34]: + int 000000000003ffffffff <- ( 000000000000 , fffffffff ) + +[45,33]: + int 000000000001ffffffff <- ( 000000000000 , fffffffff ) + +[45,32]: + int 000000000000ffffffff <- ( 000000000000 , ffffffff ) + +[45,31]: + int 0000000000007fffffff <- ( 000000000000 , ffffffff ) + +[45,30]: + int 000000000003fffffff <- ( 000000000000 , ffffffff ) + +[45,29]: + int 000000000001fffffff <- ( 000000000000 , ffffffff ) + +[45,28]: + int 000000000000fffffff <- ( 000000000000 , fffffff ) + +[45,27]: + int 0000000000007ffffff <- ( 000000000000 , fffffff ) + +[45,26]: + int 000000000003ffffff <- ( 000000000000 , fffffff ) + +[45,25]: + int 000000000001ffffff <- ( 000000000000 , fffffff ) + +[45,24]: + int 000000000000ffffff <- ( 000000000000 , ffffff ) + +[45,23]: + int 0000000000007fffff <- ( 000000000000 , ffffff ) + +[45,22]: + int 000000000003fffff <- ( 000000000000 , ffffff ) + +[45,21]: + int 000000000001fffff <- ( 000000000000 , ffffff ) + +[45,20]: + int 000000000000fffff <- ( 000000000000 , fffff ) + +[45,19]: + int 0000000000007ffff <- ( 000000000000 , fffff ) + +[45,18]: + int 000000000003ffff <- ( 000000000000 , fffff ) + +[45,17]: + int 000000000001ffff <- ( 000000000000 , fffff ) + +[45,16]: + int 000000000000ffff <- ( 000000000000 , ffff ) + +[45,15]: + int 0000000000007fff <- ( 000000000000 , ffff ) + +[45,14]: + int 000000000003fff <- ( 000000000000 , ffff ) + +[45,13]: + int 000000000001fff <- ( 000000000000 , ffff ) + +[45,12]: + int 000000000000fff <- ( 000000000000 , fff ) + +[45,11]: + int 0000000000007ff <- ( 000000000000 , fff ) + +[45,10]: + int 000000000003ff <- ( 000000000000 , fff ) + +[45,9]: + int 000000000001ff <- ( 000000000000 , fff ) + +[45,8]: + int 000000000000ff <- ( 000000000000 , ff ) + +[45,7]: + int 0000000000007f <- ( 000000000000 , ff ) + +[45,6]: + int 000000000003f <- ( 000000000000 , ff ) + +[45,5]: + int 000000000001f <- ( 000000000000 , ff ) + +[45,4]: + int 000000000000f <- ( 000000000000 , f ) + +[45,3]: + int 0000000000007 <- ( 000000000000 , f ) + +[45,2]: + int 000000000003 <- ( 000000000000 , f ) + +[45,1]: + int 000000000001 <- ( 000000000000 , f ) + +[44,64]: + int 000000000000ffffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[44,63]: + int 000000000007fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[44,62]: + int 000000000003fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[44,61]: + int 000000000001fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[44,60]: + int 000000000000fffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[44,59]: + int 000000000007ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[44,58]: + int 000000000003ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[44,57]: + int 000000000001ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[44,56]: + int 000000000000ffffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[44,55]: + int 000000000007fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[44,54]: + int 000000000003fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[44,53]: + int 000000000001fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[44,52]: + int 000000000000fffffffffffff <- ( 00000000000 , fffffffffffff ) + +[44,51]: + int 000000000007ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[44,50]: + int 000000000003ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[44,49]: + int 000000000001ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[44,48]: + int 000000000000ffffffffffff <- ( 00000000000 , ffffffffffff ) + +[44,47]: + int 000000000007fffffffffff <- ( 00000000000 , ffffffffffff ) + +[44,46]: + int 000000000003fffffffffff <- ( 00000000000 , ffffffffffff ) + +[44,45]: + int 000000000001fffffffffff <- ( 00000000000 , ffffffffffff ) + +[44,44]: + int 000000000000fffffffffff <- ( 00000000000 , fffffffffff ) + +[44,43]: + int 000000000007ffffffffff <- ( 00000000000 , fffffffffff ) + +[44,42]: + int 000000000003ffffffffff <- ( 00000000000 , fffffffffff ) + +[44,41]: + int 000000000001ffffffffff <- ( 00000000000 , fffffffffff ) + +[44,40]: + int 000000000000ffffffffff <- ( 00000000000 , ffffffffff ) + +[44,39]: + int 000000000007fffffffff <- ( 00000000000 , ffffffffff ) + +[44,38]: + int 000000000003fffffffff <- ( 00000000000 , ffffffffff ) + +[44,37]: + int 000000000001fffffffff <- ( 00000000000 , ffffffffff ) + +[44,36]: + int 000000000000fffffffff <- ( 00000000000 , fffffffff ) + +[44,35]: + int 000000000007ffffffff <- ( 00000000000 , fffffffff ) + +[44,34]: + int 000000000003ffffffff <- ( 00000000000 , fffffffff ) + +[44,33]: + int 000000000001ffffffff <- ( 00000000000 , fffffffff ) + +[44,32]: + int 000000000000ffffffff <- ( 00000000000 , ffffffff ) + +[44,31]: + int 000000000007fffffff <- ( 00000000000 , ffffffff ) + +[44,30]: + int 000000000003fffffff <- ( 00000000000 , ffffffff ) + +[44,29]: + int 000000000001fffffff <- ( 00000000000 , ffffffff ) + +[44,28]: + int 000000000000fffffff <- ( 00000000000 , fffffff ) + +[44,27]: + int 000000000007ffffff <- ( 00000000000 , fffffff ) + +[44,26]: + int 000000000003ffffff <- ( 00000000000 , fffffff ) + +[44,25]: + int 000000000001ffffff <- ( 00000000000 , fffffff ) + +[44,24]: + int 000000000000ffffff <- ( 00000000000 , ffffff ) + +[44,23]: + int 000000000007fffff <- ( 00000000000 , ffffff ) + +[44,22]: + int 000000000003fffff <- ( 00000000000 , ffffff ) + +[44,21]: + int 000000000001fffff <- ( 00000000000 , ffffff ) + +[44,20]: + int 000000000000fffff <- ( 00000000000 , fffff ) + +[44,19]: + int 000000000007ffff <- ( 00000000000 , fffff ) + +[44,18]: + int 000000000003ffff <- ( 00000000000 , fffff ) + +[44,17]: + int 000000000001ffff <- ( 00000000000 , fffff ) + +[44,16]: + int 000000000000ffff <- ( 00000000000 , ffff ) + +[44,15]: + int 000000000007fff <- ( 00000000000 , ffff ) + +[44,14]: + int 000000000003fff <- ( 00000000000 , ffff ) + +[44,13]: + int 000000000001fff <- ( 00000000000 , ffff ) + +[44,12]: + int 000000000000fff <- ( 00000000000 , fff ) + +[44,11]: + int 000000000007ff <- ( 00000000000 , fff ) + +[44,10]: + int 000000000003ff <- ( 00000000000 , fff ) + +[44,9]: + int 000000000001ff <- ( 00000000000 , fff ) + +[44,8]: + int 000000000000ff <- ( 00000000000 , ff ) + +[44,7]: + int 000000000007f <- ( 00000000000 , ff ) + +[44,6]: + int 000000000003f <- ( 00000000000 , ff ) + +[44,5]: + int 000000000001f <- ( 00000000000 , ff ) + +[44,4]: + int 000000000000f <- ( 00000000000 , f ) + +[44,3]: + int 000000000007 <- ( 00000000000 , f ) + +[44,2]: + int 000000000003 <- ( 00000000000 , f ) + +[44,1]: + int 000000000001 <- ( 00000000000 , f ) + +[43,64]: + int 00000000000ffffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[43,63]: + int 000000000007fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[43,62]: + int 000000000003fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[43,61]: + int 000000000001fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[43,60]: + int 00000000000fffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[43,59]: + int 000000000007ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[43,58]: + int 000000000003ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[43,57]: + int 000000000001ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[43,56]: + int 00000000000ffffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[43,55]: + int 000000000007fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[43,54]: + int 000000000003fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[43,53]: + int 000000000001fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[43,52]: + int 00000000000fffffffffffff <- ( 00000000000 , fffffffffffff ) + +[43,51]: + int 000000000007ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[43,50]: + int 000000000003ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[43,49]: + int 000000000001ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[43,48]: + int 00000000000ffffffffffff <- ( 00000000000 , ffffffffffff ) + +[43,47]: + int 000000000007fffffffffff <- ( 00000000000 , ffffffffffff ) + +[43,46]: + int 000000000003fffffffffff <- ( 00000000000 , ffffffffffff ) + +[43,45]: + int 000000000001fffffffffff <- ( 00000000000 , ffffffffffff ) + +[43,44]: + int 00000000000fffffffffff <- ( 00000000000 , fffffffffff ) + +[43,43]: + int 000000000007ffffffffff <- ( 00000000000 , fffffffffff ) + +[43,42]: + int 000000000003ffffffffff <- ( 00000000000 , fffffffffff ) + +[43,41]: + int 000000000001ffffffffff <- ( 00000000000 , fffffffffff ) + +[43,40]: + int 00000000000ffffffffff <- ( 00000000000 , ffffffffff ) + +[43,39]: + int 000000000007fffffffff <- ( 00000000000 , ffffffffff ) + +[43,38]: + int 000000000003fffffffff <- ( 00000000000 , ffffffffff ) + +[43,37]: + int 000000000001fffffffff <- ( 00000000000 , ffffffffff ) + +[43,36]: + int 00000000000fffffffff <- ( 00000000000 , fffffffff ) + +[43,35]: + int 000000000007ffffffff <- ( 00000000000 , fffffffff ) + +[43,34]: + int 000000000003ffffffff <- ( 00000000000 , fffffffff ) + +[43,33]: + int 000000000001ffffffff <- ( 00000000000 , fffffffff ) + +[43,32]: + int 00000000000ffffffff <- ( 00000000000 , ffffffff ) + +[43,31]: + int 000000000007fffffff <- ( 00000000000 , ffffffff ) + +[43,30]: + int 000000000003fffffff <- ( 00000000000 , ffffffff ) + +[43,29]: + int 000000000001fffffff <- ( 00000000000 , ffffffff ) + +[43,28]: + int 00000000000fffffff <- ( 00000000000 , fffffff ) + +[43,27]: + int 000000000007ffffff <- ( 00000000000 , fffffff ) + +[43,26]: + int 000000000003ffffff <- ( 00000000000 , fffffff ) + +[43,25]: + int 000000000001ffffff <- ( 00000000000 , fffffff ) + +[43,24]: + int 00000000000ffffff <- ( 00000000000 , ffffff ) + +[43,23]: + int 000000000007fffff <- ( 00000000000 , ffffff ) + +[43,22]: + int 000000000003fffff <- ( 00000000000 , ffffff ) + +[43,21]: + int 000000000001fffff <- ( 00000000000 , ffffff ) + +[43,20]: + int 00000000000fffff <- ( 00000000000 , fffff ) + +[43,19]: + int 000000000007ffff <- ( 00000000000 , fffff ) + +[43,18]: + int 000000000003ffff <- ( 00000000000 , fffff ) + +[43,17]: + int 000000000001ffff <- ( 00000000000 , fffff ) + +[43,16]: + int 00000000000ffff <- ( 00000000000 , ffff ) + +[43,15]: + int 000000000007fff <- ( 00000000000 , ffff ) + +[43,14]: + int 000000000003fff <- ( 00000000000 , ffff ) + +[43,13]: + int 000000000001fff <- ( 00000000000 , ffff ) + +[43,12]: + int 00000000000fff <- ( 00000000000 , fff ) + +[43,11]: + int 000000000007ff <- ( 00000000000 , fff ) + +[43,10]: + int 000000000003ff <- ( 00000000000 , fff ) + +[43,9]: + int 000000000001ff <- ( 00000000000 , fff ) + +[43,8]: + int 00000000000ff <- ( 00000000000 , ff ) + +[43,7]: + int 000000000007f <- ( 00000000000 , ff ) + +[43,6]: + int 000000000003f <- ( 00000000000 , ff ) + +[43,5]: + int 000000000001f <- ( 00000000000 , ff ) + +[43,4]: + int 00000000000f <- ( 00000000000 , f ) + +[43,3]: + int 000000000007 <- ( 00000000000 , f ) + +[43,2]: + int 000000000003 <- ( 00000000000 , f ) + +[43,1]: + int 000000000001 <- ( 00000000000 , f ) + +[42,64]: + int 00000000000ffffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[42,63]: + int 000000000007fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[42,62]: + int 000000000003fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[42,61]: + int 00000000001fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[42,60]: + int 00000000000fffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[42,59]: + int 000000000007ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[42,58]: + int 000000000003ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[42,57]: + int 00000000001ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[42,56]: + int 00000000000ffffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[42,55]: + int 000000000007fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[42,54]: + int 000000000003fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[42,53]: + int 00000000001fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[42,52]: + int 00000000000fffffffffffff <- ( 00000000000 , fffffffffffff ) + +[42,51]: + int 000000000007ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[42,50]: + int 000000000003ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[42,49]: + int 00000000001ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[42,48]: + int 00000000000ffffffffffff <- ( 00000000000 , ffffffffffff ) + +[42,47]: + int 000000000007fffffffffff <- ( 00000000000 , ffffffffffff ) + +[42,46]: + int 000000000003fffffffffff <- ( 00000000000 , ffffffffffff ) + +[42,45]: + int 00000000001fffffffffff <- ( 00000000000 , ffffffffffff ) + +[42,44]: + int 00000000000fffffffffff <- ( 00000000000 , fffffffffff ) + +[42,43]: + int 000000000007ffffffffff <- ( 00000000000 , fffffffffff ) + +[42,42]: + int 000000000003ffffffffff <- ( 00000000000 , fffffffffff ) + +[42,41]: + int 00000000001ffffffffff <- ( 00000000000 , fffffffffff ) + +[42,40]: + int 00000000000ffffffffff <- ( 00000000000 , ffffffffff ) + +[42,39]: + int 000000000007fffffffff <- ( 00000000000 , ffffffffff ) + +[42,38]: + int 000000000003fffffffff <- ( 00000000000 , ffffffffff ) + +[42,37]: + int 00000000001fffffffff <- ( 00000000000 , ffffffffff ) + +[42,36]: + int 00000000000fffffffff <- ( 00000000000 , fffffffff ) + +[42,35]: + int 000000000007ffffffff <- ( 00000000000 , fffffffff ) + +[42,34]: + int 000000000003ffffffff <- ( 00000000000 , fffffffff ) + +[42,33]: + int 00000000001ffffffff <- ( 00000000000 , fffffffff ) + +[42,32]: + int 00000000000ffffffff <- ( 00000000000 , ffffffff ) + +[42,31]: + int 000000000007fffffff <- ( 00000000000 , ffffffff ) + +[42,30]: + int 000000000003fffffff <- ( 00000000000 , ffffffff ) + +[42,29]: + int 00000000001fffffff <- ( 00000000000 , ffffffff ) + +[42,28]: + int 00000000000fffffff <- ( 00000000000 , fffffff ) + +[42,27]: + int 000000000007ffffff <- ( 00000000000 , fffffff ) + +[42,26]: + int 000000000003ffffff <- ( 00000000000 , fffffff ) + +[42,25]: + int 00000000001ffffff <- ( 00000000000 , fffffff ) + +[42,24]: + int 00000000000ffffff <- ( 00000000000 , ffffff ) + +[42,23]: + int 000000000007fffff <- ( 00000000000 , ffffff ) + +[42,22]: + int 000000000003fffff <- ( 00000000000 , ffffff ) + +[42,21]: + int 00000000001fffff <- ( 00000000000 , ffffff ) + +[42,20]: + int 00000000000fffff <- ( 00000000000 , fffff ) + +[42,19]: + int 000000000007ffff <- ( 00000000000 , fffff ) + +[42,18]: + int 000000000003ffff <- ( 00000000000 , fffff ) + +[42,17]: + int 00000000001ffff <- ( 00000000000 , fffff ) + +[42,16]: + int 00000000000ffff <- ( 00000000000 , ffff ) + +[42,15]: + int 000000000007fff <- ( 00000000000 , ffff ) + +[42,14]: + int 000000000003fff <- ( 00000000000 , ffff ) + +[42,13]: + int 00000000001fff <- ( 00000000000 , ffff ) + +[42,12]: + int 00000000000fff <- ( 00000000000 , fff ) + +[42,11]: + int 000000000007ff <- ( 00000000000 , fff ) + +[42,10]: + int 000000000003ff <- ( 00000000000 , fff ) + +[42,9]: + int 00000000001ff <- ( 00000000000 , fff ) + +[42,8]: + int 00000000000ff <- ( 00000000000 , ff ) + +[42,7]: + int 000000000007f <- ( 00000000000 , ff ) + +[42,6]: + int 000000000003f <- ( 00000000000 , ff ) + +[42,5]: + int 00000000001f <- ( 00000000000 , ff ) + +[42,4]: + int 00000000000f <- ( 00000000000 , f ) + +[42,3]: + int 000000000007 <- ( 00000000000 , f ) + +[42,2]: + int 000000000003 <- ( 00000000000 , f ) + +[42,1]: + int 00000000001 <- ( 00000000000 , f ) + +[41,64]: + int 00000000000ffffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[41,63]: + int 000000000007fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[41,62]: + int 00000000003fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[41,61]: + int 00000000001fffffffffffffff <- ( 00000000000 , ffffffffffffffff ) + +[41,60]: + int 00000000000fffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[41,59]: + int 000000000007ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[41,58]: + int 00000000003ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[41,57]: + int 00000000001ffffffffffffff <- ( 00000000000 , fffffffffffffff ) + +[41,56]: + int 00000000000ffffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[41,55]: + int 000000000007fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[41,54]: + int 00000000003fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[41,53]: + int 00000000001fffffffffffff <- ( 00000000000 , ffffffffffffff ) + +[41,52]: + int 00000000000fffffffffffff <- ( 00000000000 , fffffffffffff ) + +[41,51]: + int 000000000007ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[41,50]: + int 00000000003ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[41,49]: + int 00000000001ffffffffffff <- ( 00000000000 , fffffffffffff ) + +[41,48]: + int 00000000000ffffffffffff <- ( 00000000000 , ffffffffffff ) + +[41,47]: + int 000000000007fffffffffff <- ( 00000000000 , ffffffffffff ) + +[41,46]: + int 00000000003fffffffffff <- ( 00000000000 , ffffffffffff ) + +[41,45]: + int 00000000001fffffffffff <- ( 00000000000 , ffffffffffff ) + +[41,44]: + int 00000000000fffffffffff <- ( 00000000000 , fffffffffff ) + +[41,43]: + int 000000000007ffffffffff <- ( 00000000000 , fffffffffff ) + +[41,42]: + int 00000000003ffffffffff <- ( 00000000000 , fffffffffff ) + +[41,41]: + int 00000000001ffffffffff <- ( 00000000000 , fffffffffff ) + +[41,40]: + int 00000000000ffffffffff <- ( 00000000000 , ffffffffff ) + +[41,39]: + int 000000000007fffffffff <- ( 00000000000 , ffffffffff ) + +[41,38]: + int 00000000003fffffffff <- ( 00000000000 , ffffffffff ) + +[41,37]: + int 00000000001fffffffff <- ( 00000000000 , ffffffffff ) + +[41,36]: + int 00000000000fffffffff <- ( 00000000000 , fffffffff ) + +[41,35]: + int 000000000007ffffffff <- ( 00000000000 , fffffffff ) + +[41,34]: + int 00000000003ffffffff <- ( 00000000000 , fffffffff ) + +[41,33]: + int 00000000001ffffffff <- ( 00000000000 , fffffffff ) + +[41,32]: + int 00000000000ffffffff <- ( 00000000000 , ffffffff ) + +[41,31]: + int 000000000007fffffff <- ( 00000000000 , ffffffff ) + +[41,30]: + int 00000000003fffffff <- ( 00000000000 , ffffffff ) + +[41,29]: + int 00000000001fffffff <- ( 00000000000 , ffffffff ) + +[41,28]: + int 00000000000fffffff <- ( 00000000000 , fffffff ) + +[41,27]: + int 000000000007ffffff <- ( 00000000000 , fffffff ) + +[41,26]: + int 00000000003ffffff <- ( 00000000000 , fffffff ) + +[41,25]: + int 00000000001ffffff <- ( 00000000000 , fffffff ) + +[41,24]: + int 00000000000ffffff <- ( 00000000000 , ffffff ) + +[41,23]: + int 000000000007fffff <- ( 00000000000 , ffffff ) + +[41,22]: + int 00000000003fffff <- ( 00000000000 , ffffff ) + +[41,21]: + int 00000000001fffff <- ( 00000000000 , ffffff ) + +[41,20]: + int 00000000000fffff <- ( 00000000000 , fffff ) + +[41,19]: + int 000000000007ffff <- ( 00000000000 , fffff ) + +[41,18]: + int 00000000003ffff <- ( 00000000000 , fffff ) + +[41,17]: + int 00000000001ffff <- ( 00000000000 , fffff ) + +[41,16]: + int 00000000000ffff <- ( 00000000000 , ffff ) + +[41,15]: + int 000000000007fff <- ( 00000000000 , ffff ) + +[41,14]: + int 00000000003fff <- ( 00000000000 , ffff ) + +[41,13]: + int 00000000001fff <- ( 00000000000 , ffff ) + +[41,12]: + int 00000000000fff <- ( 00000000000 , fff ) + +[41,11]: + int 000000000007ff <- ( 00000000000 , fff ) + +[41,10]: + int 00000000003ff <- ( 00000000000 , fff ) + +[41,9]: + int 00000000001ff <- ( 00000000000 , fff ) + +[41,8]: + int 00000000000ff <- ( 00000000000 , ff ) + +[41,7]: + int 000000000007f <- ( 00000000000 , ff ) + +[41,6]: + int 00000000003f <- ( 00000000000 , ff ) + +[41,5]: + int 00000000001f <- ( 00000000000 , ff ) + +[41,4]: + int 00000000000f <- ( 00000000000 , f ) + +[41,3]: + int 000000000007 <- ( 00000000000 , f ) + +[41,2]: + int 00000000003 <- ( 00000000000 , f ) + +[41,1]: + int 00000000001 <- ( 00000000000 , f ) + +[40,64]: + int 00000000000ffffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[40,63]: + int 00000000007fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[40,62]: + int 00000000003fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[40,61]: + int 00000000001fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[40,60]: + int 00000000000fffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[40,59]: + int 00000000007ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[40,58]: + int 00000000003ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[40,57]: + int 00000000001ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[40,56]: + int 00000000000ffffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[40,55]: + int 00000000007fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[40,54]: + int 00000000003fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[40,53]: + int 00000000001fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[40,52]: + int 00000000000fffffffffffff <- ( 0000000000 , fffffffffffff ) + +[40,51]: + int 00000000007ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[40,50]: + int 00000000003ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[40,49]: + int 00000000001ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[40,48]: + int 00000000000ffffffffffff <- ( 0000000000 , ffffffffffff ) + +[40,47]: + int 00000000007fffffffffff <- ( 0000000000 , ffffffffffff ) + +[40,46]: + int 00000000003fffffffffff <- ( 0000000000 , ffffffffffff ) + +[40,45]: + int 00000000001fffffffffff <- ( 0000000000 , ffffffffffff ) + +[40,44]: + int 00000000000fffffffffff <- ( 0000000000 , fffffffffff ) + +[40,43]: + int 00000000007ffffffffff <- ( 0000000000 , fffffffffff ) + +[40,42]: + int 00000000003ffffffffff <- ( 0000000000 , fffffffffff ) + +[40,41]: + int 00000000001ffffffffff <- ( 0000000000 , fffffffffff ) + +[40,40]: + int 00000000000ffffffffff <- ( 0000000000 , ffffffffff ) + +[40,39]: + int 00000000007fffffffff <- ( 0000000000 , ffffffffff ) + +[40,38]: + int 00000000003fffffffff <- ( 0000000000 , ffffffffff ) + +[40,37]: + int 00000000001fffffffff <- ( 0000000000 , ffffffffff ) + +[40,36]: + int 00000000000fffffffff <- ( 0000000000 , fffffffff ) + +[40,35]: + int 00000000007ffffffff <- ( 0000000000 , fffffffff ) + +[40,34]: + int 00000000003ffffffff <- ( 0000000000 , fffffffff ) + +[40,33]: + int 00000000001ffffffff <- ( 0000000000 , fffffffff ) + +[40,32]: + int 00000000000ffffffff <- ( 0000000000 , ffffffff ) + +[40,31]: + int 00000000007fffffff <- ( 0000000000 , ffffffff ) + +[40,30]: + int 00000000003fffffff <- ( 0000000000 , ffffffff ) + +[40,29]: + int 00000000001fffffff <- ( 0000000000 , ffffffff ) + +[40,28]: + int 00000000000fffffff <- ( 0000000000 , fffffff ) + +[40,27]: + int 00000000007ffffff <- ( 0000000000 , fffffff ) + +[40,26]: + int 00000000003ffffff <- ( 0000000000 , fffffff ) + +[40,25]: + int 00000000001ffffff <- ( 0000000000 , fffffff ) + +[40,24]: + int 00000000000ffffff <- ( 0000000000 , ffffff ) + +[40,23]: + int 00000000007fffff <- ( 0000000000 , ffffff ) + +[40,22]: + int 00000000003fffff <- ( 0000000000 , ffffff ) + +[40,21]: + int 00000000001fffff <- ( 0000000000 , ffffff ) + +[40,20]: + int 00000000000fffff <- ( 0000000000 , fffff ) + +[40,19]: + int 00000000007ffff <- ( 0000000000 , fffff ) + +[40,18]: + int 00000000003ffff <- ( 0000000000 , fffff ) + +[40,17]: + int 00000000001ffff <- ( 0000000000 , fffff ) + +[40,16]: + int 00000000000ffff <- ( 0000000000 , ffff ) + +[40,15]: + int 00000000007fff <- ( 0000000000 , ffff ) + +[40,14]: + int 00000000003fff <- ( 0000000000 , ffff ) + +[40,13]: + int 00000000001fff <- ( 0000000000 , ffff ) + +[40,12]: + int 00000000000fff <- ( 0000000000 , fff ) + +[40,11]: + int 00000000007ff <- ( 0000000000 , fff ) + +[40,10]: + int 00000000003ff <- ( 0000000000 , fff ) + +[40,9]: + int 00000000001ff <- ( 0000000000 , fff ) + +[40,8]: + int 00000000000ff <- ( 0000000000 , ff ) + +[40,7]: + int 00000000007f <- ( 0000000000 , ff ) + +[40,6]: + int 00000000003f <- ( 0000000000 , ff ) + +[40,5]: + int 00000000001f <- ( 0000000000 , ff ) + +[40,4]: + int 00000000000f <- ( 0000000000 , f ) + +[40,3]: + int 00000000007 <- ( 0000000000 , f ) + +[40,2]: + int 00000000003 <- ( 0000000000 , f ) + +[40,1]: + int 00000000001 <- ( 0000000000 , f ) + +[39,64]: + int 0000000000ffffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[39,63]: + int 00000000007fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[39,62]: + int 00000000003fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[39,61]: + int 00000000001fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[39,60]: + int 0000000000fffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[39,59]: + int 00000000007ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[39,58]: + int 00000000003ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[39,57]: + int 00000000001ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[39,56]: + int 0000000000ffffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[39,55]: + int 00000000007fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[39,54]: + int 00000000003fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[39,53]: + int 00000000001fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[39,52]: + int 0000000000fffffffffffff <- ( 0000000000 , fffffffffffff ) + +[39,51]: + int 00000000007ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[39,50]: + int 00000000003ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[39,49]: + int 00000000001ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[39,48]: + int 0000000000ffffffffffff <- ( 0000000000 , ffffffffffff ) + +[39,47]: + int 00000000007fffffffffff <- ( 0000000000 , ffffffffffff ) + +[39,46]: + int 00000000003fffffffffff <- ( 0000000000 , ffffffffffff ) + +[39,45]: + int 00000000001fffffffffff <- ( 0000000000 , ffffffffffff ) + +[39,44]: + int 0000000000fffffffffff <- ( 0000000000 , fffffffffff ) + +[39,43]: + int 00000000007ffffffffff <- ( 0000000000 , fffffffffff ) + +[39,42]: + int 00000000003ffffffffff <- ( 0000000000 , fffffffffff ) + +[39,41]: + int 00000000001ffffffffff <- ( 0000000000 , fffffffffff ) + +[39,40]: + int 0000000000ffffffffff <- ( 0000000000 , ffffffffff ) + +[39,39]: + int 00000000007fffffffff <- ( 0000000000 , ffffffffff ) + +[39,38]: + int 00000000003fffffffff <- ( 0000000000 , ffffffffff ) + +[39,37]: + int 00000000001fffffffff <- ( 0000000000 , ffffffffff ) + +[39,36]: + int 0000000000fffffffff <- ( 0000000000 , fffffffff ) + +[39,35]: + int 00000000007ffffffff <- ( 0000000000 , fffffffff ) + +[39,34]: + int 00000000003ffffffff <- ( 0000000000 , fffffffff ) + +[39,33]: + int 00000000001ffffffff <- ( 0000000000 , fffffffff ) + +[39,32]: + int 0000000000ffffffff <- ( 0000000000 , ffffffff ) + +[39,31]: + int 00000000007fffffff <- ( 0000000000 , ffffffff ) + +[39,30]: + int 00000000003fffffff <- ( 0000000000 , ffffffff ) + +[39,29]: + int 00000000001fffffff <- ( 0000000000 , ffffffff ) + +[39,28]: + int 0000000000fffffff <- ( 0000000000 , fffffff ) + +[39,27]: + int 00000000007ffffff <- ( 0000000000 , fffffff ) + +[39,26]: + int 00000000003ffffff <- ( 0000000000 , fffffff ) + +[39,25]: + int 00000000001ffffff <- ( 0000000000 , fffffff ) + +[39,24]: + int 0000000000ffffff <- ( 0000000000 , ffffff ) + +[39,23]: + int 00000000007fffff <- ( 0000000000 , ffffff ) + +[39,22]: + int 00000000003fffff <- ( 0000000000 , ffffff ) + +[39,21]: + int 00000000001fffff <- ( 0000000000 , ffffff ) + +[39,20]: + int 0000000000fffff <- ( 0000000000 , fffff ) + +[39,19]: + int 00000000007ffff <- ( 0000000000 , fffff ) + +[39,18]: + int 00000000003ffff <- ( 0000000000 , fffff ) + +[39,17]: + int 00000000001ffff <- ( 0000000000 , fffff ) + +[39,16]: + int 0000000000ffff <- ( 0000000000 , ffff ) + +[39,15]: + int 00000000007fff <- ( 0000000000 , ffff ) + +[39,14]: + int 00000000003fff <- ( 0000000000 , ffff ) + +[39,13]: + int 00000000001fff <- ( 0000000000 , ffff ) + +[39,12]: + int 0000000000fff <- ( 0000000000 , fff ) + +[39,11]: + int 00000000007ff <- ( 0000000000 , fff ) + +[39,10]: + int 00000000003ff <- ( 0000000000 , fff ) + +[39,9]: + int 00000000001ff <- ( 0000000000 , fff ) + +[39,8]: + int 0000000000ff <- ( 0000000000 , ff ) + +[39,7]: + int 00000000007f <- ( 0000000000 , ff ) + +[39,6]: + int 00000000003f <- ( 0000000000 , ff ) + +[39,5]: + int 00000000001f <- ( 0000000000 , ff ) + +[39,4]: + int 0000000000f <- ( 0000000000 , f ) + +[39,3]: + int 00000000007 <- ( 0000000000 , f ) + +[39,2]: + int 00000000003 <- ( 0000000000 , f ) + +[39,1]: + int 00000000001 <- ( 0000000000 , f ) + +[38,64]: + int 0000000000ffffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[38,63]: + int 00000000007fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[38,62]: + int 00000000003fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[38,61]: + int 0000000001fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[38,60]: + int 0000000000fffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[38,59]: + int 00000000007ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[38,58]: + int 00000000003ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[38,57]: + int 0000000001ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[38,56]: + int 0000000000ffffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[38,55]: + int 00000000007fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[38,54]: + int 00000000003fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[38,53]: + int 0000000001fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[38,52]: + int 0000000000fffffffffffff <- ( 0000000000 , fffffffffffff ) + +[38,51]: + int 00000000007ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[38,50]: + int 00000000003ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[38,49]: + int 0000000001ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[38,48]: + int 0000000000ffffffffffff <- ( 0000000000 , ffffffffffff ) + +[38,47]: + int 00000000007fffffffffff <- ( 0000000000 , ffffffffffff ) + +[38,46]: + int 00000000003fffffffffff <- ( 0000000000 , ffffffffffff ) + +[38,45]: + int 0000000001fffffffffff <- ( 0000000000 , ffffffffffff ) + +[38,44]: + int 0000000000fffffffffff <- ( 0000000000 , fffffffffff ) + +[38,43]: + int 00000000007ffffffffff <- ( 0000000000 , fffffffffff ) + +[38,42]: + int 00000000003ffffffffff <- ( 0000000000 , fffffffffff ) + +[38,41]: + int 0000000001ffffffffff <- ( 0000000000 , fffffffffff ) + +[38,40]: + int 0000000000ffffffffff <- ( 0000000000 , ffffffffff ) + +[38,39]: + int 00000000007fffffffff <- ( 0000000000 , ffffffffff ) + +[38,38]: + int 00000000003fffffffff <- ( 0000000000 , ffffffffff ) + +[38,37]: + int 0000000001fffffffff <- ( 0000000000 , ffffffffff ) + +[38,36]: + int 0000000000fffffffff <- ( 0000000000 , fffffffff ) + +[38,35]: + int 00000000007ffffffff <- ( 0000000000 , fffffffff ) + +[38,34]: + int 00000000003ffffffff <- ( 0000000000 , fffffffff ) + +[38,33]: + int 0000000001ffffffff <- ( 0000000000 , fffffffff ) + +[38,32]: + int 0000000000ffffffff <- ( 0000000000 , ffffffff ) + +[38,31]: + int 00000000007fffffff <- ( 0000000000 , ffffffff ) + +[38,30]: + int 00000000003fffffff <- ( 0000000000 , ffffffff ) + +[38,29]: + int 0000000001fffffff <- ( 0000000000 , ffffffff ) + +[38,28]: + int 0000000000fffffff <- ( 0000000000 , fffffff ) + +[38,27]: + int 00000000007ffffff <- ( 0000000000 , fffffff ) + +[38,26]: + int 00000000003ffffff <- ( 0000000000 , fffffff ) + +[38,25]: + int 0000000001ffffff <- ( 0000000000 , fffffff ) + +[38,24]: + int 0000000000ffffff <- ( 0000000000 , ffffff ) + +[38,23]: + int 00000000007fffff <- ( 0000000000 , ffffff ) + +[38,22]: + int 00000000003fffff <- ( 0000000000 , ffffff ) + +[38,21]: + int 0000000001fffff <- ( 0000000000 , ffffff ) + +[38,20]: + int 0000000000fffff <- ( 0000000000 , fffff ) + +[38,19]: + int 00000000007ffff <- ( 0000000000 , fffff ) + +[38,18]: + int 00000000003ffff <- ( 0000000000 , fffff ) + +[38,17]: + int 0000000001ffff <- ( 0000000000 , fffff ) + +[38,16]: + int 0000000000ffff <- ( 0000000000 , ffff ) + +[38,15]: + int 00000000007fff <- ( 0000000000 , ffff ) + +[38,14]: + int 00000000003fff <- ( 0000000000 , ffff ) + +[38,13]: + int 0000000001fff <- ( 0000000000 , ffff ) + +[38,12]: + int 0000000000fff <- ( 0000000000 , fff ) + +[38,11]: + int 00000000007ff <- ( 0000000000 , fff ) + +[38,10]: + int 00000000003ff <- ( 0000000000 , fff ) + +[38,9]: + int 0000000001ff <- ( 0000000000 , fff ) + +[38,8]: + int 0000000000ff <- ( 0000000000 , ff ) + +[38,7]: + int 00000000007f <- ( 0000000000 , ff ) + +[38,6]: + int 00000000003f <- ( 0000000000 , ff ) + +[38,5]: + int 0000000001f <- ( 0000000000 , ff ) + +[38,4]: + int 0000000000f <- ( 0000000000 , f ) + +[38,3]: + int 00000000007 <- ( 0000000000 , f ) + +[38,2]: + int 00000000003 <- ( 0000000000 , f ) + +[38,1]: + int 0000000001 <- ( 0000000000 , f ) + +[37,64]: + int 0000000000ffffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[37,63]: + int 00000000007fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[37,62]: + int 0000000003fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[37,61]: + int 0000000001fffffffffffffff <- ( 0000000000 , ffffffffffffffff ) + +[37,60]: + int 0000000000fffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[37,59]: + int 00000000007ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[37,58]: + int 0000000003ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[37,57]: + int 0000000001ffffffffffffff <- ( 0000000000 , fffffffffffffff ) + +[37,56]: + int 0000000000ffffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[37,55]: + int 00000000007fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[37,54]: + int 0000000003fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[37,53]: + int 0000000001fffffffffffff <- ( 0000000000 , ffffffffffffff ) + +[37,52]: + int 0000000000fffffffffffff <- ( 0000000000 , fffffffffffff ) + +[37,51]: + int 00000000007ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[37,50]: + int 0000000003ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[37,49]: + int 0000000001ffffffffffff <- ( 0000000000 , fffffffffffff ) + +[37,48]: + int 0000000000ffffffffffff <- ( 0000000000 , ffffffffffff ) + +[37,47]: + int 00000000007fffffffffff <- ( 0000000000 , ffffffffffff ) + +[37,46]: + int 0000000003fffffffffff <- ( 0000000000 , ffffffffffff ) + +[37,45]: + int 0000000001fffffffffff <- ( 0000000000 , ffffffffffff ) + +[37,44]: + int 0000000000fffffffffff <- ( 0000000000 , fffffffffff ) + +[37,43]: + int 00000000007ffffffffff <- ( 0000000000 , fffffffffff ) + +[37,42]: + int 0000000003ffffffffff <- ( 0000000000 , fffffffffff ) + +[37,41]: + int 0000000001ffffffffff <- ( 0000000000 , fffffffffff ) + +[37,40]: + int 0000000000ffffffffff <- ( 0000000000 , ffffffffff ) + +[37,39]: + int 00000000007fffffffff <- ( 0000000000 , ffffffffff ) + +[37,38]: + int 0000000003fffffffff <- ( 0000000000 , ffffffffff ) + +[37,37]: + int 0000000001fffffffff <- ( 0000000000 , ffffffffff ) + +[37,36]: + int 0000000000fffffffff <- ( 0000000000 , fffffffff ) + +[37,35]: + int 00000000007ffffffff <- ( 0000000000 , fffffffff ) + +[37,34]: + int 0000000003ffffffff <- ( 0000000000 , fffffffff ) + +[37,33]: + int 0000000001ffffffff <- ( 0000000000 , fffffffff ) + +[37,32]: + int 0000000000ffffffff <- ( 0000000000 , ffffffff ) + +[37,31]: + int 00000000007fffffff <- ( 0000000000 , ffffffff ) + +[37,30]: + int 0000000003fffffff <- ( 0000000000 , ffffffff ) + +[37,29]: + int 0000000001fffffff <- ( 0000000000 , ffffffff ) + +[37,28]: + int 0000000000fffffff <- ( 0000000000 , fffffff ) + +[37,27]: + int 00000000007ffffff <- ( 0000000000 , fffffff ) + +[37,26]: + int 0000000003ffffff <- ( 0000000000 , fffffff ) + +[37,25]: + int 0000000001ffffff <- ( 0000000000 , fffffff ) + +[37,24]: + int 0000000000ffffff <- ( 0000000000 , ffffff ) + +[37,23]: + int 00000000007fffff <- ( 0000000000 , ffffff ) + +[37,22]: + int 0000000003fffff <- ( 0000000000 , ffffff ) + +[37,21]: + int 0000000001fffff <- ( 0000000000 , ffffff ) + +[37,20]: + int 0000000000fffff <- ( 0000000000 , fffff ) + +[37,19]: + int 00000000007ffff <- ( 0000000000 , fffff ) + +[37,18]: + int 0000000003ffff <- ( 0000000000 , fffff ) + +[37,17]: + int 0000000001ffff <- ( 0000000000 , fffff ) + +[37,16]: + int 0000000000ffff <- ( 0000000000 , ffff ) + +[37,15]: + int 00000000007fff <- ( 0000000000 , ffff ) + +[37,14]: + int 0000000003fff <- ( 0000000000 , ffff ) + +[37,13]: + int 0000000001fff <- ( 0000000000 , ffff ) + +[37,12]: + int 0000000000fff <- ( 0000000000 , fff ) + +[37,11]: + int 00000000007ff <- ( 0000000000 , fff ) + +[37,10]: + int 0000000003ff <- ( 0000000000 , fff ) + +[37,9]: + int 0000000001ff <- ( 0000000000 , fff ) + +[37,8]: + int 0000000000ff <- ( 0000000000 , ff ) + +[37,7]: + int 00000000007f <- ( 0000000000 , ff ) + +[37,6]: + int 0000000003f <- ( 0000000000 , ff ) + +[37,5]: + int 0000000001f <- ( 0000000000 , ff ) + +[37,4]: + int 0000000000f <- ( 0000000000 , f ) + +[37,3]: + int 00000000007 <- ( 0000000000 , f ) + +[37,2]: + int 0000000003 <- ( 0000000000 , f ) + +[37,1]: + int 0000000001 <- ( 0000000000 , f ) + +[36,64]: + int 0000000000ffffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[36,63]: + int 0000000007fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[36,62]: + int 0000000003fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[36,61]: + int 0000000001fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[36,60]: + int 0000000000fffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[36,59]: + int 0000000007ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[36,58]: + int 0000000003ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[36,57]: + int 0000000001ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[36,56]: + int 0000000000ffffffffffffff <- ( 000000000 , ffffffffffffff ) + +[36,55]: + int 0000000007fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[36,54]: + int 0000000003fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[36,53]: + int 0000000001fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[36,52]: + int 0000000000fffffffffffff <- ( 000000000 , fffffffffffff ) + +[36,51]: + int 0000000007ffffffffffff <- ( 000000000 , fffffffffffff ) + +[36,50]: + int 0000000003ffffffffffff <- ( 000000000 , fffffffffffff ) + +[36,49]: + int 0000000001ffffffffffff <- ( 000000000 , fffffffffffff ) + +[36,48]: + int 0000000000ffffffffffff <- ( 000000000 , ffffffffffff ) + +[36,47]: + int 0000000007fffffffffff <- ( 000000000 , ffffffffffff ) + +[36,46]: + int 0000000003fffffffffff <- ( 000000000 , ffffffffffff ) + +[36,45]: + int 0000000001fffffffffff <- ( 000000000 , ffffffffffff ) + +[36,44]: + int 0000000000fffffffffff <- ( 000000000 , fffffffffff ) + +[36,43]: + int 0000000007ffffffffff <- ( 000000000 , fffffffffff ) + +[36,42]: + int 0000000003ffffffffff <- ( 000000000 , fffffffffff ) + +[36,41]: + int 0000000001ffffffffff <- ( 000000000 , fffffffffff ) + +[36,40]: + int 0000000000ffffffffff <- ( 000000000 , ffffffffff ) + +[36,39]: + int 0000000007fffffffff <- ( 000000000 , ffffffffff ) + +[36,38]: + int 0000000003fffffffff <- ( 000000000 , ffffffffff ) + +[36,37]: + int 0000000001fffffffff <- ( 000000000 , ffffffffff ) + +[36,36]: + int 0000000000fffffffff <- ( 000000000 , fffffffff ) + +[36,35]: + int 0000000007ffffffff <- ( 000000000 , fffffffff ) + +[36,34]: + int 0000000003ffffffff <- ( 000000000 , fffffffff ) + +[36,33]: + int 0000000001ffffffff <- ( 000000000 , fffffffff ) + +[36,32]: + int 0000000000ffffffff <- ( 000000000 , ffffffff ) + +[36,31]: + int 0000000007fffffff <- ( 000000000 , ffffffff ) + +[36,30]: + int 0000000003fffffff <- ( 000000000 , ffffffff ) + +[36,29]: + int 0000000001fffffff <- ( 000000000 , ffffffff ) + +[36,28]: + int 0000000000fffffff <- ( 000000000 , fffffff ) + +[36,27]: + int 0000000007ffffff <- ( 000000000 , fffffff ) + +[36,26]: + int 0000000003ffffff <- ( 000000000 , fffffff ) + +[36,25]: + int 0000000001ffffff <- ( 000000000 , fffffff ) + +[36,24]: + int 0000000000ffffff <- ( 000000000 , ffffff ) + +[36,23]: + int 0000000007fffff <- ( 000000000 , ffffff ) + +[36,22]: + int 0000000003fffff <- ( 000000000 , ffffff ) + +[36,21]: + int 0000000001fffff <- ( 000000000 , ffffff ) + +[36,20]: + int 0000000000fffff <- ( 000000000 , fffff ) + +[36,19]: + int 0000000007ffff <- ( 000000000 , fffff ) + +[36,18]: + int 0000000003ffff <- ( 000000000 , fffff ) + +[36,17]: + int 0000000001ffff <- ( 000000000 , fffff ) + +[36,16]: + int 0000000000ffff <- ( 000000000 , ffff ) + +[36,15]: + int 0000000007fff <- ( 000000000 , ffff ) + +[36,14]: + int 0000000003fff <- ( 000000000 , ffff ) + +[36,13]: + int 0000000001fff <- ( 000000000 , ffff ) + +[36,12]: + int 0000000000fff <- ( 000000000 , fff ) + +[36,11]: + int 0000000007ff <- ( 000000000 , fff ) + +[36,10]: + int 0000000003ff <- ( 000000000 , fff ) + +[36,9]: + int 0000000001ff <- ( 000000000 , fff ) + +[36,8]: + int 0000000000ff <- ( 000000000 , ff ) + +[36,7]: + int 0000000007f <- ( 000000000 , ff ) + +[36,6]: + int 0000000003f <- ( 000000000 , ff ) + +[36,5]: + int 0000000001f <- ( 000000000 , ff ) + +[36,4]: + int 0000000000f <- ( 000000000 , f ) + +[36,3]: + int 0000000007 <- ( 000000000 , f ) + +[36,2]: + int 0000000003 <- ( 000000000 , f ) + +[36,1]: + int 0000000001 <- ( 000000000 , f ) + +[35,64]: + int 000000000ffffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[35,63]: + int 0000000007fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[35,62]: + int 0000000003fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[35,61]: + int 0000000001fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[35,60]: + int 000000000fffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[35,59]: + int 0000000007ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[35,58]: + int 0000000003ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[35,57]: + int 0000000001ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[35,56]: + int 000000000ffffffffffffff <- ( 000000000 , ffffffffffffff ) + +[35,55]: + int 0000000007fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[35,54]: + int 0000000003fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[35,53]: + int 0000000001fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[35,52]: + int 000000000fffffffffffff <- ( 000000000 , fffffffffffff ) + +[35,51]: + int 0000000007ffffffffffff <- ( 000000000 , fffffffffffff ) + +[35,50]: + int 0000000003ffffffffffff <- ( 000000000 , fffffffffffff ) + +[35,49]: + int 0000000001ffffffffffff <- ( 000000000 , fffffffffffff ) + +[35,48]: + int 000000000ffffffffffff <- ( 000000000 , ffffffffffff ) + +[35,47]: + int 0000000007fffffffffff <- ( 000000000 , ffffffffffff ) + +[35,46]: + int 0000000003fffffffffff <- ( 000000000 , ffffffffffff ) + +[35,45]: + int 0000000001fffffffffff <- ( 000000000 , ffffffffffff ) + +[35,44]: + int 000000000fffffffffff <- ( 000000000 , fffffffffff ) + +[35,43]: + int 0000000007ffffffffff <- ( 000000000 , fffffffffff ) + +[35,42]: + int 0000000003ffffffffff <- ( 000000000 , fffffffffff ) + +[35,41]: + int 0000000001ffffffffff <- ( 000000000 , fffffffffff ) + +[35,40]: + int 000000000ffffffffff <- ( 000000000 , ffffffffff ) + +[35,39]: + int 0000000007fffffffff <- ( 000000000 , ffffffffff ) + +[35,38]: + int 0000000003fffffffff <- ( 000000000 , ffffffffff ) + +[35,37]: + int 0000000001fffffffff <- ( 000000000 , ffffffffff ) + +[35,36]: + int 000000000fffffffff <- ( 000000000 , fffffffff ) + +[35,35]: + int 0000000007ffffffff <- ( 000000000 , fffffffff ) + +[35,34]: + int 0000000003ffffffff <- ( 000000000 , fffffffff ) + +[35,33]: + int 0000000001ffffffff <- ( 000000000 , fffffffff ) + +[35,32]: + int 000000000ffffffff <- ( 000000000 , ffffffff ) + +[35,31]: + int 0000000007fffffff <- ( 000000000 , ffffffff ) + +[35,30]: + int 0000000003fffffff <- ( 000000000 , ffffffff ) + +[35,29]: + int 0000000001fffffff <- ( 000000000 , ffffffff ) + +[35,28]: + int 000000000fffffff <- ( 000000000 , fffffff ) + +[35,27]: + int 0000000007ffffff <- ( 000000000 , fffffff ) + +[35,26]: + int 0000000003ffffff <- ( 000000000 , fffffff ) + +[35,25]: + int 0000000001ffffff <- ( 000000000 , fffffff ) + +[35,24]: + int 000000000ffffff <- ( 000000000 , ffffff ) + +[35,23]: + int 0000000007fffff <- ( 000000000 , ffffff ) + +[35,22]: + int 0000000003fffff <- ( 000000000 , ffffff ) + +[35,21]: + int 0000000001fffff <- ( 000000000 , ffffff ) + +[35,20]: + int 000000000fffff <- ( 000000000 , fffff ) + +[35,19]: + int 0000000007ffff <- ( 000000000 , fffff ) + +[35,18]: + int 0000000003ffff <- ( 000000000 , fffff ) + +[35,17]: + int 0000000001ffff <- ( 000000000 , fffff ) + +[35,16]: + int 000000000ffff <- ( 000000000 , ffff ) + +[35,15]: + int 0000000007fff <- ( 000000000 , ffff ) + +[35,14]: + int 0000000003fff <- ( 000000000 , ffff ) + +[35,13]: + int 0000000001fff <- ( 000000000 , ffff ) + +[35,12]: + int 000000000fff <- ( 000000000 , fff ) + +[35,11]: + int 0000000007ff <- ( 000000000 , fff ) + +[35,10]: + int 0000000003ff <- ( 000000000 , fff ) + +[35,9]: + int 0000000001ff <- ( 000000000 , fff ) + +[35,8]: + int 000000000ff <- ( 000000000 , ff ) + +[35,7]: + int 0000000007f <- ( 000000000 , ff ) + +[35,6]: + int 0000000003f <- ( 000000000 , ff ) + +[35,5]: + int 0000000001f <- ( 000000000 , ff ) + +[35,4]: + int 000000000f <- ( 000000000 , f ) + +[35,3]: + int 0000000007 <- ( 000000000 , f ) + +[35,2]: + int 0000000003 <- ( 000000000 , f ) + +[35,1]: + int 0000000001 <- ( 000000000 , f ) + +[34,64]: + int 000000000ffffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[34,63]: + int 0000000007fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[34,62]: + int 0000000003fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[34,61]: + int 000000001fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[34,60]: + int 000000000fffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[34,59]: + int 0000000007ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[34,58]: + int 0000000003ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[34,57]: + int 000000001ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[34,56]: + int 000000000ffffffffffffff <- ( 000000000 , ffffffffffffff ) + +[34,55]: + int 0000000007fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[34,54]: + int 0000000003fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[34,53]: + int 000000001fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[34,52]: + int 000000000fffffffffffff <- ( 000000000 , fffffffffffff ) + +[34,51]: + int 0000000007ffffffffffff <- ( 000000000 , fffffffffffff ) + +[34,50]: + int 0000000003ffffffffffff <- ( 000000000 , fffffffffffff ) + +[34,49]: + int 000000001ffffffffffff <- ( 000000000 , fffffffffffff ) + +[34,48]: + int 000000000ffffffffffff <- ( 000000000 , ffffffffffff ) + +[34,47]: + int 0000000007fffffffffff <- ( 000000000 , ffffffffffff ) + +[34,46]: + int 0000000003fffffffffff <- ( 000000000 , ffffffffffff ) + +[34,45]: + int 000000001fffffffffff <- ( 000000000 , ffffffffffff ) + +[34,44]: + int 000000000fffffffffff <- ( 000000000 , fffffffffff ) + +[34,43]: + int 0000000007ffffffffff <- ( 000000000 , fffffffffff ) + +[34,42]: + int 0000000003ffffffffff <- ( 000000000 , fffffffffff ) + +[34,41]: + int 000000001ffffffffff <- ( 000000000 , fffffffffff ) + +[34,40]: + int 000000000ffffffffff <- ( 000000000 , ffffffffff ) + +[34,39]: + int 0000000007fffffffff <- ( 000000000 , ffffffffff ) + +[34,38]: + int 0000000003fffffffff <- ( 000000000 , ffffffffff ) + +[34,37]: + int 000000001fffffffff <- ( 000000000 , ffffffffff ) + +[34,36]: + int 000000000fffffffff <- ( 000000000 , fffffffff ) + +[34,35]: + int 0000000007ffffffff <- ( 000000000 , fffffffff ) + +[34,34]: + int 0000000003ffffffff <- ( 000000000 , fffffffff ) + +[34,33]: + int 000000001ffffffff <- ( 000000000 , fffffffff ) + +[34,32]: + int 000000000ffffffff <- ( 000000000 , ffffffff ) + +[34,31]: + int 0000000007fffffff <- ( 000000000 , ffffffff ) + +[34,30]: + int 0000000003fffffff <- ( 000000000 , ffffffff ) + +[34,29]: + int 000000001fffffff <- ( 000000000 , ffffffff ) + +[34,28]: + int 000000000fffffff <- ( 000000000 , fffffff ) + +[34,27]: + int 0000000007ffffff <- ( 000000000 , fffffff ) + +[34,26]: + int 0000000003ffffff <- ( 000000000 , fffffff ) + +[34,25]: + int 000000001ffffff <- ( 000000000 , fffffff ) + +[34,24]: + int 000000000ffffff <- ( 000000000 , ffffff ) + +[34,23]: + int 0000000007fffff <- ( 000000000 , ffffff ) + +[34,22]: + int 0000000003fffff <- ( 000000000 , ffffff ) + +[34,21]: + int 000000001fffff <- ( 000000000 , ffffff ) + +[34,20]: + int 000000000fffff <- ( 000000000 , fffff ) + +[34,19]: + int 0000000007ffff <- ( 000000000 , fffff ) + +[34,18]: + int 0000000003ffff <- ( 000000000 , fffff ) + +[34,17]: + int 000000001ffff <- ( 000000000 , fffff ) + +[34,16]: + int 000000000ffff <- ( 000000000 , ffff ) + +[34,15]: + int 0000000007fff <- ( 000000000 , ffff ) + +[34,14]: + int 0000000003fff <- ( 000000000 , ffff ) + +[34,13]: + int 000000001fff <- ( 000000000 , ffff ) + +[34,12]: + int 000000000fff <- ( 000000000 , fff ) + +[34,11]: + int 0000000007ff <- ( 000000000 , fff ) + +[34,10]: + int 0000000003ff <- ( 000000000 , fff ) + +[34,9]: + int 000000001ff <- ( 000000000 , fff ) + +[34,8]: + int 000000000ff <- ( 000000000 , ff ) + +[34,7]: + int 0000000007f <- ( 000000000 , ff ) + +[34,6]: + int 0000000003f <- ( 000000000 , ff ) + +[34,5]: + int 000000001f <- ( 000000000 , ff ) + +[34,4]: + int 000000000f <- ( 000000000 , f ) + +[34,3]: + int 0000000007 <- ( 000000000 , f ) + +[34,2]: + int 0000000003 <- ( 000000000 , f ) + +[34,1]: + int 000000001 <- ( 000000000 , f ) + +[33,64]: + int 000000000ffffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[33,63]: + int 0000000007fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[33,62]: + int 000000003fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[33,61]: + int 000000001fffffffffffffff <- ( 000000000 , ffffffffffffffff ) + +[33,60]: + int 000000000fffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[33,59]: + int 0000000007ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[33,58]: + int 000000003ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[33,57]: + int 000000001ffffffffffffff <- ( 000000000 , fffffffffffffff ) + +[33,56]: + int 000000000ffffffffffffff <- ( 000000000 , ffffffffffffff ) + +[33,55]: + int 0000000007fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[33,54]: + int 000000003fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[33,53]: + int 000000001fffffffffffff <- ( 000000000 , ffffffffffffff ) + +[33,52]: + int 000000000fffffffffffff <- ( 000000000 , fffffffffffff ) + +[33,51]: + int 0000000007ffffffffffff <- ( 000000000 , fffffffffffff ) + +[33,50]: + int 000000003ffffffffffff <- ( 000000000 , fffffffffffff ) + +[33,49]: + int 000000001ffffffffffff <- ( 000000000 , fffffffffffff ) + +[33,48]: + int 000000000ffffffffffff <- ( 000000000 , ffffffffffff ) + +[33,47]: + int 0000000007fffffffffff <- ( 000000000 , ffffffffffff ) + +[33,46]: + int 000000003fffffffffff <- ( 000000000 , ffffffffffff ) + +[33,45]: + int 000000001fffffffffff <- ( 000000000 , ffffffffffff ) + +[33,44]: + int 000000000fffffffffff <- ( 000000000 , fffffffffff ) + +[33,43]: + int 0000000007ffffffffff <- ( 000000000 , fffffffffff ) + +[33,42]: + int 000000003ffffffffff <- ( 000000000 , fffffffffff ) + +[33,41]: + int 000000001ffffffffff <- ( 000000000 , fffffffffff ) + +[33,40]: + int 000000000ffffffffff <- ( 000000000 , ffffffffff ) + +[33,39]: + int 0000000007fffffffff <- ( 000000000 , ffffffffff ) + +[33,38]: + int 000000003fffffffff <- ( 000000000 , ffffffffff ) + +[33,37]: + int 000000001fffffffff <- ( 000000000 , ffffffffff ) + +[33,36]: + int 000000000fffffffff <- ( 000000000 , fffffffff ) + +[33,35]: + int 0000000007ffffffff <- ( 000000000 , fffffffff ) + +[33,34]: + int 000000003ffffffff <- ( 000000000 , fffffffff ) + +[33,33]: + int 000000001ffffffff <- ( 000000000 , fffffffff ) + +[33,32]: + int 000000000ffffffff <- ( 000000000 , ffffffff ) + +[33,31]: + int 0000000007fffffff <- ( 000000000 , ffffffff ) + +[33,30]: + int 000000003fffffff <- ( 000000000 , ffffffff ) + +[33,29]: + int 000000001fffffff <- ( 000000000 , ffffffff ) + +[33,28]: + int 000000000fffffff <- ( 000000000 , fffffff ) + +[33,27]: + int 0000000007ffffff <- ( 000000000 , fffffff ) + +[33,26]: + int 000000003ffffff <- ( 000000000 , fffffff ) + +[33,25]: + int 000000001ffffff <- ( 000000000 , fffffff ) + +[33,24]: + int 000000000ffffff <- ( 000000000 , ffffff ) + +[33,23]: + int 0000000007fffff <- ( 000000000 , ffffff ) + +[33,22]: + int 000000003fffff <- ( 000000000 , ffffff ) + +[33,21]: + int 000000001fffff <- ( 000000000 , ffffff ) + +[33,20]: + int 000000000fffff <- ( 000000000 , fffff ) + +[33,19]: + int 0000000007ffff <- ( 000000000 , fffff ) + +[33,18]: + int 000000003ffff <- ( 000000000 , fffff ) + +[33,17]: + int 000000001ffff <- ( 000000000 , fffff ) + +[33,16]: + int 000000000ffff <- ( 000000000 , ffff ) + +[33,15]: + int 0000000007fff <- ( 000000000 , ffff ) + +[33,14]: + int 000000003fff <- ( 000000000 , ffff ) + +[33,13]: + int 000000001fff <- ( 000000000 , ffff ) + +[33,12]: + int 000000000fff <- ( 000000000 , fff ) + +[33,11]: + int 0000000007ff <- ( 000000000 , fff ) + +[33,10]: + int 000000003ff <- ( 000000000 , fff ) + +[33,9]: + int 000000001ff <- ( 000000000 , fff ) + +[33,8]: + int 000000000ff <- ( 000000000 , ff ) + +[33,7]: + int 0000000007f <- ( 000000000 , ff ) + +[33,6]: + int 000000003f <- ( 000000000 , ff ) + +[33,5]: + int 000000001f <- ( 000000000 , ff ) + +[33,4]: + int 000000000f <- ( 000000000 , f ) + +[33,3]: + int 0000000007 <- ( 000000000 , f ) + +[33,2]: + int 000000003 <- ( 000000000 , f ) + +[33,1]: + int 000000001 <- ( 000000000 , f ) + +[32,64]: + int 000000000ffffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[32,63]: + int 000000007fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[32,62]: + int 000000003fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[32,61]: + int 000000001fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[32,60]: + int 000000000fffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[32,59]: + int 000000007ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[32,58]: + int 000000003ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[32,57]: + int 000000001ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[32,56]: + int 000000000ffffffffffffff <- ( 00000000 , ffffffffffffff ) + +[32,55]: + int 000000007fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[32,54]: + int 000000003fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[32,53]: + int 000000001fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[32,52]: + int 000000000fffffffffffff <- ( 00000000 , fffffffffffff ) + +[32,51]: + int 000000007ffffffffffff <- ( 00000000 , fffffffffffff ) + +[32,50]: + int 000000003ffffffffffff <- ( 00000000 , fffffffffffff ) + +[32,49]: + int 000000001ffffffffffff <- ( 00000000 , fffffffffffff ) + +[32,48]: + int 000000000ffffffffffff <- ( 00000000 , ffffffffffff ) + +[32,47]: + int 000000007fffffffffff <- ( 00000000 , ffffffffffff ) + +[32,46]: + int 000000003fffffffffff <- ( 00000000 , ffffffffffff ) + +[32,45]: + int 000000001fffffffffff <- ( 00000000 , ffffffffffff ) + +[32,44]: + int 000000000fffffffffff <- ( 00000000 , fffffffffff ) + +[32,43]: + int 000000007ffffffffff <- ( 00000000 , fffffffffff ) + +[32,42]: + int 000000003ffffffffff <- ( 00000000 , fffffffffff ) + +[32,41]: + int 000000001ffffffffff <- ( 00000000 , fffffffffff ) + +[32,40]: + int 000000000ffffffffff <- ( 00000000 , ffffffffff ) + +[32,39]: + int 000000007fffffffff <- ( 00000000 , ffffffffff ) + +[32,38]: + int 000000003fffffffff <- ( 00000000 , ffffffffff ) + +[32,37]: + int 000000001fffffffff <- ( 00000000 , ffffffffff ) + +[32,36]: + int 000000000fffffffff <- ( 00000000 , fffffffff ) + +[32,35]: + int 000000007ffffffff <- ( 00000000 , fffffffff ) + +[32,34]: + int 000000003ffffffff <- ( 00000000 , fffffffff ) + +[32,33]: + int 000000001ffffffff <- ( 00000000 , fffffffff ) + +[32,32]: + int 000000000ffffffff <- ( 00000000 , ffffffff ) + +[32,31]: + int 000000007fffffff <- ( 00000000 , ffffffff ) + +[32,30]: + int 000000003fffffff <- ( 00000000 , ffffffff ) + +[32,29]: + int 000000001fffffff <- ( 00000000 , ffffffff ) + +[32,28]: + int 000000000fffffff <- ( 00000000 , fffffff ) + +[32,27]: + int 000000007ffffff <- ( 00000000 , fffffff ) + +[32,26]: + int 000000003ffffff <- ( 00000000 , fffffff ) + +[32,25]: + int 000000001ffffff <- ( 00000000 , fffffff ) + +[32,24]: + int 000000000ffffff <- ( 00000000 , ffffff ) + +[32,23]: + int 000000007fffff <- ( 00000000 , ffffff ) + +[32,22]: + int 000000003fffff <- ( 00000000 , ffffff ) + +[32,21]: + int 000000001fffff <- ( 00000000 , ffffff ) + +[32,20]: + int 000000000fffff <- ( 00000000 , fffff ) + +[32,19]: + int 000000007ffff <- ( 00000000 , fffff ) + +[32,18]: + int 000000003ffff <- ( 00000000 , fffff ) + +[32,17]: + int 000000001ffff <- ( 00000000 , fffff ) + +[32,16]: + int 000000000ffff <- ( 00000000 , ffff ) + +[32,15]: + int 000000007fff <- ( 00000000 , ffff ) + +[32,14]: + int 000000003fff <- ( 00000000 , ffff ) + +[32,13]: + int 000000001fff <- ( 00000000 , ffff ) + +[32,12]: + int 000000000fff <- ( 00000000 , fff ) + +[32,11]: + int 000000007ff <- ( 00000000 , fff ) + +[32,10]: + int 000000003ff <- ( 00000000 , fff ) + +[32,9]: + int 000000001ff <- ( 00000000 , fff ) + +[32,8]: + int 000000000ff <- ( 00000000 , ff ) + +[32,7]: + int 000000007f <- ( 00000000 , ff ) + +[32,6]: + int 000000003f <- ( 00000000 , ff ) + +[32,5]: + int 000000001f <- ( 00000000 , ff ) + +[32,4]: + int 000000000f <- ( 00000000 , f ) + +[32,3]: + int 000000007 <- ( 00000000 , f ) + +[32,2]: + int 000000003 <- ( 00000000 , f ) + +[32,1]: + int 000000001 <- ( 00000000 , f ) + +[31,64]: + int 00000000ffffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[31,63]: + int 000000007fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[31,62]: + int 000000003fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[31,61]: + int 000000001fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[31,60]: + int 00000000fffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[31,59]: + int 000000007ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[31,58]: + int 000000003ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[31,57]: + int 000000001ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[31,56]: + int 00000000ffffffffffffff <- ( 00000000 , ffffffffffffff ) + +[31,55]: + int 000000007fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[31,54]: + int 000000003fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[31,53]: + int 000000001fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[31,52]: + int 00000000fffffffffffff <- ( 00000000 , fffffffffffff ) + +[31,51]: + int 000000007ffffffffffff <- ( 00000000 , fffffffffffff ) + +[31,50]: + int 000000003ffffffffffff <- ( 00000000 , fffffffffffff ) + +[31,49]: + int 000000001ffffffffffff <- ( 00000000 , fffffffffffff ) + +[31,48]: + int 00000000ffffffffffff <- ( 00000000 , ffffffffffff ) + +[31,47]: + int 000000007fffffffffff <- ( 00000000 , ffffffffffff ) + +[31,46]: + int 000000003fffffffffff <- ( 00000000 , ffffffffffff ) + +[31,45]: + int 000000001fffffffffff <- ( 00000000 , ffffffffffff ) + +[31,44]: + int 00000000fffffffffff <- ( 00000000 , fffffffffff ) + +[31,43]: + int 000000007ffffffffff <- ( 00000000 , fffffffffff ) + +[31,42]: + int 000000003ffffffffff <- ( 00000000 , fffffffffff ) + +[31,41]: + int 000000001ffffffffff <- ( 00000000 , fffffffffff ) + +[31,40]: + int 00000000ffffffffff <- ( 00000000 , ffffffffff ) + +[31,39]: + int 000000007fffffffff <- ( 00000000 , ffffffffff ) + +[31,38]: + int 000000003fffffffff <- ( 00000000 , ffffffffff ) + +[31,37]: + int 000000001fffffffff <- ( 00000000 , ffffffffff ) + +[31,36]: + int 00000000fffffffff <- ( 00000000 , fffffffff ) + +[31,35]: + int 000000007ffffffff <- ( 00000000 , fffffffff ) + +[31,34]: + int 000000003ffffffff <- ( 00000000 , fffffffff ) + +[31,33]: + int 000000001ffffffff <- ( 00000000 , fffffffff ) + +[31,32]: + int 00000000ffffffff <- ( 00000000 , ffffffff ) + +[31,31]: + int 000000007fffffff <- ( 00000000 , ffffffff ) + +[31,30]: + int 000000003fffffff <- ( 00000000 , ffffffff ) + +[31,29]: + int 000000001fffffff <- ( 00000000 , ffffffff ) + +[31,28]: + int 00000000fffffff <- ( 00000000 , fffffff ) + +[31,27]: + int 000000007ffffff <- ( 00000000 , fffffff ) + +[31,26]: + int 000000003ffffff <- ( 00000000 , fffffff ) + +[31,25]: + int 000000001ffffff <- ( 00000000 , fffffff ) + +[31,24]: + int 00000000ffffff <- ( 00000000 , ffffff ) + +[31,23]: + int 000000007fffff <- ( 00000000 , ffffff ) + +[31,22]: + int 000000003fffff <- ( 00000000 , ffffff ) + +[31,21]: + int 000000001fffff <- ( 00000000 , ffffff ) + +[31,20]: + int 00000000fffff <- ( 00000000 , fffff ) + +[31,19]: + int 000000007ffff <- ( 00000000 , fffff ) + +[31,18]: + int 000000003ffff <- ( 00000000 , fffff ) + +[31,17]: + int 000000001ffff <- ( 00000000 , fffff ) + +[31,16]: + int 00000000ffff <- ( 00000000 , ffff ) + +[31,15]: + int 000000007fff <- ( 00000000 , ffff ) + +[31,14]: + int 000000003fff <- ( 00000000 , ffff ) + +[31,13]: + int 000000001fff <- ( 00000000 , ffff ) + +[31,12]: + int 00000000fff <- ( 00000000 , fff ) + +[31,11]: + int 000000007ff <- ( 00000000 , fff ) + +[31,10]: + int 000000003ff <- ( 00000000 , fff ) + +[31,9]: + int 000000001ff <- ( 00000000 , fff ) + +[31,8]: + int 00000000ff <- ( 00000000 , ff ) + +[31,7]: + int 000000007f <- ( 00000000 , ff ) + +[31,6]: + int 000000003f <- ( 00000000 , ff ) + +[31,5]: + int 000000001f <- ( 00000000 , ff ) + +[31,4]: + int 00000000f <- ( 00000000 , f ) + +[31,3]: + int 000000007 <- ( 00000000 , f ) + +[31,2]: + int 000000003 <- ( 00000000 , f ) + +[31,1]: + int 000000001 <- ( 00000000 , f ) + +[30,64]: + int 00000000ffffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[30,63]: + int 000000007fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[30,62]: + int 000000003fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[30,61]: + int 00000001fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[30,60]: + int 00000000fffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[30,59]: + int 000000007ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[30,58]: + int 000000003ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[30,57]: + int 00000001ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[30,56]: + int 00000000ffffffffffffff <- ( 00000000 , ffffffffffffff ) + +[30,55]: + int 000000007fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[30,54]: + int 000000003fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[30,53]: + int 00000001fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[30,52]: + int 00000000fffffffffffff <- ( 00000000 , fffffffffffff ) + +[30,51]: + int 000000007ffffffffffff <- ( 00000000 , fffffffffffff ) + +[30,50]: + int 000000003ffffffffffff <- ( 00000000 , fffffffffffff ) + +[30,49]: + int 00000001ffffffffffff <- ( 00000000 , fffffffffffff ) + +[30,48]: + int 00000000ffffffffffff <- ( 00000000 , ffffffffffff ) + +[30,47]: + int 000000007fffffffffff <- ( 00000000 , ffffffffffff ) + +[30,46]: + int 000000003fffffffffff <- ( 00000000 , ffffffffffff ) + +[30,45]: + int 00000001fffffffffff <- ( 00000000 , ffffffffffff ) + +[30,44]: + int 00000000fffffffffff <- ( 00000000 , fffffffffff ) + +[30,43]: + int 000000007ffffffffff <- ( 00000000 , fffffffffff ) + +[30,42]: + int 000000003ffffffffff <- ( 00000000 , fffffffffff ) + +[30,41]: + int 00000001ffffffffff <- ( 00000000 , fffffffffff ) + +[30,40]: + int 00000000ffffffffff <- ( 00000000 , ffffffffff ) + +[30,39]: + int 000000007fffffffff <- ( 00000000 , ffffffffff ) + +[30,38]: + int 000000003fffffffff <- ( 00000000 , ffffffffff ) + +[30,37]: + int 00000001fffffffff <- ( 00000000 , ffffffffff ) + +[30,36]: + int 00000000fffffffff <- ( 00000000 , fffffffff ) + +[30,35]: + int 000000007ffffffff <- ( 00000000 , fffffffff ) + +[30,34]: + int 000000003ffffffff <- ( 00000000 , fffffffff ) + +[30,33]: + int 00000001ffffffff <- ( 00000000 , fffffffff ) + +[30,32]: + int 00000000ffffffff <- ( 00000000 , ffffffff ) + +[30,31]: + int 000000007fffffff <- ( 00000000 , ffffffff ) + +[30,30]: + int 000000003fffffff <- ( 00000000 , ffffffff ) + +[30,29]: + int 00000001fffffff <- ( 00000000 , ffffffff ) + +[30,28]: + int 00000000fffffff <- ( 00000000 , fffffff ) + +[30,27]: + int 000000007ffffff <- ( 00000000 , fffffff ) + +[30,26]: + int 000000003ffffff <- ( 00000000 , fffffff ) + +[30,25]: + int 00000001ffffff <- ( 00000000 , fffffff ) + +[30,24]: + int 00000000ffffff <- ( 00000000 , ffffff ) + +[30,23]: + int 000000007fffff <- ( 00000000 , ffffff ) + +[30,22]: + int 000000003fffff <- ( 00000000 , ffffff ) + +[30,21]: + int 00000001fffff <- ( 00000000 , ffffff ) + +[30,20]: + int 00000000fffff <- ( 00000000 , fffff ) + +[30,19]: + int 000000007ffff <- ( 00000000 , fffff ) + +[30,18]: + int 000000003ffff <- ( 00000000 , fffff ) + +[30,17]: + int 00000001ffff <- ( 00000000 , fffff ) + +[30,16]: + int 00000000ffff <- ( 00000000 , ffff ) + +[30,15]: + int 000000007fff <- ( 00000000 , ffff ) + +[30,14]: + int 000000003fff <- ( 00000000 , ffff ) + +[30,13]: + int 00000001fff <- ( 00000000 , ffff ) + +[30,12]: + int 00000000fff <- ( 00000000 , fff ) + +[30,11]: + int 000000007ff <- ( 00000000 , fff ) + +[30,10]: + int 000000003ff <- ( 00000000 , fff ) + +[30,9]: + int 00000001ff <- ( 00000000 , fff ) + +[30,8]: + int 00000000ff <- ( 00000000 , ff ) + +[30,7]: + int 000000007f <- ( 00000000 , ff ) + +[30,6]: + int 000000003f <- ( 00000000 , ff ) + +[30,5]: + int 00000001f <- ( 00000000 , ff ) + +[30,4]: + int 00000000f <- ( 00000000 , f ) + +[30,3]: + int 000000007 <- ( 00000000 , f ) + +[30,2]: + int 000000003 <- ( 00000000 , f ) + +[30,1]: + int 00000001 <- ( 00000000 , f ) + +[29,64]: + int 00000000ffffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[29,63]: + int 000000007fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[29,62]: + int 00000003fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[29,61]: + int 00000001fffffffffffffff <- ( 00000000 , ffffffffffffffff ) + +[29,60]: + int 00000000fffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[29,59]: + int 000000007ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[29,58]: + int 00000003ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[29,57]: + int 00000001ffffffffffffff <- ( 00000000 , fffffffffffffff ) + +[29,56]: + int 00000000ffffffffffffff <- ( 00000000 , ffffffffffffff ) + +[29,55]: + int 000000007fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[29,54]: + int 00000003fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[29,53]: + int 00000001fffffffffffff <- ( 00000000 , ffffffffffffff ) + +[29,52]: + int 00000000fffffffffffff <- ( 00000000 , fffffffffffff ) + +[29,51]: + int 000000007ffffffffffff <- ( 00000000 , fffffffffffff ) + +[29,50]: + int 00000003ffffffffffff <- ( 00000000 , fffffffffffff ) + +[29,49]: + int 00000001ffffffffffff <- ( 00000000 , fffffffffffff ) + +[29,48]: + int 00000000ffffffffffff <- ( 00000000 , ffffffffffff ) + +[29,47]: + int 000000007fffffffffff <- ( 00000000 , ffffffffffff ) + +[29,46]: + int 00000003fffffffffff <- ( 00000000 , ffffffffffff ) + +[29,45]: + int 00000001fffffffffff <- ( 00000000 , ffffffffffff ) + +[29,44]: + int 00000000fffffffffff <- ( 00000000 , fffffffffff ) + +[29,43]: + int 000000007ffffffffff <- ( 00000000 , fffffffffff ) + +[29,42]: + int 00000003ffffffffff <- ( 00000000 , fffffffffff ) + +[29,41]: + int 00000001ffffffffff <- ( 00000000 , fffffffffff ) + +[29,40]: + int 00000000ffffffffff <- ( 00000000 , ffffffffff ) + +[29,39]: + int 000000007fffffffff <- ( 00000000 , ffffffffff ) + +[29,38]: + int 00000003fffffffff <- ( 00000000 , ffffffffff ) + +[29,37]: + int 00000001fffffffff <- ( 00000000 , ffffffffff ) + +[29,36]: + int 00000000fffffffff <- ( 00000000 , fffffffff ) + +[29,35]: + int 000000007ffffffff <- ( 00000000 , fffffffff ) + +[29,34]: + int 00000003ffffffff <- ( 00000000 , fffffffff ) + +[29,33]: + int 00000001ffffffff <- ( 00000000 , fffffffff ) + +[29,32]: + int 00000000ffffffff <- ( 00000000 , ffffffff ) + +[29,31]: + int 000000007fffffff <- ( 00000000 , ffffffff ) + +[29,30]: + int 00000003fffffff <- ( 00000000 , ffffffff ) + +[29,29]: + int 00000001fffffff <- ( 00000000 , ffffffff ) + +[29,28]: + int 00000000fffffff <- ( 00000000 , fffffff ) + +[29,27]: + int 000000007ffffff <- ( 00000000 , fffffff ) + +[29,26]: + int 00000003ffffff <- ( 00000000 , fffffff ) + +[29,25]: + int 00000001ffffff <- ( 00000000 , fffffff ) + +[29,24]: + int 00000000ffffff <- ( 00000000 , ffffff ) + +[29,23]: + int 000000007fffff <- ( 00000000 , ffffff ) + +[29,22]: + int 00000003fffff <- ( 00000000 , ffffff ) + +[29,21]: + int 00000001fffff <- ( 00000000 , ffffff ) + +[29,20]: + int 00000000fffff <- ( 00000000 , fffff ) + +[29,19]: + int 000000007ffff <- ( 00000000 , fffff ) + +[29,18]: + int 00000003ffff <- ( 00000000 , fffff ) + +[29,17]: + int 00000001ffff <- ( 00000000 , fffff ) + +[29,16]: + int 00000000ffff <- ( 00000000 , ffff ) + +[29,15]: + int 000000007fff <- ( 00000000 , ffff ) + +[29,14]: + int 00000003fff <- ( 00000000 , ffff ) + +[29,13]: + int 00000001fff <- ( 00000000 , ffff ) + +[29,12]: + int 00000000fff <- ( 00000000 , fff ) + +[29,11]: + int 000000007ff <- ( 00000000 , fff ) + +[29,10]: + int 00000003ff <- ( 00000000 , fff ) + +[29,9]: + int 00000001ff <- ( 00000000 , fff ) + +[29,8]: + int 00000000ff <- ( 00000000 , ff ) + +[29,7]: + int 000000007f <- ( 00000000 , ff ) + +[29,6]: + int 00000003f <- ( 00000000 , ff ) + +[29,5]: + int 00000001f <- ( 00000000 , ff ) + +[29,4]: + int 00000000f <- ( 00000000 , f ) + +[29,3]: + int 000000007 <- ( 00000000 , f ) + +[29,2]: + int 00000003 <- ( 00000000 , f ) + +[29,1]: + int 00000001 <- ( 00000000 , f ) + +[28,64]: + int 00000000ffffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[28,63]: + int 00000007fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[28,62]: + int 00000003fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[28,61]: + int 00000001fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[28,60]: + int 00000000fffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[28,59]: + int 00000007ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[28,58]: + int 00000003ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[28,57]: + int 00000001ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[28,56]: + int 00000000ffffffffffffff <- ( 0000000 , ffffffffffffff ) + +[28,55]: + int 00000007fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[28,54]: + int 00000003fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[28,53]: + int 00000001fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[28,52]: + int 00000000fffffffffffff <- ( 0000000 , fffffffffffff ) + +[28,51]: + int 00000007ffffffffffff <- ( 0000000 , fffffffffffff ) + +[28,50]: + int 00000003ffffffffffff <- ( 0000000 , fffffffffffff ) + +[28,49]: + int 00000001ffffffffffff <- ( 0000000 , fffffffffffff ) + +[28,48]: + int 00000000ffffffffffff <- ( 0000000 , ffffffffffff ) + +[28,47]: + int 00000007fffffffffff <- ( 0000000 , ffffffffffff ) + +[28,46]: + int 00000003fffffffffff <- ( 0000000 , ffffffffffff ) + +[28,45]: + int 00000001fffffffffff <- ( 0000000 , ffffffffffff ) + +[28,44]: + int 00000000fffffffffff <- ( 0000000 , fffffffffff ) + +[28,43]: + int 00000007ffffffffff <- ( 0000000 , fffffffffff ) + +[28,42]: + int 00000003ffffffffff <- ( 0000000 , fffffffffff ) + +[28,41]: + int 00000001ffffffffff <- ( 0000000 , fffffffffff ) + +[28,40]: + int 00000000ffffffffff <- ( 0000000 , ffffffffff ) + +[28,39]: + int 00000007fffffffff <- ( 0000000 , ffffffffff ) + +[28,38]: + int 00000003fffffffff <- ( 0000000 , ffffffffff ) + +[28,37]: + int 00000001fffffffff <- ( 0000000 , ffffffffff ) + +[28,36]: + int 00000000fffffffff <- ( 0000000 , fffffffff ) + +[28,35]: + int 00000007ffffffff <- ( 0000000 , fffffffff ) + +[28,34]: + int 00000003ffffffff <- ( 0000000 , fffffffff ) + +[28,33]: + int 00000001ffffffff <- ( 0000000 , fffffffff ) + +[28,32]: + int 00000000ffffffff <- ( 0000000 , ffffffff ) + +[28,31]: + int 00000007fffffff <- ( 0000000 , ffffffff ) + +[28,30]: + int 00000003fffffff <- ( 0000000 , ffffffff ) + +[28,29]: + int 00000001fffffff <- ( 0000000 , ffffffff ) + +[28,28]: + int 00000000fffffff <- ( 0000000 , fffffff ) + +[28,27]: + int 00000007ffffff <- ( 0000000 , fffffff ) + +[28,26]: + int 00000003ffffff <- ( 0000000 , fffffff ) + +[28,25]: + int 00000001ffffff <- ( 0000000 , fffffff ) + +[28,24]: + int 00000000ffffff <- ( 0000000 , ffffff ) + +[28,23]: + int 00000007fffff <- ( 0000000 , ffffff ) + +[28,22]: + int 00000003fffff <- ( 0000000 , ffffff ) + +[28,21]: + int 00000001fffff <- ( 0000000 , ffffff ) + +[28,20]: + int 00000000fffff <- ( 0000000 , fffff ) + +[28,19]: + int 00000007ffff <- ( 0000000 , fffff ) + +[28,18]: + int 00000003ffff <- ( 0000000 , fffff ) + +[28,17]: + int 00000001ffff <- ( 0000000 , fffff ) + +[28,16]: + int 00000000ffff <- ( 0000000 , ffff ) + +[28,15]: + int 00000007fff <- ( 0000000 , ffff ) + +[28,14]: + int 00000003fff <- ( 0000000 , ffff ) + +[28,13]: + int 00000001fff <- ( 0000000 , ffff ) + +[28,12]: + int 00000000fff <- ( 0000000 , fff ) + +[28,11]: + int 00000007ff <- ( 0000000 , fff ) + +[28,10]: + int 00000003ff <- ( 0000000 , fff ) + +[28,9]: + int 00000001ff <- ( 0000000 , fff ) + +[28,8]: + int 00000000ff <- ( 0000000 , ff ) + +[28,7]: + int 00000007f <- ( 0000000 , ff ) + +[28,6]: + int 00000003f <- ( 0000000 , ff ) + +[28,5]: + int 00000001f <- ( 0000000 , ff ) + +[28,4]: + int 00000000f <- ( 0000000 , f ) + +[28,3]: + int 00000007 <- ( 0000000 , f ) + +[28,2]: + int 00000003 <- ( 0000000 , f ) + +[28,1]: + int 00000001 <- ( 0000000 , f ) + +[27,64]: + int 0000000ffffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[27,63]: + int 00000007fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[27,62]: + int 00000003fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[27,61]: + int 00000001fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[27,60]: + int 0000000fffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[27,59]: + int 00000007ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[27,58]: + int 00000003ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[27,57]: + int 00000001ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[27,56]: + int 0000000ffffffffffffff <- ( 0000000 , ffffffffffffff ) + +[27,55]: + int 00000007fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[27,54]: + int 00000003fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[27,53]: + int 00000001fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[27,52]: + int 0000000fffffffffffff <- ( 0000000 , fffffffffffff ) + +[27,51]: + int 00000007ffffffffffff <- ( 0000000 , fffffffffffff ) + +[27,50]: + int 00000003ffffffffffff <- ( 0000000 , fffffffffffff ) + +[27,49]: + int 00000001ffffffffffff <- ( 0000000 , fffffffffffff ) + +[27,48]: + int 0000000ffffffffffff <- ( 0000000 , ffffffffffff ) + +[27,47]: + int 00000007fffffffffff <- ( 0000000 , ffffffffffff ) + +[27,46]: + int 00000003fffffffffff <- ( 0000000 , ffffffffffff ) + +[27,45]: + int 00000001fffffffffff <- ( 0000000 , ffffffffffff ) + +[27,44]: + int 0000000fffffffffff <- ( 0000000 , fffffffffff ) + +[27,43]: + int 00000007ffffffffff <- ( 0000000 , fffffffffff ) + +[27,42]: + int 00000003ffffffffff <- ( 0000000 , fffffffffff ) + +[27,41]: + int 00000001ffffffffff <- ( 0000000 , fffffffffff ) + +[27,40]: + int 0000000ffffffffff <- ( 0000000 , ffffffffff ) + +[27,39]: + int 00000007fffffffff <- ( 0000000 , ffffffffff ) + +[27,38]: + int 00000003fffffffff <- ( 0000000 , ffffffffff ) + +[27,37]: + int 00000001fffffffff <- ( 0000000 , ffffffffff ) + +[27,36]: + int 0000000fffffffff <- ( 0000000 , fffffffff ) + +[27,35]: + int 00000007ffffffff <- ( 0000000 , fffffffff ) + +[27,34]: + int 00000003ffffffff <- ( 0000000 , fffffffff ) + +[27,33]: + int 00000001ffffffff <- ( 0000000 , fffffffff ) + +[27,32]: + int 0000000ffffffff <- ( 0000000 , ffffffff ) + +[27,31]: + int 00000007fffffff <- ( 0000000 , ffffffff ) + +[27,30]: + int 00000003fffffff <- ( 0000000 , ffffffff ) + +[27,29]: + int 00000001fffffff <- ( 0000000 , ffffffff ) + +[27,28]: + int 0000000fffffff <- ( 0000000 , fffffff ) + +[27,27]: + int 00000007ffffff <- ( 0000000 , fffffff ) + +[27,26]: + int 00000003ffffff <- ( 0000000 , fffffff ) + +[27,25]: + int 00000001ffffff <- ( 0000000 , fffffff ) + +[27,24]: + int 0000000ffffff <- ( 0000000 , ffffff ) + +[27,23]: + int 00000007fffff <- ( 0000000 , ffffff ) + +[27,22]: + int 00000003fffff <- ( 0000000 , ffffff ) + +[27,21]: + int 00000001fffff <- ( 0000000 , ffffff ) + +[27,20]: + int 0000000fffff <- ( 0000000 , fffff ) + +[27,19]: + int 00000007ffff <- ( 0000000 , fffff ) + +[27,18]: + int 00000003ffff <- ( 0000000 , fffff ) + +[27,17]: + int 00000001ffff <- ( 0000000 , fffff ) + +[27,16]: + int 0000000ffff <- ( 0000000 , ffff ) + +[27,15]: + int 00000007fff <- ( 0000000 , ffff ) + +[27,14]: + int 00000003fff <- ( 0000000 , ffff ) + +[27,13]: + int 00000001fff <- ( 0000000 , ffff ) + +[27,12]: + int 0000000fff <- ( 0000000 , fff ) + +[27,11]: + int 00000007ff <- ( 0000000 , fff ) + +[27,10]: + int 00000003ff <- ( 0000000 , fff ) + +[27,9]: + int 00000001ff <- ( 0000000 , fff ) + +[27,8]: + int 0000000ff <- ( 0000000 , ff ) + +[27,7]: + int 00000007f <- ( 0000000 , ff ) + +[27,6]: + int 00000003f <- ( 0000000 , ff ) + +[27,5]: + int 00000001f <- ( 0000000 , ff ) + +[27,4]: + int 0000000f <- ( 0000000 , f ) + +[27,3]: + int 00000007 <- ( 0000000 , f ) + +[27,2]: + int 00000003 <- ( 0000000 , f ) + +[27,1]: + int 00000001 <- ( 0000000 , f ) + +[26,64]: + int 0000000ffffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[26,63]: + int 00000007fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[26,62]: + int 00000003fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[26,61]: + int 0000001fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[26,60]: + int 0000000fffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[26,59]: + int 00000007ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[26,58]: + int 00000003ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[26,57]: + int 0000001ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[26,56]: + int 0000000ffffffffffffff <- ( 0000000 , ffffffffffffff ) + +[26,55]: + int 00000007fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[26,54]: + int 00000003fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[26,53]: + int 0000001fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[26,52]: + int 0000000fffffffffffff <- ( 0000000 , fffffffffffff ) + +[26,51]: + int 00000007ffffffffffff <- ( 0000000 , fffffffffffff ) + +[26,50]: + int 00000003ffffffffffff <- ( 0000000 , fffffffffffff ) + +[26,49]: + int 0000001ffffffffffff <- ( 0000000 , fffffffffffff ) + +[26,48]: + int 0000000ffffffffffff <- ( 0000000 , ffffffffffff ) + +[26,47]: + int 00000007fffffffffff <- ( 0000000 , ffffffffffff ) + +[26,46]: + int 00000003fffffffffff <- ( 0000000 , ffffffffffff ) + +[26,45]: + int 0000001fffffffffff <- ( 0000000 , ffffffffffff ) + +[26,44]: + int 0000000fffffffffff <- ( 0000000 , fffffffffff ) + +[26,43]: + int 00000007ffffffffff <- ( 0000000 , fffffffffff ) + +[26,42]: + int 00000003ffffffffff <- ( 0000000 , fffffffffff ) + +[26,41]: + int 0000001ffffffffff <- ( 0000000 , fffffffffff ) + +[26,40]: + int 0000000ffffffffff <- ( 0000000 , ffffffffff ) + +[26,39]: + int 00000007fffffffff <- ( 0000000 , ffffffffff ) + +[26,38]: + int 00000003fffffffff <- ( 0000000 , ffffffffff ) + +[26,37]: + int 0000001fffffffff <- ( 0000000 , ffffffffff ) + +[26,36]: + int 0000000fffffffff <- ( 0000000 , fffffffff ) + +[26,35]: + int 00000007ffffffff <- ( 0000000 , fffffffff ) + +[26,34]: + int 00000003ffffffff <- ( 0000000 , fffffffff ) + +[26,33]: + int 0000001ffffffff <- ( 0000000 , fffffffff ) + +[26,32]: + int 0000000ffffffff <- ( 0000000 , ffffffff ) + +[26,31]: + int 00000007fffffff <- ( 0000000 , ffffffff ) + +[26,30]: + int 00000003fffffff <- ( 0000000 , ffffffff ) + +[26,29]: + int 0000001fffffff <- ( 0000000 , ffffffff ) + +[26,28]: + int 0000000fffffff <- ( 0000000 , fffffff ) + +[26,27]: + int 00000007ffffff <- ( 0000000 , fffffff ) + +[26,26]: + int 00000003ffffff <- ( 0000000 , fffffff ) + +[26,25]: + int 0000001ffffff <- ( 0000000 , fffffff ) + +[26,24]: + int 0000000ffffff <- ( 0000000 , ffffff ) + +[26,23]: + int 00000007fffff <- ( 0000000 , ffffff ) + +[26,22]: + int 00000003fffff <- ( 0000000 , ffffff ) + +[26,21]: + int 0000001fffff <- ( 0000000 , ffffff ) + +[26,20]: + int 0000000fffff <- ( 0000000 , fffff ) + +[26,19]: + int 00000007ffff <- ( 0000000 , fffff ) + +[26,18]: + int 00000003ffff <- ( 0000000 , fffff ) + +[26,17]: + int 0000001ffff <- ( 0000000 , fffff ) + +[26,16]: + int 0000000ffff <- ( 0000000 , ffff ) + +[26,15]: + int 00000007fff <- ( 0000000 , ffff ) + +[26,14]: + int 00000003fff <- ( 0000000 , ffff ) + +[26,13]: + int 0000001fff <- ( 0000000 , ffff ) + +[26,12]: + int 0000000fff <- ( 0000000 , fff ) + +[26,11]: + int 00000007ff <- ( 0000000 , fff ) + +[26,10]: + int 00000003ff <- ( 0000000 , fff ) + +[26,9]: + int 0000001ff <- ( 0000000 , fff ) + +[26,8]: + int 0000000ff <- ( 0000000 , ff ) + +[26,7]: + int 00000007f <- ( 0000000 , ff ) + +[26,6]: + int 00000003f <- ( 0000000 , ff ) + +[26,5]: + int 0000001f <- ( 0000000 , ff ) + +[26,4]: + int 0000000f <- ( 0000000 , f ) + +[26,3]: + int 00000007 <- ( 0000000 , f ) + +[26,2]: + int 00000003 <- ( 0000000 , f ) + +[26,1]: + int 0000001 <- ( 0000000 , f ) + +[25,64]: + int 0000000ffffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[25,63]: + int 00000007fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[25,62]: + int 0000003fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[25,61]: + int 0000001fffffffffffffff <- ( 0000000 , ffffffffffffffff ) + +[25,60]: + int 0000000fffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[25,59]: + int 00000007ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[25,58]: + int 0000003ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[25,57]: + int 0000001ffffffffffffff <- ( 0000000 , fffffffffffffff ) + +[25,56]: + int 0000000ffffffffffffff <- ( 0000000 , ffffffffffffff ) + +[25,55]: + int 00000007fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[25,54]: + int 0000003fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[25,53]: + int 0000001fffffffffffff <- ( 0000000 , ffffffffffffff ) + +[25,52]: + int 0000000fffffffffffff <- ( 0000000 , fffffffffffff ) + +[25,51]: + int 00000007ffffffffffff <- ( 0000000 , fffffffffffff ) + +[25,50]: + int 0000003ffffffffffff <- ( 0000000 , fffffffffffff ) + +[25,49]: + int 0000001ffffffffffff <- ( 0000000 , fffffffffffff ) + +[25,48]: + int 0000000ffffffffffff <- ( 0000000 , ffffffffffff ) + +[25,47]: + int 00000007fffffffffff <- ( 0000000 , ffffffffffff ) + +[25,46]: + int 0000003fffffffffff <- ( 0000000 , ffffffffffff ) + +[25,45]: + int 0000001fffffffffff <- ( 0000000 , ffffffffffff ) + +[25,44]: + int 0000000fffffffffff <- ( 0000000 , fffffffffff ) + +[25,43]: + int 00000007ffffffffff <- ( 0000000 , fffffffffff ) + +[25,42]: + int 0000003ffffffffff <- ( 0000000 , fffffffffff ) + +[25,41]: + int 0000001ffffffffff <- ( 0000000 , fffffffffff ) + +[25,40]: + int 0000000ffffffffff <- ( 0000000 , ffffffffff ) + +[25,39]: + int 00000007fffffffff <- ( 0000000 , ffffffffff ) + +[25,38]: + int 0000003fffffffff <- ( 0000000 , ffffffffff ) + +[25,37]: + int 0000001fffffffff <- ( 0000000 , ffffffffff ) + +[25,36]: + int 0000000fffffffff <- ( 0000000 , fffffffff ) + +[25,35]: + int 00000007ffffffff <- ( 0000000 , fffffffff ) + +[25,34]: + int 0000003ffffffff <- ( 0000000 , fffffffff ) + +[25,33]: + int 0000001ffffffff <- ( 0000000 , fffffffff ) + +[25,32]: + int 0000000ffffffff <- ( 0000000 , ffffffff ) + +[25,31]: + int 00000007fffffff <- ( 0000000 , ffffffff ) + +[25,30]: + int 0000003fffffff <- ( 0000000 , ffffffff ) + +[25,29]: + int 0000001fffffff <- ( 0000000 , ffffffff ) + +[25,28]: + int 0000000fffffff <- ( 0000000 , fffffff ) + +[25,27]: + int 00000007ffffff <- ( 0000000 , fffffff ) + +[25,26]: + int 0000003ffffff <- ( 0000000 , fffffff ) + +[25,25]: + int 0000001ffffff <- ( 0000000 , fffffff ) + +[25,24]: + int 0000000ffffff <- ( 0000000 , ffffff ) + +[25,23]: + int 00000007fffff <- ( 0000000 , ffffff ) + +[25,22]: + int 0000003fffff <- ( 0000000 , ffffff ) + +[25,21]: + int 0000001fffff <- ( 0000000 , ffffff ) + +[25,20]: + int 0000000fffff <- ( 0000000 , fffff ) + +[25,19]: + int 00000007ffff <- ( 0000000 , fffff ) + +[25,18]: + int 0000003ffff <- ( 0000000 , fffff ) + +[25,17]: + int 0000001ffff <- ( 0000000 , fffff ) + +[25,16]: + int 0000000ffff <- ( 0000000 , ffff ) + +[25,15]: + int 00000007fff <- ( 0000000 , ffff ) + +[25,14]: + int 0000003fff <- ( 0000000 , ffff ) + +[25,13]: + int 0000001fff <- ( 0000000 , ffff ) + +[25,12]: + int 0000000fff <- ( 0000000 , fff ) + +[25,11]: + int 00000007ff <- ( 0000000 , fff ) + +[25,10]: + int 0000003ff <- ( 0000000 , fff ) + +[25,9]: + int 0000001ff <- ( 0000000 , fff ) + +[25,8]: + int 0000000ff <- ( 0000000 , ff ) + +[25,7]: + int 00000007f <- ( 0000000 , ff ) + +[25,6]: + int 0000003f <- ( 0000000 , ff ) + +[25,5]: + int 0000001f <- ( 0000000 , ff ) + +[25,4]: + int 0000000f <- ( 0000000 , f ) + +[25,3]: + int 00000007 <- ( 0000000 , f ) + +[25,2]: + int 0000003 <- ( 0000000 , f ) + +[25,1]: + int 0000001 <- ( 0000000 , f ) + +[24,64]: + int 0000000ffffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[24,63]: + int 0000007fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[24,62]: + int 0000003fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[24,61]: + int 0000001fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[24,60]: + int 0000000fffffffffffffff <- ( 000000 , fffffffffffffff ) + +[24,59]: + int 0000007ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[24,58]: + int 0000003ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[24,57]: + int 0000001ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[24,56]: + int 0000000ffffffffffffff <- ( 000000 , ffffffffffffff ) + +[24,55]: + int 0000007fffffffffffff <- ( 000000 , ffffffffffffff ) + +[24,54]: + int 0000003fffffffffffff <- ( 000000 , ffffffffffffff ) + +[24,53]: + int 0000001fffffffffffff <- ( 000000 , ffffffffffffff ) + +[24,52]: + int 0000000fffffffffffff <- ( 000000 , fffffffffffff ) + +[24,51]: + int 0000007ffffffffffff <- ( 000000 , fffffffffffff ) + +[24,50]: + int 0000003ffffffffffff <- ( 000000 , fffffffffffff ) + +[24,49]: + int 0000001ffffffffffff <- ( 000000 , fffffffffffff ) + +[24,48]: + int 0000000ffffffffffff <- ( 000000 , ffffffffffff ) + +[24,47]: + int 0000007fffffffffff <- ( 000000 , ffffffffffff ) + +[24,46]: + int 0000003fffffffffff <- ( 000000 , ffffffffffff ) + +[24,45]: + int 0000001fffffffffff <- ( 000000 , ffffffffffff ) + +[24,44]: + int 0000000fffffffffff <- ( 000000 , fffffffffff ) + +[24,43]: + int 0000007ffffffffff <- ( 000000 , fffffffffff ) + +[24,42]: + int 0000003ffffffffff <- ( 000000 , fffffffffff ) + +[24,41]: + int 0000001ffffffffff <- ( 000000 , fffffffffff ) + +[24,40]: + int 0000000ffffffffff <- ( 000000 , ffffffffff ) + +[24,39]: + int 0000007fffffffff <- ( 000000 , ffffffffff ) + +[24,38]: + int 0000003fffffffff <- ( 000000 , ffffffffff ) + +[24,37]: + int 0000001fffffffff <- ( 000000 , ffffffffff ) + +[24,36]: + int 0000000fffffffff <- ( 000000 , fffffffff ) + +[24,35]: + int 0000007ffffffff <- ( 000000 , fffffffff ) + +[24,34]: + int 0000003ffffffff <- ( 000000 , fffffffff ) + +[24,33]: + int 0000001ffffffff <- ( 000000 , fffffffff ) + +[24,32]: + int 0000000ffffffff <- ( 000000 , ffffffff ) + +[24,31]: + int 0000007fffffff <- ( 000000 , ffffffff ) + +[24,30]: + int 0000003fffffff <- ( 000000 , ffffffff ) + +[24,29]: + int 0000001fffffff <- ( 000000 , ffffffff ) + +[24,28]: + int 0000000fffffff <- ( 000000 , fffffff ) + +[24,27]: + int 0000007ffffff <- ( 000000 , fffffff ) + +[24,26]: + int 0000003ffffff <- ( 000000 , fffffff ) + +[24,25]: + int 0000001ffffff <- ( 000000 , fffffff ) + +[24,24]: + int 0000000ffffff <- ( 000000 , ffffff ) + +[24,23]: + int 0000007fffff <- ( 000000 , ffffff ) + +[24,22]: + int 0000003fffff <- ( 000000 , ffffff ) + +[24,21]: + int 0000001fffff <- ( 000000 , ffffff ) + +[24,20]: + int 0000000fffff <- ( 000000 , fffff ) + +[24,19]: + int 0000007ffff <- ( 000000 , fffff ) + +[24,18]: + int 0000003ffff <- ( 000000 , fffff ) + +[24,17]: + int 0000001ffff <- ( 000000 , fffff ) + +[24,16]: + int 0000000ffff <- ( 000000 , ffff ) + +[24,15]: + int 0000007fff <- ( 000000 , ffff ) + +[24,14]: + int 0000003fff <- ( 000000 , ffff ) + +[24,13]: + int 0000001fff <- ( 000000 , ffff ) + +[24,12]: + int 0000000fff <- ( 000000 , fff ) + +[24,11]: + int 0000007ff <- ( 000000 , fff ) + +[24,10]: + int 0000003ff <- ( 000000 , fff ) + +[24,9]: + int 0000001ff <- ( 000000 , fff ) + +[24,8]: + int 0000000ff <- ( 000000 , ff ) + +[24,7]: + int 0000007f <- ( 000000 , ff ) + +[24,6]: + int 0000003f <- ( 000000 , ff ) + +[24,5]: + int 0000001f <- ( 000000 , ff ) + +[24,4]: + int 0000000f <- ( 000000 , f ) + +[24,3]: + int 0000007 <- ( 000000 , f ) + +[24,2]: + int 0000003 <- ( 000000 , f ) + +[24,1]: + int 0000001 <- ( 000000 , f ) + +[23,64]: + int 000000ffffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[23,63]: + int 0000007fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[23,62]: + int 0000003fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[23,61]: + int 0000001fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[23,60]: + int 000000fffffffffffffff <- ( 000000 , fffffffffffffff ) + +[23,59]: + int 0000007ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[23,58]: + int 0000003ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[23,57]: + int 0000001ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[23,56]: + int 000000ffffffffffffff <- ( 000000 , ffffffffffffff ) + +[23,55]: + int 0000007fffffffffffff <- ( 000000 , ffffffffffffff ) + +[23,54]: + int 0000003fffffffffffff <- ( 000000 , ffffffffffffff ) + +[23,53]: + int 0000001fffffffffffff <- ( 000000 , ffffffffffffff ) + +[23,52]: + int 000000fffffffffffff <- ( 000000 , fffffffffffff ) + +[23,51]: + int 0000007ffffffffffff <- ( 000000 , fffffffffffff ) + +[23,50]: + int 0000003ffffffffffff <- ( 000000 , fffffffffffff ) + +[23,49]: + int 0000001ffffffffffff <- ( 000000 , fffffffffffff ) + +[23,48]: + int 000000ffffffffffff <- ( 000000 , ffffffffffff ) + +[23,47]: + int 0000007fffffffffff <- ( 000000 , ffffffffffff ) + +[23,46]: + int 0000003fffffffffff <- ( 000000 , ffffffffffff ) + +[23,45]: + int 0000001fffffffffff <- ( 000000 , ffffffffffff ) + +[23,44]: + int 000000fffffffffff <- ( 000000 , fffffffffff ) + +[23,43]: + int 0000007ffffffffff <- ( 000000 , fffffffffff ) + +[23,42]: + int 0000003ffffffffff <- ( 000000 , fffffffffff ) + +[23,41]: + int 0000001ffffffffff <- ( 000000 , fffffffffff ) + +[23,40]: + int 000000ffffffffff <- ( 000000 , ffffffffff ) + +[23,39]: + int 0000007fffffffff <- ( 000000 , ffffffffff ) + +[23,38]: + int 0000003fffffffff <- ( 000000 , ffffffffff ) + +[23,37]: + int 0000001fffffffff <- ( 000000 , ffffffffff ) + +[23,36]: + int 000000fffffffff <- ( 000000 , fffffffff ) + +[23,35]: + int 0000007ffffffff <- ( 000000 , fffffffff ) + +[23,34]: + int 0000003ffffffff <- ( 000000 , fffffffff ) + +[23,33]: + int 0000001ffffffff <- ( 000000 , fffffffff ) + +[23,32]: + int 000000ffffffff <- ( 000000 , ffffffff ) + +[23,31]: + int 0000007fffffff <- ( 000000 , ffffffff ) + +[23,30]: + int 0000003fffffff <- ( 000000 , ffffffff ) + +[23,29]: + int 0000001fffffff <- ( 000000 , ffffffff ) + +[23,28]: + int 000000fffffff <- ( 000000 , fffffff ) + +[23,27]: + int 0000007ffffff <- ( 000000 , fffffff ) + +[23,26]: + int 0000003ffffff <- ( 000000 , fffffff ) + +[23,25]: + int 0000001ffffff <- ( 000000 , fffffff ) + +[23,24]: + int 000000ffffff <- ( 000000 , ffffff ) + +[23,23]: + int 0000007fffff <- ( 000000 , ffffff ) + +[23,22]: + int 0000003fffff <- ( 000000 , ffffff ) + +[23,21]: + int 0000001fffff <- ( 000000 , ffffff ) + +[23,20]: + int 000000fffff <- ( 000000 , fffff ) + +[23,19]: + int 0000007ffff <- ( 000000 , fffff ) + +[23,18]: + int 0000003ffff <- ( 000000 , fffff ) + +[23,17]: + int 0000001ffff <- ( 000000 , fffff ) + +[23,16]: + int 000000ffff <- ( 000000 , ffff ) + +[23,15]: + int 0000007fff <- ( 000000 , ffff ) + +[23,14]: + int 0000003fff <- ( 000000 , ffff ) + +[23,13]: + int 0000001fff <- ( 000000 , ffff ) + +[23,12]: + int 000000fff <- ( 000000 , fff ) + +[23,11]: + int 0000007ff <- ( 000000 , fff ) + +[23,10]: + int 0000003ff <- ( 000000 , fff ) + +[23,9]: + int 0000001ff <- ( 000000 , fff ) + +[23,8]: + int 000000ff <- ( 000000 , ff ) + +[23,7]: + int 0000007f <- ( 000000 , ff ) + +[23,6]: + int 0000003f <- ( 000000 , ff ) + +[23,5]: + int 0000001f <- ( 000000 , ff ) + +[23,4]: + int 000000f <- ( 000000 , f ) + +[23,3]: + int 0000007 <- ( 000000 , f ) + +[23,2]: + int 0000003 <- ( 000000 , f ) + +[23,1]: + int 0000001 <- ( 000000 , f ) + +[22,64]: + int 000000ffffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[22,63]: + int 0000007fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[22,62]: + int 0000003fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[22,61]: + int 000001fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[22,60]: + int 000000fffffffffffffff <- ( 000000 , fffffffffffffff ) + +[22,59]: + int 0000007ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[22,58]: + int 0000003ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[22,57]: + int 000001ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[22,56]: + int 000000ffffffffffffff <- ( 000000 , ffffffffffffff ) + +[22,55]: + int 0000007fffffffffffff <- ( 000000 , ffffffffffffff ) + +[22,54]: + int 0000003fffffffffffff <- ( 000000 , ffffffffffffff ) + +[22,53]: + int 000001fffffffffffff <- ( 000000 , ffffffffffffff ) + +[22,52]: + int 000000fffffffffffff <- ( 000000 , fffffffffffff ) + +[22,51]: + int 0000007ffffffffffff <- ( 000000 , fffffffffffff ) + +[22,50]: + int 0000003ffffffffffff <- ( 000000 , fffffffffffff ) + +[22,49]: + int 000001ffffffffffff <- ( 000000 , fffffffffffff ) + +[22,48]: + int 000000ffffffffffff <- ( 000000 , ffffffffffff ) + +[22,47]: + int 0000007fffffffffff <- ( 000000 , ffffffffffff ) + +[22,46]: + int 0000003fffffffffff <- ( 000000 , ffffffffffff ) + +[22,45]: + int 000001fffffffffff <- ( 000000 , ffffffffffff ) + +[22,44]: + int 000000fffffffffff <- ( 000000 , fffffffffff ) + +[22,43]: + int 0000007ffffffffff <- ( 000000 , fffffffffff ) + +[22,42]: + int 0000003ffffffffff <- ( 000000 , fffffffffff ) + +[22,41]: + int 000001ffffffffff <- ( 000000 , fffffffffff ) + +[22,40]: + int 000000ffffffffff <- ( 000000 , ffffffffff ) + +[22,39]: + int 0000007fffffffff <- ( 000000 , ffffffffff ) + +[22,38]: + int 0000003fffffffff <- ( 000000 , ffffffffff ) + +[22,37]: + int 000001fffffffff <- ( 000000 , ffffffffff ) + +[22,36]: + int 000000fffffffff <- ( 000000 , fffffffff ) + +[22,35]: + int 0000007ffffffff <- ( 000000 , fffffffff ) + +[22,34]: + int 0000003ffffffff <- ( 000000 , fffffffff ) + +[22,33]: + int 000001ffffffff <- ( 000000 , fffffffff ) + +[22,32]: + int 000000ffffffff <- ( 000000 , ffffffff ) + +[22,31]: + int 0000007fffffff <- ( 000000 , ffffffff ) + +[22,30]: + int 0000003fffffff <- ( 000000 , ffffffff ) + +[22,29]: + int 000001fffffff <- ( 000000 , ffffffff ) + +[22,28]: + int 000000fffffff <- ( 000000 , fffffff ) + +[22,27]: + int 0000007ffffff <- ( 000000 , fffffff ) + +[22,26]: + int 0000003ffffff <- ( 000000 , fffffff ) + +[22,25]: + int 000001ffffff <- ( 000000 , fffffff ) + +[22,24]: + int 000000ffffff <- ( 000000 , ffffff ) + +[22,23]: + int 0000007fffff <- ( 000000 , ffffff ) + +[22,22]: + int 0000003fffff <- ( 000000 , ffffff ) + +[22,21]: + int 000001fffff <- ( 000000 , ffffff ) + +[22,20]: + int 000000fffff <- ( 000000 , fffff ) + +[22,19]: + int 0000007ffff <- ( 000000 , fffff ) + +[22,18]: + int 0000003ffff <- ( 000000 , fffff ) + +[22,17]: + int 000001ffff <- ( 000000 , fffff ) + +[22,16]: + int 000000ffff <- ( 000000 , ffff ) + +[22,15]: + int 0000007fff <- ( 000000 , ffff ) + +[22,14]: + int 0000003fff <- ( 000000 , ffff ) + +[22,13]: + int 000001fff <- ( 000000 , ffff ) + +[22,12]: + int 000000fff <- ( 000000 , fff ) + +[22,11]: + int 0000007ff <- ( 000000 , fff ) + +[22,10]: + int 0000003ff <- ( 000000 , fff ) + +[22,9]: + int 000001ff <- ( 000000 , fff ) + +[22,8]: + int 000000ff <- ( 000000 , ff ) + +[22,7]: + int 0000007f <- ( 000000 , ff ) + +[22,6]: + int 0000003f <- ( 000000 , ff ) + +[22,5]: + int 000001f <- ( 000000 , ff ) + +[22,4]: + int 000000f <- ( 000000 , f ) + +[22,3]: + int 0000007 <- ( 000000 , f ) + +[22,2]: + int 0000003 <- ( 000000 , f ) + +[22,1]: + int 000001 <- ( 000000 , f ) + +[21,64]: + int 000000ffffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[21,63]: + int 0000007fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[21,62]: + int 000003fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[21,61]: + int 000001fffffffffffffff <- ( 000000 , ffffffffffffffff ) + +[21,60]: + int 000000fffffffffffffff <- ( 000000 , fffffffffffffff ) + +[21,59]: + int 0000007ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[21,58]: + int 000003ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[21,57]: + int 000001ffffffffffffff <- ( 000000 , fffffffffffffff ) + +[21,56]: + int 000000ffffffffffffff <- ( 000000 , ffffffffffffff ) + +[21,55]: + int 0000007fffffffffffff <- ( 000000 , ffffffffffffff ) + +[21,54]: + int 000003fffffffffffff <- ( 000000 , ffffffffffffff ) + +[21,53]: + int 000001fffffffffffff <- ( 000000 , ffffffffffffff ) + +[21,52]: + int 000000fffffffffffff <- ( 000000 , fffffffffffff ) + +[21,51]: + int 0000007ffffffffffff <- ( 000000 , fffffffffffff ) + +[21,50]: + int 000003ffffffffffff <- ( 000000 , fffffffffffff ) + +[21,49]: + int 000001ffffffffffff <- ( 000000 , fffffffffffff ) + +[21,48]: + int 000000ffffffffffff <- ( 000000 , ffffffffffff ) + +[21,47]: + int 0000007fffffffffff <- ( 000000 , ffffffffffff ) + +[21,46]: + int 000003fffffffffff <- ( 000000 , ffffffffffff ) + +[21,45]: + int 000001fffffffffff <- ( 000000 , ffffffffffff ) + +[21,44]: + int 000000fffffffffff <- ( 000000 , fffffffffff ) + +[21,43]: + int 0000007ffffffffff <- ( 000000 , fffffffffff ) + +[21,42]: + int 000003ffffffffff <- ( 000000 , fffffffffff ) + +[21,41]: + int 000001ffffffffff <- ( 000000 , fffffffffff ) + +[21,40]: + int 000000ffffffffff <- ( 000000 , ffffffffff ) + +[21,39]: + int 0000007fffffffff <- ( 000000 , ffffffffff ) + +[21,38]: + int 000003fffffffff <- ( 000000 , ffffffffff ) + +[21,37]: + int 000001fffffffff <- ( 000000 , ffffffffff ) + +[21,36]: + int 000000fffffffff <- ( 000000 , fffffffff ) + +[21,35]: + int 0000007ffffffff <- ( 000000 , fffffffff ) + +[21,34]: + int 000003ffffffff <- ( 000000 , fffffffff ) + +[21,33]: + int 000001ffffffff <- ( 000000 , fffffffff ) + +[21,32]: + int 000000ffffffff <- ( 000000 , ffffffff ) + +[21,31]: + int 0000007fffffff <- ( 000000 , ffffffff ) + +[21,30]: + int 000003fffffff <- ( 000000 , ffffffff ) + +[21,29]: + int 000001fffffff <- ( 000000 , ffffffff ) + +[21,28]: + int 000000fffffff <- ( 000000 , fffffff ) + +[21,27]: + int 0000007ffffff <- ( 000000 , fffffff ) + +[21,26]: + int 000003ffffff <- ( 000000 , fffffff ) + +[21,25]: + int 000001ffffff <- ( 000000 , fffffff ) + +[21,24]: + int 000000ffffff <- ( 000000 , ffffff ) + +[21,23]: + int 0000007fffff <- ( 000000 , ffffff ) + +[21,22]: + int 000003fffff <- ( 000000 , ffffff ) + +[21,21]: + int 000001fffff <- ( 000000 , ffffff ) + +[21,20]: + int 000000fffff <- ( 000000 , fffff ) + +[21,19]: + int 0000007ffff <- ( 000000 , fffff ) + +[21,18]: + int 000003ffff <- ( 000000 , fffff ) + +[21,17]: + int 000001ffff <- ( 000000 , fffff ) + +[21,16]: + int 000000ffff <- ( 000000 , ffff ) + +[21,15]: + int 0000007fff <- ( 000000 , ffff ) + +[21,14]: + int 000003fff <- ( 000000 , ffff ) + +[21,13]: + int 000001fff <- ( 000000 , ffff ) + +[21,12]: + int 000000fff <- ( 000000 , fff ) + +[21,11]: + int 0000007ff <- ( 000000 , fff ) + +[21,10]: + int 000003ff <- ( 000000 , fff ) + +[21,9]: + int 000001ff <- ( 000000 , fff ) + +[21,8]: + int 000000ff <- ( 000000 , ff ) + +[21,7]: + int 0000007f <- ( 000000 , ff ) + +[21,6]: + int 000003f <- ( 000000 , ff ) + +[21,5]: + int 000001f <- ( 000000 , ff ) + +[21,4]: + int 000000f <- ( 000000 , f ) + +[21,3]: + int 0000007 <- ( 000000 , f ) + +[21,2]: + int 000003 <- ( 000000 , f ) + +[21,1]: + int 000001 <- ( 000000 , f ) + +[20,64]: + int 000000ffffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[20,63]: + int 000007fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[20,62]: + int 000003fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[20,61]: + int 000001fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[20,60]: + int 000000fffffffffffffff <- ( 00000 , fffffffffffffff ) + +[20,59]: + int 000007ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[20,58]: + int 000003ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[20,57]: + int 000001ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[20,56]: + int 000000ffffffffffffff <- ( 00000 , ffffffffffffff ) + +[20,55]: + int 000007fffffffffffff <- ( 00000 , ffffffffffffff ) + +[20,54]: + int 000003fffffffffffff <- ( 00000 , ffffffffffffff ) + +[20,53]: + int 000001fffffffffffff <- ( 00000 , ffffffffffffff ) + +[20,52]: + int 000000fffffffffffff <- ( 00000 , fffffffffffff ) + +[20,51]: + int 000007ffffffffffff <- ( 00000 , fffffffffffff ) + +[20,50]: + int 000003ffffffffffff <- ( 00000 , fffffffffffff ) + +[20,49]: + int 000001ffffffffffff <- ( 00000 , fffffffffffff ) + +[20,48]: + int 000000ffffffffffff <- ( 00000 , ffffffffffff ) + +[20,47]: + int 000007fffffffffff <- ( 00000 , ffffffffffff ) + +[20,46]: + int 000003fffffffffff <- ( 00000 , ffffffffffff ) + +[20,45]: + int 000001fffffffffff <- ( 00000 , ffffffffffff ) + +[20,44]: + int 000000fffffffffff <- ( 00000 , fffffffffff ) + +[20,43]: + int 000007ffffffffff <- ( 00000 , fffffffffff ) + +[20,42]: + int 000003ffffffffff <- ( 00000 , fffffffffff ) + +[20,41]: + int 000001ffffffffff <- ( 00000 , fffffffffff ) + +[20,40]: + int 000000ffffffffff <- ( 00000 , ffffffffff ) + +[20,39]: + int 000007fffffffff <- ( 00000 , ffffffffff ) + +[20,38]: + int 000003fffffffff <- ( 00000 , ffffffffff ) + +[20,37]: + int 000001fffffffff <- ( 00000 , ffffffffff ) + +[20,36]: + int 000000fffffffff <- ( 00000 , fffffffff ) + +[20,35]: + int 000007ffffffff <- ( 00000 , fffffffff ) + +[20,34]: + int 000003ffffffff <- ( 00000 , fffffffff ) + +[20,33]: + int 000001ffffffff <- ( 00000 , fffffffff ) + +[20,32]: + int 000000ffffffff <- ( 00000 , ffffffff ) + +[20,31]: + int 000007fffffff <- ( 00000 , ffffffff ) + +[20,30]: + int 000003fffffff <- ( 00000 , ffffffff ) + +[20,29]: + int 000001fffffff <- ( 00000 , ffffffff ) + +[20,28]: + int 000000fffffff <- ( 00000 , fffffff ) + +[20,27]: + int 000007ffffff <- ( 00000 , fffffff ) + +[20,26]: + int 000003ffffff <- ( 00000 , fffffff ) + +[20,25]: + int 000001ffffff <- ( 00000 , fffffff ) + +[20,24]: + int 000000ffffff <- ( 00000 , ffffff ) + +[20,23]: + int 000007fffff <- ( 00000 , ffffff ) + +[20,22]: + int 000003fffff <- ( 00000 , ffffff ) + +[20,21]: + int 000001fffff <- ( 00000 , ffffff ) + +[20,20]: + int 000000fffff <- ( 00000 , fffff ) + +[20,19]: + int 000007ffff <- ( 00000 , fffff ) + +[20,18]: + int 000003ffff <- ( 00000 , fffff ) + +[20,17]: + int 000001ffff <- ( 00000 , fffff ) + +[20,16]: + int 000000ffff <- ( 00000 , ffff ) + +[20,15]: + int 000007fff <- ( 00000 , ffff ) + +[20,14]: + int 000003fff <- ( 00000 , ffff ) + +[20,13]: + int 000001fff <- ( 00000 , ffff ) + +[20,12]: + int 000000fff <- ( 00000 , fff ) + +[20,11]: + int 000007ff <- ( 00000 , fff ) + +[20,10]: + int 000003ff <- ( 00000 , fff ) + +[20,9]: + int 000001ff <- ( 00000 , fff ) + +[20,8]: + int 000000ff <- ( 00000 , ff ) + +[20,7]: + int 000007f <- ( 00000 , ff ) + +[20,6]: + int 000003f <- ( 00000 , ff ) + +[20,5]: + int 000001f <- ( 00000 , ff ) + +[20,4]: + int 000000f <- ( 00000 , f ) + +[20,3]: + int 000007 <- ( 00000 , f ) + +[20,2]: + int 000003 <- ( 00000 , f ) + +[20,1]: + int 000001 <- ( 00000 , f ) + +[19,64]: + int 00000ffffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[19,63]: + int 000007fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[19,62]: + int 000003fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[19,61]: + int 000001fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[19,60]: + int 00000fffffffffffffff <- ( 00000 , fffffffffffffff ) + +[19,59]: + int 000007ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[19,58]: + int 000003ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[19,57]: + int 000001ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[19,56]: + int 00000ffffffffffffff <- ( 00000 , ffffffffffffff ) + +[19,55]: + int 000007fffffffffffff <- ( 00000 , ffffffffffffff ) + +[19,54]: + int 000003fffffffffffff <- ( 00000 , ffffffffffffff ) + +[19,53]: + int 000001fffffffffffff <- ( 00000 , ffffffffffffff ) + +[19,52]: + int 00000fffffffffffff <- ( 00000 , fffffffffffff ) + +[19,51]: + int 000007ffffffffffff <- ( 00000 , fffffffffffff ) + +[19,50]: + int 000003ffffffffffff <- ( 00000 , fffffffffffff ) + +[19,49]: + int 000001ffffffffffff <- ( 00000 , fffffffffffff ) + +[19,48]: + int 00000ffffffffffff <- ( 00000 , ffffffffffff ) + +[19,47]: + int 000007fffffffffff <- ( 00000 , ffffffffffff ) + +[19,46]: + int 000003fffffffffff <- ( 00000 , ffffffffffff ) + +[19,45]: + int 000001fffffffffff <- ( 00000 , ffffffffffff ) + +[19,44]: + int 00000fffffffffff <- ( 00000 , fffffffffff ) + +[19,43]: + int 000007ffffffffff <- ( 00000 , fffffffffff ) + +[19,42]: + int 000003ffffffffff <- ( 00000 , fffffffffff ) + +[19,41]: + int 000001ffffffffff <- ( 00000 , fffffffffff ) + +[19,40]: + int 00000ffffffffff <- ( 00000 , ffffffffff ) + +[19,39]: + int 000007fffffffff <- ( 00000 , ffffffffff ) + +[19,38]: + int 000003fffffffff <- ( 00000 , ffffffffff ) + +[19,37]: + int 000001fffffffff <- ( 00000 , ffffffffff ) + +[19,36]: + int 00000fffffffff <- ( 00000 , fffffffff ) + +[19,35]: + int 000007ffffffff <- ( 00000 , fffffffff ) + +[19,34]: + int 000003ffffffff <- ( 00000 , fffffffff ) + +[19,33]: + int 000001ffffffff <- ( 00000 , fffffffff ) + +[19,32]: + int 00000ffffffff <- ( 00000 , ffffffff ) + +[19,31]: + int 000007fffffff <- ( 00000 , ffffffff ) + +[19,30]: + int 000003fffffff <- ( 00000 , ffffffff ) + +[19,29]: + int 000001fffffff <- ( 00000 , ffffffff ) + +[19,28]: + int 00000fffffff <- ( 00000 , fffffff ) + +[19,27]: + int 000007ffffff <- ( 00000 , fffffff ) + +[19,26]: + int 000003ffffff <- ( 00000 , fffffff ) + +[19,25]: + int 000001ffffff <- ( 00000 , fffffff ) + +[19,24]: + int 00000ffffff <- ( 00000 , ffffff ) + +[19,23]: + int 000007fffff <- ( 00000 , ffffff ) + +[19,22]: + int 000003fffff <- ( 00000 , ffffff ) + +[19,21]: + int 000001fffff <- ( 00000 , ffffff ) + +[19,20]: + int 00000fffff <- ( 00000 , fffff ) + +[19,19]: + int 000007ffff <- ( 00000 , fffff ) + +[19,18]: + int 000003ffff <- ( 00000 , fffff ) + +[19,17]: + int 000001ffff <- ( 00000 , fffff ) + +[19,16]: + int 00000ffff <- ( 00000 , ffff ) + +[19,15]: + int 000007fff <- ( 00000 , ffff ) + +[19,14]: + int 000003fff <- ( 00000 , ffff ) + +[19,13]: + int 000001fff <- ( 00000 , ffff ) + +[19,12]: + int 00000fff <- ( 00000 , fff ) + +[19,11]: + int 000007ff <- ( 00000 , fff ) + +[19,10]: + int 000003ff <- ( 00000 , fff ) + +[19,9]: + int 000001ff <- ( 00000 , fff ) + +[19,8]: + int 00000ff <- ( 00000 , ff ) + +[19,7]: + int 000007f <- ( 00000 , ff ) + +[19,6]: + int 000003f <- ( 00000 , ff ) + +[19,5]: + int 000001f <- ( 00000 , ff ) + +[19,4]: + int 00000f <- ( 00000 , f ) + +[19,3]: + int 000007 <- ( 00000 , f ) + +[19,2]: + int 000003 <- ( 00000 , f ) + +[19,1]: + int 000001 <- ( 00000 , f ) + +[18,64]: + int 00000ffffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[18,63]: + int 000007fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[18,62]: + int 000003fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[18,61]: + int 00001fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[18,60]: + int 00000fffffffffffffff <- ( 00000 , fffffffffffffff ) + +[18,59]: + int 000007ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[18,58]: + int 000003ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[18,57]: + int 00001ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[18,56]: + int 00000ffffffffffffff <- ( 00000 , ffffffffffffff ) + +[18,55]: + int 000007fffffffffffff <- ( 00000 , ffffffffffffff ) + +[18,54]: + int 000003fffffffffffff <- ( 00000 , ffffffffffffff ) + +[18,53]: + int 00001fffffffffffff <- ( 00000 , ffffffffffffff ) + +[18,52]: + int 00000fffffffffffff <- ( 00000 , fffffffffffff ) + +[18,51]: + int 000007ffffffffffff <- ( 00000 , fffffffffffff ) + +[18,50]: + int 000003ffffffffffff <- ( 00000 , fffffffffffff ) + +[18,49]: + int 00001ffffffffffff <- ( 00000 , fffffffffffff ) + +[18,48]: + int 00000ffffffffffff <- ( 00000 , ffffffffffff ) + +[18,47]: + int 000007fffffffffff <- ( 00000 , ffffffffffff ) + +[18,46]: + int 000003fffffffffff <- ( 00000 , ffffffffffff ) + +[18,45]: + int 00001fffffffffff <- ( 00000 , ffffffffffff ) + +[18,44]: + int 00000fffffffffff <- ( 00000 , fffffffffff ) + +[18,43]: + int 000007ffffffffff <- ( 00000 , fffffffffff ) + +[18,42]: + int 000003ffffffffff <- ( 00000 , fffffffffff ) + +[18,41]: + int 00001ffffffffff <- ( 00000 , fffffffffff ) + +[18,40]: + int 00000ffffffffff <- ( 00000 , ffffffffff ) + +[18,39]: + int 000007fffffffff <- ( 00000 , ffffffffff ) + +[18,38]: + int 000003fffffffff <- ( 00000 , ffffffffff ) + +[18,37]: + int 00001fffffffff <- ( 00000 , ffffffffff ) + +[18,36]: + int 00000fffffffff <- ( 00000 , fffffffff ) + +[18,35]: + int 000007ffffffff <- ( 00000 , fffffffff ) + +[18,34]: + int 000003ffffffff <- ( 00000 , fffffffff ) + +[18,33]: + int 00001ffffffff <- ( 00000 , fffffffff ) + +[18,32]: + int 00000ffffffff <- ( 00000 , ffffffff ) + +[18,31]: + int 000007fffffff <- ( 00000 , ffffffff ) + +[18,30]: + int 000003fffffff <- ( 00000 , ffffffff ) + +[18,29]: + int 00001fffffff <- ( 00000 , ffffffff ) + +[18,28]: + int 00000fffffff <- ( 00000 , fffffff ) + +[18,27]: + int 000007ffffff <- ( 00000 , fffffff ) + +[18,26]: + int 000003ffffff <- ( 00000 , fffffff ) + +[18,25]: + int 00001ffffff <- ( 00000 , fffffff ) + +[18,24]: + int 00000ffffff <- ( 00000 , ffffff ) + +[18,23]: + int 000007fffff <- ( 00000 , ffffff ) + +[18,22]: + int 000003fffff <- ( 00000 , ffffff ) + +[18,21]: + int 00001fffff <- ( 00000 , ffffff ) + +[18,20]: + int 00000fffff <- ( 00000 , fffff ) + +[18,19]: + int 000007ffff <- ( 00000 , fffff ) + +[18,18]: + int 000003ffff <- ( 00000 , fffff ) + +[18,17]: + int 00001ffff <- ( 00000 , fffff ) + +[18,16]: + int 00000ffff <- ( 00000 , ffff ) + +[18,15]: + int 000007fff <- ( 00000 , ffff ) + +[18,14]: + int 000003fff <- ( 00000 , ffff ) + +[18,13]: + int 00001fff <- ( 00000 , ffff ) + +[18,12]: + int 00000fff <- ( 00000 , fff ) + +[18,11]: + int 000007ff <- ( 00000 , fff ) + +[18,10]: + int 000003ff <- ( 00000 , fff ) + +[18,9]: + int 00001ff <- ( 00000 , fff ) + +[18,8]: + int 00000ff <- ( 00000 , ff ) + +[18,7]: + int 000007f <- ( 00000 , ff ) + +[18,6]: + int 000003f <- ( 00000 , ff ) + +[18,5]: + int 00001f <- ( 00000 , ff ) + +[18,4]: + int 00000f <- ( 00000 , f ) + +[18,3]: + int 000007 <- ( 00000 , f ) + +[18,2]: + int 000003 <- ( 00000 , f ) + +[18,1]: + int 00001 <- ( 00000 , f ) + +[17,64]: + int 00000ffffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[17,63]: + int 000007fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[17,62]: + int 00003fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[17,61]: + int 00001fffffffffffffff <- ( 00000 , ffffffffffffffff ) + +[17,60]: + int 00000fffffffffffffff <- ( 00000 , fffffffffffffff ) + +[17,59]: + int 000007ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[17,58]: + int 00003ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[17,57]: + int 00001ffffffffffffff <- ( 00000 , fffffffffffffff ) + +[17,56]: + int 00000ffffffffffffff <- ( 00000 , ffffffffffffff ) + +[17,55]: + int 000007fffffffffffff <- ( 00000 , ffffffffffffff ) + +[17,54]: + int 00003fffffffffffff <- ( 00000 , ffffffffffffff ) + +[17,53]: + int 00001fffffffffffff <- ( 00000 , ffffffffffffff ) + +[17,52]: + int 00000fffffffffffff <- ( 00000 , fffffffffffff ) + +[17,51]: + int 000007ffffffffffff <- ( 00000 , fffffffffffff ) + +[17,50]: + int 00003ffffffffffff <- ( 00000 , fffffffffffff ) + +[17,49]: + int 00001ffffffffffff <- ( 00000 , fffffffffffff ) + +[17,48]: + int 00000ffffffffffff <- ( 00000 , ffffffffffff ) + +[17,47]: + int 000007fffffffffff <- ( 00000 , ffffffffffff ) + +[17,46]: + int 00003fffffffffff <- ( 00000 , ffffffffffff ) + +[17,45]: + int 00001fffffffffff <- ( 00000 , ffffffffffff ) + +[17,44]: + int 00000fffffffffff <- ( 00000 , fffffffffff ) + +[17,43]: + int 000007ffffffffff <- ( 00000 , fffffffffff ) + +[17,42]: + int 00003ffffffffff <- ( 00000 , fffffffffff ) + +[17,41]: + int 00001ffffffffff <- ( 00000 , fffffffffff ) + +[17,40]: + int 00000ffffffffff <- ( 00000 , ffffffffff ) + +[17,39]: + int 000007fffffffff <- ( 00000 , ffffffffff ) + +[17,38]: + int 00003fffffffff <- ( 00000 , ffffffffff ) + +[17,37]: + int 00001fffffffff <- ( 00000 , ffffffffff ) + +[17,36]: + int 00000fffffffff <- ( 00000 , fffffffff ) + +[17,35]: + int 000007ffffffff <- ( 00000 , fffffffff ) + +[17,34]: + int 00003ffffffff <- ( 00000 , fffffffff ) + +[17,33]: + int 00001ffffffff <- ( 00000 , fffffffff ) + +[17,32]: + int 00000ffffffff <- ( 00000 , ffffffff ) + +[17,31]: + int 000007fffffff <- ( 00000 , ffffffff ) + +[17,30]: + int 00003fffffff <- ( 00000 , ffffffff ) + +[17,29]: + int 00001fffffff <- ( 00000 , ffffffff ) + +[17,28]: + int 00000fffffff <- ( 00000 , fffffff ) + +[17,27]: + int 000007ffffff <- ( 00000 , fffffff ) + +[17,26]: + int 00003ffffff <- ( 00000 , fffffff ) + +[17,25]: + int 00001ffffff <- ( 00000 , fffffff ) + +[17,24]: + int 00000ffffff <- ( 00000 , ffffff ) + +[17,23]: + int 000007fffff <- ( 00000 , ffffff ) + +[17,22]: + int 00003fffff <- ( 00000 , ffffff ) + +[17,21]: + int 00001fffff <- ( 00000 , ffffff ) + +[17,20]: + int 00000fffff <- ( 00000 , fffff ) + +[17,19]: + int 000007ffff <- ( 00000 , fffff ) + +[17,18]: + int 00003ffff <- ( 00000 , fffff ) + +[17,17]: + int 00001ffff <- ( 00000 , fffff ) + +[17,16]: + int 00000ffff <- ( 00000 , ffff ) + +[17,15]: + int 000007fff <- ( 00000 , ffff ) + +[17,14]: + int 00003fff <- ( 00000 , ffff ) + +[17,13]: + int 00001fff <- ( 00000 , ffff ) + +[17,12]: + int 00000fff <- ( 00000 , fff ) + +[17,11]: + int 000007ff <- ( 00000 , fff ) + +[17,10]: + int 00003ff <- ( 00000 , fff ) + +[17,9]: + int 00001ff <- ( 00000 , fff ) + +[17,8]: + int 00000ff <- ( 00000 , ff ) + +[17,7]: + int 000007f <- ( 00000 , ff ) + +[17,6]: + int 00003f <- ( 00000 , ff ) + +[17,5]: + int 00001f <- ( 00000 , ff ) + +[17,4]: + int 00000f <- ( 00000 , f ) + +[17,3]: + int 000007 <- ( 00000 , f ) + +[17,2]: + int 00003 <- ( 00000 , f ) + +[17,1]: + int 00001 <- ( 00000 , f ) + +[16,64]: + int 00000ffffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[16,63]: + int 00007fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[16,62]: + int 00003fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[16,61]: + int 00001fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[16,60]: + int 00000fffffffffffffff <- ( 0000 , fffffffffffffff ) + +[16,59]: + int 00007ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[16,58]: + int 00003ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[16,57]: + int 00001ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[16,56]: + int 00000ffffffffffffff <- ( 0000 , ffffffffffffff ) + +[16,55]: + int 00007fffffffffffff <- ( 0000 , ffffffffffffff ) + +[16,54]: + int 00003fffffffffffff <- ( 0000 , ffffffffffffff ) + +[16,53]: + int 00001fffffffffffff <- ( 0000 , ffffffffffffff ) + +[16,52]: + int 00000fffffffffffff <- ( 0000 , fffffffffffff ) + +[16,51]: + int 00007ffffffffffff <- ( 0000 , fffffffffffff ) + +[16,50]: + int 00003ffffffffffff <- ( 0000 , fffffffffffff ) + +[16,49]: + int 00001ffffffffffff <- ( 0000 , fffffffffffff ) + +[16,48]: + int 00000ffffffffffff <- ( 0000 , ffffffffffff ) + +[16,47]: + int 00007fffffffffff <- ( 0000 , ffffffffffff ) + +[16,46]: + int 00003fffffffffff <- ( 0000 , ffffffffffff ) + +[16,45]: + int 00001fffffffffff <- ( 0000 , ffffffffffff ) + +[16,44]: + int 00000fffffffffff <- ( 0000 , fffffffffff ) + +[16,43]: + int 00007ffffffffff <- ( 0000 , fffffffffff ) + +[16,42]: + int 00003ffffffffff <- ( 0000 , fffffffffff ) + +[16,41]: + int 00001ffffffffff <- ( 0000 , fffffffffff ) + +[16,40]: + int 00000ffffffffff <- ( 0000 , ffffffffff ) + +[16,39]: + int 00007fffffffff <- ( 0000 , ffffffffff ) + +[16,38]: + int 00003fffffffff <- ( 0000 , ffffffffff ) + +[16,37]: + int 00001fffffffff <- ( 0000 , ffffffffff ) + +[16,36]: + int 00000fffffffff <- ( 0000 , fffffffff ) + +[16,35]: + int 00007ffffffff <- ( 0000 , fffffffff ) + +[16,34]: + int 00003ffffffff <- ( 0000 , fffffffff ) + +[16,33]: + int 00001ffffffff <- ( 0000 , fffffffff ) + +[16,32]: + int 00000ffffffff <- ( 0000 , ffffffff ) + +[16,31]: + int 00007fffffff <- ( 0000 , ffffffff ) + +[16,30]: + int 00003fffffff <- ( 0000 , ffffffff ) + +[16,29]: + int 00001fffffff <- ( 0000 , ffffffff ) + +[16,28]: + int 00000fffffff <- ( 0000 , fffffff ) + +[16,27]: + int 00007ffffff <- ( 0000 , fffffff ) + +[16,26]: + int 00003ffffff <- ( 0000 , fffffff ) + +[16,25]: + int 00001ffffff <- ( 0000 , fffffff ) + +[16,24]: + int 00000ffffff <- ( 0000 , ffffff ) + +[16,23]: + int 00007fffff <- ( 0000 , ffffff ) + +[16,22]: + int 00003fffff <- ( 0000 , ffffff ) + +[16,21]: + int 00001fffff <- ( 0000 , ffffff ) + +[16,20]: + int 00000fffff <- ( 0000 , fffff ) + +[16,19]: + int 00007ffff <- ( 0000 , fffff ) + +[16,18]: + int 00003ffff <- ( 0000 , fffff ) + +[16,17]: + int 00001ffff <- ( 0000 , fffff ) + +[16,16]: + int 00000ffff <- ( 0000 , ffff ) + +[16,15]: + int 00007fff <- ( 0000 , ffff ) + +[16,14]: + int 00003fff <- ( 0000 , ffff ) + +[16,13]: + int 00001fff <- ( 0000 , ffff ) + +[16,12]: + int 00000fff <- ( 0000 , fff ) + +[16,11]: + int 00007ff <- ( 0000 , fff ) + +[16,10]: + int 00003ff <- ( 0000 , fff ) + +[16,9]: + int 00001ff <- ( 0000 , fff ) + +[16,8]: + int 00000ff <- ( 0000 , ff ) + +[16,7]: + int 00007f <- ( 0000 , ff ) + +[16,6]: + int 00003f <- ( 0000 , ff ) + +[16,5]: + int 00001f <- ( 0000 , ff ) + +[16,4]: + int 00000f <- ( 0000 , f ) + +[16,3]: + int 00007 <- ( 0000 , f ) + +[16,2]: + int 00003 <- ( 0000 , f ) + +[16,1]: + int 00001 <- ( 0000 , f ) + +[15,64]: + int 0000ffffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[15,63]: + int 00007fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[15,62]: + int 00003fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[15,61]: + int 00001fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[15,60]: + int 0000fffffffffffffff <- ( 0000 , fffffffffffffff ) + +[15,59]: + int 00007ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[15,58]: + int 00003ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[15,57]: + int 00001ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[15,56]: + int 0000ffffffffffffff <- ( 0000 , ffffffffffffff ) + +[15,55]: + int 00007fffffffffffff <- ( 0000 , ffffffffffffff ) + +[15,54]: + int 00003fffffffffffff <- ( 0000 , ffffffffffffff ) + +[15,53]: + int 00001fffffffffffff <- ( 0000 , ffffffffffffff ) + +[15,52]: + int 0000fffffffffffff <- ( 0000 , fffffffffffff ) + +[15,51]: + int 00007ffffffffffff <- ( 0000 , fffffffffffff ) + +[15,50]: + int 00003ffffffffffff <- ( 0000 , fffffffffffff ) + +[15,49]: + int 00001ffffffffffff <- ( 0000 , fffffffffffff ) + +[15,48]: + int 0000ffffffffffff <- ( 0000 , ffffffffffff ) + +[15,47]: + int 00007fffffffffff <- ( 0000 , ffffffffffff ) + +[15,46]: + int 00003fffffffffff <- ( 0000 , ffffffffffff ) + +[15,45]: + int 00001fffffffffff <- ( 0000 , ffffffffffff ) + +[15,44]: + int 0000fffffffffff <- ( 0000 , fffffffffff ) + +[15,43]: + int 00007ffffffffff <- ( 0000 , fffffffffff ) + +[15,42]: + int 00003ffffffffff <- ( 0000 , fffffffffff ) + +[15,41]: + int 00001ffffffffff <- ( 0000 , fffffffffff ) + +[15,40]: + int 0000ffffffffff <- ( 0000 , ffffffffff ) + +[15,39]: + int 00007fffffffff <- ( 0000 , ffffffffff ) + +[15,38]: + int 00003fffffffff <- ( 0000 , ffffffffff ) + +[15,37]: + int 00001fffffffff <- ( 0000 , ffffffffff ) + +[15,36]: + int 0000fffffffff <- ( 0000 , fffffffff ) + +[15,35]: + int 00007ffffffff <- ( 0000 , fffffffff ) + +[15,34]: + int 00003ffffffff <- ( 0000 , fffffffff ) + +[15,33]: + int 00001ffffffff <- ( 0000 , fffffffff ) + +[15,32]: + int 0000ffffffff <- ( 0000 , ffffffff ) + +[15,31]: + int 00007fffffff <- ( 0000 , ffffffff ) + +[15,30]: + int 00003fffffff <- ( 0000 , ffffffff ) + +[15,29]: + int 00001fffffff <- ( 0000 , ffffffff ) + +[15,28]: + int 0000fffffff <- ( 0000 , fffffff ) + +[15,27]: + int 00007ffffff <- ( 0000 , fffffff ) + +[15,26]: + int 00003ffffff <- ( 0000 , fffffff ) + +[15,25]: + int 00001ffffff <- ( 0000 , fffffff ) + +[15,24]: + int 0000ffffff <- ( 0000 , ffffff ) + +[15,23]: + int 00007fffff <- ( 0000 , ffffff ) + +[15,22]: + int 00003fffff <- ( 0000 , ffffff ) + +[15,21]: + int 00001fffff <- ( 0000 , ffffff ) + +[15,20]: + int 0000fffff <- ( 0000 , fffff ) + +[15,19]: + int 00007ffff <- ( 0000 , fffff ) + +[15,18]: + int 00003ffff <- ( 0000 , fffff ) + +[15,17]: + int 00001ffff <- ( 0000 , fffff ) + +[15,16]: + int 0000ffff <- ( 0000 , ffff ) + +[15,15]: + int 00007fff <- ( 0000 , ffff ) + +[15,14]: + int 00003fff <- ( 0000 , ffff ) + +[15,13]: + int 00001fff <- ( 0000 , ffff ) + +[15,12]: + int 0000fff <- ( 0000 , fff ) + +[15,11]: + int 00007ff <- ( 0000 , fff ) + +[15,10]: + int 00003ff <- ( 0000 , fff ) + +[15,9]: + int 00001ff <- ( 0000 , fff ) + +[15,8]: + int 0000ff <- ( 0000 , ff ) + +[15,7]: + int 00007f <- ( 0000 , ff ) + +[15,6]: + int 00003f <- ( 0000 , ff ) + +[15,5]: + int 00001f <- ( 0000 , ff ) + +[15,4]: + int 0000f <- ( 0000 , f ) + +[15,3]: + int 00007 <- ( 0000 , f ) + +[15,2]: + int 00003 <- ( 0000 , f ) + +[15,1]: + int 00001 <- ( 0000 , f ) + +[14,64]: + int 0000ffffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[14,63]: + int 00007fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[14,62]: + int 00003fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[14,61]: + int 0001fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[14,60]: + int 0000fffffffffffffff <- ( 0000 , fffffffffffffff ) + +[14,59]: + int 00007ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[14,58]: + int 00003ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[14,57]: + int 0001ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[14,56]: + int 0000ffffffffffffff <- ( 0000 , ffffffffffffff ) + +[14,55]: + int 00007fffffffffffff <- ( 0000 , ffffffffffffff ) + +[14,54]: + int 00003fffffffffffff <- ( 0000 , ffffffffffffff ) + +[14,53]: + int 0001fffffffffffff <- ( 0000 , ffffffffffffff ) + +[14,52]: + int 0000fffffffffffff <- ( 0000 , fffffffffffff ) + +[14,51]: + int 00007ffffffffffff <- ( 0000 , fffffffffffff ) + +[14,50]: + int 00003ffffffffffff <- ( 0000 , fffffffffffff ) + +[14,49]: + int 0001ffffffffffff <- ( 0000 , fffffffffffff ) + +[14,48]: + int 0000ffffffffffff <- ( 0000 , ffffffffffff ) + +[14,47]: + int 00007fffffffffff <- ( 0000 , ffffffffffff ) + +[14,46]: + int 00003fffffffffff <- ( 0000 , ffffffffffff ) + +[14,45]: + int 0001fffffffffff <- ( 0000 , ffffffffffff ) + +[14,44]: + int 0000fffffffffff <- ( 0000 , fffffffffff ) + +[14,43]: + int 00007ffffffffff <- ( 0000 , fffffffffff ) + +[14,42]: + int 00003ffffffffff <- ( 0000 , fffffffffff ) + +[14,41]: + int 0001ffffffffff <- ( 0000 , fffffffffff ) + +[14,40]: + int 0000ffffffffff <- ( 0000 , ffffffffff ) + +[14,39]: + int 00007fffffffff <- ( 0000 , ffffffffff ) + +[14,38]: + int 00003fffffffff <- ( 0000 , ffffffffff ) + +[14,37]: + int 0001fffffffff <- ( 0000 , ffffffffff ) + +[14,36]: + int 0000fffffffff <- ( 0000 , fffffffff ) + +[14,35]: + int 00007ffffffff <- ( 0000 , fffffffff ) + +[14,34]: + int 00003ffffffff <- ( 0000 , fffffffff ) + +[14,33]: + int 0001ffffffff <- ( 0000 , fffffffff ) + +[14,32]: + int 0000ffffffff <- ( 0000 , ffffffff ) + +[14,31]: + int 00007fffffff <- ( 0000 , ffffffff ) + +[14,30]: + int 00003fffffff <- ( 0000 , ffffffff ) + +[14,29]: + int 0001fffffff <- ( 0000 , ffffffff ) + +[14,28]: + int 0000fffffff <- ( 0000 , fffffff ) + +[14,27]: + int 00007ffffff <- ( 0000 , fffffff ) + +[14,26]: + int 00003ffffff <- ( 0000 , fffffff ) + +[14,25]: + int 0001ffffff <- ( 0000 , fffffff ) + +[14,24]: + int 0000ffffff <- ( 0000 , ffffff ) + +[14,23]: + int 00007fffff <- ( 0000 , ffffff ) + +[14,22]: + int 00003fffff <- ( 0000 , ffffff ) + +[14,21]: + int 0001fffff <- ( 0000 , ffffff ) + +[14,20]: + int 0000fffff <- ( 0000 , fffff ) + +[14,19]: + int 00007ffff <- ( 0000 , fffff ) + +[14,18]: + int 00003ffff <- ( 0000 , fffff ) + +[14,17]: + int 0001ffff <- ( 0000 , fffff ) + +[14,16]: + int 0000ffff <- ( 0000 , ffff ) + +[14,15]: + int 00007fff <- ( 0000 , ffff ) + +[14,14]: + int 00003fff <- ( 0000 , ffff ) + +[14,13]: + int 0001fff <- ( 0000 , ffff ) + +[14,12]: + int 0000fff <- ( 0000 , fff ) + +[14,11]: + int 00007ff <- ( 0000 , fff ) + +[14,10]: + int 00003ff <- ( 0000 , fff ) + +[14,9]: + int 0001ff <- ( 0000 , fff ) + +[14,8]: + int 0000ff <- ( 0000 , ff ) + +[14,7]: + int 00007f <- ( 0000 , ff ) + +[14,6]: + int 00003f <- ( 0000 , ff ) + +[14,5]: + int 0001f <- ( 0000 , ff ) + +[14,4]: + int 0000f <- ( 0000 , f ) + +[14,3]: + int 00007 <- ( 0000 , f ) + +[14,2]: + int 00003 <- ( 0000 , f ) + +[14,1]: + int 0001 <- ( 0000 , f ) + +[13,64]: + int 0000ffffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[13,63]: + int 00007fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[13,62]: + int 0003fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[13,61]: + int 0001fffffffffffffff <- ( 0000 , ffffffffffffffff ) + +[13,60]: + int 0000fffffffffffffff <- ( 0000 , fffffffffffffff ) + +[13,59]: + int 00007ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[13,58]: + int 0003ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[13,57]: + int 0001ffffffffffffff <- ( 0000 , fffffffffffffff ) + +[13,56]: + int 0000ffffffffffffff <- ( 0000 , ffffffffffffff ) + +[13,55]: + int 00007fffffffffffff <- ( 0000 , ffffffffffffff ) + +[13,54]: + int 0003fffffffffffff <- ( 0000 , ffffffffffffff ) + +[13,53]: + int 0001fffffffffffff <- ( 0000 , ffffffffffffff ) + +[13,52]: + int 0000fffffffffffff <- ( 0000 , fffffffffffff ) + +[13,51]: + int 00007ffffffffffff <- ( 0000 , fffffffffffff ) + +[13,50]: + int 0003ffffffffffff <- ( 0000 , fffffffffffff ) + +[13,49]: + int 0001ffffffffffff <- ( 0000 , fffffffffffff ) + +[13,48]: + int 0000ffffffffffff <- ( 0000 , ffffffffffff ) + +[13,47]: + int 00007fffffffffff <- ( 0000 , ffffffffffff ) + +[13,46]: + int 0003fffffffffff <- ( 0000 , ffffffffffff ) + +[13,45]: + int 0001fffffffffff <- ( 0000 , ffffffffffff ) + +[13,44]: + int 0000fffffffffff <- ( 0000 , fffffffffff ) + +[13,43]: + int 00007ffffffffff <- ( 0000 , fffffffffff ) + +[13,42]: + int 0003ffffffffff <- ( 0000 , fffffffffff ) + +[13,41]: + int 0001ffffffffff <- ( 0000 , fffffffffff ) + +[13,40]: + int 0000ffffffffff <- ( 0000 , ffffffffff ) + +[13,39]: + int 00007fffffffff <- ( 0000 , ffffffffff ) + +[13,38]: + int 0003fffffffff <- ( 0000 , ffffffffff ) + +[13,37]: + int 0001fffffffff <- ( 0000 , ffffffffff ) + +[13,36]: + int 0000fffffffff <- ( 0000 , fffffffff ) + +[13,35]: + int 00007ffffffff <- ( 0000 , fffffffff ) + +[13,34]: + int 0003ffffffff <- ( 0000 , fffffffff ) + +[13,33]: + int 0001ffffffff <- ( 0000 , fffffffff ) + +[13,32]: + int 0000ffffffff <- ( 0000 , ffffffff ) + +[13,31]: + int 00007fffffff <- ( 0000 , ffffffff ) + +[13,30]: + int 0003fffffff <- ( 0000 , ffffffff ) + +[13,29]: + int 0001fffffff <- ( 0000 , ffffffff ) + +[13,28]: + int 0000fffffff <- ( 0000 , fffffff ) + +[13,27]: + int 00007ffffff <- ( 0000 , fffffff ) + +[13,26]: + int 0003ffffff <- ( 0000 , fffffff ) + +[13,25]: + int 0001ffffff <- ( 0000 , fffffff ) + +[13,24]: + int 0000ffffff <- ( 0000 , ffffff ) + +[13,23]: + int 00007fffff <- ( 0000 , ffffff ) + +[13,22]: + int 0003fffff <- ( 0000 , ffffff ) + +[13,21]: + int 0001fffff <- ( 0000 , ffffff ) + +[13,20]: + int 0000fffff <- ( 0000 , fffff ) + +[13,19]: + int 00007ffff <- ( 0000 , fffff ) + +[13,18]: + int 0003ffff <- ( 0000 , fffff ) + +[13,17]: + int 0001ffff <- ( 0000 , fffff ) + +[13,16]: + int 0000ffff <- ( 0000 , ffff ) + +[13,15]: + int 00007fff <- ( 0000 , ffff ) + +[13,14]: + int 0003fff <- ( 0000 , ffff ) + +[13,13]: + int 0001fff <- ( 0000 , ffff ) + +[13,12]: + int 0000fff <- ( 0000 , fff ) + +[13,11]: + int 00007ff <- ( 0000 , fff ) + +[13,10]: + int 0003ff <- ( 0000 , fff ) + +[13,9]: + int 0001ff <- ( 0000 , fff ) + +[13,8]: + int 0000ff <- ( 0000 , ff ) + +[13,7]: + int 00007f <- ( 0000 , ff ) + +[13,6]: + int 0003f <- ( 0000 , ff ) + +[13,5]: + int 0001f <- ( 0000 , ff ) + +[13,4]: + int 0000f <- ( 0000 , f ) + +[13,3]: + int 00007 <- ( 0000 , f ) + +[13,2]: + int 0003 <- ( 0000 , f ) + +[13,1]: + int 0001 <- ( 0000 , f ) + +[12,64]: + int 0000ffffffffffffffff <- ( 000 , ffffffffffffffff ) + +[12,63]: + int 0007fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[12,62]: + int 0003fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[12,61]: + int 0001fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[12,60]: + int 0000fffffffffffffff <- ( 000 , fffffffffffffff ) + +[12,59]: + int 0007ffffffffffffff <- ( 000 , fffffffffffffff ) + +[12,58]: + int 0003ffffffffffffff <- ( 000 , fffffffffffffff ) + +[12,57]: + int 0001ffffffffffffff <- ( 000 , fffffffffffffff ) + +[12,56]: + int 0000ffffffffffffff <- ( 000 , ffffffffffffff ) + +[12,55]: + int 0007fffffffffffff <- ( 000 , ffffffffffffff ) + +[12,54]: + int 0003fffffffffffff <- ( 000 , ffffffffffffff ) + +[12,53]: + int 0001fffffffffffff <- ( 000 , ffffffffffffff ) + +[12,52]: + int 0000fffffffffffff <- ( 000 , fffffffffffff ) + +[12,51]: + int 0007ffffffffffff <- ( 000 , fffffffffffff ) + +[12,50]: + int 0003ffffffffffff <- ( 000 , fffffffffffff ) + +[12,49]: + int 0001ffffffffffff <- ( 000 , fffffffffffff ) + +[12,48]: + int 0000ffffffffffff <- ( 000 , ffffffffffff ) + +[12,47]: + int 0007fffffffffff <- ( 000 , ffffffffffff ) + +[12,46]: + int 0003fffffffffff <- ( 000 , ffffffffffff ) + +[12,45]: + int 0001fffffffffff <- ( 000 , ffffffffffff ) + +[12,44]: + int 0000fffffffffff <- ( 000 , fffffffffff ) + +[12,43]: + int 0007ffffffffff <- ( 000 , fffffffffff ) + +[12,42]: + int 0003ffffffffff <- ( 000 , fffffffffff ) + +[12,41]: + int 0001ffffffffff <- ( 000 , fffffffffff ) + +[12,40]: + int 0000ffffffffff <- ( 000 , ffffffffff ) + +[12,39]: + int 0007fffffffff <- ( 000 , ffffffffff ) + +[12,38]: + int 0003fffffffff <- ( 000 , ffffffffff ) + +[12,37]: + int 0001fffffffff <- ( 000 , ffffffffff ) + +[12,36]: + int 0000fffffffff <- ( 000 , fffffffff ) + +[12,35]: + int 0007ffffffff <- ( 000 , fffffffff ) + +[12,34]: + int 0003ffffffff <- ( 000 , fffffffff ) + +[12,33]: + int 0001ffffffff <- ( 000 , fffffffff ) + +[12,32]: + int 0000ffffffff <- ( 000 , ffffffff ) + +[12,31]: + int 0007fffffff <- ( 000 , ffffffff ) + +[12,30]: + int 0003fffffff <- ( 000 , ffffffff ) + +[12,29]: + int 0001fffffff <- ( 000 , ffffffff ) + +[12,28]: + int 0000fffffff <- ( 000 , fffffff ) + +[12,27]: + int 0007ffffff <- ( 000 , fffffff ) + +[12,26]: + int 0003ffffff <- ( 000 , fffffff ) + +[12,25]: + int 0001ffffff <- ( 000 , fffffff ) + +[12,24]: + int 0000ffffff <- ( 000 , ffffff ) + +[12,23]: + int 0007fffff <- ( 000 , ffffff ) + +[12,22]: + int 0003fffff <- ( 000 , ffffff ) + +[12,21]: + int 0001fffff <- ( 000 , ffffff ) + +[12,20]: + int 0000fffff <- ( 000 , fffff ) + +[12,19]: + int 0007ffff <- ( 000 , fffff ) + +[12,18]: + int 0003ffff <- ( 000 , fffff ) + +[12,17]: + int 0001ffff <- ( 000 , fffff ) + +[12,16]: + int 0000ffff <- ( 000 , ffff ) + +[12,15]: + int 0007fff <- ( 000 , ffff ) + +[12,14]: + int 0003fff <- ( 000 , ffff ) + +[12,13]: + int 0001fff <- ( 000 , ffff ) + +[12,12]: + int 0000fff <- ( 000 , fff ) + +[12,11]: + int 0007ff <- ( 000 , fff ) + +[12,10]: + int 0003ff <- ( 000 , fff ) + +[12,9]: + int 0001ff <- ( 000 , fff ) + +[12,8]: + int 0000ff <- ( 000 , ff ) + +[12,7]: + int 0007f <- ( 000 , ff ) + +[12,6]: + int 0003f <- ( 000 , ff ) + +[12,5]: + int 0001f <- ( 000 , ff ) + +[12,4]: + int 0000f <- ( 000 , f ) + +[12,3]: + int 0007 <- ( 000 , f ) + +[12,2]: + int 0003 <- ( 000 , f ) + +[12,1]: + int 0001 <- ( 000 , f ) + +[11,64]: + int 000ffffffffffffffff <- ( 000 , ffffffffffffffff ) + +[11,63]: + int 0007fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[11,62]: + int 0003fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[11,61]: + int 0001fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[11,60]: + int 000fffffffffffffff <- ( 000 , fffffffffffffff ) + +[11,59]: + int 0007ffffffffffffff <- ( 000 , fffffffffffffff ) + +[11,58]: + int 0003ffffffffffffff <- ( 000 , fffffffffffffff ) + +[11,57]: + int 0001ffffffffffffff <- ( 000 , fffffffffffffff ) + +[11,56]: + int 000ffffffffffffff <- ( 000 , ffffffffffffff ) + +[11,55]: + int 0007fffffffffffff <- ( 000 , ffffffffffffff ) + +[11,54]: + int 0003fffffffffffff <- ( 000 , ffffffffffffff ) + +[11,53]: + int 0001fffffffffffff <- ( 000 , ffffffffffffff ) + +[11,52]: + int 000fffffffffffff <- ( 000 , fffffffffffff ) + +[11,51]: + int 0007ffffffffffff <- ( 000 , fffffffffffff ) + +[11,50]: + int 0003ffffffffffff <- ( 000 , fffffffffffff ) + +[11,49]: + int 0001ffffffffffff <- ( 000 , fffffffffffff ) + +[11,48]: + int 000ffffffffffff <- ( 000 , ffffffffffff ) + +[11,47]: + int 0007fffffffffff <- ( 000 , ffffffffffff ) + +[11,46]: + int 0003fffffffffff <- ( 000 , ffffffffffff ) + +[11,45]: + int 0001fffffffffff <- ( 000 , ffffffffffff ) + +[11,44]: + int 000fffffffffff <- ( 000 , fffffffffff ) + +[11,43]: + int 0007ffffffffff <- ( 000 , fffffffffff ) + +[11,42]: + int 0003ffffffffff <- ( 000 , fffffffffff ) + +[11,41]: + int 0001ffffffffff <- ( 000 , fffffffffff ) + +[11,40]: + int 000ffffffffff <- ( 000 , ffffffffff ) + +[11,39]: + int 0007fffffffff <- ( 000 , ffffffffff ) + +[11,38]: + int 0003fffffffff <- ( 000 , ffffffffff ) + +[11,37]: + int 0001fffffffff <- ( 000 , ffffffffff ) + +[11,36]: + int 000fffffffff <- ( 000 , fffffffff ) + +[11,35]: + int 0007ffffffff <- ( 000 , fffffffff ) + +[11,34]: + int 0003ffffffff <- ( 000 , fffffffff ) + +[11,33]: + int 0001ffffffff <- ( 000 , fffffffff ) + +[11,32]: + int 000ffffffff <- ( 000 , ffffffff ) + +[11,31]: + int 0007fffffff <- ( 000 , ffffffff ) + +[11,30]: + int 0003fffffff <- ( 000 , ffffffff ) + +[11,29]: + int 0001fffffff <- ( 000 , ffffffff ) + +[11,28]: + int 000fffffff <- ( 000 , fffffff ) + +[11,27]: + int 0007ffffff <- ( 000 , fffffff ) + +[11,26]: + int 0003ffffff <- ( 000 , fffffff ) + +[11,25]: + int 0001ffffff <- ( 000 , fffffff ) + +[11,24]: + int 000ffffff <- ( 000 , ffffff ) + +[11,23]: + int 0007fffff <- ( 000 , ffffff ) + +[11,22]: + int 0003fffff <- ( 000 , ffffff ) + +[11,21]: + int 0001fffff <- ( 000 , ffffff ) + +[11,20]: + int 000fffff <- ( 000 , fffff ) + +[11,19]: + int 0007ffff <- ( 000 , fffff ) + +[11,18]: + int 0003ffff <- ( 000 , fffff ) + +[11,17]: + int 0001ffff <- ( 000 , fffff ) + +[11,16]: + int 000ffff <- ( 000 , ffff ) + +[11,15]: + int 0007fff <- ( 000 , ffff ) + +[11,14]: + int 0003fff <- ( 000 , ffff ) + +[11,13]: + int 0001fff <- ( 000 , ffff ) + +[11,12]: + int 000fff <- ( 000 , fff ) + +[11,11]: + int 0007ff <- ( 000 , fff ) + +[11,10]: + int 0003ff <- ( 000 , fff ) + +[11,9]: + int 0001ff <- ( 000 , fff ) + +[11,8]: + int 000ff <- ( 000 , ff ) + +[11,7]: + int 0007f <- ( 000 , ff ) + +[11,6]: + int 0003f <- ( 000 , ff ) + +[11,5]: + int 0001f <- ( 000 , ff ) + +[11,4]: + int 000f <- ( 000 , f ) + +[11,3]: + int 0007 <- ( 000 , f ) + +[11,2]: + int 0003 <- ( 000 , f ) + +[11,1]: + int 0001 <- ( 000 , f ) + +[10,64]: + int 000ffffffffffffffff <- ( 000 , ffffffffffffffff ) + +[10,63]: + int 0007fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[10,62]: + int 0003fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[10,61]: + int 001fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[10,60]: + int 000fffffffffffffff <- ( 000 , fffffffffffffff ) + +[10,59]: + int 0007ffffffffffffff <- ( 000 , fffffffffffffff ) + +[10,58]: + int 0003ffffffffffffff <- ( 000 , fffffffffffffff ) + +[10,57]: + int 001ffffffffffffff <- ( 000 , fffffffffffffff ) + +[10,56]: + int 000ffffffffffffff <- ( 000 , ffffffffffffff ) + +[10,55]: + int 0007fffffffffffff <- ( 000 , ffffffffffffff ) + +[10,54]: + int 0003fffffffffffff <- ( 000 , ffffffffffffff ) + +[10,53]: + int 001fffffffffffff <- ( 000 , ffffffffffffff ) + +[10,52]: + int 000fffffffffffff <- ( 000 , fffffffffffff ) + +[10,51]: + int 0007ffffffffffff <- ( 000 , fffffffffffff ) + +[10,50]: + int 0003ffffffffffff <- ( 000 , fffffffffffff ) + +[10,49]: + int 001ffffffffffff <- ( 000 , fffffffffffff ) + +[10,48]: + int 000ffffffffffff <- ( 000 , ffffffffffff ) + +[10,47]: + int 0007fffffffffff <- ( 000 , ffffffffffff ) + +[10,46]: + int 0003fffffffffff <- ( 000 , ffffffffffff ) + +[10,45]: + int 001fffffffffff <- ( 000 , ffffffffffff ) + +[10,44]: + int 000fffffffffff <- ( 000 , fffffffffff ) + +[10,43]: + int 0007ffffffffff <- ( 000 , fffffffffff ) + +[10,42]: + int 0003ffffffffff <- ( 000 , fffffffffff ) + +[10,41]: + int 001ffffffffff <- ( 000 , fffffffffff ) + +[10,40]: + int 000ffffffffff <- ( 000 , ffffffffff ) + +[10,39]: + int 0007fffffffff <- ( 000 , ffffffffff ) + +[10,38]: + int 0003fffffffff <- ( 000 , ffffffffff ) + +[10,37]: + int 001fffffffff <- ( 000 , ffffffffff ) + +[10,36]: + int 000fffffffff <- ( 000 , fffffffff ) + +[10,35]: + int 0007ffffffff <- ( 000 , fffffffff ) + +[10,34]: + int 0003ffffffff <- ( 000 , fffffffff ) + +[10,33]: + int 001ffffffff <- ( 000 , fffffffff ) + +[10,32]: + int 000ffffffff <- ( 000 , ffffffff ) + +[10,31]: + int 0007fffffff <- ( 000 , ffffffff ) + +[10,30]: + int 0003fffffff <- ( 000 , ffffffff ) + +[10,29]: + int 001fffffff <- ( 000 , ffffffff ) + +[10,28]: + int 000fffffff <- ( 000 , fffffff ) + +[10,27]: + int 0007ffffff <- ( 000 , fffffff ) + +[10,26]: + int 0003ffffff <- ( 000 , fffffff ) + +[10,25]: + int 001ffffff <- ( 000 , fffffff ) + +[10,24]: + int 000ffffff <- ( 000 , ffffff ) + +[10,23]: + int 0007fffff <- ( 000 , ffffff ) + +[10,22]: + int 0003fffff <- ( 000 , ffffff ) + +[10,21]: + int 001fffff <- ( 000 , ffffff ) + +[10,20]: + int 000fffff <- ( 000 , fffff ) + +[10,19]: + int 0007ffff <- ( 000 , fffff ) + +[10,18]: + int 0003ffff <- ( 000 , fffff ) + +[10,17]: + int 001ffff <- ( 000 , fffff ) + +[10,16]: + int 000ffff <- ( 000 , ffff ) + +[10,15]: + int 0007fff <- ( 000 , ffff ) + +[10,14]: + int 0003fff <- ( 000 , ffff ) + +[10,13]: + int 001fff <- ( 000 , ffff ) + +[10,12]: + int 000fff <- ( 000 , fff ) + +[10,11]: + int 0007ff <- ( 000 , fff ) + +[10,10]: + int 0003ff <- ( 000 , fff ) + +[10,9]: + int 001ff <- ( 000 , fff ) + +[10,8]: + int 000ff <- ( 000 , ff ) + +[10,7]: + int 0007f <- ( 000 , ff ) + +[10,6]: + int 0003f <- ( 000 , ff ) + +[10,5]: + int 001f <- ( 000 , ff ) + +[10,4]: + int 000f <- ( 000 , f ) + +[10,3]: + int 0007 <- ( 000 , f ) + +[10,2]: + int 0003 <- ( 000 , f ) + +[10,1]: + int 001 <- ( 000 , f ) + +[9,64]: + int 000ffffffffffffffff <- ( 000 , ffffffffffffffff ) + +[9,63]: + int 0007fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[9,62]: + int 003fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[9,61]: + int 001fffffffffffffff <- ( 000 , ffffffffffffffff ) + +[9,60]: + int 000fffffffffffffff <- ( 000 , fffffffffffffff ) + +[9,59]: + int 0007ffffffffffffff <- ( 000 , fffffffffffffff ) + +[9,58]: + int 003ffffffffffffff <- ( 000 , fffffffffffffff ) + +[9,57]: + int 001ffffffffffffff <- ( 000 , fffffffffffffff ) + +[9,56]: + int 000ffffffffffffff <- ( 000 , ffffffffffffff ) + +[9,55]: + int 0007fffffffffffff <- ( 000 , ffffffffffffff ) + +[9,54]: + int 003fffffffffffff <- ( 000 , ffffffffffffff ) + +[9,53]: + int 001fffffffffffff <- ( 000 , ffffffffffffff ) + +[9,52]: + int 000fffffffffffff <- ( 000 , fffffffffffff ) + +[9,51]: + int 0007ffffffffffff <- ( 000 , fffffffffffff ) + +[9,50]: + int 003ffffffffffff <- ( 000 , fffffffffffff ) + +[9,49]: + int 001ffffffffffff <- ( 000 , fffffffffffff ) + +[9,48]: + int 000ffffffffffff <- ( 000 , ffffffffffff ) + +[9,47]: + int 0007fffffffffff <- ( 000 , ffffffffffff ) + +[9,46]: + int 003fffffffffff <- ( 000 , ffffffffffff ) + +[9,45]: + int 001fffffffffff <- ( 000 , ffffffffffff ) + +[9,44]: + int 000fffffffffff <- ( 000 , fffffffffff ) + +[9,43]: + int 0007ffffffffff <- ( 000 , fffffffffff ) + +[9,42]: + int 003ffffffffff <- ( 000 , fffffffffff ) + +[9,41]: + int 001ffffffffff <- ( 000 , fffffffffff ) + +[9,40]: + int 000ffffffffff <- ( 000 , ffffffffff ) + +[9,39]: + int 0007fffffffff <- ( 000 , ffffffffff ) + +[9,38]: + int 003fffffffff <- ( 000 , ffffffffff ) + +[9,37]: + int 001fffffffff <- ( 000 , ffffffffff ) + +[9,36]: + int 000fffffffff <- ( 000 , fffffffff ) + +[9,35]: + int 0007ffffffff <- ( 000 , fffffffff ) + +[9,34]: + int 003ffffffff <- ( 000 , fffffffff ) + +[9,33]: + int 001ffffffff <- ( 000 , fffffffff ) + +[9,32]: + int 000ffffffff <- ( 000 , ffffffff ) + +[9,31]: + int 0007fffffff <- ( 000 , ffffffff ) + +[9,30]: + int 003fffffff <- ( 000 , ffffffff ) + +[9,29]: + int 001fffffff <- ( 000 , ffffffff ) + +[9,28]: + int 000fffffff <- ( 000 , fffffff ) + +[9,27]: + int 0007ffffff <- ( 000 , fffffff ) + +[9,26]: + int 003ffffff <- ( 000 , fffffff ) + +[9,25]: + int 001ffffff <- ( 000 , fffffff ) + +[9,24]: + int 000ffffff <- ( 000 , ffffff ) + +[9,23]: + int 0007fffff <- ( 000 , ffffff ) + +[9,22]: + int 003fffff <- ( 000 , ffffff ) + +[9,21]: + int 001fffff <- ( 000 , ffffff ) + +[9,20]: + int 000fffff <- ( 000 , fffff ) + +[9,19]: + int 0007ffff <- ( 000 , fffff ) + +[9,18]: + int 003ffff <- ( 000 , fffff ) + +[9,17]: + int 001ffff <- ( 000 , fffff ) + +[9,16]: + int 000ffff <- ( 000 , ffff ) + +[9,15]: + int 0007fff <- ( 000 , ffff ) + +[9,14]: + int 003fff <- ( 000 , ffff ) + +[9,13]: + int 001fff <- ( 000 , ffff ) + +[9,12]: + int 000fff <- ( 000 , fff ) + +[9,11]: + int 0007ff <- ( 000 , fff ) + +[9,10]: + int 003ff <- ( 000 , fff ) + +[9,9]: + int 001ff <- ( 000 , fff ) + +[9,8]: + int 000ff <- ( 000 , ff ) + +[9,7]: + int 0007f <- ( 000 , ff ) + +[9,6]: + int 003f <- ( 000 , ff ) + +[9,5]: + int 001f <- ( 000 , ff ) + +[9,4]: + int 000f <- ( 000 , f ) + +[9,3]: + int 0007 <- ( 000 , f ) + +[9,2]: + int 003 <- ( 000 , f ) + +[9,1]: + int 001 <- ( 000 , f ) + +[8,64]: + int 000ffffffffffffffff <- ( 00 , ffffffffffffffff ) + +[8,63]: + int 007fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[8,62]: + int 003fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[8,61]: + int 001fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[8,60]: + int 000fffffffffffffff <- ( 00 , fffffffffffffff ) + +[8,59]: + int 007ffffffffffffff <- ( 00 , fffffffffffffff ) + +[8,58]: + int 003ffffffffffffff <- ( 00 , fffffffffffffff ) + +[8,57]: + int 001ffffffffffffff <- ( 00 , fffffffffffffff ) + +[8,56]: + int 000ffffffffffffff <- ( 00 , ffffffffffffff ) + +[8,55]: + int 007fffffffffffff <- ( 00 , ffffffffffffff ) + +[8,54]: + int 003fffffffffffff <- ( 00 , ffffffffffffff ) + +[8,53]: + int 001fffffffffffff <- ( 00 , ffffffffffffff ) + +[8,52]: + int 000fffffffffffff <- ( 00 , fffffffffffff ) + +[8,51]: + int 007ffffffffffff <- ( 00 , fffffffffffff ) + +[8,50]: + int 003ffffffffffff <- ( 00 , fffffffffffff ) + +[8,49]: + int 001ffffffffffff <- ( 00 , fffffffffffff ) + +[8,48]: + int 000ffffffffffff <- ( 00 , ffffffffffff ) + +[8,47]: + int 007fffffffffff <- ( 00 , ffffffffffff ) + +[8,46]: + int 003fffffffffff <- ( 00 , ffffffffffff ) + +[8,45]: + int 001fffffffffff <- ( 00 , ffffffffffff ) + +[8,44]: + int 000fffffffffff <- ( 00 , fffffffffff ) + +[8,43]: + int 007ffffffffff <- ( 00 , fffffffffff ) + +[8,42]: + int 003ffffffffff <- ( 00 , fffffffffff ) + +[8,41]: + int 001ffffffffff <- ( 00 , fffffffffff ) + +[8,40]: + int 000ffffffffff <- ( 00 , ffffffffff ) + +[8,39]: + int 007fffffffff <- ( 00 , ffffffffff ) + +[8,38]: + int 003fffffffff <- ( 00 , ffffffffff ) + +[8,37]: + int 001fffffffff <- ( 00 , ffffffffff ) + +[8,36]: + int 000fffffffff <- ( 00 , fffffffff ) + +[8,35]: + int 007ffffffff <- ( 00 , fffffffff ) + +[8,34]: + int 003ffffffff <- ( 00 , fffffffff ) + +[8,33]: + int 001ffffffff <- ( 00 , fffffffff ) + +[8,32]: + int 000ffffffff <- ( 00 , ffffffff ) + +[8,31]: + int 007fffffff <- ( 00 , ffffffff ) + +[8,30]: + int 003fffffff <- ( 00 , ffffffff ) + +[8,29]: + int 001fffffff <- ( 00 , ffffffff ) + +[8,28]: + int 000fffffff <- ( 00 , fffffff ) + +[8,27]: + int 007ffffff <- ( 00 , fffffff ) + +[8,26]: + int 003ffffff <- ( 00 , fffffff ) + +[8,25]: + int 001ffffff <- ( 00 , fffffff ) + +[8,24]: + int 000ffffff <- ( 00 , ffffff ) + +[8,23]: + int 007fffff <- ( 00 , ffffff ) + +[8,22]: + int 003fffff <- ( 00 , ffffff ) + +[8,21]: + int 001fffff <- ( 00 , ffffff ) + +[8,20]: + int 000fffff <- ( 00 , fffff ) + +[8,19]: + int 007ffff <- ( 00 , fffff ) + +[8,18]: + int 003ffff <- ( 00 , fffff ) + +[8,17]: + int 001ffff <- ( 00 , fffff ) + +[8,16]: + int 000ffff <- ( 00 , ffff ) + +[8,15]: + int 007fff <- ( 00 , ffff ) + +[8,14]: + int 003fff <- ( 00 , ffff ) + +[8,13]: + int 001fff <- ( 00 , ffff ) + +[8,12]: + int 000fff <- ( 00 , fff ) + +[8,11]: + int 007ff <- ( 00 , fff ) + +[8,10]: + int 003ff <- ( 00 , fff ) + +[8,9]: + int 001ff <- ( 00 , fff ) + +[8,8]: + int 000ff <- ( 00 , ff ) + +[8,7]: + int 007f <- ( 00 , ff ) + +[8,6]: + int 003f <- ( 00 , ff ) + +[8,5]: + int 001f <- ( 00 , ff ) + +[8,4]: + int 000f <- ( 00 , f ) + +[8,3]: + int 007 <- ( 00 , f ) + +[8,2]: + int 003 <- ( 00 , f ) + +[8,1]: + int 001 <- ( 00 , f ) + +[7,64]: + int 00ffffffffffffffff <- ( 00 , ffffffffffffffff ) + +[7,63]: + int 007fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[7,62]: + int 003fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[7,61]: + int 001fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[7,60]: + int 00fffffffffffffff <- ( 00 , fffffffffffffff ) + +[7,59]: + int 007ffffffffffffff <- ( 00 , fffffffffffffff ) + +[7,58]: + int 003ffffffffffffff <- ( 00 , fffffffffffffff ) + +[7,57]: + int 001ffffffffffffff <- ( 00 , fffffffffffffff ) + +[7,56]: + int 00ffffffffffffff <- ( 00 , ffffffffffffff ) + +[7,55]: + int 007fffffffffffff <- ( 00 , ffffffffffffff ) + +[7,54]: + int 003fffffffffffff <- ( 00 , ffffffffffffff ) + +[7,53]: + int 001fffffffffffff <- ( 00 , ffffffffffffff ) + +[7,52]: + int 00fffffffffffff <- ( 00 , fffffffffffff ) + +[7,51]: + int 007ffffffffffff <- ( 00 , fffffffffffff ) + +[7,50]: + int 003ffffffffffff <- ( 00 , fffffffffffff ) + +[7,49]: + int 001ffffffffffff <- ( 00 , fffffffffffff ) + +[7,48]: + int 00ffffffffffff <- ( 00 , ffffffffffff ) + +[7,47]: + int 007fffffffffff <- ( 00 , ffffffffffff ) + +[7,46]: + int 003fffffffffff <- ( 00 , ffffffffffff ) + +[7,45]: + int 001fffffffffff <- ( 00 , ffffffffffff ) + +[7,44]: + int 00fffffffffff <- ( 00 , fffffffffff ) + +[7,43]: + int 007ffffffffff <- ( 00 , fffffffffff ) + +[7,42]: + int 003ffffffffff <- ( 00 , fffffffffff ) + +[7,41]: + int 001ffffffffff <- ( 00 , fffffffffff ) + +[7,40]: + int 00ffffffffff <- ( 00 , ffffffffff ) + +[7,39]: + int 007fffffffff <- ( 00 , ffffffffff ) + +[7,38]: + int 003fffffffff <- ( 00 , ffffffffff ) + +[7,37]: + int 001fffffffff <- ( 00 , ffffffffff ) + +[7,36]: + int 00fffffffff <- ( 00 , fffffffff ) + +[7,35]: + int 007ffffffff <- ( 00 , fffffffff ) + +[7,34]: + int 003ffffffff <- ( 00 , fffffffff ) + +[7,33]: + int 001ffffffff <- ( 00 , fffffffff ) + +[7,32]: + int 00ffffffff <- ( 00 , ffffffff ) + +[7,31]: + int 007fffffff <- ( 00 , ffffffff ) + +[7,30]: + int 003fffffff <- ( 00 , ffffffff ) + +[7,29]: + int 001fffffff <- ( 00 , ffffffff ) + +[7,28]: + int 00fffffff <- ( 00 , fffffff ) + +[7,27]: + int 007ffffff <- ( 00 , fffffff ) + +[7,26]: + int 003ffffff <- ( 00 , fffffff ) + +[7,25]: + int 001ffffff <- ( 00 , fffffff ) + +[7,24]: + int 00ffffff <- ( 00 , ffffff ) + +[7,23]: + int 007fffff <- ( 00 , ffffff ) + +[7,22]: + int 003fffff <- ( 00 , ffffff ) + +[7,21]: + int 001fffff <- ( 00 , ffffff ) + +[7,20]: + int 00fffff <- ( 00 , fffff ) + +[7,19]: + int 007ffff <- ( 00 , fffff ) + +[7,18]: + int 003ffff <- ( 00 , fffff ) + +[7,17]: + int 001ffff <- ( 00 , fffff ) + +[7,16]: + int 00ffff <- ( 00 , ffff ) + +[7,15]: + int 007fff <- ( 00 , ffff ) + +[7,14]: + int 003fff <- ( 00 , ffff ) + +[7,13]: + int 001fff <- ( 00 , ffff ) + +[7,12]: + int 00fff <- ( 00 , fff ) + +[7,11]: + int 007ff <- ( 00 , fff ) + +[7,10]: + int 003ff <- ( 00 , fff ) + +[7,9]: + int 001ff <- ( 00 , fff ) + +[7,8]: + int 00ff <- ( 00 , ff ) + +[7,7]: + int 007f <- ( 00 , ff ) + +[7,6]: + int 003f <- ( 00 , ff ) + +[7,5]: + int 001f <- ( 00 , ff ) + +[7,4]: + int 00f <- ( 00 , f ) + +[7,3]: + int 007 <- ( 00 , f ) + +[7,2]: + int 003 <- ( 00 , f ) + +[7,1]: + int 001 <- ( 00 , f ) + +[6,64]: + int 00ffffffffffffffff <- ( 00 , ffffffffffffffff ) + +[6,63]: + int 007fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[6,62]: + int 003fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[6,61]: + int 01fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[6,60]: + int 00fffffffffffffff <- ( 00 , fffffffffffffff ) + +[6,59]: + int 007ffffffffffffff <- ( 00 , fffffffffffffff ) + +[6,58]: + int 003ffffffffffffff <- ( 00 , fffffffffffffff ) + +[6,57]: + int 01ffffffffffffff <- ( 00 , fffffffffffffff ) + +[6,56]: + int 00ffffffffffffff <- ( 00 , ffffffffffffff ) + +[6,55]: + int 007fffffffffffff <- ( 00 , ffffffffffffff ) + +[6,54]: + int 003fffffffffffff <- ( 00 , ffffffffffffff ) + +[6,53]: + int 01fffffffffffff <- ( 00 , ffffffffffffff ) + +[6,52]: + int 00fffffffffffff <- ( 00 , fffffffffffff ) + +[6,51]: + int 007ffffffffffff <- ( 00 , fffffffffffff ) + +[6,50]: + int 003ffffffffffff <- ( 00 , fffffffffffff ) + +[6,49]: + int 01ffffffffffff <- ( 00 , fffffffffffff ) + +[6,48]: + int 00ffffffffffff <- ( 00 , ffffffffffff ) + +[6,47]: + int 007fffffffffff <- ( 00 , ffffffffffff ) + +[6,46]: + int 003fffffffffff <- ( 00 , ffffffffffff ) + +[6,45]: + int 01fffffffffff <- ( 00 , ffffffffffff ) + +[6,44]: + int 00fffffffffff <- ( 00 , fffffffffff ) + +[6,43]: + int 007ffffffffff <- ( 00 , fffffffffff ) + +[6,42]: + int 003ffffffffff <- ( 00 , fffffffffff ) + +[6,41]: + int 01ffffffffff <- ( 00 , fffffffffff ) + +[6,40]: + int 00ffffffffff <- ( 00 , ffffffffff ) + +[6,39]: + int 007fffffffff <- ( 00 , ffffffffff ) + +[6,38]: + int 003fffffffff <- ( 00 , ffffffffff ) + +[6,37]: + int 01fffffffff <- ( 00 , ffffffffff ) + +[6,36]: + int 00fffffffff <- ( 00 , fffffffff ) + +[6,35]: + int 007ffffffff <- ( 00 , fffffffff ) + +[6,34]: + int 003ffffffff <- ( 00 , fffffffff ) + +[6,33]: + int 01ffffffff <- ( 00 , fffffffff ) + +[6,32]: + int 00ffffffff <- ( 00 , ffffffff ) + +[6,31]: + int 007fffffff <- ( 00 , ffffffff ) + +[6,30]: + int 003fffffff <- ( 00 , ffffffff ) + +[6,29]: + int 01fffffff <- ( 00 , ffffffff ) + +[6,28]: + int 00fffffff <- ( 00 , fffffff ) + +[6,27]: + int 007ffffff <- ( 00 , fffffff ) + +[6,26]: + int 003ffffff <- ( 00 , fffffff ) + +[6,25]: + int 01ffffff <- ( 00 , fffffff ) + +[6,24]: + int 00ffffff <- ( 00 , ffffff ) + +[6,23]: + int 007fffff <- ( 00 , ffffff ) + +[6,22]: + int 003fffff <- ( 00 , ffffff ) + +[6,21]: + int 01fffff <- ( 00 , ffffff ) + +[6,20]: + int 00fffff <- ( 00 , fffff ) + +[6,19]: + int 007ffff <- ( 00 , fffff ) + +[6,18]: + int 003ffff <- ( 00 , fffff ) + +[6,17]: + int 01ffff <- ( 00 , fffff ) + +[6,16]: + int 00ffff <- ( 00 , ffff ) + +[6,15]: + int 007fff <- ( 00 , ffff ) + +[6,14]: + int 003fff <- ( 00 , ffff ) + +[6,13]: + int 01fff <- ( 00 , ffff ) + +[6,12]: + int 00fff <- ( 00 , fff ) + +[6,11]: + int 007ff <- ( 00 , fff ) + +[6,10]: + int 003ff <- ( 00 , fff ) + +[6,9]: + int 01ff <- ( 00 , fff ) + +[6,8]: + int 00ff <- ( 00 , ff ) + +[6,7]: + int 007f <- ( 00 , ff ) + +[6,6]: + int 003f <- ( 00 , ff ) + +[6,5]: + int 01f <- ( 00 , ff ) + +[6,4]: + int 00f <- ( 00 , f ) + +[6,3]: + int 007 <- ( 00 , f ) + +[6,2]: + int 003 <- ( 00 , f ) + +[6,1]: + int 01 <- ( 00 , f ) + +[5,64]: + int 00ffffffffffffffff <- ( 00 , ffffffffffffffff ) + +[5,63]: + int 007fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[5,62]: + int 03fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[5,61]: + int 01fffffffffffffff <- ( 00 , ffffffffffffffff ) + +[5,60]: + int 00fffffffffffffff <- ( 00 , fffffffffffffff ) + +[5,59]: + int 007ffffffffffffff <- ( 00 , fffffffffffffff ) + +[5,58]: + int 03ffffffffffffff <- ( 00 , fffffffffffffff ) + +[5,57]: + int 01ffffffffffffff <- ( 00 , fffffffffffffff ) + +[5,56]: + int 00ffffffffffffff <- ( 00 , ffffffffffffff ) + +[5,55]: + int 007fffffffffffff <- ( 00 , ffffffffffffff ) + +[5,54]: + int 03fffffffffffff <- ( 00 , ffffffffffffff ) + +[5,53]: + int 01fffffffffffff <- ( 00 , ffffffffffffff ) + +[5,52]: + int 00fffffffffffff <- ( 00 , fffffffffffff ) + +[5,51]: + int 007ffffffffffff <- ( 00 , fffffffffffff ) + +[5,50]: + int 03ffffffffffff <- ( 00 , fffffffffffff ) + +[5,49]: + int 01ffffffffffff <- ( 00 , fffffffffffff ) + +[5,48]: + int 00ffffffffffff <- ( 00 , ffffffffffff ) + +[5,47]: + int 007fffffffffff <- ( 00 , ffffffffffff ) + +[5,46]: + int 03fffffffffff <- ( 00 , ffffffffffff ) + +[5,45]: + int 01fffffffffff <- ( 00 , ffffffffffff ) + +[5,44]: + int 00fffffffffff <- ( 00 , fffffffffff ) + +[5,43]: + int 007ffffffffff <- ( 00 , fffffffffff ) + +[5,42]: + int 03ffffffffff <- ( 00 , fffffffffff ) + +[5,41]: + int 01ffffffffff <- ( 00 , fffffffffff ) + +[5,40]: + int 00ffffffffff <- ( 00 , ffffffffff ) + +[5,39]: + int 007fffffffff <- ( 00 , ffffffffff ) + +[5,38]: + int 03fffffffff <- ( 00 , ffffffffff ) + +[5,37]: + int 01fffffffff <- ( 00 , ffffffffff ) + +[5,36]: + int 00fffffffff <- ( 00 , fffffffff ) + +[5,35]: + int 007ffffffff <- ( 00 , fffffffff ) + +[5,34]: + int 03ffffffff <- ( 00 , fffffffff ) + +[5,33]: + int 01ffffffff <- ( 00 , fffffffff ) + +[5,32]: + int 00ffffffff <- ( 00 , ffffffff ) + +[5,31]: + int 007fffffff <- ( 00 , ffffffff ) + +[5,30]: + int 03fffffff <- ( 00 , ffffffff ) + +[5,29]: + int 01fffffff <- ( 00 , ffffffff ) + +[5,28]: + int 00fffffff <- ( 00 , fffffff ) + +[5,27]: + int 007ffffff <- ( 00 , fffffff ) + +[5,26]: + int 03ffffff <- ( 00 , fffffff ) + +[5,25]: + int 01ffffff <- ( 00 , fffffff ) + +[5,24]: + int 00ffffff <- ( 00 , ffffff ) + +[5,23]: + int 007fffff <- ( 00 , ffffff ) + +[5,22]: + int 03fffff <- ( 00 , ffffff ) + +[5,21]: + int 01fffff <- ( 00 , ffffff ) + +[5,20]: + int 00fffff <- ( 00 , fffff ) + +[5,19]: + int 007ffff <- ( 00 , fffff ) + +[5,18]: + int 03ffff <- ( 00 , fffff ) + +[5,17]: + int 01ffff <- ( 00 , fffff ) + +[5,16]: + int 00ffff <- ( 00 , ffff ) + +[5,15]: + int 007fff <- ( 00 , ffff ) + +[5,14]: + int 03fff <- ( 00 , ffff ) + +[5,13]: + int 01fff <- ( 00 , ffff ) + +[5,12]: + int 00fff <- ( 00 , fff ) + +[5,11]: + int 007ff <- ( 00 , fff ) + +[5,10]: + int 03ff <- ( 00 , fff ) + +[5,9]: + int 01ff <- ( 00 , fff ) + +[5,8]: + int 00ff <- ( 00 , ff ) + +[5,7]: + int 007f <- ( 00 , ff ) + +[5,6]: + int 03f <- ( 00 , ff ) + +[5,5]: + int 01f <- ( 00 , ff ) + +[5,4]: + int 00f <- ( 00 , f ) + +[5,3]: + int 007 <- ( 00 , f ) + +[5,2]: + int 03 <- ( 00 , f ) + +[5,1]: + int 01 <- ( 00 , f ) + +[4,64]: + int 00ffffffffffffffff <- ( 0 , ffffffffffffffff ) + +[4,63]: + int 07fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[4,62]: + int 03fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[4,61]: + int 01fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[4,60]: + int 00fffffffffffffff <- ( 0 , fffffffffffffff ) + +[4,59]: + int 07ffffffffffffff <- ( 0 , fffffffffffffff ) + +[4,58]: + int 03ffffffffffffff <- ( 0 , fffffffffffffff ) + +[4,57]: + int 01ffffffffffffff <- ( 0 , fffffffffffffff ) + +[4,56]: + int 00ffffffffffffff <- ( 0 , ffffffffffffff ) + +[4,55]: + int 07fffffffffffff <- ( 0 , ffffffffffffff ) + +[4,54]: + int 03fffffffffffff <- ( 0 , ffffffffffffff ) + +[4,53]: + int 01fffffffffffff <- ( 0 , ffffffffffffff ) + +[4,52]: + int 00fffffffffffff <- ( 0 , fffffffffffff ) + +[4,51]: + int 07ffffffffffff <- ( 0 , fffffffffffff ) + +[4,50]: + int 03ffffffffffff <- ( 0 , fffffffffffff ) + +[4,49]: + int 01ffffffffffff <- ( 0 , fffffffffffff ) + +[4,48]: + int 00ffffffffffff <- ( 0 , ffffffffffff ) + +[4,47]: + int 07fffffffffff <- ( 0 , ffffffffffff ) + +[4,46]: + int 03fffffffffff <- ( 0 , ffffffffffff ) + +[4,45]: + int 01fffffffffff <- ( 0 , ffffffffffff ) + +[4,44]: + int 00fffffffffff <- ( 0 , fffffffffff ) + +[4,43]: + int 07ffffffffff <- ( 0 , fffffffffff ) + +[4,42]: + int 03ffffffffff <- ( 0 , fffffffffff ) + +[4,41]: + int 01ffffffffff <- ( 0 , fffffffffff ) + +[4,40]: + int 00ffffffffff <- ( 0 , ffffffffff ) + +[4,39]: + int 07fffffffff <- ( 0 , ffffffffff ) + +[4,38]: + int 03fffffffff <- ( 0 , ffffffffff ) + +[4,37]: + int 01fffffffff <- ( 0 , ffffffffff ) + +[4,36]: + int 00fffffffff <- ( 0 , fffffffff ) + +[4,35]: + int 07ffffffff <- ( 0 , fffffffff ) + +[4,34]: + int 03ffffffff <- ( 0 , fffffffff ) + +[4,33]: + int 01ffffffff <- ( 0 , fffffffff ) + +[4,32]: + int 00ffffffff <- ( 0 , ffffffff ) + +[4,31]: + int 07fffffff <- ( 0 , ffffffff ) + +[4,30]: + int 03fffffff <- ( 0 , ffffffff ) + +[4,29]: + int 01fffffff <- ( 0 , ffffffff ) + +[4,28]: + int 00fffffff <- ( 0 , fffffff ) + +[4,27]: + int 07ffffff <- ( 0 , fffffff ) + +[4,26]: + int 03ffffff <- ( 0 , fffffff ) + +[4,25]: + int 01ffffff <- ( 0 , fffffff ) + +[4,24]: + int 00ffffff <- ( 0 , ffffff ) + +[4,23]: + int 07fffff <- ( 0 , ffffff ) + +[4,22]: + int 03fffff <- ( 0 , ffffff ) + +[4,21]: + int 01fffff <- ( 0 , ffffff ) + +[4,20]: + int 00fffff <- ( 0 , fffff ) + +[4,19]: + int 07ffff <- ( 0 , fffff ) + +[4,18]: + int 03ffff <- ( 0 , fffff ) + +[4,17]: + int 01ffff <- ( 0 , fffff ) + +[4,16]: + int 00ffff <- ( 0 , ffff ) + +[4,15]: + int 07fff <- ( 0 , ffff ) + +[4,14]: + int 03fff <- ( 0 , ffff ) + +[4,13]: + int 01fff <- ( 0 , ffff ) + +[4,12]: + int 00fff <- ( 0 , fff ) + +[4,11]: + int 07ff <- ( 0 , fff ) + +[4,10]: + int 03ff <- ( 0 , fff ) + +[4,9]: + int 01ff <- ( 0 , fff ) + +[4,8]: + int 00ff <- ( 0 , ff ) + +[4,7]: + int 07f <- ( 0 , ff ) + +[4,6]: + int 03f <- ( 0 , ff ) + +[4,5]: + int 01f <- ( 0 , ff ) + +[4,4]: + int 00f <- ( 0 , f ) + +[4,3]: + int 07 <- ( 0 , f ) + +[4,2]: + int 03 <- ( 0 , f ) + +[4,1]: + int 01 <- ( 0 , f ) + +[3,64]: + int 0ffffffffffffffff <- ( 0 , ffffffffffffffff ) + +[3,63]: + int 07fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[3,62]: + int 03fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[3,61]: + int 01fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[3,60]: + int 0fffffffffffffff <- ( 0 , fffffffffffffff ) + +[3,59]: + int 07ffffffffffffff <- ( 0 , fffffffffffffff ) + +[3,58]: + int 03ffffffffffffff <- ( 0 , fffffffffffffff ) + +[3,57]: + int 01ffffffffffffff <- ( 0 , fffffffffffffff ) + +[3,56]: + int 0ffffffffffffff <- ( 0 , ffffffffffffff ) + +[3,55]: + int 07fffffffffffff <- ( 0 , ffffffffffffff ) + +[3,54]: + int 03fffffffffffff <- ( 0 , ffffffffffffff ) + +[3,53]: + int 01fffffffffffff <- ( 0 , ffffffffffffff ) + +[3,52]: + int 0fffffffffffff <- ( 0 , fffffffffffff ) + +[3,51]: + int 07ffffffffffff <- ( 0 , fffffffffffff ) + +[3,50]: + int 03ffffffffffff <- ( 0 , fffffffffffff ) + +[3,49]: + int 01ffffffffffff <- ( 0 , fffffffffffff ) + +[3,48]: + int 0ffffffffffff <- ( 0 , ffffffffffff ) + +[3,47]: + int 07fffffffffff <- ( 0 , ffffffffffff ) + +[3,46]: + int 03fffffffffff <- ( 0 , ffffffffffff ) + +[3,45]: + int 01fffffffffff <- ( 0 , ffffffffffff ) + +[3,44]: + int 0fffffffffff <- ( 0 , fffffffffff ) + +[3,43]: + int 07ffffffffff <- ( 0 , fffffffffff ) + +[3,42]: + int 03ffffffffff <- ( 0 , fffffffffff ) + +[3,41]: + int 01ffffffffff <- ( 0 , fffffffffff ) + +[3,40]: + int 0ffffffffff <- ( 0 , ffffffffff ) + +[3,39]: + int 07fffffffff <- ( 0 , ffffffffff ) + +[3,38]: + int 03fffffffff <- ( 0 , ffffffffff ) + +[3,37]: + int 01fffffffff <- ( 0 , ffffffffff ) + +[3,36]: + int 0fffffffff <- ( 0 , fffffffff ) + +[3,35]: + int 07ffffffff <- ( 0 , fffffffff ) + +[3,34]: + int 03ffffffff <- ( 0 , fffffffff ) + +[3,33]: + int 01ffffffff <- ( 0 , fffffffff ) + +[3,32]: + int 0ffffffff <- ( 0 , ffffffff ) + +[3,31]: + int 07fffffff <- ( 0 , ffffffff ) + +[3,30]: + int 03fffffff <- ( 0 , ffffffff ) + +[3,29]: + int 01fffffff <- ( 0 , ffffffff ) + +[3,28]: + int 0fffffff <- ( 0 , fffffff ) + +[3,27]: + int 07ffffff <- ( 0 , fffffff ) + +[3,26]: + int 03ffffff <- ( 0 , fffffff ) + +[3,25]: + int 01ffffff <- ( 0 , fffffff ) + +[3,24]: + int 0ffffff <- ( 0 , ffffff ) + +[3,23]: + int 07fffff <- ( 0 , ffffff ) + +[3,22]: + int 03fffff <- ( 0 , ffffff ) + +[3,21]: + int 01fffff <- ( 0 , ffffff ) + +[3,20]: + int 0fffff <- ( 0 , fffff ) + +[3,19]: + int 07ffff <- ( 0 , fffff ) + +[3,18]: + int 03ffff <- ( 0 , fffff ) + +[3,17]: + int 01ffff <- ( 0 , fffff ) + +[3,16]: + int 0ffff <- ( 0 , ffff ) + +[3,15]: + int 07fff <- ( 0 , ffff ) + +[3,14]: + int 03fff <- ( 0 , ffff ) + +[3,13]: + int 01fff <- ( 0 , ffff ) + +[3,12]: + int 0fff <- ( 0 , fff ) + +[3,11]: + int 07ff <- ( 0 , fff ) + +[3,10]: + int 03ff <- ( 0 , fff ) + +[3,9]: + int 01ff <- ( 0 , fff ) + +[3,8]: + int 0ff <- ( 0 , ff ) + +[3,7]: + int 07f <- ( 0 , ff ) + +[3,6]: + int 03f <- ( 0 , ff ) + +[3,5]: + int 01f <- ( 0 , ff ) + +[3,4]: + int 0f <- ( 0 , f ) + +[3,3]: + int 07 <- ( 0 , f ) + +[3,2]: + int 03 <- ( 0 , f ) + +[3,1]: + int 01 <- ( 0 , f ) + +[2,64]: + int 0ffffffffffffffff <- ( 0 , ffffffffffffffff ) + +[2,63]: + int 07fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[2,62]: + int 03fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[2,61]: + int 1fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[2,60]: + int 0fffffffffffffff <- ( 0 , fffffffffffffff ) + +[2,59]: + int 07ffffffffffffff <- ( 0 , fffffffffffffff ) + +[2,58]: + int 03ffffffffffffff <- ( 0 , fffffffffffffff ) + +[2,57]: + int 1ffffffffffffff <- ( 0 , fffffffffffffff ) + +[2,56]: + int 0ffffffffffffff <- ( 0 , ffffffffffffff ) + +[2,55]: + int 07fffffffffffff <- ( 0 , ffffffffffffff ) + +[2,54]: + int 03fffffffffffff <- ( 0 , ffffffffffffff ) + +[2,53]: + int 1fffffffffffff <- ( 0 , ffffffffffffff ) + +[2,52]: + int 0fffffffffffff <- ( 0 , fffffffffffff ) + +[2,51]: + int 07ffffffffffff <- ( 0 , fffffffffffff ) + +[2,50]: + int 03ffffffffffff <- ( 0 , fffffffffffff ) + +[2,49]: + int 1ffffffffffff <- ( 0 , fffffffffffff ) + +[2,48]: + int 0ffffffffffff <- ( 0 , ffffffffffff ) + +[2,47]: + int 07fffffffffff <- ( 0 , ffffffffffff ) + +[2,46]: + int 03fffffffffff <- ( 0 , ffffffffffff ) + +[2,45]: + int 1fffffffffff <- ( 0 , ffffffffffff ) + +[2,44]: + int 0fffffffffff <- ( 0 , fffffffffff ) + +[2,43]: + int 07ffffffffff <- ( 0 , fffffffffff ) + +[2,42]: + int 03ffffffffff <- ( 0 , fffffffffff ) + +[2,41]: + int 1ffffffffff <- ( 0 , fffffffffff ) + +[2,40]: + int 0ffffffffff <- ( 0 , ffffffffff ) + +[2,39]: + int 07fffffffff <- ( 0 , ffffffffff ) + +[2,38]: + int 03fffffffff <- ( 0 , ffffffffff ) + +[2,37]: + int 1fffffffff <- ( 0 , ffffffffff ) + +[2,36]: + int 0fffffffff <- ( 0 , fffffffff ) + +[2,35]: + int 07ffffffff <- ( 0 , fffffffff ) + +[2,34]: + int 03ffffffff <- ( 0 , fffffffff ) + +[2,33]: + int 1ffffffff <- ( 0 , fffffffff ) + +[2,32]: + int 0ffffffff <- ( 0 , ffffffff ) + +[2,31]: + int 07fffffff <- ( 0 , ffffffff ) + +[2,30]: + int 03fffffff <- ( 0 , ffffffff ) + +[2,29]: + int 1fffffff <- ( 0 , ffffffff ) + +[2,28]: + int 0fffffff <- ( 0 , fffffff ) + +[2,27]: + int 07ffffff <- ( 0 , fffffff ) + +[2,26]: + int 03ffffff <- ( 0 , fffffff ) + +[2,25]: + int 1ffffff <- ( 0 , fffffff ) + +[2,24]: + int 0ffffff <- ( 0 , ffffff ) + +[2,23]: + int 07fffff <- ( 0 , ffffff ) + +[2,22]: + int 03fffff <- ( 0 , ffffff ) + +[2,21]: + int 1fffff <- ( 0 , ffffff ) + +[2,20]: + int 0fffff <- ( 0 , fffff ) + +[2,19]: + int 07ffff <- ( 0 , fffff ) + +[2,18]: + int 03ffff <- ( 0 , fffff ) + +[2,17]: + int 1ffff <- ( 0 , fffff ) + +[2,16]: + int 0ffff <- ( 0 , ffff ) + +[2,15]: + int 07fff <- ( 0 , ffff ) + +[2,14]: + int 03fff <- ( 0 , ffff ) + +[2,13]: + int 1fff <- ( 0 , ffff ) + +[2,12]: + int 0fff <- ( 0 , fff ) + +[2,11]: + int 07ff <- ( 0 , fff ) + +[2,10]: + int 03ff <- ( 0 , fff ) + +[2,9]: + int 1ff <- ( 0 , fff ) + +[2,8]: + int 0ff <- ( 0 , ff ) + +[2,7]: + int 07f <- ( 0 , ff ) + +[2,6]: + int 03f <- ( 0 , ff ) + +[2,5]: + int 1f <- ( 0 , ff ) + +[2,4]: + int 0f <- ( 0 , f ) + +[2,3]: + int 07 <- ( 0 , f ) + +[2,2]: + int 03 <- ( 0 , f ) + +[2,1]: + int 1 <- ( 0 , f ) + +[1,64]: + int 0ffffffffffffffff <- ( 0 , ffffffffffffffff ) + +[1,63]: + int 07fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[1,62]: + int 3fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[1,61]: + int 1fffffffffffffff <- ( 0 , ffffffffffffffff ) + +[1,60]: + int 0fffffffffffffff <- ( 0 , fffffffffffffff ) + +[1,59]: + int 07ffffffffffffff <- ( 0 , fffffffffffffff ) + +[1,58]: + int 3ffffffffffffff <- ( 0 , fffffffffffffff ) + +[1,57]: + int 1ffffffffffffff <- ( 0 , fffffffffffffff ) + +[1,56]: + int 0ffffffffffffff <- ( 0 , ffffffffffffff ) + +[1,55]: + int 07fffffffffffff <- ( 0 , ffffffffffffff ) + +[1,54]: + int 3fffffffffffff <- ( 0 , ffffffffffffff ) + +[1,53]: + int 1fffffffffffff <- ( 0 , ffffffffffffff ) + +[1,52]: + int 0fffffffffffff <- ( 0 , fffffffffffff ) + +[1,51]: + int 07ffffffffffff <- ( 0 , fffffffffffff ) + +[1,50]: + int 3ffffffffffff <- ( 0 , fffffffffffff ) + +[1,49]: + int 1ffffffffffff <- ( 0 , fffffffffffff ) + +[1,48]: + int 0ffffffffffff <- ( 0 , ffffffffffff ) + +[1,47]: + int 07fffffffffff <- ( 0 , ffffffffffff ) + +[1,46]: + int 3fffffffffff <- ( 0 , ffffffffffff ) + +[1,45]: + int 1fffffffffff <- ( 0 , ffffffffffff ) + +[1,44]: + int 0fffffffffff <- ( 0 , fffffffffff ) + +[1,43]: + int 07ffffffffff <- ( 0 , fffffffffff ) + +[1,42]: + int 3ffffffffff <- ( 0 , fffffffffff ) + +[1,41]: + int 1ffffffffff <- ( 0 , fffffffffff ) + +[1,40]: + int 0ffffffffff <- ( 0 , ffffffffff ) + +[1,39]: + int 07fffffffff <- ( 0 , ffffffffff ) + +[1,38]: + int 3fffffffff <- ( 0 , ffffffffff ) + +[1,37]: + int 1fffffffff <- ( 0 , ffffffffff ) + +[1,36]: + int 0fffffffff <- ( 0 , fffffffff ) + +[1,35]: + int 07ffffffff <- ( 0 , fffffffff ) + +[1,34]: + int 3ffffffff <- ( 0 , fffffffff ) + +[1,33]: + int 1ffffffff <- ( 0 , fffffffff ) + +[1,32]: + int 0ffffffff <- ( 0 , ffffffff ) + +[1,31]: + int 07fffffff <- ( 0 , ffffffff ) + +[1,30]: + int 3fffffff <- ( 0 , ffffffff ) + +[1,29]: + int 1fffffff <- ( 0 , ffffffff ) + +[1,28]: + int 0fffffff <- ( 0 , fffffff ) + +[1,27]: + int 07ffffff <- ( 0 , fffffff ) + +[1,26]: + int 3ffffff <- ( 0 , fffffff ) + +[1,25]: + int 1ffffff <- ( 0 , fffffff ) + +[1,24]: + int 0ffffff <- ( 0 , ffffff ) + +[1,23]: + int 07fffff <- ( 0 , ffffff ) + +[1,22]: + int 3fffff <- ( 0 , ffffff ) + +[1,21]: + int 1fffff <- ( 0 , ffffff ) + +[1,20]: + int 0fffff <- ( 0 , fffff ) + +[1,19]: + int 07ffff <- ( 0 , fffff ) + +[1,18]: + int 3ffff <- ( 0 , fffff ) + +[1,17]: + int 1ffff <- ( 0 , fffff ) + +[1,16]: + int 0ffff <- ( 0 , ffff ) + +[1,15]: + int 07fff <- ( 0 , ffff ) + +[1,14]: + int 3fff <- ( 0 , ffff ) + +[1,13]: + int 1fff <- ( 0 , ffff ) + +[1,12]: + int 0fff <- ( 0 , fff ) + +[1,11]: + int 07ff <- ( 0 , fff ) + +[1,10]: + int 3ff <- ( 0 , fff ) + +[1,9]: + int 1ff <- ( 0 , fff ) + +[1,8]: + int 0ff <- ( 0 , ff ) + +[1,7]: + int 07f <- ( 0 , ff ) + +[1,6]: + int 3f <- ( 0 , ff ) + +[1,5]: + int 1f <- ( 0 , ff ) + +[1,4]: + int 0f <- ( 0 , f ) + +[1,3]: + int 07 <- ( 0 , f ) + +[1,2]: + int 3 <- ( 0 , f ) + +[1,1]: + int 1 <- ( 0 , f ) +Program completed |