Skip to main content
Code Golf

Return to Answer

Post Timeline

added 48 characters in body
Source Link
ceilingcat
ceilingcat
  • 8.3k
  • 2
  • 32
  • 32

AMD64 machine language on Linux, 51 4644 4441 bytes

0:  6a 00                   push   0x0
2:  57                      push   rdi             ; push 1st arg onto stack
3:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
6:  5f                      pop    rdi
7:  56                      push   rsi             ; push 2nd arg onto stack
8:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
b:  83 fa 2a                cmp    edx,0x2a        ; multiplication?
e:  74 0e0b                   je     1e1b <_mul>
10: 83 fa 2b2d                cmp    edx,0x2b0x2d        ; additionsubtraction?
13: 74 0f0a                   je     241f <_add><_sub>
15: 83 fa 2d              78 0a cmp    edx,0x2d
18: 74 08            js     21 <_add> je     22 <_sub>; if the comparison is negative, must ;be subtractionaddition
1a17: de f9                   fdivp  st(1),st
1c19: eb 08                   jmp    2623 <L>
000000000000001e000000000000001b <_mul>:
1e1b: de c9                   fmulp  st(1),st
201d: eb 04                   jmp    2623 <L>
0000000000000022000000000000001f <_sub>:
221f: d9 e0                   fchs                   ; flip sign of value on top of x87 stack (subtraction)
00000000000000240000000000000021 <_add>:
2421: de c1                   faddp  st(1),st
00000000000000260000000000000023 <L>:
2623: df 34 24                fbstp  TBYTE PTR [rsp] ; transfer from x87 stack to integer stack
2926: 58                      pop    rax             ; transfer result to rax
2a27: 5a                      pop    rdx
2b28: c3                      ret

Today I learned the x87 floating point unit has hardware support for packed BCD arithmetic. To Try it online!Try it online! compile and run the following C program.

(*f)()="\x6A\x00\x57\xDF\x24\x24\x5F\x56\xDF\x24\x24\x83\xFA\x2A\x74\x0E\x83\xFA\x2B\x74\x0F"="\x6A\x00\x57\xDF\x24\x24\x5F\x56\xDF\x24\x24\x83\xFA\x2A\x74\x0B\x83\xFA\x2D\x74"
"\x83\xFA\x2D\x74\x08\xDE\xF9\xEB\x08\xDE\xC9\xEB\x04\xD9\xE0\xDE\xC1\xDF\x34\x24\x58\x5A\xC3";"\x0A\x78\x0A\xDE\xF9\xEB\x08\xDE\xC9\xEB\x04\xD9\xE0\xDE\xC1\xDF\x34\x24\x58\x5A\xC3";

int main(){
  printf("%08x + %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '+'));
  printf("%08x * %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '*'));
  printf("%08x / %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '/'));
  printf("%08x - %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '-'));
}

AMD64 machine language on Linux, 51 46 44 bytes

0:  6a 00                   push   0x0
2:  57                      push   rdi             ; push 1st arg onto stack
3:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
6:  5f                      pop    rdi
7:  56                      push   rsi             ; push 2nd arg onto stack
8:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
b:  83 fa 2a                cmp    edx,0x2a        ; multiplication?
e:  74 0e                   je     1e <_mul>
10: 83 fa 2b                cmp    edx,0x2b        ; addition
13: 74 0f                   je     24 <_add>
15: 83 fa 2d                cmp    edx,0x2d
18: 74 08                   je     22 <_sub>       ; subtraction
1a: de f9                   fdivp  st(1),st
1c: eb 08                   jmp    26 <L>
000000000000001e <_mul>:
1e: de c9                   fmulp  st(1),st
20: eb 04                   jmp    26 <L>
0000000000000022 <_sub>:
22: d9 e0                   fchs
0000000000000024 <_add>:
24: de c1                   faddp  st(1),st
0000000000000026 <L>:
26: df 34 24                fbstp  TBYTE PTR [rsp] ; transfer from x87 stack to integer stack
29: 58                      pop    rax             ; transfer result to rax
2a: 5a                      pop    rdx
2b: c3                      ret

Today I learned the x87 floating point unit has hardware support for packed BCD arithmetic. To Try it online! compile and run the following C program.

(*f)()="\x6A\x00\x57\xDF\x24\x24\x5F\x56\xDF\x24\x24\x83\xFA\x2A\x74\x0E\x83\xFA\x2B\x74\x0F"
"\x83\xFA\x2D\x74\x08\xDE\xF9\xEB\x08\xDE\xC9\xEB\x04\xD9\xE0\xDE\xC1\xDF\x34\x24\x58\x5A\xC3";

int main(){
  printf("%08x + %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '+'));
  printf("%08x * %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '*'));
  printf("%08x / %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '/'));
  printf("%08x - %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '-'));
}

AMD64 machine language on Linux, 51 44 41 bytes

0:  6a 00                   push   0x0
2:  57                      push   rdi             ; push 1st arg onto stack
3:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
6:  5f                      pop    rdi
7:  56                      push   rsi             ; push 2nd arg onto stack
8:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
b:  83 fa 2a                cmp    edx,0x2a        ; multiplication?
e:  74 0b                   je     1b <_mul>
10: 83 fa 2d                cmp    edx,0x2d        ; subtraction?
13: 74 0a                   je     1f <_sub>
15: 78 0a                   js     21 <_add>       ; if the comparison is negative, must be addition
17: de f9                   fdivp  st(1),st
19: eb 08                   jmp    23 <L>
000000000000001b <_mul>:
1b: de c9                   fmulp  st(1),st
1d: eb 04                   jmp    23 <L>
000000000000001f <_sub>:
1f: d9 e0                   fchs                   ; flip sign of value on top of x87 stack (subtraction)
0000000000000021 <_add>:
21: de c1                   faddp  st(1),st
0000000000000023 <L>:
23: df 34 24                fbstp  TBYTE PTR [rsp] ; transfer from x87 stack to integer stack
26: 58                      pop    rax             ; transfer result to rax
27: 5a                      pop    rdx
28: c3                      ret

Today I learned the x87 floating point unit has hardware support for packed BCD arithmetic. To Try it online! compile and run the following C program.

(*f)()="\x6A\x00\x57\xDF\x24\x24\x5F\x56\xDF\x24\x24\x83\xFA\x2A\x74\x0B\x83\xFA\x2D\x74"
"\x0A\x78\x0A\xDE\xF9\xEB\x08\xDE\xC9\xEB\x04\xD9\xE0\xDE\xC1\xDF\x34\x24\x58\x5A\xC3";

int main(){
 printf("%08x + %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '+'));
 printf("%08x * %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '*'));
 printf("%08x / %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '/'));
 printf("%08x - %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '-'));
}
deleted 61 characters in body
Source Link
ceilingcat
ceilingcat
  • 8.3k
  • 2
  • 32
  • 32

AMD64 machine language on Linux, 51 46 4644 bytes

0:  6a 00                   push   0x0
2:  57                      push   rdi             ; push 1st arg onto stack
3:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
6:  5f                      pop    rdi
7:  56                      push   rsi             ; push 2nd arg onto stack
8:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
b:  83 fa 2a                cmp    edx,0x2a        ; multiplication?
e:  74 160e                   je     261e <_mul>
10: 83 fa 2b                cmp    edx,0x2b.        ; addition?
13: 74 090f                   je     1e24 <_add>
15: 83 fa 2d                cmp    edx,0x2d        ; subtraction?
18: 74 08                   je     22 <_sub>       ; subtraction
1a: de f9                   fdivp  st(1),st
1c: eb 0a08                   jmp    2826 <L>
000000000000001e <_add><_mul>:
1e: de c1c9                   faddpfmulp  st(1),st
20: eb 0604                   jmp    2826 <L>
0000000000000022 <_sub>:
22: de e9                   fsubp  st(1),st
24: eb 02    d9 e0              jmp    28 <L>fchs
00000000000000260000000000000024 <_mul><_add>:
2624: de c9c1                   fmulpfaddp  st(1),st
00000000000000280000000000000026 <L>:
2826: df 34 24                fbstp  TBYTE PTR [rsp] ; transfer from x87 stack to integer stack
2b29: 58                      pop    rax             ; transfer result to rax
2c2a: 5a                      pop    rdx
2d2b: c3                      ret

Today I learned the x87 floating point unit has hardware support for packed BCD arithmetic. To Try it online!Try it online! compile and run the following C program.

(*f)()="\x6A\x00\x57\xDF\x24\x24\x5F\x56\xDF\x24\x24\x83\xFA\x2A\x74\x16\x83\xFA\x2B\x74\x09\x83\xFA\x2D\x74\x08\xDE\xF9\xEB\x0A\xDE\xC1\xEB\x06\xDE\xE9\xEB\x02\xDE\xC9\xDF\x34\x24\x58\x5A\xC3";="\x6A\x00\x57\xDF\x24\x24\x5F\x56\xDF\x24\x24\x83\xFA\x2A\x74\x0E\x83\xFA\x2B\x74\x0F"
"\x83\xFA\x2D\x74\x08\xDE\xF9\xEB\x08\xDE\xC9\xEB\x04\xD9\xE0\xDE\xC1\xDF\x34\x24\x58\x5A\xC3";

int main(){
  printf("%08x + %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '+'));
  printf("%08x * %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '*'));
  printf("%08x / %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '/'));
  printf("%08x - %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '-'));
}

AMD64 machine language on Linux, 51 46 bytes

0:  6a 00                   push   0x0
2:  57                      push   rdi             ; push 1st arg onto stack
3:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
6:  5f                      pop    rdi
7:  56                      push   rsi             ; push 2nd arg onto stack
8:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
b:  83 fa 2a                cmp    edx,0x2a        ; multiplication?
e:  74 16                   je     26 <_mul>
10: 83 fa 2b                cmp    edx,0x2b.       ; addition?
13: 74 09                   je     1e <_add>
15: 83 fa 2d                cmp    edx,0x2d        ; subtraction?
18: 74 08                   je     22 <_sub>
1a: de f9                   fdivp  st(1),st
1c: eb 0a                   jmp    28 <L>
000000000000001e <_add>:
1e: de c1                   faddp  st(1),st
20: eb 06                   jmp    28 <L>
0000000000000022 <_sub>:
22: de e9                   fsubp  st(1),st
24: eb 02                   jmp    28 <L>
0000000000000026 <_mul>:
26: de c9                   fmulp  st(1),st
0000000000000028 <L>:
28: df 34 24                fbstp  TBYTE PTR [rsp] ; transfer from x87 stack to integer stack
2b: 58                      pop    rax             ; transfer result to rax
2c: 5a                      pop    rdx
2d: c3                      ret

Today I learned the x87 floating point unit has hardware support for packed BCD arithmetic. To Try it online! compile and run the following C program.

(*f)()="\x6A\x00\x57\xDF\x24\x24\x5F\x56\xDF\x24\x24\x83\xFA\x2A\x74\x16\x83\xFA\x2B\x74\x09\x83\xFA\x2D\x74\x08\xDE\xF9\xEB\x0A\xDE\xC1\xEB\x06\xDE\xE9\xEB\x02\xDE\xC9\xDF\x34\x24\x58\x5A\xC3";

int main(){
  printf("%08x + %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '+'));
  printf("%08x * %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '*'));
  printf("%08x / %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '/'));
  printf("%08x - %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '-'));
}

AMD64 machine language on Linux, 51 46 44 bytes

0:  6a 00                   push   0x0
2:  57                      push   rdi             ; push 1st arg onto stack
3:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
6:  5f                      pop    rdi
7:  56                      push   rsi             ; push 2nd arg onto stack
8:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
b:  83 fa 2a                cmp    edx,0x2a        ; multiplication?
e:  74 0e                   je     1e <_mul>
10: 83 fa 2b                cmp    edx,0x2b        ; addition
13: 74 0f                   je     24 <_add>
15: 83 fa 2d                cmp    edx,0x2d
18: 74 08                   je     22 <_sub>       ; subtraction
1a: de f9                   fdivp  st(1),st
1c: eb 08                   jmp    26 <L>
000000000000001e <_mul>:
1e: de c9                   fmulp  st(1),st
20: eb 04                   jmp    26 <L>
0000000000000022 <_sub>:
22: d9 e0                   fchs
0000000000000024 <_add>:
24: de c1                   faddp  st(1),st
0000000000000026 <L>:
26: df 34 24                fbstp  TBYTE PTR [rsp] ; transfer from x87 stack to integer stack
29: 58                      pop    rax             ; transfer result to rax
2a: 5a                      pop    rdx
2b: c3                      ret

Today I learned the x87 floating point unit has hardware support for packed BCD arithmetic. To Try it online! compile and run the following C program.

(*f)()="\x6A\x00\x57\xDF\x24\x24\x5F\x56\xDF\x24\x24\x83\xFA\x2A\x74\x0E\x83\xFA\x2B\x74\x0F"
"\x83\xFA\x2D\x74\x08\xDE\xF9\xEB\x08\xDE\xC9\xEB\x04\xD9\xE0\xDE\xC1\xDF\x34\x24\x58\x5A\xC3";

int main(){
  printf("%08x + %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '+'));
  printf("%08x * %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '*'));
  printf("%08x / %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '/'));
  printf("%08x - %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '-'));
}
deleted 122 characters in body
Source Link
ceilingcat
ceilingcat
  • 8.3k
  • 2
  • 32
  • 32

AMD64 machine language on Linux, 51 5046 bytes

0:  6a 00                   push   0x0
2:  57                      push   rdi                 ; push 1st arg onto stack
3:  6adf 0024 24                fbld  push TBYTE PTR 0x0
5:[rsp] ; 56copy to x87 stack
6:  5f                 push   rsi  pop    rdi
7:  56         ; push 2nd arg onto stack
6:  df 64 24 01   push   rsi       fbld   TBYTE PTR [rsp+0x1] ; copypush to2nd x87arg onto stack
a8:  df 24 24                fbld   TBYTE PTR [rsp]
d:  59                      pop    rcx
e:  59                      pop; copy to x87 rcxstack
fb:  83 fa 2a                cmp    edx,0x2a            ; multiplication?
12e:  74 16                   je     2a26 <_mul>
1410: 83 fa 2b                cmp    edx,0x2b     .       ; addition?
1713: 74 09                   je     221e <_add>
1915: 83 fa 2d                cmp    edx,0x2d            ; subtraction?
1c18: 74 08                   je     2622 <_sub>
1e1a: de f9                   fdivp  st(1),st
201c: eb 0a                   jmp    2c28 <L>
0000000000000022000000000000001e <_add>:
221e: de c1                   faddp  st(1),st
2420: eb 06                   jmp    2c28 <L>
00000000000000260000000000000022 <_sub>:
2622: de e9                   fsubp  st(1),st
2824: eb 02                   jmp    2c28 <L>
000000000000002a0000000000000026 <_mul>:
2a26: de c9                   fmulp  st(1),st
000000000000002c0000000000000028 <L>:
2c28: df 34 24                fbstp  TBYTE PTR [rsp]     ; transfer from x87 stack to integer stack
2f2b: 58                      pop    rax                 ; transfer result to rax
302c: 5a                      pop    rdx
312d: c3                      ret

Today I learned the x87 floating point unit has hardware support for packed BCD arithmetic. To Try it online!Try it online! compile and run the following C program.

(*f)()="\x6A\x00\x57\x6A\x00\x56\xDF\x64\x24\x10\xDF\x24\x24\x59\x59\x83\xFA\x2A\x74\x16\x83\xFA\x2B\x74\x09\x83\xFA\x2D\x74\x08\xDE\xF9\xEB\x0A\xDE\xC1\xEB\x06\xDE\xE9\xEB\x02\xDE\xC9\xDF\x34\x24\x58\x5A\xC3";="\x6A\x00\x57\xDF\x24\x24\x5F\x56\xDF\x24\x24\x83\xFA\x2A\x74\x16\x83\xFA\x2B\x74\x09\x83\xFA\x2D\x74\x08\xDE\xF9\xEB\x0A\xDE\xC1\xEB\x06\xDE\xE9\xEB\x02\xDE\xC9\xDF\x34\x24\x58\x5A\xC3";

int main(){
  printf("%08x + %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '+'));
  printf("%08x * %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '*'));
  printf("%08x / %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '/'));
  printf("%08x - %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '-'));
}

AMD64 machine language on Linux, 51 50 bytes

0:  6a 00                   push   0x0
2:  57                      push   rdi                 ; push 1st arg onto stack
3:  6a 00                   push   0x0
5:  56                      push   rsi                 ; push 2nd arg onto stack
6:  df 64 24 01             fbld   TBYTE PTR [rsp+0x1] ; copy to x87 stack
a:  df 24 24                fbld   TBYTE PTR [rsp]
d:  59                      pop    rcx
e:  59                      pop    rcx
f:  83 fa 2a                cmp    edx,0x2a            ; multiplication?
12: 74 16                   je     2a <_mul>
14: 83 fa 2b                cmp    edx,0x2b            ; addition?
17: 74 09                   je     22 <_add>
19: 83 fa 2d                cmp    edx,0x2d            ; subtraction?
1c: 74 08                   je     26 <_sub>
1e: de f9                   fdivp  st(1),st
20: eb 0a                   jmp    2c <L>
0000000000000022 <_add>:
22: de c1                   faddp  st(1),st
24: eb 06                   jmp    2c <L>
0000000000000026 <_sub>:
26: de e9                   fsubp  st(1),st
28: eb 02                   jmp    2c <L>
000000000000002a <_mul>:
2a: de c9                   fmulp  st(1),st
000000000000002c <L>:
2c: df 34 24                fbstp  TBYTE PTR [rsp]     ; transfer from x87 stack to integer stack
2f: 58                      pop    rax                 ; transfer result to rax
30: 5a                      pop    rdx
31: c3                      ret

Today I learned the x87 floating point unit has hardware support for packed BCD arithmetic. To Try it online! compile and run the following C program.

(*f)()="\x6A\x00\x57\x6A\x00\x56\xDF\x64\x24\x10\xDF\x24\x24\x59\x59\x83\xFA\x2A\x74\x16\x83\xFA\x2B\x74\x09\x83\xFA\x2D\x74\x08\xDE\xF9\xEB\x0A\xDE\xC1\xEB\x06\xDE\xE9\xEB\x02\xDE\xC9\xDF\x34\x24\x58\x5A\xC3";

int main(){
  printf("%08x + %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '+'));
  printf("%08x * %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '*'));
  printf("%08x / %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '/'));
  printf("%08x - %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '-'));
}

AMD64 machine language on Linux, 51 46 bytes

0:  6a 00                   push   0x0
2:  57                      push   rdi             ; push 1st arg onto stack
3:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
6:  5f                      pop    rdi
7:  56                      push   rsi             ; push 2nd arg onto stack
8:  df 24 24                fbld   TBYTE PTR [rsp] ; copy to x87 stack
b:  83 fa 2a                cmp    edx,0x2a        ; multiplication?
e:  74 16                   je     26 <_mul>
10: 83 fa 2b                cmp    edx,0x2b.       ; addition?
13: 74 09                   je     1e <_add>
15: 83 fa 2d                cmp    edx,0x2d        ; subtraction?
18: 74 08                   je     22 <_sub>
1a: de f9                   fdivp  st(1),st
1c: eb 0a                   jmp    28 <L>
000000000000001e <_add>:
1e: de c1                   faddp  st(1),st
20: eb 06                   jmp    28 <L>
0000000000000022 <_sub>:
22: de e9                   fsubp  st(1),st
24: eb 02                   jmp    28 <L>
0000000000000026 <_mul>:
26: de c9                   fmulp  st(1),st
0000000000000028 <L>:
28: df 34 24                fbstp  TBYTE PTR [rsp] ; transfer from x87 stack to integer stack
2b: 58                      pop    rax             ; transfer result to rax
2c: 5a                      pop    rdx
2d: c3                      ret

Today I learned the x87 floating point unit has hardware support for packed BCD arithmetic. To Try it online! compile and run the following C program.

(*f)()="\x6A\x00\x57\xDF\x24\x24\x5F\x56\xDF\x24\x24\x83\xFA\x2A\x74\x16\x83\xFA\x2B\x74\x09\x83\xFA\x2D\x74\x08\xDE\xF9\xEB\x0A\xDE\xC1\xEB\x06\xDE\xE9\xEB\x02\xDE\xC9\xDF\x34\x24\x58\x5A\xC3";

int main(){
  printf("%08x + %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '+'));
  printf("%08x * %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '*'));
  printf("%08x / %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '/'));
  printf("%08x - %08x = %08x\n", 0x00000127, 0x00000003,f(0x00000127, 0x00000003, '-'));
}
deleted 368 characters in body
Source Link
ceilingcat
ceilingcat
  • 8.3k
  • 2
  • 32
  • 32
deleted 45 characters in body
Source Link
ceilingcat
ceilingcat
  • 8.3k
  • 2
  • 32
  • 32
Source Link
ceilingcat
ceilingcat
  • 8.3k
  • 2
  • 32
  • 32