well - i wanted to start by spliting those offsets into the 6 groups for each byte

a bit of luck - that went surprisingly well :t

because of the fact that bytes have 8 bits, we can split the low-order base-210 into a base-6 digit and a base-35 digit

that way, we can use the base-6 digit to address 1 of 6 bytes and the base-35 digit to address bits

we can also use the base-6 digit to select the "parse" values for the base-35 values

you can do that by a set of look-up tables or by branching, i guess

nonetheless, when the offsets are split into 6 groups of 8....

`------------0`

001 01

011 11

013 13

017 17

019 19

023 23

029 29

031 31

------------35

037 02

041 06

043 08

047 12

053 18

059 24

061 26

067 32

------------70

071 01

073 03

079 09

083 13

089 19

097 27

101 31

103 33

------------105

107 02

109 04

113 08

121 16

127 22

131 26

137 32

139 34

------------140

143 03

149 09

151 11

157 17

163 23

167 27

169 29

173 33

------------175

179 04

181 06

187 12

191 16

193 18

197 22

199 24

209 34

that worked out nicely

so, it would seem that the best approach is to actually mix bases

a simple example...

`high order low order`

base4294967296digit base35digit

in this case, we need to take the base-4294967296 digit and MOD 6 to figure out how to parse the low-order base-35 digit into bits

rather than constantly dividing to get the mod-6 "remainder", we can keep another high-order digit in parallel

`high order low order`

base4294967296digit

base35digit

mod6digit

the base-4294967296 digit can be used to address bytes

and, the mod-6 digit can be used to parse the low-order digit

the limits of the above method are

`max file: 4gb`

range: 140g = 150,323,855,360

if we wanted a larger range, we could use a real mixture of bases - lol

`high order low order`

base4294967296digit base6digit base35digit

max file: 24gb

range: 840g = 901,943,132,160

which makes it a little tricky to address bytes, but it's do-able