<<  >> (p.28)
    Author Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it  (Read 324873 times)

    • racminer
    Member
    **
    Offline Offline

    Activity: 245
    Merit: 17


    View Profile
    December 03, 2018, 06:57:32 AM
     #541

    #58 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf has been spent an hour ago


    tx: 17d31de2bd300bc1bad430ec0db77ca27466bbb97bf03df6a3ff386d60e58996

  • stalker00075
    Newbie
    *
    Offline Offline

    Activity: 54
    Merit: 0


    View Profile
    December 03, 2018, 09:14:52 AM
    Last edit: December 03, 2018, 09:40:23 AM by stalker00075
     #542
    arulbero Help!
    what key can there be 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
    2..............
    3..............

  • arulbero
    Legendary
    *
    Offline Offline

    Activity: 2023
    Merit: 2267


    View Profile
    December 03, 2018, 05:16:44 PM
     #543
    Quote from: stalker00075 on December 03, 2018, 09:14:52 AM
    arulbero Help!
    what key can there be 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
    2..............
    3..............

    Code:
    Private key : 00000000000000000000000000000000000000000000000002c675b852189a21
    Public key  : 11569442e870326ceec0de24eb5478c19e146ecd9d15e4666440f2f638875f42 524c08d882f868347f8b69d3330dc1913a159d8fb2b27864f197693a0eb39a23
     
    PrKey WIF c.: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjv2kTamEYQT9BNC7o1
    Address c.  : 8c2a6071f89c90c4dab5ab295d7729d1b54ea60f
    Address c.  : 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf

  • arulbero
    Legendary
    *
    Offline Offline

    Activity: 2023
    Merit: 2267


    View Profile
    December 03, 2018, 06:00:53 PM
     #544
    Quote from: j2002ba2 on November 25, 2018, 07:24:32 PM
    Using Pollard Rho method, the expected work is 3*2^80 group operations with almost zero memory requirements.

    Note that unlike BSGS  this method is probabilistic, and might fail with very low probability (on the order of 2^-160).

    One can improve the algorithm using Distinguished Points, bringing the expected work down to 1.253*2^80 group operations, using both less memory and less group operations (on average) than BSGS.


    Pollard Rho can be modified for an interval shorter than the whole group, at the cost of more group operations, i.e. for range 1 to 2^160 a possible solution would take 10*3*2^80 group ops plus 10*2^16 group points additional memory.

    There are other probabilistic algorithms when private key is in a range significantly smaller than the size of the whole group - Pollard Kangaroo, and Gaudry-Schost algorithms.

    Pollard Kangaroo with four kangaroos (the optimal) and distinguished points (DP) has expected work 1.715*2^80.

    Four set Gaudry-Schost algorithm with DP gives 1.661*2^80 group operations, and is easy to parallelise.

    There might be additional memory requirements for both methods, negligible compared to the enormous cost of BSGS.

    Thanks for the information, I will take a look at these algorithms.

  • Andzhig
    Jr. Member
    *
    Offline Offline

    Activity: 184
    Merit: 3


    View Profile
    December 03, 2018, 08:00:04 PM
    Last edit: December 05, 2018, 04:20:26 AM by Andzhig
     #545
    arulbero,thx.

    (for reference)
    1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
    bin 1011000110011101011011100001010010000110001001101000100001
    hex 2C675B852189A21
    dec 199976667976342049

    1011000110011101011011100001010010000110001001101000100001 33 zeros,25 ones.

    10110001 10011101 01101110 00010100 10000110 00100110 10001000 01  33-25  
    11110101 10010010 11100100 10000011 11001010 11101011 00001110 0    28-29                      
    10011101 00011000 10110110 00111010 11000100 11111111 11011111      22-34  
    11010101 01111100 00111111 00110110 11001111 11000010 0010100        24-31                          
    10001101 10111110 11011011 01010110 10110100 01111101 000100         23-31                          

    1111111111111111111111111000000000000000000000000000000000
    111111111111111111111111111110000000000000000000000000000
    11111111111111111111111111111111110000000000000000000000
    1111111111111111111111111111111000000000000000000000000
    111111111111111111111111111111100000000000000000000000

    79  1001111
    86  1010110
    71  1000111
    81  1010001
    86  1010110
    104 1101000 (1+9+9+9+7+6+6+6+7+9+7+6+3+4+2+0+4+9)

    7D4FE747      
    B862A62E      
    1A96CA8D8      
    34A65911D      
    4AED21170      
    9DE820A7C      
    1757756A93    
    22382FACD0    
    4B5F8303E9    
    E9AE4933D6    
    153869ACC5B    
    2A221C58D8F    
    6BD3B27C591    
    E02B35A358F    
    122FCA143C05  
    2EC18388D544  
    6CD610B53CBA  
    ADE6D7CE3B9B  
    174176B015F4D  
    22BD43C2E9354  
    75070A1A009D4  
    EFAE164CB9E3C  
    180788E47E326C
    236FB6D5AD1F44
    6ABE1F9B67E114
    9D18B63AC4FFDF
    1EB25C90795D61C
    2C675B852189A21
    5 or 6 or 7 ...

    Well, what's next, 288230376151711744-576460752303423488 ,if 6 it's 430000000000000000-500000000000000000 if 7 500000000000000000-570000000000000000

  • holy_ship
    Jr. Member
    *
    Offline Offline

    Activity: 116
    Merit: 1


    View Profile
    December 05, 2018, 04:54:03 AM
     #546
    haha! puzzle 58 is cracked. some guys with superclusters got involved?  Grin

  • PietCoin97
    Jr. Member
    *
    Offline Offline

    Activity: 91
    Merit: 3


    View Profile
    December 05, 2018, 07:41:51 PM
     #547
    Quote from: arulbero on November 11, 2018, 08:38:51 PM
    Quote from: noaj24 on November 11, 2018, 08:29:24 PM
    If the public key is revealed it is still safe from bruteforce if the attacker don't know the range of bits to search for?

    Of course.
    Many blocks mined by Satoshi have txs with "pay to public key" script (P2PK) instead of "pay to public key hash" script (P2PKH, pay to address).

    The public keys are known, but the btc are still there:

    block #100

    https://www.blockchain.com/it/btc/tx/2d05f0c9c3e1c226e63b5fac240137687544cf631cd616fd34fd188fc9020866

    PUSHDATA(65)[04e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5bdb44f1793b3749 5d80324acba7c8f537caaf8432b8d47987313060cc82d8a93] CHECKSIG

    Code:
    x = e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5

    y = bdb44f1793b37495d80324acba7c8f537caaf8432b8d47987313060cc82d8a93

    you say we could calculate a specific search space when we know the pub key from these addresses.

    but why are the BTC still there ?

    is it also impossible with the specific search space ?

    i have a list with 42k of this addresses

  • bill32767
    Newbie
    *
    Offline Offline

    Activity: 26
    Merit: 1


    View Profile
    December 05, 2018, 08:57:14 PM
     #548
    Quote from: PietCoin97 on December 05, 2018, 07:41:51 PM
    Quote from: arulbero on November 11, 2018, 08:38:51 PM
    Quote from: noaj24 on November 11, 2018, 08:29:24 PM
    If the public key is revealed it is still safe from bruteforce if the attacker don't know the range of bits to search for?

    Of course.
    Many blocks mined by Satoshi have txs with "pay to public key" script (P2PK) instead of "pay to public key hash" script (P2PKH, pay to address).

    The public keys are known, but the btc are still there:

    block #100

    https://www.blockchain.com/it/btc/tx/2d05f0c9c3e1c226e63b5fac240137687544cf631cd616fd34fd188fc9020866

    PUSHDATA(65)[04e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5bdb44f1793b3749 5d80324acba7c8f537caaf8432b8d47987313060cc82d8a93] CHECKSIG

    Code:
    x = e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5

    y = bdb44f1793b37495d80324acba7c8f537caaf8432b8d47987313060cc82d8a93

    you say we could calculate a specific search space when we know the pub key from these addresses.

    but why are the BTC still there ?

    is it also impossible with the specific search space ?

    i have a list with 42k of this addresses

    I believe his explanations were clear. He could calculate the private key from a minimal range e.g 2^80 but cannot calculate if its above that using Baby Step Giant Step as he explained previously. The puzzle keys are within a known range making it easy to get the private key after the funds has been spent. Your 42k address is IMPOSSIBLE to crack (at least not in this generation or next) even if you got all their public keys because their range are scary and larger than you can imagine.

  • bill32767
    Newbie
    *
    Offline Offline

    Activity: 26
    Merit: 1


    View Profile
    December 05, 2018, 09:08:06 PM
     #549
    Quote from: Andzhig on December 03, 2018, 08:00:04 PM
    arulbero,thx.

    (for reference)
    1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
    bin 1011000110011101011011100001010010000110001001101000100001
    hex 2C675B852189A21
    dec 199976667976342049

    1011000110011101011011100001010010000110001001101000100001 33 zeros,25 ones.

    10110001 10011101 01101110 00010100 10000110 00100110 10001000 01  33-25  
    11110101 10010010 11100100 10000011 11001010 11101011 00001110 0    28-29                      
    10011101 00011000 10110110 00111010 11000100 11111111 11011111      22-34  
    11010101 01111100 00111111 00110110 11001111 11000010 0010100        24-31                          
    10001101 10111110 11011011 01010110 10110100 01111101 000100         23-31                          

    1111111111111111111111111000000000000000000000000000000000
    111111111111111111111111111110000000000000000000000000000
    11111111111111111111111111111111110000000000000000000000
    1111111111111111111111111111111000000000000000000000000
    111111111111111111111111111111100000000000000000000000

    79  1001111
    86  1010110
    71  1000111
    81  1010001
    86  1010110
    104 1101000 (1+9+9+9+7+6+6+6+7+9+7+6+3+4+2+0+4+9)

    7D4FE747      
    B862A62E      
    1A96CA8D8      
    34A65911D      
    4AED21170      
    9DE820A7C      
    1757756A93    
    22382FACD0    
    4B5F8303E9    
    E9AE4933D6    
    153869ACC5B    
    2A221C58D8F    
    6BD3B27C591    
    E02B35A358F    
    122FCA143C05  
    2EC18388D544  
    6CD610B53CBA  
    ADE6D7CE3B9B  
    174176B015F4D  
    22BD43C2E9354  
    75070A1A009D4  
    EFAE164CB9E3C  
    180788E47E326C
    236FB6D5AD1F44
    6ABE1F9B67E114
    9D18B63AC4FFDF
    1EB25C90795D61C
    2C675B852189A21
    5 or 6 or 7 ...

    Well, what's next, 288230376151711744-576460752303423488 ,if 6 it's 430000000000000000-500000000000000000 if 7 500000000000000000-570000000000000000

    You always gat some SH*T to post anytime an address is being swept. Are you the one sweeping them? Do you have a formula or anything close? What exactly do your calculations mean? I'll appreciate some explanations!

  • arulbero
    Legendary
    *
    Offline Offline

    Activity: 2023
    Merit: 2267


    View Profile
    December 05, 2018, 09:08:45 PM
     #550
    Quote from: PietCoin97 on December 05, 2018, 07:41:51 PM
    you say we could calculate a specific search space when we know the pub key from these addresses.

    but why are the BTC still there ?

    is it also impossible with the specific search space ?

    We can't "calculate" a specific search space, we need to know the specific search space before starting the computation. That's the reason why those btc are still there, because nobody (except the btc owner) knows the specific search space for those private keys.

  • PietCoin97
    Jr. Member
    *
    Offline Offline

    Activity: 91
    Merit: 3


    View Profile
    December 05, 2018, 09:30:39 PM
     #551
    Quote from: arulbero on December 05, 2018, 09:08:45 PM
    Quote from: PietCoin97 on December 05, 2018, 07:41:51 PM
    you say we could calculate a specific search space when we know the pub key from these addresses.

    but why are the BTC still there ?

    is it also impossible with the specific search space ?

    We can't "calculate" a specific search space, we need to know the specific search space before starting the computation. That's the reason why those btc are still there, because nobody (except the btc owner) knows the specific search space for those private keys.

    OK so the possibility that the addresses are in the 250 - 256 space is high.

    When we take one of these space and make this with the baby step giant step?

    Or do I understand something really wrong?

  • Bajula
    Member
    **
    Offline Offline

    Activity: 166
    Merit: 16


    View Profile
    December 06, 2018, 04:38:50 AM
     #552
    Quote from: PietCoin97 on December 05, 2018, 09:30:39 PM
    Quote from: arulbero on December 05, 2018, 09:08:45 PM
    Quote from: PietCoin97 on December 05, 2018, 07:41:51 PM
    you say we could calculate a specific search space when we know the pub key from these addresses.

    but why are the BTC still there ?

    is it also impossible with the specific search space ?

    We can't "calculate" a specific search space, we need to know the specific search space before starting the computation. That's the reason why those btc are still there, because nobody (except the btc owner) knows the specific search space for those private keys.

    OK so the possibility that the addresses are in the 250 - 256 space is high.

    When we take one of these space and make this with the baby step giant step?

    Or do I understand something really wrong?

    Each is double what is was before.. so imagine the memory needed for such a thing.  Let's say (arbitrary example- not real) it takes 8 gb ram to do giant step 1 >>> 28  then 29 would be 16 gb ram  30 would be 32 .. --> 40 would be 32 terrabytes ram ---> 50 would be 32 PETAbytes of on board ram... etc....  so you can see where the issue lies.

  • Andzhig
    Jr. Member
    *
    Offline Offline

    Activity: 184
    Merit: 3


    View Profile
    December 06, 2018, 05:08:14 AM
    Last edit: December 06, 2018, 05:39:16 AM by Andzhig
     #553
    Quote
    Do you have a formula or anything close?
    There is no formula, there is a random and our collective unconscious. Therefore, someone will write something, someone will think of something.  Grin You never know, I will write now and you will light up (light bulb lights up).

    Take the last number found. 1011000110011101011011100001010010000110001001101000100001 take the first 3 bytes from it 10110001 10011101 01101110 here we have 10 zeros. Check how many combinations will be from the first byte 10110001, 8008 combinations which we need in place 583 (depending on the given data of course, table for counting in python, I'll leave it down) bin 101100011001110101101110 dec 11640174 multiply this number 34 times by 2 will get ~199976666598998016 practically what you need 199976667976342049. 199976667976342049-199976666598998016=1377344033 error on 1377344033 using a scanner "bitcrack" it's practically nothing. You need to guess just 3 bytes then "bitcrack" will do everything himself.

    The most important question is how to guess these 3 bytes (and multiply by 2 35 times for 59 puzzle).

    Now back to my writing.

    Quote
    174176B015F4D  
    22BD43C2E9354  
    75070A1A009D4  
    EFAE164CB9E3C  
    180788E47E326C
    236FB6D5AD1F44
    6ABE1F9B67E114
    9D18B63AC4FFDF
    1EB25C90795D61C
    2C675B852189A21
    5 or 6 or 7 ...

    Well, what's next, 288230376151711744-576460752303423488 ,if 6 it's 430000000000000000-500000000000000000 if 7 500000000000000000-570000000000000000

    Depending on the initial number in hex, we get our initial bytes in bit.

    hex ~610000000000000-6F0000000000000 ~436849163854938112-499899558638125056, 710000000000000-7F0000000000000 ~508906757892866048-571957152676052992.

    6 or 7 implies 110 or 111
    Quote
    ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
    ("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),

    ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
    ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),

    ("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
    ("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),

    ("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
    ("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),

    As we judging by the previous numbers 6 we have mostly hex letters 6ABCDEF and seven with hex numbers 7123456789.

    We narrow our space 6A0000000000000-6F0000000000000 477381560501272576-499899558638125056.

    And we get 16 bytes.

    Quote
    ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
    ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),

    For each of which options are possible with 8-15 zeros.

    But then you have to think further, or launch a "bitcrack" for everyone 16. It can run multiple copies at the same time. Or try to further filter for example in three bytes "111". On the example of our previous number 10110001 10011101 01101110 here are 2 of them "111" the number of options reduced from 8008 to 4802.



    python script
    Quote
    l1= [("10110001")]
     
    #l1= [("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
    #     ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111")]
     

    l2= [("10000000"),("10000001"),("10000010"),("10000011"),("10000100"),("10000101"),("10000110"),("10000111"),
         ("10001000"),("10001001"),("10001010"),("10001011"),("10001100"),("10001101"),("10001110"),("10001111"),
         ("10010000"),("10010001"),("10010010"),("10010011"),("10010100"),("10010101"),("10010110"),("10010111"),
         ("10011000"),("10011001"),("10011010"),("10011011"),("10011100"),("10011101"),("10011110"),("10011111"),
         ("10100000"),("10100001"),("10100010"),("10100011"),("10100100"),("10100101"),("10100110"),("10100111"),
         ("10101000"),("10101001"),("10101010"),("10101011"),("10101100"),("10101101"),("10101110"),("10101111"),
         ("10110000"),("10110001"),("10110010"),("10110011"),("10110100"),("10110101"),("10110110"),("10110111"),
         ("10111000"),("10111001"),("10111010"),("10111011"),("10111100"),("10111101"),("10111110"),("10111111"),
         ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
         ("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
         ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
         ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
         ("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
         ("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
         ("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
         ("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
         ("00000000"),("00000001"),("00000010"),("00000011"),("00000100"),("00000101"),("00000110"),("00000111"),
         ("00001000"),("00001001"),("00001010"),("00001011"),("00001100"),("00001101"),("00001110"),("00001111"),
         ("00010000"),("00010001"),("00010010"),("00010011"),("00010100"),("00010101"),("00010110"),("00010111"),
         ("00011000"),("00011001"),("00011010"),("00011011"),("00011100"),("00011101"),("00011110"),("00011111"),
         ("00100000"),("00100001"),("00100010"),("00100011"),("00100100"),("00100101"),("00100110"),("00100111"),
         ("00101000"),("00101001"),("00101010"),("00101011"),("00101100"),("00101101"),("00101110"),("00101111"),
         ("00110000"),("00110001"),("00110010"),("00110011"),("00110100"),("00110101"),("00110110"),("00110111"),
         ("00111000"),("00111001"),("00111010"),("00111011"),("00111100"),("00111101"),("00111110"),("00111111"),
         ("01000000"),("01000001"),("01000010"),("01000011"),("01000100"),("01000101"),("01000110"),("01000111"),
         ("01001000"),("01001001"),("01001010"),("01001011"),("01001100"),("01001101"),("01001110"),("01001111"),
         ("01010000"),("01010001"),("01010010"),("01010011"),("01010100"),("01010101"),("01010110"),("01010111"),
         ("01011000"),("01011001"),("01011010"),("01011011"),("01011100"),("01011101"),("01011110"),("01011111"),
         ("01100000"),("01100001"),("01100010"),("01100011"),("01100100"),("01100101"),("01100110"),("01100111"),
         ("01101000"),("01101001"),("01101010"),("01101011"),("01101100"),("01101101"),("01101110"),("01101111"),
         ("01110000"),("01110001"),("01110010"),("01110011"),("01110100"),("01110101"),("01110110"),("01110111"),
         ("01111000"),("01111001"),("01111010"),("01111011"),("01111100"),("01111101"),("01111110"),("01111111")]





    def funk():
        for element1 in (l1):
            for element2 in (l2):
                for element3 in (l2):
                    bina = element1+element2+element3
                    nuli = bina.count("0")
                    if nuli == 10: #zeros count
                    
                        print(bina)
                    pass
                else:
                    pass
        return None                                    
                      
    funk()



    [/size]

  • bill32767
    Newbie
    *
    Offline Offline

    Activity: 26
    Merit: 1


    View Profile
    December 06, 2018, 08:22:43 AM
     #554
    Quote from: Andzhig on December 06, 2018, 05:08:14 AM
    Quote
    Do you have a formula or anything close?
    There is no formula, there is a random and our collective unconscious. Therefore, someone will write something, someone will think of something.  Grin You never know, I will write now and you will light up (light bulb lights up).

    Take the last number found. 1011000110011101011011100001010010000110001001101000100001 take the first 3 bytes from it 10110001 10011101 01101110 here we have 10 zeros. Check how many combinations will be from the first byte 10110001, 8008 combinations which we need in place 583 (depending on the given data of course, table for counting in python, I'll leave it down) bin 101100011001110101101110 dec 11640174 multiply this number 34 times by 2 will get ~199976666598998016 practically what you need 199976667976342049. 199976667976342049-199976666598998016=1377344033 error on 1377344033 using a scanner "bitcrack" it's practically nothing. You need to guess just 3 bytes then "bitcrack" will do everything himself.

    The most important question is how to guess these 3 bytes (and multiply by 2 35 times for 59 puzzle).

    Now back to my writing.

    Quote
    174176B015F4D  
    22BD43C2E9354  
    75070A1A009D4  
    EFAE164CB9E3C  
    180788E47E326C
    236FB6D5AD1F44
    6ABE1F9B67E114
    9D18B63AC4FFDF
    1EB25C90795D61C
    2C675B852189A21
    5 or 6 or 7 ...

    Well, what's next, 288230376151711744-576460752303423488 ,if 6 it's 430000000000000000-500000000000000000 if 7 500000000000000000-570000000000000000

    Depending on the initial number in hex, we get our initial bytes in bit.

    hex ~610000000000000-6F0000000000000 ~436849163854938112-499899558638125056, 710000000000000-7F0000000000000 ~508906757892866048-571957152676052992.

    6 or 7 implies 110 or 111
    Quote
    ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
    ("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),

    ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
    ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),

    ("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
    ("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),

    ("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
    ("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),

    As we judging by the previous numbers 6 we have mostly hex letters 6ABCDEF and seven with hex numbers 7123456789.

    We narrow our space 6A0000000000000-6F0000000000000 477381560501272576-499899558638125056.

    And we get 16 bytes.

    Quote
    ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
    ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),

    For each of which options are possible with 8-15 zeros.

    But then you have to think further, or launch a "bitcrack" for everyone 16. It can run multiple copies at the same time. Or try to further filter for example in three bytes "111". On the example of our previous number 10110001 10011101 01101110 here are 2 of them "111" the number of options reduced from 8008 to 4802.



    python script
    Quote
    l1= [("10110001")]
     
    #l1= [("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
    #     ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111")]
     

    l2= [("10000000"),("10000001"),("10000010"),("10000011"),("10000100"),("10000101"),("10000110"),("10000111"),
         ("10001000"),("10001001"),("10001010"),("10001011"),("10001100"),("10001101"),("10001110"),("10001111"),
         ("10010000"),("10010001"),("10010010"),("10010011"),("10010100"),("10010101"),("10010110"),("10010111"),
         ("10011000"),("10011001"),("10011010"),("10011011"),("10011100"),("10011101"),("10011110"),("10011111"),
         ("10100000"),("10100001"),("10100010"),("10100011"),("10100100"),("10100101"),("10100110"),("10100111"),
         ("10101000"),("10101001"),("10101010"),("10101011"),("10101100"),("10101101"),("10101110"),("10101111"),
         ("10110000"),("10110001"),("10110010"),("10110011"),("10110100"),("10110101"),("10110110"),("10110111"),
         ("10111000"),("10111001"),("10111010"),("10111011"),("10111100"),("10111101"),("10111110"),("10111111"),
         ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
         ("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
         ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
         ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
         ("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
         ("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
         ("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
         ("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
         ("00000000"),("00000001"),("00000010"),("00000011"),("00000100"),("00000101"),("00000110"),("00000111"),
         ("00001000"),("00001001"),("00001010"),("00001011"),("00001100"),("00001101"),("00001110"),("00001111"),
         ("00010000"),("00010001"),("00010010"),("00010011"),("00010100"),("00010101"),("00010110"),("00010111"),
         ("00011000"),("00011001"),("00011010"),("00011011"),("00011100"),("00011101"),("00011110"),("00011111"),
         ("00100000"),("00100001"),("00100010"),("00100011"),("00100100"),("00100101"),("00100110"),("00100111"),
         ("00101000"),("00101001"),("00101010"),("00101011"),("00101100"),("00101101"),("00101110"),("00101111"),
         ("00110000"),("00110001"),("00110010"),("00110011"),("00110100"),("00110101"),("00110110"),("00110111"),
         ("00111000"),("00111001"),("00111010"),("00111011"),("00111100"),("00111101"),("00111110"),("00111111"),
         ("01000000"),("01000001"),("01000010"),("01000011"),("01000100"),("01000101"),("01000110"),("01000111"),
         ("01001000"),("01001001"),("01001010"),("01001011"),("01001100"),("01001101"),("01001110"),("01001111"),
         ("01010000"),("01010001"),("01010010"),("01010011"),("01010100"),("01010101"),("01010110"),("01010111"),
         ("01011000"),("01011001"),("01011010"),("01011011"),("01011100"),("01011101"),("01011110"),("01011111"),
         ("01100000"),("01100001"),("01100010"),("01100011"),("01100100"),("01100101"),("01100110"),("01100111"),
         ("01101000"),("01101001"),("01101010"),("01101011"),("01101100"),("01101101"),("01101110"),("01101111"),
         ("01110000"),("01110001"),("01110010"),("01110011"),("01110100"),("01110101"),("01110110"),("01110111"),
         ("01111000"),("01111001"),("01111010"),("01111011"),("01111100"),("01111101"),("01111110"),("01111111")]





    def funk():
        for element1 in (l1):
            for element2 in (l2):
                for element3 in (l2):
                    bina = element1+element2+element3
                    nuli = bina.count("0")
                    if nuli == 10: #zeros count
                    
                        print(bina)
                    pass
                else:
                    pass
        return None                                    
                      
    funk()



    [/size]

    Now I understand you but in the end its all  guessing work. I have a similar pattern, I will post it here since I have given up...the value of bitcoin is really falling rapidly making the puzzle seam useless

  • bill32767
    Newbie
    *
    Offline Offline

    Activity: 26
    Merit: 1


    View Profile
    December 06, 2018, 08:44:53 AM
     #555
    For those interested:
    Key
    1    1   2^1 = 2   (-1)
    2   3   2^2 = 4   (-1)
    3   7   2^3 = 8   (-1)
    4   8   2^4 = 16 (-NO3)
    5   21   2^5 = 32 (-NO3,-NO2)
    6   49   2^6 = 64 (-NO4)
    7   76   2^7 = 128 (-NO5,-NO4,-NO2)___(-NO2)
    8   224   2^8 = 256 (-NO5)
    9   467   2^9 = 512 (-NO5,-NO4)
    10   514   2^10 = 1024 (-NO9)
    11   1155   2^11 = 2048 (-NO9,-NO8,-NO7)
    12   2683   2^12 = 4096 (-NO10,-NO8,-NO7,*NO3*)
    13   5216   2^13 = 8192 (-NO11,-NO9,-NO8,-NO7,-NO5)
    14   10544   2^14 = 16384 (-NO12,-NO10,-NO9,-NO7,-NO6,-NO4)
    15   26867   2^15 = 32768 (-NO13,+NO11,+NO8) OR (-NO12,-NO10,-NO9,-NO8,-NO4)
    16   51510   2^16 = 65536 (-NO14,+NO11,+NO8) OR (-NO13,-NO12,-NO10,-NO9,-NO7,-NO6,-NO3,-NO1)
    17   95823   2^17 = 131072 (-NO15,-NO11,-NO8,-NO7,-NO6)___(+NO14,-NO7)
    18   198669   2^18 = 262144 (-NO16,+NO11) OR (-NO15,-NO14,-NO13,-NO12,-NO11)
    19   357535   2^19 = 524288 (-NO17,NO15,NO11,NO10,*+NO7*)
    20   863317   2^20 = 1048576 (-NO18,+NO16,+NO13,+NO11,+NO10,+NO6)
    21   1811764   2^21 = 2097152 (-NO19,+NO18,-NO14,-NO12,-N011,-NO10)
    22   3007503   2^22 = 4194304 (-NO20,NO17,NO13,+NO10)
    23   5598802   2^23 = 8388608 (-NO21,NO19,NO17,NO15,NO13,+NO11,+NO10)
    24   14,428,676   2^24 = 16,777,216 (-NO22,+N021,-NO18,+NO13,+NO11) OR (-NO21,-NO18,+NO13,+NO11)
    25   33,185,509   2^25 = 33,554,432 (-NO18,-NO16,-NO15,-NO13,*-NO8,-NO5*) OR (-NO23)
    26   54,538,862   2^26 = 67,108,864 (-NO24,+NO22,+NO13,+NO12,*+NO9,+NO6)
    27   111,949,941   2^27 = 134,217,728 (-NO25,+NO23,+NO21,+NO19,+NO18,+NO13,+NO12,+NO11,)___(+NO24,+NO23,+NO22,+NO21,+NO19,+NO18,+NO)
    28   227,634,408   2^28 = 268,435,456 (-NO26,+24,+23,+20,+16,+14,+13,+11,+10,*+7,+6,+5,+3) OR (-NO25,-23,+20,+16,+14,+13,+11,*+10,+7,+6,+5,+3)
    29   400,708,894   2^29 = 536,870,912 (-NO27,-21,+17,+14,+12,+10,*+8,+4,+3,+2,+1)
    30   1,033,162,084   2^30 = 1,073,741,824 (-NO25,-22,-21,-19,-17,-16,-13,-12,*-9,-7,-5)
    31   2,102,388,551   2^31 = 2,147,483,648 (-NO25,-23,-21,-20,-12,-11,*-7,-5,-4,-3,-)
    32   3,093,472,814   2^32 = 4,294,967,296 (-NO30,-26,-25,-24,-23,-21,*+17,+15,+13,+10,**+9,+5,+3,+2,+1) OR (-NO30,-27,+22,+21,*+17,+15,+13,+10,**+9,+5,+3,+2,+1)
    33   7,137,437,912   2^33 = 8,589,934,592 (-NO30,-28,-26,-25,-23,-20,*-17,-16,-14,-12,-11,**+7,+6,+4,+3)
    34   14,133,072,157   2^34 = 17,179,869,184 (-NO31,-29,-28,-26,-24,-23,-20,*-19,-17,-14,-13,-11,-10,**-9,-7,-6,-5,-1-)
    35   20,112,871,792   2^35 = 34,359,738,368 (-NO33,-32,-30#,-28,-24,-21,-20,*+17,+12,*+8,+6,+5,+4)
    36   42,387,769,980   2^36 = 68,719,476,736 (-NO34,-33#,-29,-24,-23,*+17,+11,+9,+6--2)
    37   100,251,560,595   2^37 = 137,438,953,472 (-NO35,-31#,-29,-27,-23,-20,*+18,+16,+14,+13,+11,**+10)
    38   146,971,536,592   2^38 = 274,877,906,944 (-NO36,-35,-34,-32,-31,-30,-29#,+28,+27,+21,+20,*-21K) OR (-NO36,-35,-34,-33,#+29,+28,+27,+21,+20,*-21K)
    39   323,724,968,937   2^39 = 549,755,813,888 (-NO37,-36,-34,-31,-30#,+28--23,*+17,+16,+10,-023)
    40   1,003,651,412,950   2^40 = 1,099,511,627,776 (-NO36,-34,-33,-30,#-28,-24,-23,-21,-20,*-18,-17,-15,-14,-12,*+)
    41   1,458,252,205,147   2^41 = 2,199,023,255,552 (-NO39,-37,-35,-34,-31,#+26,+25,+23,+21,*-341K)
    42   2,895,374,552,463   2^42 = 4,398,046,511,104 **(-NO40,-38,-36,-35,-34,-32,-31,-30,#-28,--25,-22,*+300K)
    43   7,409,811,047,825   2^43 = 8,796,093,022,208 (-NO40,-38,-33,-31,-30,#-26,-23,-22,-20,*-19,-15K)
    44   15,404,761,757,071   2^44 = 17,592,186,044,416 (-NO40,-39,$-38,-37,-36,-35,-34,-32,-30,#-27,-26,-23,-21,-20,*+600K)
    45   19,996,463,086,597   2^45 = 35,184,372,088,832 (-NO43,-42,-40,-39,-38,-36,$-30,#+27,+25,+21,*-800K) OR (-NO43,-42,-41,$+37,+36,-1BILION*)
    46   51,408,670,348,612   2^46 = 70,368,744,177,664 (-NO44,-40,$-37,-36,-35,-34,-33,-31,#+59M*)
    47   119,666,659,114,170   2^47 = 140,737,488,355,328 (-NO44,-41,-40,$-37,-35,-33,*+200M)
    48   191,206,974,700,443   2^48 = 281,474,976,710,656 (-NO46,-44,-41,$-36,-35,-32,-30,*+399M*)
    49   409,118,905,032,525   2^49 = 562,949,953,421,312 (-NO47,-43,-41,-40,-39,$-38,-37,-35,-31,-30,*+700M*)
    50   611,140,496,167,764   2^50 = 1,125,899,906,842,624 (-NO48,-47,-46,-44,-42$,-37,-35,-33,-32,-31,-30#,-26*+3M*)
    51   2,058,769,515,153,876   2^51 = 2,251,799,813,685,248 (-NO47,-45,-43,-42,-41,-40,-39#,-36*+2BILION*)
    52   4,216,495,639,600,700   2^52 = 4,503,599,627,370,496 (-NO48,-42,-40#,-36,-35,-34,-33,-31,-30*,+600M*)
    53   6,763,683,971,478,124   2^53 = 9,007,199,254,740,992 (-NO50,-49,-48,-47$,-46,-45,-44,-43,-40#,+550BILION*)
    54   9,974,455,244,496,710   2^54 = 18,014,398,509,481,984 (-NO52,-51,-50,-47$,-44#,-38,-35,-32*,-29,-27,-25,-22,-200k*)
    55   30,045,390,491,869,460   2^55 = 36,028,797,018,963,968 (-NO52,-50$,-48,-46,-41#,+100BILLION)
    56   44,218,742,292,676,575   2^56 = 72,057,594,037,927,936 (-NO54,-53,-49$,-47,-46,-45,-"[43]"42,-41,-40,-39#,+200BILION*)
    57   138,245,758,910,846,492   2^57 = 144,115,188,075,855,872 (-NO52,-50$,-47,-46,-44,-43,-41*,-38*+30BILL)
    58   199,976,667,976,342,049   2^58 = 288,230,376,151,711,744 (-NO56,-53,-52,-51,-48,-47$,-43,-41#,-40*)
    59            2^59 = 576,460,752,303,423,488
    60            2^60 = 1,152,921,504,606,846,976



    * point of brute force

  • PietCoin97
    Jr. Member
    *
    Offline Offline

    Activity: 91
    Merit: 3


    View Profile
    December 06, 2018, 10:15:42 PM
     #556
    Quote from: Andzhig on December 06, 2018, 05:08:14 AM
    Quote
    Do you have a formula or anything close?
    There is no formula, there is a random and our collective unconscious. Therefore, someone will write something, someone will think of something.  Grin You never know, I will write now and you will light up (light bulb lights up).

    Take the last number found. 1011000110011101011011100001010010000110001001101000100001 take the first 3 bytes from it 10110001 10011101 01101110 here we have 10 zeros. Check how many combinations will be from the first byte 10110001, 8008 combinations which we need in place 583 (depending on the given data of course, table for counting in python, I'll leave it down) bin 101100011001110101101110 dec 11640174 multiply this number 34 times by 2 will get ~199976666598998016 practically what you need 199976667976342049. 199976667976342049-199976666598998016=1377344033 error on 1377344033 using a scanner "bitcrack" it's practically nothing. You need to guess just 3 bytes then "bitcrack" will do everything himself.

    The most important question is how to guess these 3 bytes (and multiply by 2 35 times for 59 puzzle).

    Now back to my writing.

    Quote
    174176B015F4D  
    22BD43C2E9354  
    75070A1A009D4  
    EFAE164CB9E3C  
    180788E47E326C
    236FB6D5AD1F44
    6ABE1F9B67E114
    9D18B63AC4FFDF
    1EB25C90795D61C
    2C675B852189A21
    5 or 6 or 7 ...

    Well, what's next, 288230376151711744-576460752303423488 ,if 6 it's 430000000000000000-500000000000000000 if 7 500000000000000000-570000000000000000

    Depending on the initial number in hex, we get our initial bytes in bit.

    hex ~610000000000000-6F0000000000000 ~436849163854938112-499899558638125056, 710000000000000-7F0000000000000 ~508906757892866048-571957152676052992.

    6 or 7 implies 110 or 111
    Quote
    ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
    ("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),

    ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
    ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),

    ("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
    ("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),

    ("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
    ("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),

    As we judging by the previous numbers 6 we have mostly hex letters 6ABCDEF and seven with hex numbers 7123456789.

    We narrow our space 6A0000000000000-6F0000000000000 477381560501272576-499899558638125056.

    And we get 16 bytes.

    Quote
    ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
    ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),

    For each of which options are possible with 8-15 zeros.

    But then you have to think further, or launch a "bitcrack" for everyone 16. It can run multiple copies at the same time. Or try to further filter for example in three bytes "111". On the example of our previous number 10110001 10011101 01101110 here are 2 of them "111" the number of options reduced from 8008 to 4802.



    python script
    Quote
    l1= [("10110001")]
     
    #l1= [("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
    #     ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111")]
     

    l2= [("10000000"),("10000001"),("10000010"),("10000011"),("10000100"),("10000101"),("10000110"),("10000111"),
         ("10001000"),("10001001"),("10001010"),("10001011"),("10001100"),("10001101"),("10001110"),("10001111"),
         ("10010000"),("10010001"),("10010010"),("10010011"),("10010100"),("10010101"),("10010110"),("10010111"),
         ("10011000"),("10011001"),("10011010"),("10011011"),("10011100"),("10011101"),("10011110"),("10011111"),
         ("10100000"),("10100001"),("10100010"),("10100011"),("10100100"),("10100101"),("10100110"),("10100111"),
         ("10101000"),("10101001"),("10101010"),("10101011"),("10101100"),("10101101"),("10101110"),("10101111"),
         ("10110000"),("10110001"),("10110010"),("10110011"),("10110100"),("10110101"),("10110110"),("10110111"),
         ("10111000"),("10111001"),("10111010"),("10111011"),("10111100"),("10111101"),("10111110"),("10111111"),
         ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
         ("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
         ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
         ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
         ("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
         ("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
         ("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
         ("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
         ("00000000"),("00000001"),("00000010"),("00000011"),("00000100"),("00000101"),("00000110"),("00000111"),
         ("00001000"),("00001001"),("00001010"),("00001011"),("00001100"),("00001101"),("00001110"),("00001111"),
         ("00010000"),("00010001"),("00010010"),("00010011"),("00010100"),("00010101"),("00010110"),("00010111"),
         ("00011000"),("00011001"),("00011010"),("00011011"),("00011100"),("00011101"),("00011110"),("00011111"),
         ("00100000"),("00100001"),("00100010"),("00100011"),("00100100"),("00100101"),("00100110"),("00100111"),
         ("00101000"),("00101001"),("00101010"),("00101011"),("00101100"),("00101101"),("00101110"),("00101111"),
         ("00110000"),("00110001"),("00110010"),("00110011"),("00110100"),("00110101"),("00110110"),("00110111"),
         ("00111000"),("00111001"),("00111010"),("00111011"),("00111100"),("00111101"),("00111110"),("00111111"),
         ("01000000"),("01000001"),("01000010"),("01000011"),("01000100"),("01000101"),("01000110"),("01000111"),
         ("01001000"),("01001001"),("01001010"),("01001011"),("01001100"),("01001101"),("01001110"),("01001111"),
         ("01010000"),("01010001"),("01010010"),("01010011"),("01010100"),("01010101"),("01010110"),("01010111"),
         ("01011000"),("01011001"),("01011010"),("01011011"),("01011100"),("01011101"),("01011110"),("01011111"),
         ("01100000"),("01100001"),("01100010"),("01100011"),("01100100"),("01100101"),("01100110"),("01100111"),
         ("01101000"),("01101001"),("01101010"),("01101011"),("01101100"),("01101101"),("01101110"),("01101111"),
         ("01110000"),("01110001"),("01110010"),("01110011"),("01110100"),("01110101"),("01110110"),("01110111"),
         ("01111000"),("01111001"),("01111010"),("01111011"),("01111100"),("01111101"),("01111110"),("01111111")]





    def funk():
        for element1 in (l1):
            for element2 in (l2):
                for element3 in (l2):
                    bina = element1+element2+element3
                    nuli = bina.count("0")
                    if nuli == 10: #zeros count
                    
                        print(bina)
                    pass
                else:
                    pass
        return None                                    
                      
    funk()



    [/size]


    when i take the only first 8 bits and start with 110 and the other bits change i have ths space from 60 to 6F

    i search now with this setting with 5 cards with 245 Mkeys per card

    cuBitCrack -d 0 -c -o found0.txt --keyspace 68*************:69************* -b 15 -t 512 -p 4120 -i adresses_50BTC.1.txt --continue test1.txt

    but for every card another search space in this area

    make this sense or not?

  • Andzhig
    Jr. Member
    *
    Offline Offline

    Activity: 184
    Merit: 3


    View Profile
    December 07, 2018, 12:09:40 AM
    Last edit: December 07, 2018, 12:48:28 AM by Andzhig
     #557
    Quote
    make this sense or not?

    Try to run bitcrack in python.

    It’s hard to say how best to look for 1 video card at full speed or run multiple copies of the program for one card at a lower speed but with more space options. Depends on the setting.

    Here is an example script for 20 copies of the program on 1 video card with minimal settings ( apologize, the code may look more compact, I don’t bother with that much).

    My setup example cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s  where new1.txt address list, find.txt file for dropping found,  -c -u comp, uncomp addresses we are also looking for collisions, -b 32 -t 256 -p 15 directly settings for video card it is necessary to select a compromise between the number of copies of the program, or rather the minimum ones at which the program will not begin to crash.

    for work script copy bitcrack prog. files to dir C:\crackbit ,in it to throw the file with addresses and name new1.txt create empty file find.txt. Create empty file with extension on C:\testpy.cmd

    Or rename to your own in the python editor itself Edite\Replace... Replace All...

    Quote
    import random
    from bitcoin import *
    import subprocess
    import time
    #from PyRandLib import *
    #rand = FastRand63()
    #random.seed(rand())


    while 1 == 1:
        ii = 1
        while ii <= 10000000:
            rando = random.randrange(430000000000000000,440000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)


            rando = random.randrange(440000000000000000,450000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(450000000000000000,460000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(460000000000000000,470000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(470000000000000000,480000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(480000000000000000,490000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(490000000000000000,500000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(500000000000000000,510000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(510000000000000000,520000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(520000000000000000,530000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(530000000000000000,540000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(540000000000000000,550000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(550000000000000000,560000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(430000000000000000,440000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(440000000000000000,450000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(450000000000000000,460000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(460000000000000000,470000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(470000000000000000,480000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(480000000000000000,490000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            time.sleep(0.1)

            rando = random.randrange(490000000000000000,550000000000000000,1) #288230376151711744,576460752303423488
            ran = rando
            myhex = "%064x" % ran
            myhex = myhex[:64]
            priv = myhex
            pub = privtopub(priv)
            pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
            addr = pubtoaddr(pubkey1)

            oy = """cd "C:\crackbit" """
            ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
            f=open("C:/testpy.cmd","w")
            f.write (oy)
            f.write (ey)
            f.write (priv)
            f.close()

            subprocess.Popen([r"C:/testpy.cmd"])

            print(rando,addr,priv,bin(rando))

            
            time.sleep(180.0) # time for scan in sec
            subprocess.call("taskkillIM cuBitCrack.exe")
            ii = ii +1

        pass
    [/size]

    Will scan randomly assigned ranges.with a 180 second scan interval.

    Quote
    436255798676581527 1DEJj2kLLPApXWKtvN6LxK4khX6TWe1vRs 000000000000000000000000000000000000000000000000060de45667526c97 0b11000001101111001000101011001100111010100100110110010010111
    441507056942360318 1PfpMYgqG1XvqGAB7VbmEkqi5LJcZXH1tE 00000000000000000000000000000000000000000000000006208c543ee0a6fe 0b11000100000100011000101010000111110111000001010011011111110
    459138491207522404 1P65P9uq3jh6dQGn71ty1ncwetfsYYaDBJ 000000000000000000000000000000000000000000000000065f30066f221864 0b11001011111001100000000011001101111001000100001100001100100
    461915945739820515 1AVY8PpJWoRitWvqLo3TM4Mkjox4DdXHMU 00000000000000000000000000000000000000000000000006690e1af5e91de3 0b11001101001000011100001101011110101111010010001110111100011
    475748685656264755 1QCr7MjWX8KPqroPCGvCd8154TYQSQ7qjb 000000000000000000000000000000000000000000000000069a32e8b2e69033 0b11010011010001100101110100010110010111001101001000000110011
    480437702123105246 1Q5bJch874J1qLFX9d1kGbg5hwS29WXYPZ 00000000000000000000000000000000000000000000000006aadb8b6bc0abde 0b11010101010110110111000101101101011110000001010101111011110
    499681233881334263 1J2jKM66vsbxnQwhny6FNbnFhYW6SoPYhy 00000000000000000000000000000000000000000000000006ef396f4e6d01f7 0b11011101111001110010110111101001110011011010000000111110111
    505963224890171215 1PmhNACinLrHKpZKAe2qRVQHUpb4fg64b2 00000000000000000000000000000000000000000000000007058adf50fd5f4f 0b11100000101100010101101111101010000111111010101111101001111
    519981219040329526 1BdnH1wb1EJ8AerfecP8MoyhhAErELxhdN 00000000000000000000000000000000000000000000000007375829eac5ff36 0b11100110111010110000010100111101010110001011111111100110110
    525573134512519358 1N51AuBTfKXuFW5gz8SmrvZSjXuJUqFS5v 000000000000000000000000000000000000000000000000074b35fb321b78be 0b11101001011001101011111101100110010000110110111100010111110
    535208647800522894 1AKrVPBrepAGQ5iUh1hGtXZtK1UG9jM6oC 000000000000000000000000000000000000000000000000076d716df4de088e 0b11101101101011100010110110111110100110111100000100010001110
    547573542492859303 1218GFAz7U2CMt3Dg1NANWXASRPd2GUehZ 00000000000000000000000000000000000000000000000007995f3c58b06ba7 0b11110011001010111110011110001011000101100000110101110100111
    551235443847304427 1FWRjD8vc5V1292wmwETiEwKEvCRDwnN47 00000000000000000000000000000000000000000000000007a661b7321f94eb 0b11110100110011000011011011100110010000111111001010011101011
    431862599371012664 1NQtY7KvWhLZSMvubxJ1N3qFobn9mWK3vR 00000000000000000000000000000000000000000000000005fe48befb493a38 0b10111111110010010001011111011111011010010010011101000111000
    442689619007000816 1JZQqE3Hq7615DE7akCA6W8WgWGrbAQvpu 0000000000000000000000000000000000000000000000000624bfdceeaa50f0 0b11000100100101111111101110011101110101010100101000011110000
    450054996901302633 1MY1L5LjuLGVqSEGkdTqMa2KrmjPMhBVfW 000000000000000000000000000000000000000000000000063eeaa29bb11169 0b11000111110111010101010001010011011101100010001000101101001
    463404660570563360 1EwsCkEFdGfkDvkyjntydoq7Prrm6kXzeY 000000000000000000000000000000000000000000000000066e58156491a320 0b11001101110010110000001010101100100100100011010001100100000
    476391074956334032 1HM3dYR8RUgwD2NpwpmbGaE5VPpej4hrbu 000000000000000000000000000000000000000000000000069c7b289cf053d0 0b11010011100011110110010100010011100111100000101001111010000
    485975192431053672 1E4YP4KmAu62DiR1rxDmCoNvBKvyq8HAN2 00000000000000000000000000000000000000000000000006be87dcda814b68 0b11010111110100001111101110011011010100000010100101101101000
    495091615987254152 12jHiq9UrxA9Uk38W9B1YH6Y8pVzKJ4VSx 00000000000000000000000000000000000000000000000006deeb339e31c388 0b11011011110111010110011001110011110001100011100001110001000

    180 sec

    Quote
    434397307476904640 1KwmnYnwx3RBdai8Hg6gg9YioUqRE5SyPz 00000000000000000000000000000000000000000000000006074a0cb38c0ac0 0b11000000111010010100000110010110011100011000000101011000000
    448180614452161049 1Dm66qi8M9XV1nXmUpNTXKPkuJfiCqAbka 000000000000000000000000000000000000000000000000063841e4efa32a19 0b11000111000010000011110010011101111101000110010101000011001
    455848687860036132 1AohCP71Q6ETRPAJvfYL1YA9FgJimUrTYD 00000000000000000000000000000000000000000000000006537ff76739b224 0b11001010011011111111111011101100111001110011011001000100100
    462603130947331666 1JRTAE82D57BKeK42BD7V6AEbaUXwVvQh1 000000000000000000000000000000000000000000000000066b7f18bc196652 0b11001101011011111110001100010111100000110010110011001010010
    477874477159224936 1PiJTdZZXpU3qCLhJQ8XDJcTTGfjvyQWbW 00000000000000000000000000000000000000000000000006a1c04e1a4d1668 0b11010100001110000000100111000011010010011010001011001101000
    489611196952328879 1J7acijCcCh6RomLPNGhziRz4UaKeuHWPe 00000000000000000000000000000000000000000000000006cb72ca2065baaf 0b11011001011011100101100101000100000011001011011101010101111
    497692554980595627 1CZf3pPim9Qv5EaM4mPMbrNQ1WAd4bSFoR 00000000000000000000000000000000000000000000000006e828bdeaf997ab 0b11011101000001010001011110111101010111110011001011110101011
    504154894995661991 1LhjwaKt5Z6ZRDp6zRspzxa66vm54L4Uf5 00000000000000000000000000000000000000000000000006ff1e34b3fda4a7 0b11011111111000111100011010010110011111111011010010010100111
    513734719315617733 18S5yDG4t1z6cNy5XL3E4dCsZsLbzJFWuv 000000000000000000000000000000000000000000000000072127015d97a7c5 0b11100100001001001110000000101011101100101111010011111000101
    524089558560688939 1HMtuBWjn84XVrPTp472avYm122Ug9J9mY 0000000000000000000000000000000000000000000000000745f0ad40804b2b 0b11101000101111100001010110101000000100000000100101100101011
    533526184362501078 1LbVYerCAykwoFRNNq1HEcEETnx99kofNN 0000000000000000000000000000000000000000000000000767773ce94be3d6 0b11101100111011101110011110011101001010010111110001111010110
    541141267079494343 1MkHc9tQ2zfWfmKqDjCyZ8mT8DFaxcmQwr 0000000000000000000000000000000000000000000000000782851d8593fac7 0b11110000010100001010001110110000101100100111111101011000111
    557294163226682575 1GbmYRdFQ7Muj2qLETcnFTRjt6JT2nt65W 00000000000000000000000000000000000000000000000007bbe816ba8664cf 0b11110111011111010000001011010111010100001100110010011001111
    431426588295510113 1H7JEXVK6n2DR2m5dvnCGS8mog2Ub5Hpob 00000000000000000000000000000000000000000000000005fcbc323e033861 0b10111111100101111000011001000111110000000110011100001100001
    440184254933268814 16unzLvdVK3onNS5PkUELXvYELMEnj25Aj 000000000000000000000000000000000000000000000000061bd93f6704794e 0b11000011011110110010011111101100111000001000111100101001110
    452076765920283756 13uebyVH62vYMvKKKiWWtXFCv1EMyFMxQE 0000000000000000000000000000000000000000000000000646196c63e2cc6c 0b11001000110000110010110110001100011111000101100110001101100
    466109431548019383 14sP97eQyj6GRXAdccdpdpbLF67EzVNd4r 0000000000000000000000000000000000000000000000000677f40ef5e102b7 0b11001110111111101000000111011110101111000010000001010110111
    473565831398854640 1GgMgAuUF4U8XjYo5pGFmuZvPRbSoxJYaJ 0000000000000000000000000000000000000000000000000692719d564a8ff0 0b11010010010011100011001110101010110010010101000111111110000
    481001336899844371 13sMZvkWA7aqSKAXAtAPWEwS2UQFc3Wruc 00000000000000000000000000000000000000000000000006acdc2ade673913 0b11010101100110111000010101011011110011001110011100100010011
    505710979847703937 19LpNTAN5orXp3pD27Hkqy3BKB1p88uyyz 0000000000000000000000000000000000000000000000000704a574f0d64d81 0b11100000100101001010111010011110000110101100100110110000001

    On 5 cards, maybe you can run 500 copies of the program at the same time.

  • Andzhig
    Jr. Member
    *
    Offline Offline

    Activity: 184
    Merit: 3


    View Profile
    December 07, 2018, 12:35:24 AM
     #558
    It may be worth looking for the next 10-20 filter puzzles 60,61,62,63.... Need to analyze what bits can be in those addresses, there, of course, the error (deviation) may exceed the number with 9 zeros.

                                                                                                             0  111  101        
    101100011001110101101110 0001010010000110001001101000100001 33-25   10  2    3      11640174 B19D6E
    111101011001001011100100 100000111100101011101011000011100 28-29     11  2    2        16093924 F592E4
    100111010001100010110110 00111010110001001111111111011111 22-34      12  1    3        10295478 9D18B6
    110101010111110000111111 0011011011001111110000100010100 24-31        8   3    2        13990975 D57C3F
    100011011011111011011011 010101101011010001111101000100 23-31          8   1    5        9289435  8DBEDB
    110000000011110001000111 00100011111100011001001101100 29-24           14  2    0        12598343 C03C47
    111011111010111000010110 0100110010111001111000111100 22-30             9   3    3        15707670 EFAE16
    111010100000111000010100 001101000000000100111010000 33-18              14  2    2        15339028 EA0E14
    100010101111010100001111 00001011101001001101010100 26-24               11  2    2        9106703  8AF50F
    101110100000101110110101 1000000010101111101001101 24-25                 11  2    5        12192693 BA0BB5
    101011011110011011010111 110011100011101110011011  17-31                  8   2    4        11396823 ADE6D7
    110110011010110000100001 01101010011110010111010  23-24                   13  0    2        14265377 D9AC21
    101110110000011000001110 0010001101010101000100 27-19                     13  2    2        12256782 BB060E
    100100010111111001010000 101000011110000000101 26 -19                      13  2    2        9535056  917E50
    111000000010101100110101 10100011010110001111 22-22                        13  1    2        14691125 E02B35
    110101111010011101100100 1111100010110010001 19-24                          10  2    3        14133092 D7A764
    101010001000100001110001 011000110110001111 23-19                           15  1    1        11044977 A88871
    101010011100001101001101 01100110001011011 20-21                             12  1    3        11125581 A9C34D
    111010011010111001001001 0011001111010110  18-22                             11  2    2       15314505 E9AE49
    100101101011111100000110 000001111101001  19-20                               11  2    2        9879302  96BF06
    100010001110000010111110 10110011010000 21-17                                 13  2    1        8970430  88E0BE
    101110101011101110101011 0101010010011 14 -22                                  8   3    6        12237739 BABBAB
    100111011110100000100000 101001111100 19- 17                                   14  2    2        10348576 9DE820
    100101011101101001000010 00101110000 20-15                                     13  1    3        9820738  95DA42
    110100101001100101100100 0100011101 18-16                                       13  0    3        13801828 D29964
    110101001011011001010100 011011000 17-16                                        12  0    4        13940308 D4B654
    101110000110001010100110 00101110  17-15                                         13  1    2        12083878 B862A6
    111110101001111111001110 1000111  10-21                                           7   4    1        16424910 FA9FCE
    111101100101001100110101 100100 14-16                                             10  1    3        16143157 F65335
    101111110001001010101000 11110 13-16                                              12  2    3        12522152 BF12A8
    110110010001011011001110 1000 14-14                                                11  1    3        14227150 D916CE
    110101011000011100001110 101 13-14                                                 12  2    2        13993742 D5870E
    110100000000110010011011 10 15-11                                                  14  0    2        13634715 D00C9B
    111111010010111101110010 1 8-17                                                      8   4    3        16592754 FD2F72
    110111000010101000000100  15-9                                                       15  1    2        14428676 DC2A04

    repeat 4 > 11 2 2, repeat 2 > 10 2 3,  repeat 2 > 12 1 3, repeat 2 > 14 2 2 ,repeat 2> 13 2 2.  

  • PietCoin97
    Jr. Member
    *
    Offline Offline

    Activity: 91
    Merit: 3


    View Profile
    December 07, 2018, 02:32:00 PM
     #559
    OK so the code will be really long with 500 starting points.

    So how do this code work do the code check mabey 10mkey per search space and then the change after 180 sec?

    And do the code print all like you show me or only founds?

  • Andzhig
    Jr. Member
    *
    Offline Offline

    Activity: 184
    Merit: 3


    View Profile
    December 07, 2018, 06:07:54 PM
    Last edit: December 07, 2018, 06:20:54 PM by Andzhig
     #560
    Quote
    And do the code print all like you show me or only founds?
    not understood. Only this will write or that you indicate to him in the "print (blablabla)". python 3 just run bitcrack so that it does not start manually. Can run from python idle, can simply double click on the blablabla.py file script without idle.

    110101110001101001111000 484369781529509888 18PeFv41FQ7uVDdNGt7i1LfnZZyezSsejP 00000000000000000000000000000000000000000000000006b8d3c000000000 0b11010111000110100111100000000000000000000000000000000000000
    110101101000001110001010 483042189958447104 1EJg7g9vsQPCRuGaVxAUHGiwsZ5b4H4h4K 00000000000000000000000000000000000000000000000006b41c5000000000 0b11010110100000111000101000000000000000000000000000000000000
    110101110011000101010111 484570957797654528 1A1D9jeYo8r7fkkTRLDRoMMn4iMSkytjcw 00000000000000000000000000000000000000000000000006b98ab800000000 0b11010111001100010101011100000000000000000000000000000000000
    110100111000001000111111 476275417443991552 16aVvWoxxC4eJ8cEtP4FUpz3cLaB2pPV12 000000000000000000000000000000000000000000000000069c11f800000000 0b11010011100000100011111100000000000000000000000000000000000
    110100111011011000110111 476732539403239424 1Mbyuvjvyty1Lc849rn87mhQRE6v6FpQHQ 000000000000000000000000000000000000000000000000069db1b800000000 0b11010011101101100011011100000000000000000000000000000000000
    110111010100111100011100 498343612245868544 121Hz1XawZudRzMhtEYNxceTUFvrLfwCYK 00000000000000000000000000000000000000000000000006ea78e000000000 0b11011101010011110001110000000000000000000000000000000000000
    110101010000011010001000 479690809797509120 15EKuQWW97hDEysicZMbojpGGQWoB2VBhy 00000000000000000000000000000000000000000000000006a8344000000000 0b11010101000001101000100000000000000000000000000000000000000
    110101000010000011110111 477671522333360128 1MvzoKWtgELYWMwMbstqyBEhDREGL4KwXN 00000000000000000000000000000000000000000000000006a107b800000000 0b11010100001000001111011100000000000000000000000000000000000
    110101011001100111101000 480987134006657024 1DTwSYy5X2zLTcRZq5EcFKfk5ctMPFmcCt 00000000000000000000000000000000000000000000000006accf4000000000 0b11010101100110011110100000000000000000000000000000000000000
    110110010011011010010000 489120496395223040 1J5WMtSWrufSZ5u36DoBucXQLqVHB3N7Qh 00000000000000000000000000000000000000000000000006c9b48000000000 0b11011001001101101001000000000000000000000000000000000000000

    Try this one for the test (yet without filter 111 101).

    Settings, anyway, will have to sort out. You have such  -b 15 -t 512 -p 4120 why did you choose -b 15? Let's try these -b 32 -t 256 -p 512 for 10 copies.

    Quote
    import random
    from bitcoin import *
    import subprocess
    import time
    #from PyRandLib import *
    #rand = FastRand63()
    #random.seed(rand())

    #l1= [("11010000")]

    l1= [("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"), # start 8 bit, random list or 1 first.
         ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111")]
     

    l2= [("10000000"),("10000001"),("10000010"),("10000011"),("10000100"),("10000101"),("10000110"),("10000111"), # second and third bits random list.
         ("10001000"),("10001001"),("10001010"),("10001011"),("10001100"),("10001101"),("10001110"),("10001111"),
         ("10010000"),("10010001"),("10010010"),("10010011"),("10010100"),("10010101"),("10010110"),("10010111"),
         ("10011000"),("10011001"),("10011010"),("10011011"),("10011100"),("10011101"),("10011110"),("10011111"),
         ("10100000"),("10100001"),("10100010"),("10100011"),("10100100"),("10100101"),("10100110"),("10100111"),
         ("10101000"),("10101001"),("10101010"),("10101011"),("10101100"),("10101101"),("10101110"),("10101111"),
         ("10110000"),("10110001"),("10110010"),("10110011"),("10110100"),("10110101"),("10110110"),("10110111"),
         ("10111000"),("10111001"),("10111010"),("10111011"),("10111100"),("10111101"),("10111110"),("10111111"),
         ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
         ("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
         ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
         ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
         ("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
         ("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
         ("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
         ("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
         ("00000000"),("00000001"),("00000010"),("00000011"),("00000100"),("00000101"),("00000110"),("00000111"),
         ("00001000"),("00001001"),("00001010"),("00001011"),("00001100"),("00001101"),("00001110"),("00001111"),
         ("00010000"),("00010001"),("00010010"),("00010011"),("00010100"),("00010101"),("00010110"),("00010111"),
         ("00011000"),("00011001"),("00011010"),("00011011"),("00011100"),("00011101"),("00011110"),("00011111"),
         ("00100000"),("00100001"),("00100010"),("00100011"),("00100100"),("00100101"),("00100110"),("00100111"),
         ("00101000"),("00101001"),("00101010"),("00101011"),("00101100"),("00101101"),("00101110"),("00101111"),
         ("00110000"),("00110001"),("00110010"),("00110011"),("00110100"),("00110101"),("00110110"),("00110111"),
         ("00111000"),("00111001"),("00111010"),("00111011"),("00111100"),("00111101"),("00111110"),("00111111"),
         ("01000000"),("01000001"),("01000010"),("01000011"),("01000100"),("01000101"),("01000110"),("01000111"),
         ("01001000"),("01001001"),("01001010"),("01001011"),("01001100"),("01001101"),("01001110"),("01001111"),
         ("01010000"),("01010001"),("01010010"),("01010011"),("01010100"),("01010101"),("01010110"),("01010111"),
         ("01011000"),("01011001"),("01011010"),("01011011"),("01011100"),("01011101"),("01011110"),("01011111"),
         ("01100000"),("01100001"),("01100010"),("01100011"),("01100100"),("01100101"),("01100110"),("01100111"),
         ("01101000"),("01101001"),("01101010"),("01101011"),("01101100"),("01101101"),("01101110"),("01101111"),
         ("01110000"),("01110001"),("01110010"),("01110011"),("01110100"),("01110101"),("01110110"),("01110111"),
         ("01111000"),("01111001"),("01111010"),("01111011"),("01111100"),("01111101"),("01111110"),("01111111")]


    def take1():
        yy = str(random.choice(l1))
        return yy

    def take2():
        uu = str(random.choice(l2))
        return uu

    def rana():
        s = [take2(),take2()]
        d = ''.join(random.sample(s,len(s)))
        bina = (take1()+d)
        return bina


    def funk():
        aaa = rana()
        b = int(aaa,2)*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2
        ran = b
        myhex = "%064x" % ran
        myhex = myhex[:64]
        priv = myhex
        pub = privtopub(priv)
        pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
        addr = pubtoaddr(pubkey1)

        oy = """cd "C:\crackbit" """
        ey = "\nstartmin cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 512 -s " # bitcrack settings
        f=open("C:/testpy.cmd","w")
        f.write (oy)
        f.write (ey)
        f.write (priv)
        f.close()

        subprocess.Popen([r"C:/testpy.cmd"])

        print(aaa,b,addr,priv,bin(b)) # print(blablabla)

        time.sleep(0.1)
        return None
                    
    while True:
        for a in range(10): # number of copies
            funk()

        time.sleep(180.0) # break between restarts, scan time, in sec
        subprocess.call("taskkillIM cuBitCrack.exe")
    [/size]
    Pages: « 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 [28] 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 ... 568 »
      Print  
Page 27
Viewing Page: 28

IRLBTC™ © 2025 IRLBTC.com