Bitcoin Forum
February 10, 2025, 11:05:05 AM *
News: Community Awards voting is open
 
   Home   Help Search Login Register More  
Pages: « 1 ... 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 [157] 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 ... 369 »
  Print  
Author Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it  (Read 253280 times)
lordfrs
Jr. Member
*
Offline Offline

Activity: 57
Merit: 1


View Profile
August 12, 2023, 07:04:17 AM
 #3121

Puzzle #66 is not about pattern dudes

is all about logic and hardware power

If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.

there's no pattern.

I rented 4090s for 2 months. how do you think I lost the $23k?

what I need to know is what you meant by "optimized software"

Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan.

and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range.

Please explain...

I am still waiting for an explanation for your defined term "optimized software"

The fastest I can achieve on a 14 * 4090 is below

GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 03:37:01 2023
Global start : 2CA60FFFFFFFFFFFF (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 1359F000000000001 (65 bit)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

[00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0]

So I want to understand your magic for the defined term optimized software


where did you rent the cards ?

If you want to buy me a coffee

Btc = 3246y1G9YjnQQNRUrVMnaeCFrymZRgJAP7

Doge = DGNd8UTi8jVTVZ2twhKydyqicynbsERMjs
bestie1549
Jr. Member
*
Offline Offline

Activity: 75
Merit: 5


View Profile
August 12, 2023, 07:35:01 AM
 #3122

Puzzle #66 is not about pattern dudes

is all about logic and hardware power

If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.

there's no pattern.

I rented 4090s for 2 months. how do you think I lost the $23k?

what I need to know is what you meant by "optimized software"

Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan.

and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range.

Please explain...

I am still waiting for an explanation for your defined term "optimized software"

The fastest I can achieve on a 14 * 4090 is below

GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 03:37:01 2023
Global start : 2CA60FFFFFFFFFFFF (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 1359F000000000001 (65 bit)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

[00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0]

So I want to understand your magic for the defined term optimized software


where did you rent the cards ?

vast.ai
bestie1549
Jr. Member
*
Offline Offline

Activity: 75
Merit: 5


View Profile
August 12, 2023, 10:18:56 AM
 #3123

Puzzle #66 is not about pattern dudes

is all about logic and hardware power

If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.

there's no pattern.

I rented 4090s for 2 months. how do you think I lost the $23k?

what I need to know is what you meant by "optimized software"

Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan.

and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range.

Please explain...

I am still waiting for an explanation for your defined term "optimized software"

The fastest I can achieve on a 14 * 4090 is below

GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 03:37:01 2023
Global start : 2CA60FFFFFFFFFFFF (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 1359F000000000001 (65 bit)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

[00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0]

So I want to understand your magic for the defined term optimized software


where did you rent the cards ?

vast.ai

I achieved the same result with 12 devices in a single machine

"
KeyHunt-Cuda v1.07

COMP MODE    : COMPRESSED
COIN TYPE    : BITCOIN
SEARCH MODE  : Single Address
DEVICE       : GPU
CPU THREAD   : 0
GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
GPU GRIDSIZE : 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 10:07:11 2023
Global start : 2E601111111111111 (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 119FEEEEEEEEEEEEF (65 bit)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

[00:04:38] [CPU+GPU: 71921.28 Mk/s] [GPU: 71921.28 Mk/s] [C: 0.000094 %] [R: 0] [T: 19,155,554,140,160 (45 bit)] [F: 0]
"

But the time is still not adding up... if you can do the calculations and also note the costs of renting the machines. you would end up resorting to random generation of at least the 1st 1 to 3 characters because scanning all that range from 20 to wherever you think the key would be doesn't cost pennies

but the 1s and 0s scanning can assure you you scanned all the ranges covering that specifically defined bit ranges without worries
and you can just keep doing it over and over again until you find the bit configuration for the specified puzzle you're searching for
tptkimikaze
Newbie
*
Offline Offline

Activity: 25
Merit: 2


View Profile
August 12, 2023, 11:32:21 AM
 #3124

Puzzle #66 is not about pattern dudes

is all about logic and hardware power

If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.

there's no pattern.

I rented 4090s for 2 months. how do you think I lost the $23k?

what I need to know is what you meant by "optimized software"

Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan.

and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range.

Please explain...

I am still waiting for an explanation for your defined term "optimized software"

The fastest I can achieve on a 14 * 4090 is below

GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 03:37:01 2023
Global start : 2CA60FFFFFFFFFFFF (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 1359F000000000001 (65 bit)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512)

[00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0]

So I want to understand your magic for the defined term optimized software


where did you rent the cards ?

vast.ai

I achieved the same result with 12 devices in a single machine

"
KeyHunt-Cuda v1.07

COMP MODE    : COMPRESSED
COIN TYPE    : BITCOIN
SEARCH MODE  : Single Address
DEVICE       : GPU
CPU THREAD   : 0
GPU IDS      : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
GPU GRIDSIZE : 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512
SSE          : YES
RKEY         : 0 Mkeys
MAX FOUND    : 65536
BTC ADDRESS  : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
OUTPUT FILE  : Found.txt

Start Time   : Sat Aug 12 10:07:11 2023
Global start : 2E601111111111111 (66 bit)
Global end   : 40000000000000000 (67 bit)
Global range : 119FEEEEEEEEEEEEF (65 bit)

GPU          : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

GPU          : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512)

[00:04:38] [CPU+GPU: 71921.28 Mk/s] [GPU: 71921.28 Mk/s] [C: 0.000094 %] [R: 0] [T: 19,155,554,140,160 (45 bit)] [F: 0]
"

But the time is still not adding up... if you can do the calculations and also note the costs of renting the machines. you would end up resorting to random generation of at least the 1st 1 to 3 characters because scanning all that range from 20 to wherever you think the key would be doesn't cost pennies

but the 1s and 0s scanning can assure you you scanned all the ranges covering that specifically defined bit ranges without worries
and you can just keep doing it over and over again until you find the bit configuration for the specified puzzle you're searching for

I guess that's what James idea trying to tell. Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range.
tptkimikaze
Newbie
*
Offline Offline

Activity: 25
Merit: 2


View Profile
August 12, 2023, 11:48:04 AM
Last edit: August 12, 2023, 12:05:04 PM by tptkimikaze
 #3125

Code:
from itertools import combinations
import sys


def place_ones(size, count):
    for positions in combinations(range(size), count):
        p = [0] * size

        for i in positions:
            p[i] = 1

        yield p

f = open("demo.txt", "a")
print(list(place_ones(60, 30)), file=f)

f.close())

Simple combination for bits. Maybe someone can add some coding to convert 0s and 1s to hexadecimal, print in bat file, put it in bitcrack and run it.

Step 1

Let's say start scanning from 60 bits.

0s - 30 - 1s -30 = 50%
0s - 31 - 1s  29 = 51.67%
0s - 32 - 1s  28 = 53.4%
0s - 33 - 1s  27 = 55%
0s - 34 - 1s  26 = 56.67%
0s - 35 - 1s  25 = 58.34%
0s - 36 - 1s  24 = 60%

Then reverse 0s and 1s position in max 60% which is most likely where the key are.

Step 2
Convert Binary to Hexa

Step 3
Print in .CMD for continuous execution in Bitcrack.

Step 4
Run until it hits the key or else increase the percentages if it doesn't.

Make sense or any argument?

I am doing it already but doesn't have huge power like you guys. Maybe share it here and someone can crack it very soon here.
vneos
Newbie
*
Offline Offline

Activity: 27
Merit: 9


View Profile
August 12, 2023, 12:07:47 PM
 #3126

Quote
Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range.

The key is how to write code to run the specified 0 and 1 digits on the gpu.

Also, I think that there is a high probability that the hexadecimal number of the private key for puzzle 66 starts with 3. That is, the highest 2 bits of the binary private key we can both set to 1, and we can specify the number of bits for 0s and 1s, and we can even search for less than just 2^63 private keys if we use bits with a probability of more than 40%! Of course, this is an extreme case, using too many coincidences.

If we continue to exclude combinations with negligible probability, such as 10 consecutive 0's or 1's, then the search space will be further reduced.

tptkimikaze
Newbie
*
Offline Offline

Activity: 25
Merit: 2


View Profile
August 12, 2023, 12:10:52 PM
 #3127

Quote
Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range.

The key is how to write code to run the specified 0 and 1 digits on the gpu.

Also, I think that there is a high probability that the hexadecimal number of the private key for puzzle 66 starts with 3. That is, the highest 2 bits of the binary private key we can both set to 1, and we can specify the number of bits for 0s and 1s, and we can even search for less than just 2^63 private keys if we use bits with a probability of more than 40%! Of course, this is an extreme case, using too many coincidences.

If we continue to exclude combinations with negligible probability, such as 10 consecutive 0's or 1's, then the search space will be further reduced.



You don't write it in GPU. Just write it in Python, print it in CMD and automate it in Bitcrack. Then the whole thing transfered to GPU already with Bitcrack.
tptkimikaze
Newbie
*
Offline Offline

Activity: 25
Merit: 2


View Profile
August 12, 2023, 12:19:58 PM
 #3128

Quote
Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range.

The key is how to write code to run the specified 0 and 1 digits on the gpu.

Also, I think that there is a high probability that the hexadecimal number of the private key for puzzle 66 starts with 3. That is, the highest 2 bits of the binary private key we can both set to 1, and we can specify the number of bits for 0s and 1s, and we can even search for less than just 2^63 private keys if we use bits with a probability of more than 40%! Of course, this is an extreme case, using too many coincidences.

If we continue to exclude combinations with negligible probability, such as 10 consecutive 0's or 1's, then the search space will be further reduced.



Step 1

Let's say start scanning from 60 bits. Coding in Python.

0s - 30 - 1s -30 = 50%
0s - 31 - 1s  29 = 51.67%
0s - 32 - 1s  28 = 53.4%
0s - 33 - 1s  27 = 55%
0s - 34 - 1s  26 = 56.67%
0s - 35 - 1s  25 = 58.34%
0s - 36 - 1s  24 = 60%

Then reverse 0s and 1s position in max 60% which is most likely where the key are.

Step 2
Convert Binary to Hexa

Step 3
Print in .CMD for continuous execution in Bitcrack.

Step 4
Run until it hits the key or else increase the percentages if it doesn't.

Make sense?
vneos
Newbie
*
Offline Offline

Activity: 27
Merit: 9


View Profile
August 12, 2023, 12:21:45 PM
Last edit: August 12, 2023, 08:50:41 PM by Mr. Big
 #3129

Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Code:
000000000000000000000000000000000000000000000000000000003d94cd64
hash160: d39c4704664e1deb76c9331e637564c257d68a08
Target hash found!
Time: 0 h, 1 m, 28 s

Code:
import hashlib
import ecdsa
import random
import time
from multiprocessing import Process, Event

target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"

def binary_to_hex(bin_string):
    return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)


def worker(num_zeros, num_ones, stop_event):


    while True:
        if stop_event.is_set():
            break

        bits = ['0'] * num_zeros + ['1'] * (num_ones - 4)
        random.shuffle(bits)

        bits.insert(0, '1')
        bits.insert(1, '1')
        bits.insert(2, '1')
        bits.insert(3, '1')
        private_key_bin = ''.join(bits)

        private_key_bin = '0' * (256 - 30) + private_key_bin

        private_key_hex = binary_to_hex(private_key_bin)

        sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1)
        public_key = sk.get_verifying_key().to_string().hex()

        compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64]
        compressed_public_key_bytes = bytes.fromhex(compressed_public_key)

        ripemd160_hash = hashlib.new('ripemd160')
        ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest())
        hashed_compressed_public_key = ripemd160_hash.digest().hex()


        if hashed_compressed_public_key == target_hash:
            print(private_key_hex)
            print("hash160:", hashed_compressed_public_key)
            print("Target hash found!")

            stop_event.set()
            break



def main():
    num_processes = 12
    processes = []
    stop_event = Event()

    start_time = time.time()

    for _ in range(num_processes):
        process = Process(target=worker, args=(14, 16, stop_event))
        processes.append(process)

    for process in processes:
        process.start()

    for process in processes:
        process.join()

    if stop_event.is_set():
        for process in processes:
            process.terminate()

    end_time = time.time()
    execution_time_seconds = end_time - start_time

    hours = int(execution_time_seconds // 3600)
    minutes = int((execution_time_seconds % 3600) // 60)
    seconds = int(execution_time_seconds % 60)

    print(f"Time: {hours} h, {minutes} m, {seconds} s")



if __name__ == '__main__':
    main()



Quote
Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Of course, it's just trying my luck. But who isn't trying their luck for hunters who don't have a lot of gpu? I believe that any other tool used by each of us hunters with only a small amount of resources is using random mode to search for private keys, so why not rule out some combinations with lower probability to try some private keys with higher probability?
digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
August 12, 2023, 01:08:44 PM
 #3130

Quote
Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Of course, it's just trying my luck. But who isn't trying their luck for hunters who don't have a lot of gpu? I believe that any other tool used by each of us hunters with only a small amount of resources is using random mode to search for private keys, so why not rule out some combinations with lower probability to try some private keys with higher probability?
More importantly, why do you guys wasting your time on keys with no exposed public key? While you depend on luck trying to find #66, you could use your skills to find a way to reduce the range of public keys.😉

🖤😏
tptkimikaze
Newbie
*
Offline Offline

Activity: 25
Merit: 2


View Profile
August 12, 2023, 02:27:52 PM
 #3131

Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Code:
000000000000000000000000000000000000000000000000000000003d94cd64
hash160: d39c4704664e1deb76c9331e637564c257d68a08
Target hash found!
Time: 0 h, 1 m, 28 s

Code:
import hashlib
import ecdsa
import random
import time
from multiprocessing import Process, Event

target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"

def binary_to_hex(bin_string):
    return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)


def worker(num_zeros, num_ones, stop_event):


    while True:
        if stop_event.is_set():
            break

        bits = ['0'] * num_zeros + ['1'] * (num_ones - 4)
        random.shuffle(bits)

        bits.insert(0, '1')
        bits.insert(1, '1')
        bits.insert(2, '1')
        bits.insert(3, '1')
        private_key_bin = ''.join(bits)

        private_key_bin = '0' * (256 - 30) + private_key_bin

        private_key_hex = binary_to_hex(private_key_bin)

        sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1)
        public_key = sk.get_verifying_key().to_string().hex()

        compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64]
        compressed_public_key_bytes = bytes.fromhex(compressed_public_key)

        ripemd160_hash = hashlib.new('ripemd160')
        ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest())
        hashed_compressed_public_key = ripemd160_hash.digest().hex()


        if hashed_compressed_public_key == target_hash:
            print(private_key_hex)
            print("hash160:", hashed_compressed_public_key)
            print("Target hash found!")

            stop_event.set()
            break



def main():
    num_processes = 12
    processes = []
    stop_event = Event()

    start_time = time.time()

    for _ in range(num_processes):
        process = Process(target=worker, args=(14, 16, stop_event))
        processes.append(process)

    for process in processes:
        process.start()

    for process in processes:
        process.join()

    if stop_event.is_set():
        for process in processes:
            process.terminate()

    end_time = time.time()
    execution_time_seconds = end_time - start_time

    hours = int(execution_time_seconds // 3600)
    minutes = int((execution_time_seconds % 3600) // 60)
    seconds = int(execution_time_seconds % 60)

    print(f"Time: {hours} h, {minutes} m, {seconds} s")



if __name__ == '__main__':
    main()

I just try it and I can find it in 30 sec on #30. For #66 it's still difficult to scan without GPU.
james5000
Jr. Member
*
Offline Offline

Activity: 69
Merit: 2


View Profile
August 12, 2023, 04:09:34 PM
 #3132

Folks, the focus shouldn't be on how many 1s or 0s bits keys should have; it should be on how to scan faster or how we can skip less probable keys.
james5000
Jr. Member
*
Offline Offline

Activity: 69
Merit: 2


View Profile
August 12, 2023, 04:44:03 PM
 #3133

Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Code:
000000000000000000000000000000000000000000000000000000003d94cd64
hash160: d39c4704664e1deb76c9331e637564c257d68a08
Target hash found!
Time: 0 h, 1 m, 28 s

Code:
import hashlib
import ecdsa
import random
import time
from multiprocessing import Process, Event

target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"

def binary_to_hex(bin_string):
    return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)


def worker(num_zeros, num_ones, stop_event):


    while True:
        if stop_event.is_set():
            break

        bits = ['0'] * num_zeros + ['1'] * (num_ones - 4)
        random.shuffle(bits)

        bits.insert(0, '1')
        bits.insert(1, '1')
        bits.insert(2, '1')
        bits.insert(3, '1')
        private_key_bin = ''.join(bits)

        private_key_bin = '0' * (256 - 30) + private_key_bin

        private_key_hex = binary_to_hex(private_key_bin)

        sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1)
        public_key = sk.get_verifying_key().to_string().hex()

        compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64]
        compressed_public_key_bytes = bytes.fromhex(compressed_public_key)

        ripemd160_hash = hashlib.new('ripemd160')
        ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest())
        hashed_compressed_public_key = ripemd160_hash.digest().hex()


        if hashed_compressed_public_key == target_hash:
            print(private_key_hex)
            print("hash160:", hashed_compressed_public_key)
            print("Target hash found!")

            stop_event.set()
            break



def main():
    num_processes = 12
    processes = []
    stop_event = Event()

    start_time = time.time()

    for _ in range(num_processes):
        process = Process(target=worker, args=(14, 16, stop_event))
        processes.append(process)

    for process in processes:
        process.start()

    for process in processes:
        process.join()

    if stop_event.is_set():
        for process in processes:
            process.terminate()

    end_time = time.time()
    execution_time_seconds = end_time - start_time

    hours = int(execution_time_seconds // 3600)
    minutes = int((execution_time_seconds % 3600) // 60)
    seconds = int(execution_time_seconds % 60)

    print(f"Time: {hours} h, {minutes} m, {seconds} s")



if __name__ == '__main__':
    main()

I just try it and I can find it in 30 sec on #30. For #66 it's still difficult to scan without GPU.

Try also for #35, #40, or #45.
bestie1549
Jr. Member
*
Offline Offline

Activity: 75
Merit: 5


View Profile
August 12, 2023, 05:33:50 PM
 #3134

Folks, the focus shouldn't be on how many 1s or 0s bits keys should have; it should be on how to scan faster or how we can skip less probable keys.
That's the point right there folk.
Before BitCrack was developed do you think people were scanning at the speed we're scanning right now?
Before BitCrack was developed people were only scanning in thousands and million keys/s and even when BitCrack was developed the GPUs available at that time were not as powerful as the ones we have right now. I understand that some projects needs to be funded but the point is that some people here don't see potentials in the logic but I believe these people are also willing to give us better means to solve the puzzles without the exposed public keys because there will be a time when all the public keys stages would have been successfully conquered and we would all be forced to start scanning the stages without the exposed public keys which would be some kind of problem then because we had only chosen to stick to the stages with the exposed pubkeys. Now let us start with making something work. the probability of guessing the 0s and 1s in levels without the pubkeys is much higher than the probability of guessing if puzzle 66 starts with either 2 or 3 because for you to find out if its 2 or 3 you'd have had to scan half of the keyspace and if you're wrong then you'd see that the investment used and time wasted to scan that range alone isn't worth it compared to guessing the 0s and 1s.

I buy the 0s and  1s scanning methodology pretty well but I'd advise we look for a way to make the scan work faster and not only based on CPUs. If we can get the logic to work efficiently well on GPUs, I'm not saying 1 week to scan the level 66,67 and 68 but we can achieve that in 3 days, with the availability of GPUs on demand and it will as well be cost efficient than scanning through all the ranges endlessly
tptkimikaze
Newbie
*
Offline Offline

Activity: 25
Merit: 2


View Profile
August 12, 2023, 07:16:01 PM
 #3135

Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Code:
000000000000000000000000000000000000000000000000000000003d94cd64
hash160: d39c4704664e1deb76c9331e637564c257d68a08
Target hash found!
Time: 0 h, 1 m, 28 s

Code:
import hashlib
import ecdsa
import random
import time
from multiprocessing import Process, Event

target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"

def binary_to_hex(bin_string):
    return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)


def worker(num_zeros, num_ones, stop_event):


    while True:
        if stop_event.is_set():
            break

        bits = ['0'] * num_zeros + ['1'] * (num_ones - 4)
        random.shuffle(bits)

        bits.insert(0, '1')
        bits.insert(1, '1')
        bits.insert(2, '1')
        bits.insert(3, '1')
        private_key_bin = ''.join(bits)

        private_key_bin = '0' * (256 - 30) + private_key_bin

        private_key_hex = binary_to_hex(private_key_bin)

        sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1)
        public_key = sk.get_verifying_key().to_string().hex()

        compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64]
        compressed_public_key_bytes = bytes.fromhex(compressed_public_key)

        ripemd160_hash = hashlib.new('ripemd160')
        ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest())
        hashed_compressed_public_key = ripemd160_hash.digest().hex()


        if hashed_compressed_public_key == target_hash:
            print(private_key_hex)
            print("hash160:", hashed_compressed_public_key)
            print("Target hash found!")

            stop_event.set()
            break



def main():
    num_processes = 12
    processes = []
    stop_event = Event()

    start_time = time.time()

    for _ in range(num_processes):
        process = Process(target=worker, args=(14, 16, stop_event))
        processes.append(process)

    for process in processes:
        process.start()

    for process in processes:
        process.join()

    if stop_event.is_set():
        for process in processes:
            process.terminate()

    end_time = time.time()
    execution_time_seconds = end_time - start_time

    hours = int(execution_time_seconds // 3600)
    minutes = int((execution_time_seconds % 3600) // 60)
    seconds = int(execution_time_seconds % 60)

    print(f"Time: {hours} h, {minutes} m, {seconds} s")



if __name__ == '__main__':
    main()

I just try it and I can find it in 30 sec on #30. For #66 it's still difficult to scan without GPU.

Try also for #35, #40, or #45.

Scan it in python without GPU too slow for 66 bit. The only way I can figure out now as I previous posted.

Step 1

Let's say start scanning from 60 bits. Use Python to do the combination.

0s - 30 - 1s -30 = 50%
0s - 31 - 1s  29 = 51.67%
0s - 32 - 1s  28 = 53.4%
0s - 33 - 1s  27 = 55%
0s - 34 - 1s  26 = 56.67%
0s - 35 - 1s  25 = 58.34%
0s - 36 - 1s  24 = 60%

Then reverse 0s and 1s position in max 60% which is most likely where the key are.

Step 2
Convert results from Binary to Hexa

Step 3
Make a batch file and run in Bitcrack to use GPU

Step 4
Run until it hits the key or else increase the percentages if it doesn't.

By using Python to eliminate those less like key first, then scan the list with GPU
tptkimikaze
Newbie
*
Offline Offline

Activity: 25
Merit: 2


View Profile
August 12, 2023, 07:35:45 PM
 #3136

Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds.

Code:
000000000000000000000000000000000000000000000000000000003d94cd64
hash160: d39c4704664e1deb76c9331e637564c257d68a08
Target hash found!
Time: 0 h, 1 m, 28 s

Code:
import hashlib
import ecdsa
import random
import time
from multiprocessing import Process, Event

target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"

def binary_to_hex(bin_string):
    return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)


def worker(num_zeros, num_ones, stop_event):


    while True:
        if stop_event.is_set():
            break

        bits = ['0'] * num_zeros + ['1'] * (num_ones - 4)
        random.shuffle(bits)

        bits.insert(0, '1')
        bits.insert(1, '1')
        bits.insert(2, '1')
        bits.insert(3, '1')
        private_key_bin = ''.join(bits)

        private_key_bin = '0' * (256 - 30) + private_key_bin

        private_key_hex = binary_to_hex(private_key_bin)

        sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1)
        public_key = sk.get_verifying_key().to_string().hex()

        compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64]
        compressed_public_key_bytes = bytes.fromhex(compressed_public_key)

        ripemd160_hash = hashlib.new('ripemd160')
        ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest())
        hashed_compressed_public_key = ripemd160_hash.digest().hex()


        if hashed_compressed_public_key == target_hash:
            print(private_key_hex)
            print("hash160:", hashed_compressed_public_key)
            print("Target hash found!")

            stop_event.set()
            break



def main():
    num_processes = 12
    processes = []
    stop_event = Event()

    start_time = time.time()

    for _ in range(num_processes):
        process = Process(target=worker, args=(14, 16, stop_event))
        processes.append(process)

    for process in processes:
        process.start()

    for process in processes:
        process.join()

    if stop_event.is_set():
        for process in processes:
            process.terminate()

    end_time = time.time()
    execution_time_seconds = end_time - start_time

    hours = int(execution_time_seconds // 3600)
    minutes = int((execution_time_seconds % 3600) // 60)
    seconds = int(execution_time_seconds % 60)

    print(f"Time: {hours} h, {minutes} m, {seconds} s")



if __name__ == '__main__':
    main()

I just try it and I can find it in 30 sec on #30. For #66 it's still difficult to scan without GPU.

Try also for #35, #40, or #45.

Scan it in python without GPU too slow for 66 bit. The only way I can figure out now as I previous posted.

Step 1

Let's say start scanning from 60 bits. Use Python to do the combination.

0s - 30 - 1s -30 = 50%
0s - 31 - 1s  29 = 51.67%
0s - 32 - 1s  28 = 53.4%
0s - 33 - 1s  27 = 55%
0s - 34 - 1s  26 = 56.67%
0s - 35 - 1s  25 = 58.34%
0s - 36 - 1s  24 = 60%

Then reverse 0s and 1s position in max 60% which is most likely where the key are.

Step 2
Convert results from Binary to Hexa

Step 3
Make a batch file and run in Bitcrack to use GPU

Step 4
Run until it hits the key or else increase the percentages if it doesn't.

By using Python to eliminate those less like key first, then scan the list with GPU

Pro Python definitely have no problem with it but I'm not pro. Combine pro Python with GPU, I believe the results will be as Bestie said, achievable in 3 days.
mcdouglasx
Full Member
***
Offline Offline

Activity: 546
Merit: 148



View Profile WWW
August 12, 2023, 07:53:15 PM
 #3137

Folks, the focus shouldn't be on how many 1s or 0s bits keys should have; it should be on how to scan faster or how we can skip less probable keys.

If you want to play luck with #66 just change the parameter of the curve.

Code:
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
G = (Gx, Gy)

for example pub pk #2 (50-50 of probabilities)


Code:
Gy = 89565891926547004231252920425935692360644145829622209833684329913297188986597
Gy = 12158399299693830322967808612713398636155367887041628176798871954788371653930
G = (Gx, Gy)

or with any other pub to skip certain keys.

james5000
Jr. Member
*
Offline Offline

Activity: 69
Merit: 2


View Profile
August 12, 2023, 08:40:49 PM
 #3138

Folks, the focus shouldn't be on how many 1s or 0s bits keys should have; it should be on how to scan faster or how we can skip less probable keys.

If you want to play luck with #66 just change the parameter of the curve.

Code:
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
G = (Gx, Gy)

for example pub pk #2 (50-50 of probabilities)


Code:
Gy = 89565891926547004231252920425935692360644145829622209833684329913297188986597
Gy = 12158399299693830322967808612713398636155367887041628176798871954788371653930
G = (Gx, Gy)

or with any other pub to skip certain keys.

Please explain how to modify the parameters of the skip keys curve?
mcdouglasx
Full Member
***
Offline Offline

Activity: 546
Merit: 148



View Profile WWW
August 12, 2023, 10:06:58 PM
 #3139

Folks, the focus shouldn't be on how many 1s or 0s bits keys should have; it should be on how to scan faster or how we can skip less probable keys.

If you want to play luck with #66 just change the parameter of the curve.

Code:
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
G = (Gx, Gy)

for example pub pk #2 (50-50 of probabilities)


Code:
Gy = 89565891926547004231252920425935692360644145829622209833684329913297188986597
Gy = 12158399299693830322967808612713398636155367887041628176798871954788371653930
G = (Gx, Gy)

or with any other pub to skip certain keys.

Please explain how to modify the parameters of the skip keys curve?

For example, the default parameter in the curve is this:

Code:
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
G = (Gx, Gy)

or in hex

Code:
Gx = 79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
Gy = 483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8


If we change this to this(pub key corresponding to private key #2):

Code:
Gx = 89565891926547004231252920425935692360644145829622209833684329913297188986597
Gy = 12158399299693830322967808612713398636155367887041628176798871954788371653930
G = (Gx, Gy)

hex
Code:
Gx = C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5
Gy  = 1AE168FEA63DC339A3C58419466CEAEEF7F632653266D0E1236431A950CFE52A


our search will go from 1,2,3,4,5,6,7..... to 2,4,6,8,10.....

if we want to search for a key in the range
Code:
2000:6000

we divide the range by 2

Code:
1000:3000

if we find the pk in 1024

multiply by 2 and this will be the original pk 2048

we would just skip odds.

if you use the pubkey from pk #3 then it would be sequence 3,6,9,12....
that is, 33.3% probability


james5000
Jr. Member
*
Offline Offline

Activity: 69
Merit: 2


View Profile
August 12, 2023, 10:19:40 PM
 #3140

Interesting!! However, in this case, you're not skipping keys; you're transposing the range from 2000:6000 to 1000:3000, which results in the same number of keys.
Pages: « 1 ... 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 [157] 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 ... 369 »
  Print  
 
Jump to:  

Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!