These charts were made fairly manually, and haven't yet been checked through an automated method. (For now, verify errors on your own or use at your own risk.)

The numbers that follow are what would be used in the third octet of an IPv4 /16 when counting according to the pattern of RFC 1219.

According to the logic presented in RFC 1219 (which is for IPv4... a similar RFC 3531 discusses some similar logic with IPv6), if sequential counting of subnets is going to be used, it makes some sense to use another counting method so that the host portion of the address is more frequently able to be re-determined without needing to perform renumbering of any devices. To pull this off, it makes sense to count the subnets by counting binary, but with the bits in reverse order so that the least significant digits appear first.

These charts are meant to simply show the numbers so one may use these charts rather than needing to calculate the numbers. (Knowing how to calculate the numbers may be a nice skill to have, but performing the calculations also may be more time consuming.)

So, after 0 (00000000 binary),
which is a subnet that should
probably be skipped
, the next
number is 128 (10000000 binary),
and then 64 (01000000 binary),
and then 192 (11000000 binary),
and then 32 (00100000 binary),
and then 160 (10100000 binary),
and then 96 (01100000 binary),
and then 224 (11100000 binary).

(The pattern on how numbers change is the same as a regular binary count with one exception: the numbers go from left to right as they increase, instead of from right to left as they increase. If one understands how to count in binary, looking at the values of the bits will hopefully reveal how the order of these numbers was derived.)

The above chart takes care of the first eight possibilities which are the possibilities of the first three bits. The next thing to do is to add 8 to each of those numbers to create another chart which, combined with the first chart, documents all the possibilities from using just the first four bits.

The next numbers are
16 (16+0+0+0) higher
than the original bunch
of 8 numbers, in order:
16 (00010000 binary),
144 (10010000 binary),
80 (01010000 binary),
208 (11010000 binary),
48 (00110000 binary),
176 (10110000 binary),
96 (01110000 binary),
240 (11110000 binary).

Since the first four bits are representable using two charts, the fifth bit will double the amount of charts up to four charts (total). One of the newer charts is done by adding eight to the initial chart, and the other is made by adding sixteen to the initial chart.

(The following numbers are
simply eight (0+8+0+0)
higher than the initial
bunch of 8 numbers.)
8 (00001000 binary),
136 (10001000 binary),
72 (01001000 binary),
200 (11001000 binary),
40 (00101000 binary),
168 (10101000 binary),
104 (01101000 binary),
232 (11101000 binary).
(The following numbers are
twenty-four (16+8+0+0)
higher than the initial
bunch of 8 numbers.)
24 (00011000 binary),
152 (10011000 binary),
88 (01011000 binary),
216 (11011000 binary),
56 (00111000 binary),
184 (10111000 binary),
120 (01111000 binary),
248 (11111000 binary).

Need more? If so: follow the above pattern for the first 32 numbers in the pattern, but then add 4 (0+0+4+0) to each number. The results are:
(The following numbers
are simply 4 (0+0+4+0)
higher than the initial
bunch of 8 numbers.)
4 (00000100 binary),
132 (10000100 binary),
68 (01000100 binary),
196 (11000100 binary),
36 (00100100 binary),
164 (10100100 binary),
100 (01100100 binary),
228 (11100100 binary).
(The following numbers
are simply 20 (16+0+4+0)
higher than the initial
bunch of 8 numbers.)
20 (00010100 binary),
148 (10010100 binary),
84 (01010100 binary),
212 (11010100 binary),
52 (00110100 binary),
180 (10110100 binary),
116 (01110100 binary),
244 (11110100 binary).
(The following numbers
are simply twelve (0+8+4+0)
higher than the initial
set of eight numbers.)
12 (00001100 binary),
140 (10001100 binary),
76 (01001100 binary),
204 (11001100 binary),
44 (00101100 binary),
172 (10101100 binary),
108 (01101100 binary),
236 (11101100 binary).
(The following numbers
are 28 (16+8+4+0)
higher than the initial
set of eight numbers.)
28 (00011100 binary),
156 (10011100 binary),
92 (01011100 binary),
220 (11011100 binary),
60 (00111100 binary),
188 (10111100 binary),
124 (01111100 binary),
252 (11111100 binary).

For the remaining charts of even numbers, simply follow all of the previous steps but add two. The early four charts created by following that pattern are:

Need more? If so: follow the above pattern for the first 32 numbers in the pattern, but then add 2 (0+2+0) to each number.
(The following numbers are
simply two (0+0+0+2) higher
than the initial 8 numbers.)
2 (00000010 binary),
130 (10000010 binary),
66 (01000010 binary),
194 (11000010 binary),
34 (00100010 binary),
162 (10100010 binary),
98 (01100010 binary),
226 (11100010 binary).
(The following numbers are
eighteen (16+0+0+2) higher
than the initial 8 numbers.)
18 (00010010 binary),
146 (10010010 binary),
82 (01010010 binary),
210 (11010010 binary),
50 (00110010 binary),
178 (10110010 binary),
98 (01110010 binary),
242 (11110010 binary).
(The following numbers are
ten (0+8+0+2) higher than
the initial eight numbers.)
10(00001010 binary),
138 (10001010 binary),
74 (01001010 binary),
202 (11001010 binary),
42 (00101010 binary),
170 (10101010 binary),
106 (01101010 binary),
234 (11101010 binary).
(The following numbers are
twenty-six (16+8+0+2) higher
than the initial eight numbers.)
26 (00011010 binary),
154 (10011010 binary),
90 (01011010 binary),
218 (11011010 binary),
58 (00111010 binary),
186 (10111010 binary),
106 (01111010 binary),
250 (11111010 binary).

The latter of the four charts that need to be added involve adding not just four, nor just two, but both two and four: Adding six. The results are:

(The following numbers are
simply six (0+0+4+2) higher
than the initial 8 numbers.)
6 (00000110 binary),
134 (10000110 binary),
70 (01000110 binary),
198 (11000110 binary),
38 (00100110 binary),
166 (10100110 binary),
102 (01100110 binary),
230 (11100110 binary).
(The following numbers are
twenty-two (16+0+4+2) higher
than the initial 8 numbers.)
22 (00010110 binary),
150 (10010110 binary),
86 (01010110 binary),
214 (11010110 binary),
54 (00110110 binary),
182 (10110110 binary),
102 (01110110 binary),
246 (11110110 binary).
(The following numbers are
fourteen (0+8+4+2) higher than
the initial eight numbers.)
14 (00001110 binary),
142 (10001110 binary),
78 (01001110 binary),
206 (11001110 binary),
46 (00101110 binary),
174 (10101110 binary),
110 (01101110 binary),
238 (11101110 binary).
(The following numbers are
simply thirty (16+8+4+2) higher
than the initial eight numbers.)
30 (00011110 binary),
158 (10011110 binary),
94 (01011110 binary),
222 (11011110 binary),
62 (00111110 binary),
190 (10111110 binary),
110 (01111110 binary),
254 (11111110 binary).

(The pattern of adding 0, 4, 2, 6, may seem like an odd order: It comes from counting in binary using the 6th and 7th bits of an eight digit number, and using the most significant digits first.

Need more? If so: follow the above pattern for the first 32 numbers in the pattern, but then add 1 (0+0+1) to each number.
Need more? If so: follow the above pattern for the first 32 numbers in the pattern, but then add 5 (4+0+1) to each number.
Need more? If so: follow the above pattern for the first 32 numbers in the pattern, but then add 3 (0+2+1) to each number.
Need more? If so: follow the above pattern for the first 32 numbers in the pattern, but then add 7 (4+2+1) to each number.
The charts for the odd numbers aren't included here because they are so similar to the charts for even numbers: Simply add one to the results of any of charts showing the even-numbered digits.

Color codes:

Tables with a background that don't involve adding eight are blue-ish (aqua / lime). Tables that do involve adding eight are red-ish (fuchsia / orange). Tables that involve adding sixteen are yellow-ish). Tables that add four are darker.

The fourth and fifth addresses in each chart differ by 160, so in decimal their last digits are always the same.