[Question]
  [
Your task: Print or return a conversion table with every byte from `00` to `ff`'s value as an unsigned integer, to its value as a signed one (using [two's complement](https://en.wikipedia.org/wiki/Two%27s_complement)).
For example:
```
0     0
1     1
2     2
3     3
4     4
5     5
6     6
7     7
8     8
9     9
10    10
11    11
12    12
13    13
14    14
15    15
16    16
17    17
18    18
19    19
20    20
21    21
22    22
23    23
24    24
25    25
26    26
27    27
28    28
29    29
30    30
31    31
32    32
33    33
34    34
35    35
36    36
37    37
38    38
39    39
40    40
41    41
42    42
43    43
44    44
45    45
46    46
47    47
48    48
49    49
50    50
51    51
52    52
53    53
54    54
55    55
56    56
57    57
58    58
59    59
60    60
61    61
62    62
63    63
64    64
65    65
66    66
67    67
68    68
69    69
70    70
71    71
72    72
73    73
74    74
75    75
76    76
77    77
78    78
79    79
80    80
81    81
82    82
83    83
84    84
85    85
86    86
87    87
88    88
89    89
90    90
91    91
92    92
93    93
94    94
95    95
96    96
97    97
98    98
99    99
100   100
101   101
102   102
103   103
104   104
105   105
106   106
107   107
108   108
109   109
110   110
111   111
112   112
113   113
114   114
115   115
116   116
117   117
118   118
119   119
120   120
121   121
122   122
123   123
124   124
125   125
126   126
127   127
128   -128
129   -127
130   -126
131   -125
132   -124
133   -123
134   -122
135   -121
136   -120
137   -119
138   -118
139   -117
140   -116
141   -115
142   -114
143   -113
144   -112
145   -111
146   -110
147   -109
148   -108
149   -107
150   -106
151   -105
152   -104
153   -103
154   -102
155   -101
156   -100
157   -99
158   -98
159   -97
160   -96
161   -95
162   -94
163   -93
164   -92
165   -91
166   -90
167   -89
168   -88
169   -87
170   -86
171   -85
172   -84
173   -83
174   -82
175   -81
176   -80
177   -79
178   -78
179   -77
180   -76
181   -75
182   -74
183   -73
184   -72
185   -71
186   -70
187   -69
188   -68
189   -67
190   -66
191   -65
192   -64
193   -63
194   -62
195   -61
196   -60
197   -59
198   -58
199   -57
200   -56
201   -55
202   -54
203   -53
204   -52
205   -51
206   -50
207   -49
208   -48
209   -47
210   -46
211   -45
212   -44
213   -43
214   -42
215   -41
216   -40
217   -39
218   -38
219   -37
220   -36
221   -35
222   -34
223   -33
224   -32
225   -31
226   -30
227   -29
228   -28
229   -27
230   -26
231   -25
232   -24
233   -23
234   -22
235   -21
236   -20
237   -19
238   -18
239   -17
240   -16
241   -15
242   -14
243   -13
244   -12
245   -11
246   -10
247   -9
248   -8
249   -7
250   -6
251   -5
252   -4
253   -3
254   -2
255   -1
```
**Formatting:**
* The output doesn't have to be padded to nicely line up like it does above (just a space in between would be fine)
* The separators can be any two strings which can't be confused for the data or each other
* Any base can be used (but if using binary, `-1` would be `-00000001`, not `11111111`)
* Trailing (and/or leading) whitespace and separators are allowed
* The output must be in the correct order
* **The output must be textual; returning arrays/lists/dictionaries is not allowed**
**Valid outputs:**
(using `...` to skip over some repetitive chunks)
Zero-padded hexadecimal:
```
00 00
01 01
...
7f 7f
80 -80
81 -7f
...
fe -02
ff -01
```
Binary with `,` and `;` for separators:
```
0,0;1,1;10,10;11,11;...;01111111,01111111;10000000,-10000000;10000001,-01111111;...;11111110,-00000010,11111111,00000001
```
Negadecimal with custom separators:
```
0 The HORSE is a noble animal. 0
1 The HORSE is a noble animal. 1
...
287 The HORSE is a noble animal. 287
288 The HORSE is a noble animal. 1932
289 The HORSE is a noble animal. 1933
...
354 The HORSE is a noble animal. 18
355 The HORSE is a noble animal. 19
```
Good luck!
  
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + [coreutils](https://www.gnu.org/software/coreutils/), 30
```
(seq 0 127;seq -128 -1)|nl -v0
```
[Try it online!](https://tio.run/##S0oszvj/X6M4tVDBQMHQyNwaxNI1NLIAEpo1eTkKumUG//8DAA "Bash – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~54~~ ~~50~~ 47 bytes
```
i;main(){for(;i<256;printf("%u,%hhd ",i++,i));}
```
[Try it online!](https://tio.run/##S9ZNT07@/z/TOjcxM09Dszotv0jDOtPGyNTMuqAoM68kTUNJtVRHNSMjRUFJJ1NbWydTU9O69v9/AA "C (gcc) – Try It Online")
## Explanation
```
i;                      // Static variable initialized to 0
main() {
    for(;i<256;         // While the variable is <= 255:
        printf("%u,%hhd ",i++,i));
                        //     Output the original, then the char-coerced
                        //     value. Increment after use.
}
```
# [C (gcc)](https://gcc.gnu.org/), 45 bytes
Non-portable, but 2 bytes shorter.
```
f(i){for(i=-1;i++<255;printf("%u,%hhd ",i));}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI1OzOi2/SCPTVtfQOlNb28bI1NS6oCgzryRNQ0m1VEc1IyNFQUknU1PTuvZ/bmJmngZQvQaIAwA "C (gcc) – Try It Online")
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 18 bytes
Full program printing to stdout with `¯` as negative symbol. Requires 0-based indexing.
```
(⍳∘≢,⍪)…127,-128…1
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qG@qp/@jtgkGXI862gv@azzq3fyoY8ajzkU6j3pXaT5qWGZoZK6ja2hkAWL@B6r5XwAA "APL (Dyalog Extended) – Try It Online")
`128…1` integers 128 through 1
`-` negate those
`127,` prepend 127
`…` fill integers from 0 until the first element of that (127)
`(`…`)` apply the tacit function:
 `,⍪` columnify and prepend [a column consisting of]…
 `⍳⍤≢` the **ɩ**ndices of the tally
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 10 bytes
```
⁹Ḷ_H%⁹żƊṢG
```
[Try it online!](https://tio.run/##y0rNyan8//9R486HO7bFe6gCGUf3HOt6uHOR@///AA "Jelly – Try It Online")
*-1 byte thanks to Jonathan Allan*
## Explanation
```
⁹Ḷ_H%⁹żƊṢG   Main niladic link
⁹             256
 Ḷ            [0..255]
  _           Subtract
   H          half (of 256) = 128 => [-128..127]
       Ɗ      (
    %           Modulo
     ⁹          256
      ż         Zip with the list at the beginning of this inner link
       Ɗ      )
         Ṣ    Sort
          G   Format as a grid
```
[Answer]
# [Python 2](https://docs.python.org/2/), 37 bytes
```
for i in range(256):print i,127-i^127
```
[Try it online!](https://tio.run/##K6gsycjPM/r/Py2/SCFTITNPoSgxLz1Vw8jUTNOqoCgzr0QhU8fQyFw3Mw5I/v8PAA "Python 2 – Try It Online")
[Answer]
# [Julia 1.0](http://julialang.org/), ~~31~~ 28 bytes
```
r=0:255
@.println(r=>r%Int8)
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/v8jWwMrI1JTLQa@gKDOvJCdPo8jWrkjVM6/EQvP/fwA "Julia 1.0 – Try It Online")
Output format:
```
0 => 0
1 => 1...
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~11~~ 10 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
₅ÝƵQÝÂ±«ø»
```
-1 byte thanks to *@ovs*.
Uses single spaces and newlines as delimiters for the output.
[Try it online.](https://tio.run/##AR4A4f9vc2FiaWX//@KChcOdxrVRw53DgsKxwqvDuMK7//8)
**Explanation:**
```
₅Ý        # Push a list in the range [0,255]
ƵQÝ       # Push a list in the range [0,127]
   Â      # Bifurcate it; short for Duplicate & Reverse copy
    ±     # Get the bitwise-NOT of each (n → -n-1)
     «    # Merge the top two lists together
ø         # Create all possible pairs of the [0..255] and [0..127,-128..-1] lists
 »        # Join each pair by spaces, and then each string by newlines
          # (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `ƵQ` is `127`.
[Answer]
# JavaScript (ES6), ~~41~~ 40 bytes
*Saved 1 byte thanks to @ovs*
Output format: `0,0 1,1 ... 255,-1`.
```
f=n=>n>>8?'':[~~n,128+~n^127]+' '+f(-~n)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zTbP1i7Pzs7CXl3dKrquLk/H0MhCuy4vztDIPFZbXUFdO01Dty5P839yfl5xfk6qXk5@ukaahqbmfwA "JavaScript (Node.js) – Try It Online")
Or maybe [39 bytes](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zTbP1i7Pzs7CXl3dKrquLk/H0MhCuy4vztDIXEdHJ1Y7TUO3Lk/zf3J@XnF@TqpeTn66RpqGpuZ/AA) or even [38 bytes](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zTbP1i7Pzs7CXl3dKrquLk/H0MhCuy4vztDIPFY7TTtNQ7cuT/N/cn5ecX5Oql5OfrpGmoam5n8A) by abusing the loose output format. (But it's ugly.)
### Commented
```
f =                  // f is a recursive function
n =>                 // taking a counter n, which is initially undefined
  n >> 8 ?           // if n = 256:
    ''               //   stop the recursion
  :                  // else:
    [                //   build an array consisting of:
      ~~n,           //     the unsigned value (coerced to a number because
                     //     it's undefined on the first iteration)
      128 + ~n ^ 127 //     the signed value, which is (127 - n) XOR 127
                     //                              = (128 + (-n - 1)) XOR 127
    ]                //   end of array
    + ' '            //   coerce the array to a string and append a space
    + f(-~n)         //   append the result of a recursive call with n + 1
```
[Answer]
# [Nim](http://nim-lang.org/) `-d:danger`, 33 32 bytes
```
for b in 0..255:b.echo' ',b.int8
```
[Try it online!](https://tio.run/##y8vM/f8/Lb9IIUkhM0/BQE/PyNTUKkkvNTkjX11BXSdJLzOvxOL//3/JaTmJ6cX/dVOsUhLz0lOLAA "Nim – Try It Online")
# [Nim](http://nim-lang.org/), 40 39 bytes
```
for b in 0..255:b.echo' ',cast[int8](b)
```
[Try it online!](https://tio.run/##y8vM/f8/Lb9IIUkhM0/BQE/PyNTUKkkvNTkjX11BXSc5sbgkOjOvxCJWI0nz/38A "Nim – Try It Online")
Probably doesn't work on big-endian architectures.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 16 bytes
```
†szeŀ256Sṙohṡ128
```
[Try it online!](https://tio.run/##yygtzv7//1HDguKq1KMNRqZmwQ93zszPeLhzoaGRxf//AA "Husk – Try It Online"), [Another method](https://tio.run/##ASIA3f9odXNr///igKBz4bmgemVvzpjFgFPhuZlvaOG5oTEyOP// "Husk – Try It Online"), [Another method](https://tio.run/##ASAA3/9odXNr///igKBzwqd6ZW/FgERT4bmZb2jhuaExMjj//w "Husk – Try It Online")
## Explanation
```
†szeŀ256Sṙohṡ128
            ṡ128 symmetric range of 128 [-128...128]
          oh     remove last element
        Sṙ       rotate 128 spaces
    ŀ256         range [0...255]
  ze             zip the two, creating pairs
†s               convert all the numbers to strings
                 (can also be mw)
```
[Answer]
# [Haskell](https://www.haskell.org/), 54 bytes
```
unlines[show x++' ':show(x-x`div`128*256)|x<-[0..255]]
```
[Try it online!](https://tio.run/##y0gszk7NyflfkpiUk2ob8780LyczL7U4ujgjv1yhQltbXUHdCsTWqNCtSEjJLEswNLLQMjI106ypsNGNNtDTMzI1jY39n5uYmWdbUFoSXFLkk6cANuz/v@S0nMT04v@6yQUFAA "Haskell – Try It Online")
* Sadly `xor` is not in prelude module.
* Table is a string of pairs separated by newlines.
[Answer]
# C#, 61 bytes
Not very creative, but I think the shortest this can get.
```
for(var i=0;i<256;)System.Console.Write(i+$",{(sbyte)i++};");
```
[Try it online!](https://tio.run/##Sy7WTS7O/P8/Lb9IoyyxSCHT1sA608bI1MxaM7iyuCQ1V885P684PydVL7wosyRVI1NbRUmnWqM4qbIkVTNTW7vWWknT@v9/AA "C#– Try It Online")
This is a **complete** program thanks to C#9 and top-level statements. [SharpLab](https://sharplab.io/#v2:C4LgTgrgdgPgZgezACgG4EMwAICWBeABgG4cAeAJgFYA2IgSgFgAoLVrAAQEYA6AYQSgBnBABsAptwDqYHMDHIcAagAkAIgA0Ab2SCARgE85dJYoC+RVXSLMgA==)
[Answer]
# [R](https://www.r-project.org/), 37 bytes
```
for(i in 0:255)cat(i,i-(i>127)*256,T)
```
[Try it online!](https://tio.run/##K/r/Py2/SCNTITNPwcDKyNRUMzmxRCNTJ1NXI9PO0MhcU8vI1EwnRPP/fwA "R – Try It Online")
Separator between converted numbers is ""; separator between each element of the list of conversions is " `TRUE`". List is appended with a trailing separator (as allowed by the challenge rules).  
"`TRUE`" is a pre-defined variable in [R](https://www.r-project.org/) that can be specified by a single character, `T`, and that has non-numeric output, so it's used as a convenient golfy separator here.
---
# [R](https://www.r-project.org/), 38 bytes
```
cat(paste(0:255,c(0:127,-128:-1),'
'))
```
[Try it online!](https://tio.run/##K/r/PzmxRKMgsbgkVcPAysjUVCcZSBsamevoGhpZWOkaauqoc6lrav7/DwA "R – Try It Online"), [Another approach](https://tio.run/##K/r/PzmxRKMgsbgkVSPRRtfAysjUVCdR18jUTEsj0c7QyFxTR51LXVPz/38A)
Previous, slightly longer attempt, but with more-conventional separators (space & newline).
[Answer]
# Python 3, ~~47~~ 41 bytes
-6 thanks to @EasyasPi
```
print([(127-i^127,i)for i in range(256)])
```
[Answer]
# [Java](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html "Primitive Data Types - Java Tutorials"), 58 chars
```
void f(){for(int i=0;i<256;out.println(i+" "+(byte)i++));}
```
[Try it online!](https://tio.run/##NcxBDoIwFATQfU/RsGptbIyJbqqngJ1xUaGQj/DblC8JIVzd2hjdzryZ3s5274PDvnkmGIOPxCeyBDXvc6UHi50ul4ncqHeGAZKLra0dr1b2c7OHho8WUJQUAbvb3cqVtUIatv1N@qKcra2PIr9wuB4MXI6ns/Ev0iEPaUABquCFEo@FnASlpDRb2tLbBwKPU6o@ "Java (OpenJDK 8) – Try It Online")
The `byte` data type is an 8-bit signed two's complement integer. It has a minimum value of -128 and a maximum value of 127 (inclusive).
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), `j`, ~~14~~ ~~9~~ 8 bytes
```
₈ʁ₇ʁḂꜝJZ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=j&code=%E2%82%88%CA%81%E2%82%87%CA%81%E1%B8%82%EA%9C%9DJZ&inputs=&header=&footer=)
[OP says it's allowable](https://chat.stackexchange.com/transcript/message/56815478#56815478)
*-5 bytes due to porting 05AB1E*
## Explained
```
₈ʁ₇ʁḂꜝJZ
₈ʁ         # Push range [0, 256)
  ₇ʁḂ      # Push [0, 128) and (128, 0]
     ꜝ     # Bit-not over that last copy
      JZ   # Merge and zip
           # The j flag joins on newlines
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `j`, 15 bytes
```
₈‹ʀ₇‹ʀḂN₇NpJZvṄ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=j&code=%E2%82%88%E2%80%B9%CA%80%E2%82%87%E2%80%B9%CA%80%E1%B8%82N%E2%82%87NpJZv%E1%B9%84&inputs=&header=&footer=)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~49~~ ~~53~~ 51 bytes
Saved 2 bytes taking a peek at [ovs](https://codegolf.stackexchange.com/users/64121/ovs)'s [Python answer](https://codegolf.stackexchange.com/a/217621/9481)!!!  
Added 8 bytes to fix a rule violation kindly pointed out by [ovs](https://codegolf.stackexchange.com/users/64121/ovs).  
Saved 2 bytes thanks to [ovs](https://codegolf.stackexchange.com/users/64121/ovs)!!!
```
f=lambda i=255:i*' 'and'%d '*2%(i,127-i^127)+f(i-1)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P802JzE3KSVRIdPWyNTUKlNLXUE9MS9FXTVFQV3LSFUjU8fQyFw3Mw5IamqnaWTqGmr@LyjKzCvRSNPQ1PwPAA "Python 2 – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 34 bytes
```
0..255|%{"$($_;($_-bxor128)-128)"}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/30BPz8jUtEa1WklFQyXeGoh1kyryiwyNLDR1QYRS7f//AA "PowerShell – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~17~~ 16 bytes
```
V256++Nd-J127xNJ
```
[Try it online!](https://tio.run/##K6gsyfj/P8zI1Exb2y9F18vQyLzCz@v/fwA "Pyth – Try It Online")
-1 byte thanks to [FryAmTheEggman](https://codegolf.stackexchange.com/users/31625/fryamtheeggman)!
---
Python 3.8 translation:
```
for N in range(256):print(str(N)+" "+str((J:=127)-N^J))
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~29~~ 33 bytes
+4 bytes: fit to the task rules. Thanks @Zaelin Goodman
```
0..127+-128..-1|%{"$(($i++);$_)"}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/30BPz9DIXFvX0MhCT0/XsEa1WklFQ0MlU1tb01olXlOp9v9/AA "PowerShell – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 36 bytes
```
256.times{|i|puts [i,127-i^127]*' '}
```
[Try it online!](https://tio.run/##KypNqvz/38jUTK8kMze1uLoms6agtKRYITpTx9DIXDczDkjGaqkrqNf@/w8A "Ruby – Try It Online")
[Answer]
# AWK, ~~48~~ 45 bytes
*Lowered to 45 bytes thanks to [Dominic van Essen](https://codegolf.stackexchange.com/questions/217614/print-a-conversion-table-for-unsigned-bytes/217641?noredirect=1#comment507707_217641).*
```
BEGIN{for(;i<256;i++)print +i,i<128?+i:i-256}
```
[Try it online!](https://tio.run/##SyzP/v/fydXd0686Lb9IwzrTxsjUzDpTW1uzoCgzr0RBO1Mn08bQyMJeO9MqUxcoV/v/PwA "AWK – Try It Online")
Had to workaround the fact that bitwise functions in GNU AWK don't accept negative arguments. Anyway, this should work on any AWK implementation.
[Answer]
# [Scala](https://www.scala-lang.org/), ~~46~~ 45 bytes
```
()=>for(i<-0 to 255)print(s"$i,${i.toByte} ")
```
Output format: `0,0 1,1 2,2 ... 127,127 128,-128 129,-127 ... 253,-3 254,-2 255,-1`  with `,` and  for separators.
[Try it online!](https://tio.run/##JcxBCsIwEAXQfU/xKV3MgIoI3Ygp1L1LDzCtEUZCEppBlNKzx4XvAK/MEqSm6eVnw000wn/Mx0fBmDPWBnhLgMkU/BnEcAPuUQ2uErvhmRbSy/4ISzj1PedFo1FpO911qx4sXb/mN7Rc8T@Im63@AA)
**Edit**: Due to conventions, the String Interpolator `f` was changed to `s`. Thanks to [user](https://codegolf.stackexchange.com/users/95792/user)!
---
### 37 bytes
... if ignoring the seperator rule.
```
()=>for(i<-0 to 255)print(i,i.toByte)
```
Output format: `(0,0)(1,1)(2,2)(...)(127,127)(128,-128)(129,-127)(...)(253,-3)(254,-2)(255,-1)` with `,` and `)(` for separators, but unfortunately also with a leading `(` and trailing `)`.
[Try it online!](https://tio.run/##JcsxCsJAEAXQPqf45QxEESFNcAOmt/QAk2SEkWV3SQZRgmdfC1//tlmi1Dw9dXbcxBL07ZqWDddSsDfASyJcpqg9iBEG3JM5QiUOwyOvZJfDCZ5x7jouqyUna@3oefy4csX/Ejff@gM)
[Answer]
# [FALSE](https://github.com/somebody1234/FALSE), 37 bytes
```
0[$$$$256=~][128>[256-]?\.44,.10,1+]#
```
[Try it online!](https://tio.run/##S0vMKU79/98gWgUIjEzNbOtiow2NLOyigWzdWPsYPRMTHT1DAx1D7Vjl//8B "FALSE – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 38 bytes
```
for i in range(256):print(i,127-i^127)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/Py2/SCFTITNPoSgxLz1Vw8jUTNOqoCgzr0QjU8fQyFw3Mw5Iav7/DwA "Python 3 – Try It Online")
[Answer]
# PHP, 64 bytes
```
<?php for($x=0;$x<256;$x++){echo$x.','.($x<128?$x:$x-256).";";}
```
```
<?php for($x = 0; $x < 256; $x++){ #Go through each number
  echo $x . ',' . #Write x, then...
($x < 128 ? $x #if x is less than 128, write x again, 
: $x - 256) . ";";  #otherwise write x - 256 
}
```
Uses ',' and '.' as separators.
[Answer]
# [Factor](https://factorcode.org/), 43 bytes
```
256 iota [ dup pprint bl 8 >signed . ] each
```
[Try it online!](https://tio.run/##JcoxCsJAEAXQq/wTpBAiYsBWbGzESiwmm68ZjLvrzoTg6deA9XsPCZ5KvV5O5@Mexs/MGGh4sUROyIXu31w0OjThLT42vfqiRohZCoaubtrtii64YZgz8r/3E3Y4mD4jBzS4gxLGWn8 "Factor – Try It Online")
[Answer]
# [jq](https://stedolan.github.io/jq/), 30 bytes
```
range(256)|[.,(128+.)%256-128]
```
[Try it online!](https://tio.run/##yyr8/78oMS89VcPI1EyzJlpPR8PQyEJbT1MVyNcFMmP///@XX1CSmZ9X/F83DwA "jq – Try It Online")
output format:
```
[
  0,
  0
]
...
[
  255,
  -1
]
```
[Answer]
# [Red](http://www.red-lang.org), 45 bytes
```
repeat n 256[print[p: n - 1 p xor 128 - 128]]
```
[Try it online!](https://tio.run/##K0pN@R@UmhId@78otSA1sUQhT8HI1Cy6oCgzryS6wArI1VUwVChQqMgvUjA0sgDxjCxiY///BwA "Red – Try It Online")
Uses @Arnauld's formula
]