tolpi/brat - Change GJY4PXRQ55XUVKTZSPP5WFKLVVEIBKIGSP7PLHXK5YFNUQWYC6KQC

fmt

Created by 9E8MxN1nvgX4DRC3PhGXug3ydrBXWfmR9XK2eNRJVkA3 today at 01:15

GJY4PXRQ55XUVKTZSPP5WFKLVVEIBKIGSP7PLHXK5YFNUQWYC6KQC

Dependencies

[2] CX5XTYKHJC2JQLVXL7BLAY3UF3ZRHDQ3LX2QOYXOJZRZBY7VMAAQC

In channels

main

Change contents

Replacement in lib/basexx.lua at line 9 [2.18959920]

B:BD[2.18960183] → [2.18960183:18960245]

local function divide_string( str, max )
   local result = {}

[2.18960183]

[2.18960245]

local function divide_string(str, max)
    local result = {}

Replacement in lib/basexx.lua at line 12 [2.18959920]

B:BD[2.18960246] → [2.18960246:18960488]

   local start = 1
   for i = 1, #str do
      if i % max == 0 then
         table.insert( result, str:sub( start, i ) )
         start = i + 1
      elseif i == #str then
         table.insert( result, str:sub( start, i ) )
      end
   end

[2.18960246]

[2.18960488]

    local start = 1
    for i = 1, #str do
        if i % max == 0 then
            table.insert(result, str:sub(start, i))
            start = i + 1
        elseif i == #str then
            table.insert(result, str:sub(start, i))
        end
    end

Replacement in lib/basexx.lua at line 22 [2.18959920]
B:BD[2.18960489] → [2.18960489:18960506]
```
   return result
```
[2.18960489]
[2.18960506]
```
    return result
```

Replacement in lib/basexx.lua at line 25 [2.18959920]

B:BD[2.18960511] → [2.18960511:18960574]

local function number_to_bit( num, length )
   local bits = {}

[2.18960511]

[2.18960574]

local function number_to_bit(num, length)
    local bits = {}

Replacement in lib/basexx.lua at line 28 [2.18959920]

B:BD[2.18960575] → [2.18960575:18960719]

   while num > 0 do
      local rest = math.floor( math.fmod( num, 2 ) )
      table.insert( bits, rest )
      num = ( num - rest ) / 2
   end

[2.18960575]

[2.18960719]

    while num > 0 do
        local rest = math.floor(math.fmod(num, 2))
        table.insert(bits, rest)
        num = (num - rest) / 2
    end

Replacement in lib/basexx.lua at line 34 [2.18959920]

B:BD[2.18960720] → [2.18960720:18960786]

   while #bits < length do
      table.insert( bits, "0" )
   end

[2.18960720]

[2.18960786]

    while #bits < length do
        table.insert(bits, "0")
    end

Replacement in lib/basexx.lua at line 38 [2.18959920]
B:BD[2.18960787] → [2.18960787:18960836]
```
   return string.reverse( table.concat( bits ) )
```
[2.18960787]
[2.18960836]
```
    return string.reverse(table.concat(bits))
```

Replacement in lib/basexx.lua at line 41 [2.18959920]

B:BD[2.18960841] → [2.18960841:18960957]

local function ignore_set( str, set )
   if set then
      str = str:gsub( "["..set.."]", "" )
   end
   return str

[2.18960841]

[2.18960957]

local function ignore_set(str, set)
    if set then
        str = str:gsub("[" .. set .. "]", "")
    end
    return str

Replacement in lib/basexx.lua at line 48 [2.18959920]

B:BD[2.18960962] → [2.18960962:18961123]

local function pure_from_bit( str )
   return ( str:gsub( '........', function ( cc )
               return string.char( tonumber( cc, 2 ) )
            end ) )

[2.18960962]

[2.18961123]

local function pure_from_bit(str)
    return (str:gsub('........', function(cc)
        return string.char(tonumber(cc, 2))
    end))

Replacement in lib/basexx.lua at line 54 [2.18959920]

B:BD[2.18961128] → [2.18961128:18961297]

local function unexpected_char_error( str, pos )
   local c = string.sub( str, pos, pos )
   return string.format( "unexpected character at position %d: '%s'", pos, c )

[2.18961128]

[2.18961297]

local function unexpected_char_error(str, pos)
    local c = string.sub(str, pos, pos)
    return string.format("unexpected character at position %d: '%s'", pos, c)

Replacement in lib/basexx.lua at line 69 [2.18959920]

B:BD[2.18961658] → [2.18961658:18961937]

function basexx.from_bit( str, ignore )
   str = ignore_set( str, ignore )
   str = string.lower( str )
   str = str:gsub( '[ilo]', function( c ) return bitMap[ c ] end )
   local pos = string.find( str, "[^01]" )
   if pos then return nil, unexpected_char_error( str, pos ) end

[2.18961658]

[2.18961937]

function basexx.from_bit(str, ignore)
    str = ignore_set(str, ignore)
    str = string.lower(str)
    str = str:gsub('[ilo]', function(c) return bitMap[c] end)
    local pos = string.find(str, "[^01]")
    if pos then return nil, unexpected_char_error(str, pos) end

Replacement in lib/basexx.lua at line 76 [2.18959920]
B:BD[2.18961938] → [2.18961938:18961969]
```
   return pure_from_bit( str )
```
[2.18961938]
[2.18961969]
```
    return pure_from_bit(str)
```

Replacement in lib/basexx.lua at line 79 [2.18959920]

B:BD[2.18961974] → [2.18961974:18962341]

function basexx.to_bit( str )
   return ( str:gsub( '.', function ( c )
               local byte = string.byte( c )
               local bits = {}
               for _ = 1,8 do
                  table.insert( bits, byte % 2 )
                  byte = math.floor( byte / 2 )
               end
               return table.concat( bits ):reverse()
            end ) )

[2.18961974]

[2.18962341]

function basexx.to_bit(str)
    return (str:gsub('.', function(c)
        local byte = string.byte(c)
        local bits = {}
        for _ = 1, 8 do
            table.insert(bits, byte % 2)
            byte = math.floor(byte / 2)
        end
        return table.concat(bits):reverse()
    end))

Replacement in lib/basexx.lua at line 95 [2.18959920]

B:BD[2.18962551] → [2.18962551:18962734]

function basexx.from_hex( str, ignore )
   str = ignore_set( str, ignore )
   local pos = string.find( str, "[^%x]" )
   if pos then return nil, unexpected_char_error( str, pos ) end

[2.18962551]

[2.18962734]

function basexx.from_hex(str, ignore)
    str = ignore_set(str, ignore)
    local pos = string.find(str, "[^%x]")
    if pos then return nil, unexpected_char_error(str, pos) end

Replacement in lib/basexx.lua at line 100 [2.18959920]

B:BD[2.18962735] → [2.18962735:18962855]

   return ( str:gsub( '..', function ( cc )
               return string.char( tonumber( cc, 16 ) )
            end ) )

[2.18962735]

[2.18962855]

    return (str:gsub('..', function(cc)
        return string.char(tonumber(cc, 16))
    end))

Replacement in lib/basexx.lua at line 105 [2.18959920]

B:BD[2.18962860] → [2.18962860:18963015]

function basexx.to_hex( str )
   return ( str:gsub( '.', function ( c )
               return string.format('%02X', string.byte( c ) )
            end ) )

[2.18962860]

[2.18963015]

function basexx.to_hex(str)
    return (str:gsub('.', function(c)
        return string.format('%02X', string.byte(c))
    end))

Replacement in lib/basexx.lua at line 115 [2.18959920]

B:BD[2.18963238] → [2.18963238:18963632]

local function from_basexx( str, alphabet, bits )
   local result = {}
   for i = 1, #str do
      local c = string.sub( str, i, i )
      if c ~= '=' then
         local index = string.find( alphabet, c, 1, true )
         if not index then
            return nil, unexpected_char_error( str, i )
         end
         table.insert( result, number_to_bit( index - 1, bits ) )
      end
   end

[2.18963238]

[2.18963632]

local function from_basexx(str, alphabet, bits)
    local result = {}
    for i = 1, #str do
        local c = string.sub(str, i, i)
        if c ~= '=' then
            local index = string.find(alphabet, c, 1, true)
            if not index then
                return nil, unexpected_char_error(str, i)
            end
            table.insert(result, number_to_bit(index - 1, bits))
        end
    end

Replacement in lib/basexx.lua at line 128 [2.18959920]

B:BD[2.18963633] → [2.18963633:18963763]

   local value = table.concat( result )
   local pad = #value % 8
   return pure_from_bit( string.sub( value, 1, #value - pad ) )

[2.18963633]

[2.18963763]

    local value = table.concat(result)
    local pad = #value % 8
    return pure_from_bit(string.sub(value, 1, #value - pad))

Replacement in lib/basexx.lua at line 133 [2.18959920]

B:BD[2.18963768] → [2.18963768:18963863]

local function to_basexx( str, alphabet, bits, pad )
   local bitString = basexx.to_bit( str )

[2.18963768]

[2.18963863]

local function to_basexx(str, alphabet, bits, pad)
    local bitString = basexx.to_bit(str)

Replacement in lib/basexx.lua at line 136 [2.18959920]

B:BD[2.18963864] → [2.18963864:18964180]

   local chunks = divide_string( bitString, bits )
   local result = {}
   for _,value in ipairs( chunks ) do
      if ( #value < bits ) then
         value = value .. string.rep( '0', bits - #value )
      end
      local pos = tonumber( value, 2 ) + 1
      table.insert( result, alphabet:sub( pos, pos ) )
   end

[2.18963864]

[2.18964180]

    local chunks = divide_string(bitString, bits)
    local result = {}
    for _, value in ipairs(chunks) do
        if (#value < bits) then
            value = value .. string.rep('0', bits - #value)
        end
        local pos = tonumber(value, 2) + 1
        table.insert(result, alphabet:sub(pos, pos))
    end

Replacement in lib/basexx.lua at line 146 [2.18959920]

B:BD[2.18964181] → [2.18964181:18964248]

   table.insert( result, pad )
   return table.concat( result )

[2.18964181]

[2.18964248]

    table.insert(result, pad)
    return table.concat(result)

Replacement in lib/basexx.lua at line 157 [2.18959920]

B:BD[2.18964588] → [2.18964588:18964730]

function basexx.from_base32( str, ignore )
   str = ignore_set( str, ignore )
   return from_basexx( string.upper( str ), base32Alphabet, 5 )

[2.18964588]

[2.18964730]

function basexx.from_base32(str, ignore)
    str = ignore_set(str, ignore)
    return from_basexx(string.upper(str), base32Alphabet, 5)

Replacement in lib/basexx.lua at line 162 [2.18959920]

B:BD[2.18964735] → [2.18964735:18964844]

function basexx.to_base32( str )
   return to_basexx( str, base32Alphabet, 5, base32PadMap[ #str % 5 + 1 ] )

[2.18964735]

[2.18964844]

function basexx.to_base32(str)
    return to_basexx(str, base32Alphabet, 5, base32PadMap[#str % 5 + 1])

Replacement in lib/basexx.lua at line 173 [2.18959920]

B:BD[2.18965181] → [2.18965181:18965416]

function basexx.from_crockford( str, ignore )
   str = ignore_set( str, ignore )
   str = string.upper( str )
   str = str:gsub( '[ILOU]', function( c ) return crockfordMap[ c ] end )
   return from_basexx( str, crockfordAlphabet, 5 )

[2.18965181]

[2.18965416]

function basexx.from_crockford(str, ignore)
    str = ignore_set(str, ignore)
    str = string.upper(str)
    str = str:gsub('[ILOU]', function(c) return crockfordMap[c] end)
    return from_basexx(str, crockfordAlphabet, 5)

Replacement in lib/basexx.lua at line 180 [2.18959920]

B:BD[2.18965421] → [2.18965421:18965510]

function basexx.to_crockford( str )
   return to_basexx( str, crockfordAlphabet, 5, "" )

[2.18965421]

[2.18965510]

function basexx.to_crockford(str)
    return to_basexx(str, crockfordAlphabet, 5, "")

Replacement in lib/basexx.lua at line 188 [2.18959920]

B:BD[2.18965715] → [2.18965715:18965861]

local base64Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"..
                       "abcdefghijklmnopqrstuvwxyz"..
                       "0123456789+/"

[2.18965715]

[2.18965861]

local base64Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ..
    "abcdefghijklmnopqrstuvwxyz" ..
    "0123456789+/"

Replacement in lib/basexx.lua at line 192 [2.18959920]

B:BD[2.18965900] → [2.18965900:18966028]

 
function basexx.from_base64( str, ignore )
   str = ignore_set( str, ignore )
   return from_basexx( str, base64Alphabet, 6 )

[2.18965900]

[2.18966028]


function basexx.from_base64(str, ignore)
    str = ignore_set(str, ignore)
    return from_basexx(str, base64Alphabet, 6)

Replacement in lib/basexx.lua at line 198 [2.18959920]

B:BD[2.18966033] → [2.18966033:18966142]

function basexx.to_base64( str )
   return to_basexx( str, base64Alphabet, 6, base64PadMap[ #str % 3 + 1 ] )

[2.18966033]

[2.18966142]

function basexx.to_base64(str)
    return to_basexx(str, base64Alphabet, 6, base64PadMap[#str % 3 + 1])

Replacement in lib/basexx.lua at line 206 [2.18959920]

B:BD[2.18966356] → [2.18966356:18966625]

local url64Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"..
                      "abcdefghijklmnopqrstuvwxyz"..
                      "0123456789-_"
 
function basexx.from_url64( str, ignore )
   str = ignore_set( str, ignore )
   return from_basexx( str, url64Alphabet, 6 )

[2.18966356]

[2.18966625]

local url64Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ..
    "abcdefghijklmnopqrstuvwxyz" ..
    "0123456789-_"
function basexx.from_url64(str, ignore)
    str = ignore_set(str, ignore)
    return from_basexx(str, url64Alphabet, 6)

Replacement in lib/basexx.lua at line 215 [2.18959920]

B:BD[2.18966630] → [2.18966630:18966711]

function basexx.to_url64( str )
   return to_basexx( str, url64Alphabet, 6, "" )

[2.18966630]

[2.18966711]

function basexx.to_url64(str)
    return to_basexx(str, url64Alphabet, 6, "")

Replacement in lib/basexx.lua at line 223 [2.18959920]

B:BD[2.18966882] → [2.18966882:18967003]

local function length_error( len, d )
   return string.format( "invalid length: %d - must be a multiple of %d", len, d )

[2.18966882]

[2.18967003]

local function length_error(len, d)
    return string.format("invalid length: %d - must be a multiple of %d", len, d)

Replacement in lib/basexx.lua at line 228 [2.18959920]

B:BD[2.18967077] → [2.18967077:18967847]

                     0x4B, 0x4C, 0x46, 0x41, 0x00, 0x3F, 0x3E, 0x45, 
                     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
                     0x08, 0x09, 0x40, 0x00, 0x49, 0x42, 0x4A, 0x47, 
                     0x51, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 
                     0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 
                     0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 
                     0x3B, 0x3C, 0x3D, 0x4D, 0x00, 0x4E, 0x43, 0x00, 
                     0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 
                     0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 
                     0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 
                     0x21, 0x22, 0x23, 0x4F, 0x00, 0x50, 0x00, 0x00 }

[2.18967077]

[2.18967847]

    0x4B, 0x4C, 0x46, 0x41, 0x00, 0x3F, 0x3E, 0x45,
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
    0x08, 0x09, 0x40, 0x00, 0x49, 0x42, 0x4A, 0x47,
    0x51, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A,
    0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32,
    0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
    0x3B, 0x3C, 0x3D, 0x4D, 0x00, 0x4E, 0x43, 0x00,
    0x00, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
    0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
    0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
    0x21, 0x22, 0x23, 0x4F, 0x00, 0x50, 0x00, 0x00 }

Replacement in lib/basexx.lua at line 240 [2.18959920]

B:BD[2.18967848] → [2.18967848:18968001]

function basexx.from_z85( str, ignore )
   str = ignore_set( str, ignore )
   if ( #str % 5 ) ~= 0 then
      return nil, length_error( #str, 5 )
   end

[2.18967848]

[2.18968001]

function basexx.from_z85(str, ignore)
    str = ignore_set(str, ignore)
    if (#str % 5) ~= 0 then
        return nil, length_error(#str, 5)
    end

Replacement in lib/basexx.lua at line 246 [2.18959920]
B:BD[2.18968002] → [2.18968002:18968023]
```
   local result = {}
```
[2.18968002]
[2.18968023]
```
    local result = {}
```

Replacement in lib/basexx.lua at line 248 [2.18959920]

B:BD[2.18968024] → [2.18968024:18968585]

   local value = 0
   for i = 1, #str do
      local index = string.byte( str, i ) - 31
      if index < 1 or index >= #z85Decoder then
         return nil, unexpected_char_error( str, i )
      end
      value = ( value * 85 ) + z85Decoder[ index ]
      if ( i % 5 ) == 0 then
         local divisor = 256 * 256 * 256
         while divisor ~= 0 do
            local b = math.floor( value / divisor ) % 256
            table.insert( result, string.char( b ) )
            divisor = math.floor( divisor / 256 )
         end
         value = 0
      end
   end

[2.18968024]

[2.18968585]

    local value = 0
    for i = 1, #str do
        local index = string.byte(str, i) - 31
        if index < 1 or index >= #z85Decoder then
            return nil, unexpected_char_error(str, i)
        end
        value = (value * 85) + z85Decoder[index]
        if (i % 5) == 0 then
            local divisor = 256 * 256 * 256
            while divisor ~= 0 do
                local b = math.floor(value / divisor) % 256
                table.insert(result, string.char(b))
                divisor = math.floor(divisor / 256)
            end
            value = 0
        end
    end

Replacement in lib/basexx.lua at line 266 [2.18959920]
B:BD[2.18968586] → [2.18968586:18968619]
```
   return table.concat( result )
```
[2.18968586]
[2.18968619]
```
    return table.concat(result)
```

Replacement in lib/basexx.lua at line 269 [2.18959920]

B:BD[2.18968624] → [2.18968624:18968803]

local z85Encoder = "0123456789"..
                   "abcdefghijklmnopqrstuvwxyz"..
                   "ABCDEFGHIJKLMNOPQRSTUVWXYZ"..
                   ".-:+=^!/*?&<>()[]{}@%$#"

[2.18968624]

[2.18968803]

local z85Encoder = "0123456789" ..
    "abcdefghijklmnopqrstuvwxyz" ..
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ..
    ".-:+=^!/*?&<>()[]{}@%$#"

Replacement in lib/basexx.lua at line 274 [2.18959920]

B:BD[2.18968804] → [2.18968804:18968912]

function basexx.to_z85( str )
   if ( #str % 4 ) ~= 0 then
      return nil, length_error( #str, 4 )
   end

[2.18968804]

[2.18968912]

function basexx.to_z85(str)
    if (#str % 4) ~= 0 then
        return nil, length_error(#str, 4)
    end

Replacement in lib/basexx.lua at line 279 [2.18959920]
B:BD[2.18968913] → [2.18968913:18968934]
```
   local result = {}
```
[2.18968913]
[2.18968934]
```
    local result = {}
```

Replacement in lib/basexx.lua at line 281 [2.18959920]

B:BD[2.18968935] → [2.18968935:18969385]

   local value = 0
   for i = 1, #str do
      local b = string.byte( str, i )
      value = ( value * 256 ) + b
      if ( i % 4 ) == 0 then
         local divisor = 85 * 85 * 85 * 85
         while divisor ~= 0 do
            local index = ( math.floor( value / divisor ) % 85 ) + 1
            table.insert( result, z85Encoder:sub( index, index ) )
            divisor = math.floor( divisor / 85 )
         end
         value = 0
      end
   end

[2.18968935]

[2.18969385]

    local value = 0
    for i = 1, #str do
        local b = string.byte(str, i)
        value = (value * 256) + b
        if (i % 4) == 0 then
            local divisor = 85 * 85 * 85 * 85
            while divisor ~= 0 do
                local index = (math.floor(value / divisor) % 85) + 1
                table.insert(result, z85Encoder:sub(index, index))
                divisor = math.floor(divisor / 85)
            end
            value = 0
        end
    end

Replacement in lib/basexx.lua at line 296 [2.18959920]
B:BD[2.18969386] → [2.18969386:18969419]
```
   return table.concat( result )
```
[2.18969386]
[2.18969419]
```
    return table.concat(result)
```

fmt