[Question]
  [
There‚Äôs a [famous tricky algorithm for counting the number of set bits](https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation) in a 32-bit unsigned integer:
```
int popcount(unsigned x) {
   x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
   x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);
   x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF);
   x = (x & 0x0000FFFF) + ((x >>16) & 0x0000FFFF);
   return x;
}
```
I won‚Äôt explain it here. But imagine similar code for 512-bit integers! The hexadecimal constants would be huge, and form a pretty pattern. Your task is simply to **print this exact output**:
```
0x55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff
0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff
0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff
0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff
0x0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
```
No trailing spaces, please ‚Äî though a single trailing newline is optional.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer (in bytes) wins.
  
[Answer]
# Python 2, 52 49 46 bytes
The kth number is given by `2**512/(2**2**k + 1)`. This is for a 512 bit number, so it's trivial to extend the pattern to different widths.
```
l=2;exec"print'0x%0128x'%(2**512/-~l);l*=l;"*9
```
3 bytes saved thanks to Dennis.  
3 bytes saved thanks to xnor.
[Answer]
# PHP, ~~111~~ ~~110~~ 108 bytes
One byte saved thanks to @user59178.
```
<?=($p=str_pad)("0x",130,5).$p($s="\n0x",131,3);for($x=1;$x<65;$x*=2)echo($p($s,131,$p(0,$x,0).$p(f,$x,f)));
```
What¬¥s the pattern for 1024 bits? :D
[Answer]
# Vim, 32 bytes
`i5<CR>3<Esc>qqYpVrf$<C-V>{yPG1vr0q6@q<C-V>{I0x<Esc>`
I only need to manually write the first `5` and `3`, and the macro takes care of the rest, "doubling the bit count" each time it runs. The order of the steps in the macro is a bit weird (make a new `f` line, block-wise copy, reuse the visual block size to put `0`s in the `f` line), but it's the fastest variant I've found.
[Answer]
## [Retina](http://github.com/mbuettner/retina), 43 bytes
```
:`
0x128$*5
:`5
3
;{:`33
0f
0(f+)(0+)
0$2$1
```
[Try it online!](http://retina.tryitonline.net/#code=OmAKMHgxMjgkKjUKOmA1CjMKO3s6YDMzCjBmCjAoZispKDArKQowJDIkMQ&input=)
### Explanation
This makes a lot of use of the generally underused `:` option which lets you print intermediate results, because it's a lot shorter to modify a single line than to build up the whole output.
```
:`
0x128$*5
```
This replaces the empty input with `0x` followed by 128 `5`s and prints it to generate the first line.
```
:`5
3
```
This one replaces the `5`s with `3`s to generate the second line and prints it as well.
```
;{:`33
0f
```
This is the last special-cased line and it turns every two `3`s into `0f` to generate the third line. This also starts a loop through the last two stages (`{`). However, this stage won't do anything after the first iteration except print the current state. The `;` suppresses the output at the very end of the program to avoid duplicating the last line.
```
0(f+)(0+)
0$2$1
```
This substitution now transforms each line into the next, by swapping every other pair of `f`s and `0`s. The "every other pair" condition is enforced by matching a zero in front of the `f`, which makes it impossible to match consecutive pairs since matches cannot overlap.
[Answer]
# J, ~~46~~ 34 bytes
~~I'm working on golfing this, but this baby likes to stay at 46 bytes...~~ Not anymore! -12 bytes thanks to miles!
```
'0x',"1'5','3','0f'(128$#)"{~2^i.7
```
[Try it online! :D](https://tio.run/nexus/j#S7S1MlCwUjD4r25Qoa6jZKhuqq6jbgzEBmnqGoZGFirKmkrVdUZxmXrm/zW5UpMz8hWU9BJ19XzcdJyD/gMA "J ‚Äì TIO Nexus")
## Result
```
   '0x',"1'5','3','0f'(128$#)"{~2^i.7
0x55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff
0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff
0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff
0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff
0x0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
```
---
For this answer, I needed (ideally) a verb with rank `0 1` so as to use it in the `u"v` definition of rank; however, miles observed that `0 _` was sufficient for the task at hand.
```
‚îå‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¨‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îê
‚îÇ= ‚îÇ< ‚îÇ<.‚îÇ<:‚îÇ> ‚îÇ>.‚îÇ>:‚îÇ+ ‚îÇ+.‚îÇ+:‚îÇ* ‚îÇ*.‚îÇ*:‚îÇ_ 0 0‚îÇ_ 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ
‚îú‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î§
‚îÇ- ‚îÇ-.‚îÇ-:‚îÇ% ‚îÇ%.‚îÇ%:‚îÇ^ ‚îÇ^.‚îÇ$ ‚îÇ$.‚îÇ$:‚îÇ~.‚îÇ~:‚îÇ0 0 0‚îÇ0 _ _‚îÇ0 _ _‚îÇ0 0 0‚îÇ2 _ 2‚îÇ0 0 0‚îÇ0 0 0‚îÇ0 0 0‚îÇ_ 1 _‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ 0 0‚îÇ_ 0 0‚îÇ
‚îú‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î§
‚îÇ| ‚îÇ|.‚îÇ, ‚îÇ,.‚îÇ,:‚îÇ; ‚îÇ;:‚îÇ# ‚îÇ#.‚îÇ#:‚îÇ! ‚îÇ/:‚îÇ\:‚îÇ0 0 0‚îÇ_ 1 _‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ1 _ _‚îÇ_ 1 _‚îÇ1 1 1‚îÇ_ 1 0‚îÇ0 0 0‚îÇ_ _ _‚îÇ_ _ _‚îÇ
‚îú‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î§
‚îÇ[ ‚îÇ[:‚îÇ] ‚îÇ{ ‚îÇ{.‚îÇ{:‚îÇ}.‚îÇ}:‚îÇ".‚îÇ":‚îÇ? ‚îÇ?.‚îÇa ‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ1 0 _‚îÇ_ 1 _‚îÇ_ 0 0‚îÇ_ 1 _‚îÇ_ 0 0‚îÇ1 _ _‚îÇ_ 1 _‚îÇ0 0 0‚îÇ_ 0 0‚îÇ_ _ _‚îÇ
‚îú‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î§
‚îÇA ‚îÇA.‚îÇb ‚îÇC ‚îÇC.‚îÇd ‚îÇD ‚îÇe ‚îÇe.‚îÇE ‚îÇE.‚îÇf ‚îÇH ‚îÇ_ _ _‚îÇ1 0 _‚îÇ_ _ _‚îÇ_ _ _‚îÇ1 1 _‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ0 _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ
‚îú‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î§
‚îÇi ‚îÇi.‚îÇi:‚îÇI ‚îÇI.‚îÇj ‚îÇj.‚îÇL ‚îÇL.‚îÇM ‚îÇo ‚îÇo.‚îÇp ‚îÇ_ _ _‚îÇ1 _ _‚îÇ0 _ _‚îÇ_ _ _‚îÇ1 _ _‚îÇ_ _ _‚îÇ0 0 0‚îÇ_ _ _‚îÇ_ 0 0‚îÇ_ _ _‚îÇ_ _ _‚îÇ0 0 0‚îÇ_ _ _‚îÇ
‚îú‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îº‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î§
‚îÇp.‚îÇp:‚îÇq ‚îÇq:‚îÇr ‚îÇr.‚îÇs ‚îÇs:‚îÇS ‚îÇt ‚îÇT ‚îÇu:‚îÇx:‚îÇ1 1 0‚îÇ0 _ _‚îÇ_ _ _‚îÇ0 0 0‚îÇ_ _ _‚îÇ0 0 0‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ_ _ _‚îÇ
‚îî‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚î¥‚îÄ‚îÄ‚îÄ‚îÄ‚îÄ‚îò
```
Here you see a bunch of verbs' string representations with their respective ranks. [This is the script I used to generate it.](https://tio.run/nexus/j#TY5LT4NAFIX38yuOUF46jhh304IYNdFEV7rDijymdkwDFbBp08pfxxlMq8ld3Mf5zj19KRcIOCTz4ZMmnYlErNJhdQGuVmjrDYPBsEGetvmcQROiLBjxyErUWaO1Y06dYBImJ8en1uuo2zFOx@bR2Us83X4bb5F9mV5l18WNuJ3dyfuPh8dq@Vk3T@3z19qhzPBx7oBxh2RpI3PtF3P8ZaG2g4z5DlGDLJLDU/e3Mzu4ExXKQ8cx9TCY2CzEcCaLqnwXTTsAynarNBrxEcCMYuw6zUgWhap4ZPHIJMulVo867Fl66KwOJhH5vIJLma2E@28e/qXr@x8 "J ‚Äì TIO Nexus")
[Answer]
# Pyth, 26 bytes
```
V9%"0x%0128x"/^2 512h^2^2N
```
Port of my Python answer.
[Answer]
# [Actually](http://github.com/Mego/Seriously), 25 bytes
```
9r`‚ïô‚ïôu9‚ïô‚ïô\#"0x%0128x"%`Mi
```
[Try it online!](http://actually.tryitonline.net/#code=OXJg4pWZ4pWZdTnilZnilZlcIyIweCUwMTI4eCIlYE1p&input=)
This solution uses the fact that `f(n) = 2**512//(2**2**n + 1)` (where `//` is floored division) to compure the values.
Explanation:
```
9r`‚ïô‚ïôu9‚ïô‚ïô\#"0x%0128x"%`Mi
9r`‚ïô‚ïôu9‚ïô‚ïô\#"0x%0128x"%`M   for n in range(1, 10):
      9‚ïô‚ïô\                   2**2**9//
   ‚ïô‚ïôu                                (2**2**n + 1)
          #"0x%0128x"%       pad with zeroes to 128 digits, prefix with "0x"
                        i  flatten and implicitly print
```
[Answer]
# JavaScript (Firefox 30+), ~~139~~ ~~113~~ ~~112~~ ~~92~~ ~~83~~ 80 bytes
```
_=>[for(x of"970123456")(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)].join`
`
```
Finally hit the recursive sweet spot :-) Uses a handy-dandy string comprehension to save 3 bytes over `.map`:
```
_=>[..."970123456"].map(x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)).join`
`
```
`.replace` is also 83 bytes:
```
_=>"970123456".replace(/./g,x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)+`
`)
```
If a leading newline were allowed, this would also be 80 bytes:
```
_=>"970123456".replace(/./g,x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):`
0x`)(128))
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~26~~ ~~22~~ 21 bytes
05AB1E uses the [CP-1252](http://www.cp1252.com) encoding.
```
9F‚Äû0x0N√ço√ó9ooNoo>√∑hJ,
```
[Try it online!](http://05ab1e.tryitonline.net/#code=OUbigJ4weDBOw41vw5c5b29Ob28-w7doSiw&input=)
**Explanation**
```
9F                      # for N in [0 ... 8]
  ‚Äû0x                   # push the string "0x"
     0N√ço√ó              # push 2**(N-2) zeroes
          9oo           # 2**2**9
                 √∑      # //
             Noo>       # (2**2**N+1)
                  h     # converted to base-16
                   J    # join everything to string
                    ,   # print with a newline
```
**Other versions that might be improved**
```
9F9ooNoo>√∑h¬æ6o√óJ7o¬£R‚Ä¶0x√ø,
9F9ooNoo>√∑h0≈æy√ó√¨R7o¬£R‚Ä¶0x√ø,
9FX0No√ó1No√óJCh7o√ó1K7o¬£‚Ä¶0x√ø,
8√ùovX0y√ó1y√óJCh7o√ó1K7o¬£‚Ä¶0x√ø,
9F1No√Ö0D>)ÀúJCh1K7o√ó7o¬£‚Ä¶0x√ø,
```
[Answer]
# [Python 2](https://docs.python.org/2/), 60 bytes
```
k=1
exec"print'0x%0128x'%int(256/k*('0'*k+'1'*k),2);k*=2;"*9
```
[Try it online!](https://tio.run/nexus/python2#@59ta8iVWpGarFRQlJlXom5QoWpgaGRRoa4K5GkYmZrpZ2tpqBuoa2VrqxsCSU0dI03rbC1bI2slLcv//wE "Python 2 ‚Äì TIO Nexus")
[Answer]
# [Bubblegum](http://esolangs.org/wiki/Bubblegum), 65 bytes
```
00000000: c5cb 4501 0441 1043 d17b d4fc 254b d110  ..E..A.C.{..%K..
00000010: f7cb 9761 9e7a 8d45 e451 4ce4 564c 04d7  ...a.z.E.QL.VL..
00000020: 2e11 b02b 8f08 80df aa5e 11fe fc77 762c  ...+.....^...wv,
00000030: 428b 5b8e ae8b 30c1 13b6 ce8b b091 377a  B.[...0.......7z
00000040: 01                                       .
```
Obligatory Bubblegum answer.
[Answer]
# Haskell, ~~84~~ 72 bytes
Porting @orlp's answer:
```
import Text.Printf
mapM(\n->printf"0x%0128x\n"$div(2^2^9)$2^2^n+1)[0..8]
```
94 byte alternatives without the power of `Text.Printf`:
```
import Data.List
mapM(putStrLn.("0x"++))$transpose$("53"++).reverse<$>sequence(["0f"]<*[1..7])
r=[0..127]
mapM(putStrLn.("0x"++))$('5'<$r):('3'<$r):[["0f"!!mod(div x(2^y))2|x<-r]|y<-[0..6]]
```
[Answer]
## Batch, 216 bytes
```
@echo off
set s=5
call:c
set s=3
call:c
set a=0
set b=f
for /l %%i in (1,1,7)do call:l %%i
exit/b
:l
set s=%a%%b%
:c
for /l %%j in (0%1,1,6)do call set s=%%s%%%%s%%
echo 0x%s%
set a=%a%%a%
set b=%b%%b%
```
[Answer]
## PowerShell v2+, 68 bytes
```
5,3|%{"0x"+"$_"*128}
($a=1)..7|%{"0x"+('0'*$a+'f'*$a)*(128/($a*=2))}
```
PowerShell doesn't have arbitrary precision integers without using `[bigint]` calls, and those can't be easily converted to hexadecimal, so we're instead treating this as a string-based challenge.
The first line handles the repeating `5` and `3` by just doing a string multiplication out to `128` characters and tacking a `0x` on the front.
The next line loops from `$a=1` to `7`, each iteration outputting another string. Again we have the `0x` tacked onto the front, and we're doing string multiplication in the middle to construct the appropriate number of `0` and `f` concatenated together, and then doing string multiplication of *that* out to the appropriate number of characters. Note we're using variable `$a` here, and not the loop counter `$_`, so we can properly scale (otherwise we'd need to loop like `1,2,4,8,16,32,64|%{...}`, which is longer).
The resulting strings are left on the pipeline, and output via implicit `Write-Output` happens at program completion, with a newline between elements.
[Answer]
# [V](http://github.com/DJMcMayhem/V), 43 bytes
```
64i0f√≤Yp√ì¬®¬®0¬´¬©¬®f¬´¬©¬©√ª2}/¬≤¬≤¬≥¬≥√≤dd{3√Ñ√í5j√í3√éi0x
```
[Try it online!](http://v.tryitonline.net/#code=NjRpMGYbw7JZcMOTwqjCqDDCq8KpwqhmwqvCqcKpw7syfS_CssKywrPCs8OyZGR7M8OEw5I1asOSM8OOaTB4&input=)
This uses one of the longest compressed regexes I've ever needed in a V answer. Here is the more readable version, where I added a byte for readable regexes, and changed the unprintable escape character to `<esc>`
```
64i0f<esc>√≤Yp√ì√∂((0+)(f+)){2}/¬≤¬≤¬≥¬≥√≤dd{3√Ñ√í5j√í3√éi0x
```
Explanation (using the readable version):
```
64i0f<esc>                                          " Insert 64 "0f"s and escape to normal mode
          √≤                      √≤                  " Recursively:
           Yp                                       "   Duplicate this line
             √ì                                      "   Substitute:
              √∂                                     "     (Optionally Turn the readable version on)
               ((0+)(f+))                           "     One or more '0's followed by one or more 'f's
                         {2}                        "     Repeated twice
                            /                       "   With:
                             ¬≤¬≤                     "     The second capture group twice (the '0's)
                               ¬≥¬≥                   "     Followed by the third capture group twice (the 'f's)
                                                    "   Once the search is not found, the loop will break
                                  dd                " Delete a line (because we have one too many)
                                    {               " Move to the first line
                                     3√Ñ             " Make three copies of this line
                                       √í5           " Replace the first one with '5's
                                         j√í3        " Move down a line and replace the second with '3's
                                            √é       " On every line:
                                             i0x    "   Insert a '0x'
```
[Answer]
## JavaScript (ES6), ~~74~~ ~~72~~ 70 bytes
Includes the optional trailing newline.
```
f=(i=1152)=>i--?f(i)+(i&127?'':`
0x`)+('53'[y=i>>7]||i&1<<y-2&&'f'):''
```
```
f=(i=1152)=>i--?f(i)+(i&127?'':`
0x`)+('53'[y=i>>7]||i&1<<y-2&&'f'):''
console.log(f())
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~66 60~~ 45 bytes
```
x=2;9.times{puts"0x%0128x"%(2**512/-~x);x*=x}
```
[Try it online!](https://tio.run/##KypNqvz/v8LWyNpSryQzN7W4uqC0pFjJoELVwNDIokJJVcNIS8vU0Ehft65C07pCy7ai9v9/AA "Ruby ‚Äì Try It Online")
Idea stolen from [orlp](https://codegolf.stackexchange.com/a/101710/18535)
[Answer]
# Pyth - ~~31~~ 30 bytes
To get pattern except for the `3`'s and `5`'s it cumulative reduces, each time doubling the chunks.
```
jm+"0x".[dd128+`3+`5.u.iNN6"0f
```
[Try it online here](http://pyth.herokuapp.com/?code=jm%2B%220x%22.%5Bdd128%2B%603%2B%605.u.iNN6%220f&debug=0).
[Answer]
# Vim 72 bytes
```
i0x128a5Ypll128r3o0x64a0fa0Ypqqffdt0fft0p@qq@qqwYp@qq@w@w@w@w:%s/0$
```
[TryItOnline!](http://v.tryitonline.net/#code=aTB4GzEyOGE1G1lwbGwxMjhyM28weBs2NGEwZhthMBtZcHFxZmZkdDBmZnQwcEBxcUBxcXdZcEBxcUB3QHdAd0B3OiVzLzAk&input=)
Unprintables:
```
i0x^[128a5^[Ypll128r3o0x^[64a0f^[a0^[Ypqqffdt0fft0p@qq@qqwYp@qq@w@w@w@w:%s/0$
```
The 4 `@w`s at the end are bugging me, but because I was relying on the `@q` to fail out at the end of a line, it fails out the @w as well. I might try just running q 32 times and seeing if it messes up the later lines.
[Answer]
# C, 146 bytes
```
#define F for(i=0;++i<129;)s[i+1]=
#define P ;puts(s);
i,j;f(){char s[131]={'0','x'};F'5'P F'3'P for(j=1;(j*=2)<129;){F(i-1)%j<j/2?'0':'f'P}}
```
Ungolfed:
```
#define F for(i=0;++i<129;)s[i+1]=
#define P ;puts(s);
i,j;f(){
  char s[131]={'0','x'};
  F'5'P
  F'3'P
  for(j=1;(j*=2)<129;){
    F(i-1)%j<j/2?'0':'f'P 
  }
}
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 211 bytes
```
+++++++>++>>-[>>>>+<<++<+<-----]>--->>++++++++++>++<<<<<<[->----[>+++<--]>-->.<.++++++++[->>>>.<<<<]>>>.>--[<]<<]+<[->>----[>+++<--]>-->.<.++++++++[<<[>+>->.<<<-]>[<+>>->>.<<<-]>]>>>.<<<<[-<+>]<[->++<]>[-<+>]<<]
```
[Try it online!](https://tio.run/##fU5bCoAwDDtQ6U4QepHSDxUEEfwQPH9NN@anYYymedD1Xo5rf7YzUwaMz9SNEEAEAi2E8ePuA0d0uJbECJcYRmto00eZaOWMGig7gkQq@R9luYlpT1N11G02acxeVwpRdayhbVBE5gs "brainfuck ‚Äì Try It Online")
[Answer]
# [GNU sed 4.2.2](https://www.gnu.org/software/sed/), 77
```
s/^/0x5/
:
s/x5{,127}$/&5/
t
p
y/5/3/
p
s/33/0f/gp
:a
s/(f+)(0+f+)/\2\1/gp
ta
```
[Try it online.](https://tio.run/##FYjRCkAwGEbv/@eQCH2btdSeRUoxuWH5d0Hy6n5zczrn8DyJMAao04IcMU5717rtngx5OpECXbAwSMIwBspjCeTGVIWvykJViejbXv8/jiLvHuK6byzNdnw)
[Answer]
# C#, 168 bytes
```
()={string R="",o="0",f="f";for(int i=0,j;i<9;i++){R+="0x";if(i>2){o+=o;f+=f;}for(j=0;j<128;){R+=i<1?"5":i<2?"3":o+f;j+=i>1?(int)Math.Pow(2,i-1):1;}R+="\n";}return R;};
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 19 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
‚å°h√Ö√©k‚ïù94"¬∫√©‚ô™‚ïõ#V‚îê5√≠‚ïí
```
[Run and debug it](https://staxlang.xyz/#p=f5688f826bbc393422a7820dbe2356bf35a1d5&i=&a=1)
Unpacked, ungolfed, and commented, it looks like this.
```
512r        [0..511]
{:Brm       convert each to bits and reverse each
M           transpose matrix, filling missing elements in rectangle with zero
m           map over each element of array, using the rest of the program.  outputs implicitly.
  4/        split bits into groups of 4
  {:b|Hm    convert each 4-bit binary number to single digit hex string
  .0xp      print "0x" without newline
```
[Run this one](https://staxlang.xyz/#c=512r++++%09[0..511]%0A%7B%3ABrm+++%09convert+each+to+bits+and+reverse+each%0AM+++++++%09transpose+matrix,+filling+missing+elements+in+rectangle+with+zero%0Am+++++++%09map+over+each+element+of+array,+using+the+rest+of+the+program.++outputs+implicitly.%0A++4%2F++++%09split+bits+into+groups+of+4%0A++%7B%3Ab%7CHm%09convert+each+4-bit+binary+number+to+single+digit+hex+string%0A++.0xp++%09print+%220x%22+without+newline&i=)
[Answer]
# [///](https://esolangs.org/wiki////), 193 bytes
```
/*/\/\///X/
0x*F/5555*G/FFFF*T/3333*U/TTTT*o/0f0f*1/oooo*t/00ff*2/tttt*g/0000*h/ffff*4/ghgh*6/gghh*7/gggg*8/hhhh*9/7788/0xGGGGGGGGXUUUUUUUUX11111111X22222222X44444444X66666666X78787878X99X77988
```
[Try it online!](https://tio.run/##LccxDoMwEETRPkeZZhZCsH0BuECQtkiTIt4tIlFAwe2dleL3i9Ec3/fhn6M1gq@IVN7kwsJHwMol4Ml7wMZnwE6pUjFwDzgpUitGngEWTwTOGjDR3BwzzdyRYsyQ6QGFKeVMudZOt06HTsdOp07nTlP@p6VoSiXn1n4 "/// ‚Äì Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 72 bytes
```
n=1n<<512n;f=(i=2n)=>i-n?`
0x`+(n/-~i+n).toString(16).slice(1)+f(i*i):''
```
[Try it online!](https://tio.run/##BcFBDsIgEAXQvRfpjASUJrrQoofwAm0QmjHkjynEuPLq@N5r@Sw1bvJuFvpMvSN4TNPJj7jmQBJGcLiJxX3eHb@zIRzsTwzYNX20TbCSP7OrRWIizyaT7IUvw9CjompJruhKmZj7Hw "JavaScript (Node.js) ‚Äì Try It Online")
# [JavaScript (Node.js)](https://nodejs.org), 69 bytes from Arnauld's
```
f=(i=4608)=>i?f(i-=4)+(i&508?'':`
0x`)+('53'[y=i>>9]||i&1<<y&&'f'):''
```
[Try it online!](https://tio.run/##DchRCoMwDADQ/x2kSRClYzpUTD2IDBS1I1KsqMgE7975Pt/UHd3Wr7Ls8eyHMQTLKJy@dU5spLYoMacUoahM5zVA2T70r70Dshc0J4sxxee6RD2r6lQKLFAJEHo/b96NifNftEgU/g "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `j`, 136 [bitsv1](https://github.com/Vyxal/Vyncode/blob/main/README.md), 17 bytes
```
‚Äõ0x53f‚Äõ0f6 ÄE‚Ä¢J‚Çáv·∫é+
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=1#WyJqPSIsIiIsIuKAmzB4NTNm4oCbMGY2yoBF4oCiSuKCh3bhuo4rIiwiIiwiIl0=)
Math? No we don't do that here. We do string manipulation instead.
## Explained
```
‚Äõ0x53f‚Äõ0f6 ÄE‚Ä¢J‚Çáv·∫é+¬≠‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Äã‚Äé‚Å™‚Å™‚Å†‚Å™‚Å™‚Å†‚Å™‚Å™‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å§‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å°‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å¢‚Äã‚Äé‚Äè‚Äã‚Å¢‚Å†‚Å°‚Äå‚Å¢‚Å£‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å§‚Å§‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å°‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å¢‚Å§‚Äã‚Äé‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å°‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å£‚Å™‚Äè‚Å†‚Äé‚Å™‚Å°‚Å™‚Å†‚Å™‚Å¢‚Å°‚Å¢‚Å™‚Äè‚Äè‚Äã‚Å°‚Å†‚Å°‚Äå‚Å£‚Å°‚Äã‚Äé‚Äè‚Äã‚Å¢‚Å†‚Å°‚Äå¬≠
      ‚Äõ0f           # ‚Äé‚Å°The string "0f"...
            ‚Ä¢       # ‚Äé‚Å¢with each character repeated n times...
         6 ÄE        # ‚Äé‚Å£for each n in [2**x for x in range(0, 7)].
             J      # ‚Äé‚Å§Appended to...
   53f              # ‚Äé‚Å¢‚Å°the list [5, 3].
# ‚Äé‚Å¢‚Å¢The top of the stack is [5, 3, "0f", "00ff", "0000ffff", ...]
              ‚Çáv·∫é   # ‚Äé‚Å¢‚Å£Take the first 128 items of each item.
                    # ‚Äé‚Å¢‚Å£This reuses previous digit/chars if the item isn't long enough
‚Äõ0x              +  # ‚Äé‚Å¢‚Å§Add the string "0x" to each item
# ‚Äé‚Å£‚Å°The j flag joins on newlines before printing
üíé Created with the help of Luminespire at https://vyxal.github.io/Luminespire
```
]