pangya.lua

-- Wireshark dissector for PangYa
-- Hacked together by John Chadwick.

local debug_level = {
  DISABLED = 0,
  VERBOSE  = 1,
}

local default_settings = {
  debug_level         = debug_level.DISABLED,
  enabled             = true,

  -- Specifies additional ports (alongside the defaults) for the various
  -- kinds of PangYa servers.
  login_server_port   = 10103, -- additional login server port
  game_server_port    = 20201, -- additional game server port
  message_server_port = 30303, -- additional message server port
}

-- region Debug helpers

local dprint = function(...) end

local function setupDebugPrint()
  if default_settings.debug_level == debug_level.DISABLED then
    dprint = function() end
  else
    dprint = function(...)
      print(table.concat({"pangya:", ...}, " "))
    end
  end
end

-- endregion

-- region Plugin info/settings

set_plugin_info({
  version = "1.0.0",
  author = "John Chadwick",
  repository = "https://github.com/pangbox/pangya-wireshark-dissector"
})

local server_type = {
  LOGIN_SERVER = 0,
  GAME_SERVER = 1,
  MESSAGE_SERVER = 2,
}

-- Constructs a map of ports to server types.
local portMapping
local function setupPortMap()
  -- Known port mappings (should be synced with pantrant)
  portMapping = {
    [10101] = server_type.LOGIN_SERVER,
    [10201] = server_type.LOGIN_SERVER,
    [10103] = server_type.LOGIN_SERVER,
    [20201] = server_type.GAME_SERVER,
    [20202] = server_type.GAME_SERVER,
    [20203] = server_type.GAME_SERVER,
    [10102] = server_type.MESSAGE_SERVER,
    [30303] = server_type.MESSAGE_SERVER,
  }
  portMapping[default_settings.login_server_port] = server_type.LOGIN_SERVER
  portMapping[default_settings.game_server_port] = server_type.GAME_SERVER
  portMapping[default_settings.message_server_port] = server_type.MESSAGE_SERVER
  return portMapping
end
setupPortMap()

local function getServerType(port)
  return portMapping[port]
end

local function serverTypeName(port)
  local type = portMapping[port]
  if type == server_type.LOGIN_SERVER then return "login"
  elseif type == server_type.GAME_SERVER then return "game"
  elseif type == server_type.MESSAGE_SERVER then return "message"
  end
  return "(unknown)"
end

local function serverTypeShorthand(type)
  if type == server_type.LOGIN_SERVER then return "LS"
  elseif type == server_type.GAME_SERVER then return "GS"
  elseif type == server_type.MESSAGE_SERVER then return "MS"
  end
  return "UK"
end

-- endregion

-- region Protocol definition

local pangya_protocol = Proto("PangYa",  "PangYa Protocol")
local key_field = ProtoField.uint8("pangya.key", "Key", base.DEC)
local type_field = ProtoField.string("pangya.type", "Type", base.ASCII, "type of server, e.g. 'game'")
local length_field = ProtoField.uint16("pangya.length", "Packet Length", base.DEC)
local server_field = ProtoField.bool("pangya.server", "Server Packet", base.NONE)
local client_field = ProtoField.bool("pangya.client", "Client Packet", base.NONE)
local salt_field = ProtoField.uint8("pangya.salt", "Salt", base.DEC)
local encrypted_field = ProtoField.bytes("pangya.encrypted", "Encrypted data", base.NONE)
local id_field = ProtoField.uint16("pangya.id", "Packet ID", base.HEX)

pangya_protocol.fields = {
  key_field,
  type_field,
  length_field,
  server_field,
  client_field,
  salt_field,
  encrypted_field,
  id_field
}

local stream_index = Field.new("tcp.stream")

-- endregion

-- region Bitops
-- (Very clever) pure Lua 5.1 bitop implementation.
-- From https://stackoverflow.com/a/32389020
-- We use this instead of the included bitop module as it may be removed in the
-- future.
-- See: https://www.wireshark.org/lists/wireshark-dev/201807/msg00046.html

OR, XOR, AND = 1, 3, 4

local function bitoper(a, b, oper)
   local r, m, s = 0, 2^31, nil
   repeat
      s,a,b = a+b+m, a%m, b%m
      r,m = r + m*oper%(s-a-b), m/2
   until m < 1
   return r
end

-- endregion

-- region Lzo1x

local LzoReader = {}

function LzoReader:new(bytes)
  local reader = { b = bytes, idx = 0 }
  setmetatable(reader, self)
  self.__index = self
  return reader
end

function LzoReader:read_u8()
  local b = self.b:get_index(self.idx)
  self.idx = self.idx + 1
  return b
end

function LzoReader:read_u16()
  local b0 = self:read_u8()
  local b1 = self:read_u8()
  return b0 + b1 * 256
end

function LzoReader:read_multi(base)
  local b = 0
  while true do
    local v = self:read_u8()
    if v == 0 then
      b = b + 255
    else
      return b + v + base
    end
  end
end

function LzoReader:read_append(output, n)
  output:append(self.b:subset(self.idx, n))
  self.idx = self.idx + n
end

local function copy_match(output, m_pos, n)
  dprint("copy_match(" .. m_pos .. ", " .. n .. ")")
  if m_pos + n > output:len() then
    -- overlapping case: go byte-by-byte
    local i = 0
    while i < n do
      output:append(output:subset(m_pos, 1))
      m_pos = m_pos + 1
      i = i + 1
    end
  else
    output:append(output:subset(m_pos, n))
  end
end

local lzo_phase = {
  begin_loop = 1,
  first_literal_run = 2,
  match = 3,
  copy_match = 4,
  match_done = 5,
  match_next = 6,
  match_end = 7
}

local function lzoPhaseStr(phase)
  if phase == lzo_phase.begin_loop then return "begin loop"
  elseif phase == lzo_phase.first_literal_run then return "first literal run"
  elseif phase == lzo_phase.match then return "match"
  elseif phase == lzo_phase.copy_match then return "copy match"
  elseif phase == lzo_phase.match_done then return "match done"
  elseif phase == lzo_phase.match_next then return "match next"
  elseif phase == lzo_phase.match_end then return "match end"
  end
  return "(unknown)"
end

local function lzoDecompress1xNext(phase, state)
  dprint("lzo phase: " .. lzoPhaseStr(phase) .. ": ip=" .. state.ip .. ", m_pos: " .. state.m_pos .. ", out: " .. state.output:tohex(true, " "))
  if phase == lzo_phase.begin_loop then
    state.t = state.ip
    if state.t >= 16 then
      return lzoDecompress1xNext(lzo_phase.match, state)
    end
    if state.t == 0 then
      state.t = state.input:read_multi(15)
    end
    state.input:read_append(state.output, state.t+3)
    return lzoDecompress1xNext(lzo_phase.first_literal_run, state)
  elseif phase == lzo_phase.first_literal_run then
    state.ip = state.input:read_u8()
    state.last2 = state.ip
    state.t = state.ip
    if state.t >= 16 then
      return lzoDecompress1xNext(lzo_phase.match, state)
    end
    state.m_pos = state.output:len() - (1 + 0x800)
    state.m_pos = state.m_pos - state.t * 4
    state.ip = state.input:read_u8()
    state.m_pos = state.m_pos - math.floor(state.ip / 4)
    if state.m_pos < 0 then
      error("lookbehind underrun (first literal run)")
    end
    copy_match(state.output, state.m_pos, 3)
    return lzoDecompress1xNext(lzo_phase.match_done, state)
  elseif phase == lzo_phase.match then
    state.t = state.ip
    state.last2 = state.ip
    if state.t >= 64 then
      dprint("state.t (" .. state.t .. ") >= 64")
      state.m_pos = state.output:len() - 1
      dprint("state.m_pos = state.output:len() - 1 = " .. state.m_pos)
      state.m_pos = state.m_pos - bitoper((state.t / 4), 7, AND)
      dprint("state.m_pos = state.m_pos - bitoper(math.floor(state.t / 4), 7, AND) = " .. state.m_pos)
      state.ip = state.input:read_u8()
      dprint("state.ip = state.input:read_u8() = " .. state.ip)
      state.m_pos = state.m_pos - (state.ip * 8)
      dprint("state.m_pos = state.m_pos - math.floor(state.ip * 8) = " .. state.m_pos)
      state.t = math.floor(state.t / 32) - 1
      dprint("state.t = math.floor(state.t / 32) - 1 = " .. state.t)
      return lzoDecompress1xNext(lzo_phase.copy_match, state)
    elseif state.t >= 32 then
      dprint("state.t (" .. state.t .. ") >= 32")
      state.t = bitoper(state.t, 31, AND)
      if state.t == 0 then
        state.t = state.input:read_multi(31)
      end
      state.m_pos = state.output:len() - 1
      local v16 = state.input:read_u16()
      state.m_pos = state.m_pos - math.floor(v16 / 4)
      state.last2 = bitoper(v16, 0xFF, AND)
    elseif state.t >= 16 then
      dprint("state.t (" .. state.t .. ") >= 16")
      state.m_pos = state.output:len()
      dprint("state.m_pos = state.output:len() = " .. state.m_pos)
      state.m_pos = state.m_pos - math.floor(bitoper(state.t, 8, AND) / 2048)
      dprint("state.m_pos = state.m_pos - math.floor(bitoper(state.t, 8, AND) / 2048) = " .. state.m_pos)
      state.t = bitoper(state.t, 7, AND)
      if state.t == 0 then
        state.t = state.input:read_multi(7)
      end
      local v16 = state.input:read_u16()
      state.m_pos = state.m_pos - v16 * 4
      dprint("state.m_pos = state.m_pos - v16 * 4 = " .. state.m_pos)
      if state.m_pos == state.output:len() then
        return state.output
      end
      state.m_pos = state.m_pos - 0x4000
      dprint("state.m_pos = state.m_pos - 0x4000 = " .. state.m_pos)
      state.last2 = bitoper(v16, 0xFF, AND)
    else
      dprint("state.t (" .. state.t .. ") < 16")
      state.m_pos = state.output:len() - 1
      state.m_pos = state.m_pos - state.t * 4
      state.ip = state.input:read_u8()
      state.m_pos = state.m_pos - math.floor(state.ip / 4)
      if state.m_pos < 0 then
        error("lookbehind underrun (match)")
      end
      copy_match(state.output, state.m_pos, 2)
      return lzoDecompress1xNext(lzo_phase.match_done, state)
    end
    return lzoDecompress1xNext(lzo_phase.copy_match, state)
  elseif phase == lzo_phase.copy_match then
    if state.m_pos < 0 then
      dprint("underrun: m_pos=" .. state.m_pos)
      error("lookbehind underrun (copy match)")
    end
    copy_match(state.output, state.m_pos, state.t+2)
    return lzoDecompress1xNext(lzo_phase.match_done, state)
  elseif phase == lzo_phase.match_done then
    state.t = bitoper(state.last2, 3, AND)
    if state.t == 0 then
      return lzoDecompress1xNext(lzo_phase.match_end, state)
    end
    return lzoDecompress1xNext(lzo_phase.match_next, state)
  elseif phase == lzo_phase.match_next then
    state.input:read_append(state.output, state.t)
    state.ip = state.input:read_u8()
    return lzoDecompress1xNext(lzo_phase.match, state)
  elseif phase == lzo_phase.match_end then
    state.ip = state.input:read_u8()
    return lzoDecompress1xNext(lzo_phase.begin_loop, state)
  end
end

local function lzoDecompress1x(b)
  local state = {
    t = 0,
    m_pos = 0,
    last2 = 0,
    output = ByteArray.new(),
    input = LzoReader:new(b),
    ip = 0
  }

  -- Initial phase
  state.ip = state.input:read_u8()
  if state.ip > 17 then
    state.t = state.ip - 17
    if state.t < 4 then
      return lzoDecompress1xNext(lzo_phase.match_next, state)
    end
    state.input:read_append(state.output, state.t)
    return lzoDecompress1xNext(lzo_phase.first_literal_run, state)
  end
  return lzoDecompress1xNext(lzo_phase.begin_loop, state)
end

-- endregion

-- region PangYa crypt tables

local crypt_table_0 = ""
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x29, 0x23, 0xBE, 0x84, 0xE1, 0x6C, 0xD6, 0xAE, 0x52, 0x90, 0x49, 0xF1, 0xBB, 0xE9, 0xEB, 0xB3, 0xA6, 0xDB, 0x3C, 0x87, 0x0C, 0x3E, 0x99, 0x24, 0x5E, 0x0D, 0x1C, 0x06, 0xB7, 0x47)
crypt_table_0 = crypt_table_0 .. string.char(0xDE, 0x12, 0x4D, 0xC8, 0x43, 0x8B, 0x1F, 0x03, 0x5A, 0x7D, 0x09, 0x38, 0x25, 0x5D, 0xD4, 0xCB, 0xFC, 0x96, 0xF5, 0x45, 0x3B, 0x13, 0x89, 0x0A, 0x32, 0x20, 0x9A, 0x50, 0xEE, 0x40, 0x78, 0x36)
crypt_table_0 = crypt_table_0 .. string.char(0xFD, 0xF6, 0x9E, 0xDC, 0xAD, 0x4F, 0x14, 0xF2, 0x44, 0x66, 0xD0, 0x6B, 0xC4, 0x30, 0xA1, 0x22, 0x91, 0x9D, 0xDA, 0xB0, 0xCA, 0x02, 0xB9, 0x72, 0x2C, 0x80, 0x7E, 0xC5, 0xD5, 0xB2, 0xEA, 0xC9)
crypt_table_0 = crypt_table_0 .. string.char(0xCC, 0x53, 0xBF, 0x67, 0x2D, 0x8E, 0x83, 0xEF, 0x57, 0x61, 0xFF, 0x69, 0x8F, 0xCD, 0xD1, 0x1E, 0x9C, 0x16, 0xE6, 0x1D, 0xF0, 0x4A, 0x77, 0xD7, 0xE8, 0x39, 0x33, 0x74, 0xF4, 0x9F, 0xA4, 0x59)
crypt_table_0 = crypt_table_0 .. string.char(0x35, 0xCF, 0xD3, 0x48, 0x75, 0xD9, 0x2A, 0xE5, 0xC0, 0xF7, 0x2B, 0x81, 0x0E, 0x5F, 0x8D, 0x7B, 0x05, 0x15, 0x07, 0x82, 0x18, 0x70, 0x92, 0x64, 0x54, 0xCE, 0xB1, 0x85, 0xF8, 0x46, 0x6A, 0x04)
crypt_table_0 = crypt_table_0 .. string.char(0x73, 0x2F, 0x68, 0x76, 0xFA, 0x11, 0x88, 0x79, 0xFE, 0xD8, 0x28, 0x0B, 0x60, 0x3D, 0x97, 0x27, 0x8A, 0xC2, 0x08, 0xA5, 0xC1, 0x8C, 0xA9, 0x95, 0x9B, 0xA8, 0xA7, 0x86, 0xB5, 0xE7, 0x55, 0x4E)
crypt_table_0 = crypt_table_0 .. string.char(0x71, 0xE2, 0xB4, 0x65, 0x7A, 0x63, 0x26, 0xDF, 0x6D, 0x62, 0xE0, 0x34, 0x3F, 0xE3, 0x41, 0x0F, 0x1B, 0xF3, 0xA0, 0x7F, 0xAA, 0x5B, 0xB8, 0x3A, 0x10, 0x4C, 0xEC, 0x31, 0x42, 0x7C, 0xE4, 0x21)
crypt_table_0 = crypt_table_0 .. string.char(0x93, 0xAF, 0x6F, 0x17, 0x56, 0xC6, 0xF9, 0x37, 0xBD, 0x6E, 0x5C, 0xC3, 0xA3, 0x98, 0xC7, 0xB6, 0x51, 0x19, 0x2E, 0xBC, 0x94, 0x4B, 0x58, 0xD2, 0xAC, 0x1A, 0xA2, 0xED, 0xFB, 0xDD, 0xBA, 0xAB)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x08, 0xA3, 0xAA, 0x3F, 0xF0, 0x1C, 0x55, 0xAD, 0x51, 0x4F, 0xC4, 0x85, 0x96, 0x58, 0x5E, 0xD5, 0x88, 0x1E, 0x81, 0x56, 0x8C, 0xBB, 0xE9, 0x9F, 0x6D, 0x25, 0xC8, 0xEB, 0x09, 0x0D)
crypt_table_0 = crypt_table_0 .. string.char(0x19, 0x1D, 0x4A, 0x07, 0x31, 0xEC, 0x97, 0x7C, 0x15, 0x48, 0x0F, 0x41, 0xD0, 0x14, 0x91, 0xE8, 0xB3, 0x50, 0x2F, 0x60, 0x90, 0x2B, 0xE3, 0xB7, 0x20, 0x2D, 0x62, 0x28, 0xD3, 0x10, 0x17, 0x5D)
crypt_table_0 = crypt_table_0 .. string.char(0xE7, 0xF7, 0xE2, 0xA8, 0xE1, 0xCF, 0x3A, 0x65, 0xCA, 0x2C, 0x0C, 0xDC, 0x05, 0x3C, 0xFA, 0xC5, 0x99, 0xB0, 0x27, 0x40, 0x68, 0xC3, 0xAB, 0xBA, 0x24, 0xC1, 0x9B, 0x61, 0xF1, 0xFC, 0xD8, 0xBF)
crypt_table_0 = crypt_table_0 .. string.char(0xE6, 0x02, 0xC0, 0xA2, 0xA5, 0xF2, 0xEA, 0xD7, 0x87, 0x70, 0xDB, 0xB1, 0xE5, 0x44, 0x73, 0x82, 0x8D, 0x9C, 0xC6, 0xCE, 0xD4, 0x57, 0x3D, 0xAC, 0xA1, 0x06, 0x9D, 0x37, 0xEF, 0xCC, 0x4B, 0xFF)
crypt_table_0 = crypt_table_0 .. string.char(0xB6, 0x4C, 0x86, 0x36, 0x93, 0x72, 0xCB, 0x8E, 0xA7, 0x69, 0x43, 0x79, 0xF9, 0x1F, 0x3E, 0xD9, 0x8A, 0x83, 0xB2, 0xB4, 0x71, 0xBD, 0x3B, 0x8B, 0x75, 0x5B, 0x29, 0xED, 0x95, 0xAE, 0xDF, 0x77)
crypt_table_0 = crypt_table_0 .. string.char(0x22, 0xAF, 0x6E, 0xEE, 0xB5, 0x12, 0x6B, 0xD1, 0x1A, 0x9E, 0x7B, 0x76, 0x7E, 0xB8, 0x74, 0x9A, 0x35, 0x4E, 0x59, 0xD6, 0xF8, 0xDE, 0xE0, 0x6C, 0x0B, 0xBC, 0xE4, 0x1B, 0x13, 0xA6, 0x89, 0xBE)
crypt_table_0 = crypt_table_0 .. string.char(0xB9, 0x7D, 0xFB, 0xD2, 0x6A, 0x03, 0x16, 0x94, 0x32, 0x67, 0x26, 0xA9, 0xF3, 0x2E, 0x6F, 0x0A, 0x7F, 0x80, 0xC7, 0x42, 0x11, 0xF5, 0xDA, 0x30, 0x46, 0x49, 0x66, 0xF6, 0xC9, 0xCD, 0x92, 0x5C)
crypt_table_0 = crypt_table_0 .. string.char(0x23, 0x7A, 0xA4, 0x64, 0x39, 0x4D, 0xFD, 0x98, 0x54, 0x5F, 0x45, 0x5A, 0x2A, 0x33, 0x78, 0xDD, 0xFE, 0x52, 0x38, 0x18, 0x84, 0x21, 0xF4, 0x53, 0x8F, 0xC2, 0x47, 0x34, 0x04, 0xA0, 0x63, 0x0E)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x5B, 0xC7, 0x3A, 0xB0, 0x11, 0x12, 0x51, 0xC2, 0xA6, 0x47, 0x6B, 0x2C, 0x13, 0xCF, 0x74, 0x68, 0x95, 0xE3, 0xA8, 0xBE, 0xFE, 0xA3, 0xB3, 0xF5, 0x8A, 0xAE, 0xCD, 0x3C, 0x3D, 0x42)
crypt_table_0 = crypt_table_0 .. string.char(0x6A, 0x1C, 0xA5, 0x63, 0x9C, 0xC3, 0x69, 0x97, 0x18, 0xF7, 0x84, 0x0E, 0xD0, 0x99, 0x7F, 0xBA, 0x2D, 0x77, 0x28, 0x2A, 0x19, 0xDC, 0x93, 0x5E, 0x22, 0x6F, 0x98, 0x9F, 0xF6, 0xDF, 0xC6, 0xDE)
crypt_table_0 = crypt_table_0 .. string.char(0x21, 0xE7, 0x55, 0x7E, 0xB8, 0x82, 0x59, 0xE5, 0x35, 0x09, 0x3B, 0x32, 0x39, 0xD3, 0xAB, 0x20, 0xFC, 0xD8, 0x2B, 0x6D, 0xFD, 0x25, 0x67, 0x8F, 0x53, 0x0A, 0x6C, 0x4C, 0x9E, 0x04, 0x62, 0xBD)
crypt_table_0 = crypt_table_0 .. string.char(0x40, 0x06, 0x15, 0xF3, 0xA7, 0x17, 0xC5, 0x73, 0x8D, 0x80, 0x8B, 0xBC, 0xC9, 0xB1, 0x6E, 0xC0, 0xE8, 0x48, 0xE0, 0xDB, 0x5D, 0x76, 0x3F, 0xD7, 0x1B, 0xE2, 0x02, 0x88, 0xF4, 0xF9, 0x8E, 0x57)
crypt_table_0 = crypt_table_0 .. string.char(0x7D, 0xA0, 0xE4, 0xBB, 0x0D, 0x23, 0x92, 0xCE, 0x05, 0xF1, 0xC1, 0x86, 0xC4, 0x30, 0xD5, 0x7A, 0x50, 0x9A, 0xAF, 0x3E, 0x94, 0x89, 0x0B, 0x31, 0x5F, 0xED, 0xF2, 0x49, 0x34, 0x0C, 0xB2, 0x37)
crypt_table_0 = crypt_table_0 .. string.char(0xFA, 0xEC, 0xD1, 0xF8, 0x65, 0x8C, 0x27, 0xF0, 0xFB, 0x1A, 0x66, 0x54, 0x43, 0xEE, 0xB5, 0xD9, 0xBF, 0x81, 0x75, 0x90, 0x64, 0x71, 0x46, 0x91, 0x5C, 0xE1, 0xD2, 0x4E, 0xAC, 0xEB, 0xAD, 0xB7)
crypt_table_0 = crypt_table_0 .. string.char(0xA9, 0x78, 0x83, 0x08, 0xA4, 0x29, 0xD6, 0x96, 0xA1, 0x4D, 0x9B, 0x60, 0x2E, 0x26, 0x24, 0xEA, 0x16, 0x41, 0x52, 0xFF, 0x4F, 0xA2, 0x4A, 0x9D, 0x58, 0x44, 0xC8, 0xCC, 0x4B, 0x1E, 0x56, 0xCA)
crypt_table_0 = crypt_table_0 .. string.char(0x2F, 0x70, 0x14, 0x33, 0x61, 0x0F, 0xDD, 0xB4, 0x36, 0x85, 0x7B, 0xE6, 0x72, 0x38, 0xCB, 0xB6, 0x1D, 0x87, 0x07, 0x1F, 0x79, 0xDA, 0xB9, 0x5A, 0xE9, 0x03, 0xEF, 0x10, 0xAA, 0x45, 0x7C, 0xD4)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x75, 0xC5, 0xAF, 0x12, 0xD3, 0x97, 0x66, 0x5B, 0x79, 0x92, 0xDF, 0x5C, 0x2A, 0xA4, 0x6F, 0xAC, 0x29, 0x07, 0xA0, 0xB0, 0x9E, 0x68, 0x7C, 0x59, 0x27, 0x7D, 0x6B, 0x43, 0x84, 0x40)
crypt_table_0 = crypt_table_0 .. string.char(0xC4, 0xA7, 0x0F, 0x71, 0x2B, 0x48, 0x3E, 0xE4, 0x0B, 0xBD, 0x8F, 0xC9, 0x3D, 0xE7, 0xCF, 0xB5, 0x1D, 0x4B, 0x81, 0xC8, 0x8B, 0x3C, 0x6E, 0x7A, 0x23, 0xAD, 0x47, 0x63, 0x39, 0x33, 0x7B, 0x9C)
crypt_table_0 = crypt_table_0 .. string.char(0x80, 0xD0, 0x9A, 0xDD, 0x30, 0x10, 0x54, 0x88, 0x77, 0x61, 0x02, 0x73, 0xD2, 0xEC, 0x7E, 0xB9, 0xC0, 0xE2, 0xF4, 0xD9, 0xD5, 0x85, 0x78, 0xF3, 0xF8, 0xDE, 0x09, 0x4E, 0x53, 0x37, 0x8D, 0x58)
crypt_table_0 = crypt_table_0 .. string.char(0xF5, 0xB8, 0x14, 0x8C, 0xA9, 0x69, 0x31, 0x4F, 0x46, 0x5A, 0x64, 0xE6, 0x2C, 0xE9, 0x91, 0xE3, 0xA8, 0xFA, 0xB2, 0x19, 0xB7, 0x99, 0x05, 0xB6, 0xC7, 0xD6, 0x86, 0x0A, 0x38, 0x35, 0x1A, 0x0C)
crypt_table_0 = crypt_table_0 .. string.char(0x52, 0xFF, 0x72, 0x08, 0xEE, 0xDB, 0xAB, 0x21, 0xFD, 0xE1, 0xEA, 0x17, 0xDC, 0x1F, 0x74, 0xCB, 0xB3, 0x8A, 0x20, 0xAA, 0xA1, 0x5D, 0xBB, 0xEB, 0xD7, 0x57, 0xD8, 0x90, 0xF9, 0xFB, 0x4D, 0xBE)
crypt_table_0 = crypt_table_0 .. string.char(0x82, 0x6D, 0x2D, 0xB4, 0x51, 0x93, 0xAE, 0x0D, 0x76, 0x6C, 0x41, 0x25, 0x89, 0x22, 0x94, 0x95, 0xC3, 0x0E, 0x8E, 0x44, 0x70, 0xCD, 0x3B, 0xBF, 0xB1, 0x1E, 0x87, 0xD4, 0xF2, 0xED, 0xFC, 0xF0)
crypt_table_0 = crypt_table_0 .. string.char(0x4A, 0x15, 0x65, 0x5F, 0xC6, 0x4C, 0x67, 0x11, 0x04, 0x9D, 0xA3, 0x55, 0xDA, 0xC2, 0x1B, 0x56, 0xA2, 0x36, 0xA6, 0x3F, 0xE8, 0xCA, 0xF1, 0xEF, 0x96, 0xE5, 0x6A, 0x28, 0x7F, 0x32, 0xE0, 0x16)
crypt_table_0 = crypt_table_0 .. string.char(0x13, 0xCE, 0x06, 0xD1, 0xA5, 0xF7, 0x3A, 0xFE, 0x42, 0x26, 0x2E, 0x5E, 0x18, 0x98, 0xF6, 0x62, 0x24, 0xC1, 0x49, 0x9F, 0x60, 0x45, 0x1C, 0xCC, 0x83, 0x9B, 0x34, 0x03, 0x50, 0x2F, 0xBA, 0xBC)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x91, 0xF5, 0x8F, 0x1C, 0x59, 0x2A, 0x90, 0x81, 0x30, 0xCC, 0x6E, 0xD3, 0xB4, 0x16, 0x50, 0x31, 0xD2, 0x4D, 0x34, 0x2B, 0x2F, 0x96, 0x7B, 0x32, 0xC7, 0x0A, 0xA8, 0x4C, 0xD5, 0x0C)
crypt_table_0 = crypt_table_0 .. string.char(0x65, 0x0D, 0xF2, 0xDA, 0xC2, 0x80, 0x63, 0xEF, 0x49, 0x40, 0xFC, 0x64, 0x86, 0x7E, 0xF8, 0xCD, 0x84, 0xE7, 0xB6, 0xBF, 0x9D, 0xEE, 0x3B, 0xF9, 0x3D, 0xA9, 0xAF, 0xEC, 0xB8, 0x79, 0xB5, 0x08)
crypt_table_0 = crypt_table_0 .. string.char(0xC3, 0x70, 0x73, 0x1A, 0x82, 0xE4, 0xDE, 0xBA, 0x39, 0xCA, 0xA6, 0x93, 0xE8, 0xA5, 0x0E, 0x7A, 0x10, 0x52, 0xAA, 0xBE, 0xE5, 0xED, 0xDD, 0x5F, 0x46, 0xAC, 0xC8, 0xC9, 0xB3, 0x8B, 0xEA, 0x8C)
crypt_table_0 = crypt_table_0 .. string.char(0x19, 0x61, 0x66, 0x5C, 0x35, 0xEB, 0xBB, 0x6D, 0x3C, 0x25, 0xBD, 0xD8, 0x29, 0x38, 0x58, 0xF1, 0xFD, 0xF4, 0x6C, 0x20, 0x2D, 0x57, 0xBC, 0x6F, 0xB2, 0x09, 0xB0, 0x3A, 0xDC, 0xA1, 0x3F, 0x45)
crypt_table_0 = crypt_table_0 .. string.char(0x17, 0x11, 0x03, 0xFB, 0x5E, 0x21, 0x41, 0x6A, 0xD9, 0xA7, 0xFF, 0x2E, 0x37, 0x89, 0x4E, 0x85, 0x6B, 0x94, 0xD0, 0xA2, 0x1E, 0x99, 0x43, 0xD4, 0x72, 0x51, 0xA4, 0x2C, 0x7D, 0xAD, 0xFA, 0x9C)
crypt_table_0 = crypt_table_0 .. string.char(0x78, 0x83, 0x9B, 0x5A, 0x3E, 0x67, 0x0F, 0x54, 0xD7, 0xCF, 0xE1, 0x87, 0xDB, 0x1F, 0x07, 0x18, 0x47, 0x62, 0x55, 0xF0, 0x27, 0x22, 0x4A, 0x77, 0xAB, 0x9E, 0x4F, 0xF7, 0x75, 0xE6, 0x5B, 0x5D)
crypt_table_0 = crypt_table_0 .. string.char(0x97, 0xC4, 0xC1, 0x48, 0xDF, 0x28, 0xA0, 0xF3, 0xAE, 0x76, 0xE9, 0x7C, 0xC5, 0xB1, 0x05, 0x56, 0x92, 0xE2, 0x44, 0xFE, 0x14, 0x8E, 0x98, 0xCB, 0x24, 0x33, 0xD1, 0xE0, 0xE3, 0xC0, 0x60, 0x69)
crypt_table_0 = crypt_table_0 .. string.char(0xB7, 0x36, 0x42, 0x23, 0x15, 0x71, 0x0B, 0xCE, 0xF6, 0x7F, 0x4B, 0xA3, 0x68, 0x9A, 0x95, 0x1D, 0x8A, 0x13, 0xC6, 0x02, 0x88, 0xB9, 0x53, 0x04, 0x06, 0x9F, 0xD6, 0x8D, 0x1B, 0x74, 0x12, 0x26)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x62, 0x65, 0xBB, 0x67, 0x4A, 0x1C, 0xAA, 0xA4, 0xB9, 0xA1, 0xE6, 0xCC, 0xE7, 0x64, 0xF1, 0xEF, 0x26, 0x57, 0xF6, 0x76, 0x0C, 0x7B, 0x48, 0x8A, 0xF3, 0x95, 0xC9, 0xD0, 0x04, 0xFC)
crypt_table_0 = crypt_table_0 .. string.char(0x0D, 0xDF, 0x88, 0xFD, 0xDC, 0x96, 0x69, 0x6C, 0xA0, 0x3C, 0xEE, 0x2D, 0x9F, 0x5B, 0x9C, 0x92, 0xE0, 0x33, 0x74, 0x36, 0xCA, 0x2F, 0xD8, 0xE5, 0x12, 0xC0, 0x87, 0x6D, 0xFE, 0xB1, 0xD7, 0x54)
crypt_table_0 = crypt_table_0 .. string.char(0xD1, 0x52, 0x91, 0x7C, 0xF5, 0x4B, 0xBA, 0x07, 0x81, 0x78, 0x7E, 0x53, 0x39, 0x4D, 0xED, 0x24, 0xE4, 0x42, 0xC5, 0xB6, 0x3B, 0xD6, 0x5F, 0x23, 0x6E, 0x80, 0xA2, 0x86, 0x30, 0x59, 0x46, 0x75)
crypt_table_0 = crypt_table_0 .. string.char(0x77, 0x72, 0x6A, 0xF9, 0xC2, 0xEC, 0xC3, 0xBC, 0x70, 0x1B, 0x40, 0x8F, 0x20, 0x66, 0xE1, 0x18, 0xA8, 0xB2, 0x22, 0x9E, 0x2A, 0xEA, 0x55, 0xE9, 0x60, 0x56, 0xE2, 0x8B, 0xCF, 0x83, 0x4C, 0x84)
crypt_table_0 = crypt_table_0 .. string.char(0x10, 0x11, 0x31, 0x25, 0x3A, 0x43, 0x3F, 0xE3, 0xAB, 0x28, 0x27, 0xB5, 0x99, 0xDA, 0x37, 0x5A, 0x8C, 0xFB, 0x49, 0x50, 0x7F, 0xA3, 0x68, 0x15, 0x6B, 0x02, 0x13, 0x0F, 0xDB, 0xCE, 0xD2, 0xA7)
crypt_table_0 = crypt_table_0 .. string.char(0xDE, 0xF0, 0x1A, 0x90, 0x2B, 0x97, 0x6F, 0x45, 0xE8, 0xCD, 0x17, 0xC1, 0x9A, 0xB7, 0xAF, 0x2E, 0xC6, 0x3D, 0xA6, 0x85, 0xF8, 0xB0, 0x51, 0xBE, 0x79, 0x5D, 0xAC, 0x9B, 0x41, 0xF7, 0xC8, 0xA5)
crypt_table_0 = crypt_table_0 .. string.char(0xDD, 0x0B, 0xD4, 0x9D, 0x89, 0x7D, 0x38, 0xF2, 0x71, 0xAD, 0x63, 0x1D, 0xCB, 0x4E, 0xFA, 0x35, 0x44, 0x1F, 0xC4, 0x14, 0x8E, 0xBD, 0x19, 0x94, 0x5E, 0x93, 0x5C, 0x34, 0x47, 0x09, 0x2C, 0x1E)
crypt_table_0 = crypt_table_0 .. string.char(0xB4, 0xC7, 0xFF, 0x98, 0xD5, 0xF4, 0xEB, 0x3E, 0xB3, 0x8D, 0x82, 0x0E, 0x29, 0x05, 0x03, 0x32, 0x73, 0x0A, 0x4F, 0xBF, 0xAE, 0xD3, 0x7A, 0x21, 0x06, 0x08, 0xB8, 0x58, 0xA9, 0xD9, 0x16, 0x61)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x5C, 0x09, 0x15, 0xE9, 0xF2, 0xFB, 0x69, 0xAF, 0x98, 0x5F, 0x78, 0x14, 0xC2, 0x2D, 0xA9, 0x63, 0x19, 0xAD, 0x92, 0xEC, 0x72, 0x13, 0xC1, 0xDF, 0x0C, 0x57, 0x70, 0xEA, 0x1B, 0xD9)
crypt_table_0 = crypt_table_0 .. string.char(0x20, 0x73, 0xF3, 0x3B, 0x7A, 0x26, 0xDE, 0xB1, 0xB2, 0xF1, 0x02, 0xBB, 0x16, 0x9E, 0x53, 0xE5, 0x34, 0xA6, 0x51, 0xFC, 0x36, 0x2B, 0x94, 0xF0, 0xC7, 0x6F, 0x1D, 0x5B, 0x6C, 0x38, 0x4A, 0x61)
crypt_table_0 = crypt_table_0 .. string.char(0x25, 0xD1, 0x2A, 0xF8, 0x31, 0x0B, 0x9C, 0x7D, 0x03, 0x55, 0x2E, 0x04, 0x54, 0x21, 0x8A, 0x8F, 0x3F, 0x64, 0x07, 0xDA, 0x56, 0xCE, 0x91, 0x5E, 0xFA, 0xA3, 0x4C, 0xC6, 0x59, 0xE3, 0x5A, 0xC5)
crypt_table_0 = crypt_table_0 .. string.char(0x81, 0x12, 0x24, 0x3E, 0x1C, 0x4E, 0x23, 0xD5, 0xD8, 0x76, 0xAE, 0x8C, 0x83, 0xB9, 0x32, 0xCB, 0xC8, 0xE6, 0x49, 0x82, 0x50, 0x6D, 0xE0, 0x47, 0x62, 0xA1, 0x10, 0xDD, 0xE8, 0x6A, 0xCC, 0x18)
crypt_table_0 = crypt_table_0 .. string.char(0xED, 0x9B, 0x22, 0xC9, 0xA5, 0x8D, 0x2F, 0x29, 0x74, 0x8E, 0xBA, 0x7E, 0x4F, 0xAB, 0x1E, 0xF4, 0x97, 0xB4, 0xA7, 0xE7, 0x48, 0x33, 0x52, 0x7B, 0x60, 0x05, 0xA0, 0x0E, 0x44, 0x41, 0xCD, 0x8B)
crypt_table_0 = crypt_table_0 .. string.char(0xBC, 0xBF, 0xB0, 0x11, 0x80, 0xAC, 0xA4, 0x66, 0x39, 0xF5, 0xE2, 0x43, 0x71, 0x28, 0x90, 0x27, 0x0F, 0x75, 0xBD, 0x0D, 0x3D, 0xFD, 0xB8, 0xD7, 0xAA, 0xB3, 0x17, 0xF6, 0x35, 0x4D, 0x95, 0xB5)
crypt_table_0 = crypt_table_0 .. string.char(0x42, 0x96, 0xB6, 0xC4, 0xB7, 0x89, 0xE1, 0x99, 0xDB, 0xCF, 0xD0, 0xCA, 0x9D, 0xC0, 0xD3, 0x68, 0x9F, 0x7F, 0x45, 0x1A, 0xC3, 0x4B, 0xD6, 0x58, 0x85, 0x88, 0x5D, 0xE4, 0xEB, 0x30, 0x77, 0x79)
crypt_table_0 = crypt_table_0 .. string.char(0xFE, 0xF9, 0x93, 0x7C, 0x6B, 0xF7, 0x46, 0xEE, 0x1F, 0xDC, 0xA2, 0xBE, 0x9A, 0xFF, 0x40, 0xD4, 0x84, 0x06, 0xD2, 0x2C, 0x6E, 0x0A, 0xEF, 0x08, 0x86, 0x65, 0x3C, 0x3A, 0x37, 0x87, 0x67, 0xA8)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x15, 0xE3, 0x6B, 0x6D, 0x4C, 0xEF, 0x73, 0x0A, 0x8E, 0x1B, 0x5A, 0x56, 0xE7, 0x90, 0xB2, 0x68, 0xA8, 0x63, 0x16, 0xFF, 0xFE, 0x42, 0x5F, 0x39, 0x4D, 0x98, 0xD2, 0xC7, 0x2F, 0x91)
crypt_table_0 = crypt_table_0 .. string.char(0x4E, 0x59, 0xA2, 0xFC, 0xFB, 0xCB, 0x22, 0x3D, 0x32, 0x96, 0xD6, 0xBF, 0x38, 0xA5, 0x84, 0x61, 0x8D, 0x2E, 0x8A, 0xAC, 0xD5, 0xB9, 0x7C, 0x8C, 0xC1, 0x71, 0xE2, 0x65, 0x06, 0x94, 0xC9, 0xBC)
crypt_table_0 = crypt_table_0 .. string.char(0x34, 0x83, 0xFA, 0x3A, 0x55, 0x45, 0x60, 0xF8, 0x27, 0xAF, 0x2D, 0x24, 0xDD, 0x6C, 0x0E, 0x99, 0x13, 0x53, 0x7F, 0x33, 0x5E, 0x3C, 0xF6, 0x7A, 0xC5, 0x8F, 0x20, 0xC0, 0x1A, 0xC8, 0xB8, 0xDE)
crypt_table_0 = crypt_table_0 .. string.char(0xB3, 0x3E, 0xF0, 0x81, 0x82, 0xFD, 0xC6, 0xEC, 0x4B, 0xBB, 0x28, 0x11, 0xB6, 0xD8, 0xAD, 0x31, 0xF5, 0x19, 0xDB, 0x36, 0x64, 0x12, 0xA9, 0x3F, 0x67, 0x0B, 0x44, 0xE0, 0x77, 0x51, 0x2C, 0x9E)
crypt_table_0 = crypt_table_0 .. string.char(0x87, 0xF2, 0xD4, 0x37, 0xE8, 0xE4, 0x5B, 0xF9, 0xE1, 0x14, 0xAA, 0x9D, 0x21, 0x26, 0xD3, 0x49, 0xBA, 0xCD, 0x03, 0x78, 0xA6, 0x86, 0xD0, 0xBD, 0xF3, 0x6F, 0x9A, 0x5D, 0x09, 0x2B, 0xD7, 0x88)
crypt_table_0 = crypt_table_0 .. string.char(0x3B, 0x41, 0x80, 0x9B, 0x1D, 0xE5, 0x04, 0x76, 0x6E, 0x7B, 0x17, 0x47, 0xD9, 0xDF, 0x1F, 0xE9, 0x48, 0xC3, 0x0D, 0x57, 0xA1, 0x66, 0xED, 0x9F, 0x23, 0xC4, 0xB4, 0xDA, 0xAB, 0xAE, 0x30, 0x2A)
crypt_table_0 = crypt_table_0 .. string.char(0x08, 0x40, 0x0F, 0x1E, 0xEA, 0x72, 0xDC, 0x97, 0x89, 0x92, 0xCA, 0x02, 0x7E, 0xC2, 0x18, 0x0C, 0x07, 0x75, 0x29, 0x50, 0x05, 0xEE, 0xA4, 0xCF, 0xCC, 0xCE, 0xB5, 0x69, 0xF7, 0x7D, 0x43, 0x8B)
crypt_table_0 = crypt_table_0 .. string.char(0x9C, 0xB0, 0x93, 0x46, 0x52, 0x58, 0x1C, 0x4F, 0xE6, 0x54, 0xA0, 0xB7, 0xA3, 0x5C, 0x35, 0x6A, 0xD1, 0xF4, 0x74, 0x4A, 0xA7, 0x79, 0x70, 0xF1, 0xEB, 0x95, 0xBE, 0x25, 0xB1, 0x85, 0x62, 0x10)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0xB4, 0xEF, 0x3A, 0x11, 0x57, 0x54, 0x61, 0xDF, 0x64, 0x07, 0xF4, 0x5E, 0x80, 0x2E, 0x55, 0xF8, 0xBA, 0xA6, 0xBD, 0x92, 0x98, 0xBF, 0x08, 0x4D, 0x93, 0x34, 0xE5, 0x43, 0x4B, 0x7D)
crypt_table_0 = crypt_table_0 .. string.char(0xF9, 0x67, 0xEE, 0x94, 0x26, 0x51, 0xDB, 0x0A, 0x48, 0xA1, 0x0C, 0x59, 0xFC, 0xE3, 0x6B, 0x0B, 0xB1, 0x9A, 0xC3, 0x85, 0x1F, 0xA3, 0x20, 0xE0, 0xE4, 0x3F, 0x6E, 0xD0, 0xC9, 0xB0, 0xF6, 0xE6)
crypt_table_0 = crypt_table_0 .. string.char(0xBC, 0x75, 0xB9, 0x4C, 0xF2, 0xCF, 0x30, 0x5C, 0xFE, 0x7F, 0x17, 0x14, 0xBE, 0xB5, 0xB6, 0xA4, 0x35, 0xE1, 0x73, 0xEC, 0x27, 0x19, 0x68, 0x18, 0xF3, 0xAD, 0x0D, 0xF1, 0x2C, 0xAC, 0xCA, 0xA9)
crypt_table_0 = crypt_table_0 .. string.char(0xC0, 0x06, 0x23, 0x9E, 0x6F, 0x4E, 0x2D, 0xCC, 0x2A, 0x8E, 0x28, 0xFF, 0xB7, 0xC7, 0xDC, 0x6C, 0x49, 0xDA, 0x5D, 0x5F, 0x15, 0x8B, 0xD9, 0x45, 0x8D, 0x89, 0xA7, 0x8F, 0xC6, 0xF0, 0xC4, 0x77)
crypt_table_0 = crypt_table_0 .. string.char(0x53, 0x74, 0x82, 0x46, 0x44, 0x41, 0x88, 0x6D, 0x16, 0xCB, 0x7C, 0xD3, 0x22, 0x42, 0xFA, 0x90, 0xD5, 0x8A, 0x72, 0x33, 0x1E, 0x31, 0x39, 0xAF, 0xD1, 0x1B, 0x1C, 0xE2, 0xD4, 0x13, 0x9B, 0x2B)
crypt_table_0 = crypt_table_0 .. string.char(0x79, 0xCD, 0x09, 0xC8, 0xC2, 0x76, 0x78, 0x4A, 0xDD, 0x63, 0x81, 0x83, 0x8C, 0xED, 0x7E, 0x21, 0x5B, 0x36, 0x71, 0xAA, 0x60, 0xEA, 0x2F, 0x12, 0x69, 0xFD, 0xF7, 0x62, 0x10, 0xAB, 0x87, 0x65)
crypt_table_0 = crypt_table_0 .. string.char(0x3D, 0x05, 0x1A, 0x40, 0xFB, 0xBB, 0xA8, 0x52, 0xB2, 0x37, 0x50, 0x04, 0xA5, 0x3B, 0xA2, 0x9C, 0x7B, 0x84, 0xF5, 0x1D, 0xAE, 0x38, 0x03, 0xD6, 0xC1, 0xD8, 0x97, 0x24, 0xDE, 0xB3, 0xE9, 0x6A)
crypt_table_0 = crypt_table_0 .. string.char(0x86, 0x5A, 0x66, 0x56, 0x47, 0x95, 0xE7, 0x91, 0xA0, 0x58, 0x70, 0x3E, 0xCE, 0xC5, 0x32, 0xD2, 0xE8, 0x0E, 0x9F, 0x96, 0xEB, 0xD7, 0x0F, 0x7A, 0x4F, 0x02, 0x9D, 0x3C, 0xB8, 0x29, 0x25, 0x99)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x83, 0xD3, 0xEB, 0xFD, 0x6A, 0x2B, 0xFB, 0xC1, 0x84, 0xD2, 0x37, 0x6D, 0x8E, 0x0C, 0x5F, 0xB3, 0xBB, 0xC6, 0xAE, 0x8B, 0x24, 0xF8, 0x0F, 0xC3, 0x06, 0x28, 0x91, 0xDE, 0x09, 0x43)
crypt_table_0 = crypt_table_0 .. string.char(0x93, 0x1B, 0xCB, 0xD1, 0xAB, 0xCE, 0xFF, 0x8D, 0xB5, 0x34, 0x81, 0x2E, 0x9E, 0x57, 0xC2, 0x76, 0xD4, 0x77, 0x4A, 0xC7, 0xE0, 0x71, 0x26, 0x73, 0x5B, 0x07, 0x59, 0x95, 0xD6, 0xA9, 0x1C, 0xE9)
crypt_table_0 = crypt_table_0 .. string.char(0x66, 0x1E, 0xDD, 0xA4, 0x7D, 0x52, 0xE2, 0x79, 0xB1, 0x55, 0xAD, 0x87, 0x47, 0xBF, 0x7B, 0x9F, 0x29, 0x8C, 0x4C, 0xE5, 0x5C, 0x11, 0xDB, 0x30, 0xC4, 0x3C, 0xC9, 0x14, 0x0E, 0x7F, 0xCF, 0x21)
crypt_table_0 = crypt_table_0 .. string.char(0x40, 0x63, 0x98, 0x6F, 0xAC, 0xB8, 0xFE, 0x38, 0x92, 0x50, 0xE8, 0x89, 0x99, 0x49, 0x61, 0x3F, 0xAF, 0xE4, 0x3A, 0xC5, 0x33, 0xA8, 0x8A, 0xCA, 0x16, 0xA6, 0xCD, 0xB9, 0x2A, 0xF2, 0xFA, 0x67)
crypt_table_0 = crypt_table_0 .. string.char(0x35, 0x9A, 0x97, 0xE7, 0xFC, 0xA7, 0x4F, 0x0A, 0x22, 0x48, 0x4B, 0x3D, 0xF0, 0x60, 0x2C, 0x64, 0x17, 0xCC, 0x42, 0xEA, 0x74, 0x0D, 0x10, 0x1F, 0x4D, 0x27, 0x19, 0xF9, 0x2D, 0xA3, 0x39, 0xF7)
crypt_table_0 = crypt_table_0 .. string.char(0x5D, 0x90, 0xF4, 0xD0, 0xB4, 0xC0, 0x25, 0xB0, 0x78, 0x08, 0x05, 0x4E, 0xEC, 0xBC, 0xA1, 0x51, 0xE1, 0xBA, 0x31, 0x96, 0x56, 0x13, 0xDA, 0x53, 0xD8, 0x0B, 0x23, 0xB2, 0xD5, 0x45, 0xF3, 0x72)
crypt_table_0 = crypt_table_0 .. string.char(0x03, 0xBD, 0x6C, 0xBE, 0x9D, 0x02, 0x3B, 0xEE, 0xED, 0xDC, 0xA0, 0x44, 0x12, 0x9B, 0x75, 0x69, 0xD7, 0xB6, 0xF1, 0x9C, 0x6E, 0xEF, 0x41, 0x1A, 0x5A, 0x04, 0x54, 0x1D, 0x2F, 0x7C, 0xA5, 0x68)
crypt_table_0 = crypt_table_0 .. string.char(0x46, 0x3E, 0xDF, 0x15, 0x58, 0xF5, 0x94, 0x86, 0xC8, 0x32, 0xE3, 0x7E, 0x65, 0x18, 0x85, 0xA2, 0x6B, 0xAA, 0x62, 0xE6, 0x80, 0x70, 0x8F, 0x82, 0x7A, 0x5E, 0xB7, 0x20, 0x88, 0xF6, 0xD9, 0x36)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0xBC, 0x5F, 0x86, 0xCE, 0xEB, 0x26, 0x6E, 0x9F, 0x1E, 0xDE, 0x98, 0x6B, 0x1C, 0xFB, 0x37, 0xEA, 0xD0, 0x92, 0x6C, 0x56, 0x18, 0xFD, 0xBF, 0x6D, 0x46, 0x53, 0x91, 0x9C, 0xB9, 0xD5)
crypt_table_0 = crypt_table_0 .. string.char(0xD9, 0xB8, 0x4D, 0x16, 0x52, 0x06, 0x24, 0xCB, 0xC6, 0x35, 0x38, 0xEC, 0x85, 0xCD, 0x28, 0x30, 0x14, 0xA3, 0xA4, 0x44, 0x0D, 0x4C, 0xE0, 0x1F, 0xA0, 0xE2, 0xC0, 0x07, 0x59, 0x73, 0xCF, 0x5E)
crypt_table_0 = crypt_table_0 .. string.char(0x84, 0xB6, 0x22, 0x08, 0xE3, 0x5D, 0x74, 0xB7, 0xC5, 0x3A, 0xAD, 0x51, 0x1B, 0x87, 0x19, 0x89, 0x2D, 0x97, 0xC7, 0xCC, 0xE8, 0x48, 0xF3, 0x66, 0x69, 0x09, 0x05, 0x2C, 0x3C, 0xD7, 0xB3, 0x03)
crypt_table_0 = crypt_table_0 .. string.char(0x9A, 0xB1, 0x88, 0x6A, 0x49, 0x2B, 0x50, 0x23, 0x75, 0x63, 0x55, 0x81, 0x29, 0x7D, 0xD6, 0x7F, 0xF9, 0x0A, 0x99, 0x95, 0xF5, 0x10, 0xF4, 0x8D, 0x25, 0x1D, 0x5A, 0x82, 0xD4, 0x41, 0xBA, 0x0C)
crypt_table_0 = crypt_table_0 .. string.char(0xA2, 0xDC, 0x77, 0x0E, 0x32, 0xF0, 0xA9, 0x94, 0x7C, 0x42, 0xEE, 0x11, 0xE1, 0x7B, 0xA7, 0xDA, 0xF2, 0x60, 0x15, 0x3F, 0x04, 0x71, 0x7E, 0xF6, 0xF1, 0x2F, 0x9B, 0xC2, 0x1A, 0xAB, 0x7A, 0xC8)
crypt_table_0 = crypt_table_0 .. string.char(0xC3, 0x9E, 0x58, 0x45, 0x4F, 0x2A, 0x21, 0xAF, 0xBB, 0x6F, 0x36, 0xD3, 0x80, 0x17, 0x65, 0x8A, 0x2E, 0xE7, 0xDF, 0xA8, 0x33, 0x20, 0x02, 0x47, 0xFF, 0x3B, 0x83, 0xEF, 0xE4, 0xFC, 0xED, 0xFA)
crypt_table_0 = crypt_table_0 .. string.char(0x4E, 0xF7, 0x5C, 0xAE, 0x93, 0xD2, 0xFE, 0xB4, 0x57, 0x8B, 0x34, 0x13, 0x76, 0x72, 0x0F, 0x96, 0x64, 0xE6, 0x61, 0xF8, 0xD1, 0xB0, 0xA6, 0xCA, 0x78, 0x8F, 0x43, 0x5B, 0xBD, 0x4A, 0xA5, 0x90)
crypt_table_0 = crypt_table_0 .. string.char(0x3D, 0xC9, 0xE5, 0x31, 0xC4, 0x54, 0x9D, 0xB5, 0x3E, 0xDD, 0x0B, 0x68, 0xD8, 0xAA, 0x70, 0x62, 0x8E, 0x67, 0x40, 0x39, 0x79, 0x27, 0xDB, 0xC1, 0xA1, 0xB2, 0x4B, 0xBE, 0xE9, 0x8C, 0xAC, 0x12)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0xA6, 0x46, 0x7E, 0xFC, 0xC2, 0xA1, 0x38, 0x5D, 0x1E, 0x79, 0xFE, 0x60, 0x56, 0x51, 0x3D, 0x8E, 0x4F, 0x21, 0xDF, 0xB7, 0xE7, 0x5F, 0x4E, 0x2E, 0x76, 0x17, 0x37, 0x7D, 0xAF, 0x3E)
crypt_table_0 = crypt_table_0 .. string.char(0xC7, 0x44, 0xD2, 0xCD, 0xDA, 0xE8, 0x92, 0xC5, 0x8A, 0x50, 0x30, 0xA8, 0xE9, 0x59, 0xE5, 0x5C, 0x99, 0x2C, 0x05, 0x72, 0x31, 0x12, 0x84, 0xA0, 0xE3, 0x89, 0xBA, 0x71, 0x97, 0x63, 0x3B, 0xEC)
crypt_table_0 = crypt_table_0 .. string.char(0x5E, 0xEA, 0x52, 0xF1, 0x7B, 0x4B, 0x66, 0xE6, 0xA3, 0xA2, 0x6A, 0xD1, 0x2A, 0x9F, 0x5A, 0x34, 0x54, 0xCA, 0xCC, 0x4C, 0x94, 0x8F, 0x9A, 0x3C, 0xFD, 0xF4, 0x91, 0x3F, 0x67, 0xA9, 0xE2, 0xB9)
crypt_table_0 = crypt_table_0 .. string.char(0x73, 0xD4, 0xD7, 0xF7, 0x0B, 0x77, 0x1F, 0xCE, 0x39, 0x40, 0x41, 0xEE, 0xAA, 0xD5, 0x2B, 0x55, 0x45, 0xBC, 0x43, 0x25, 0x6C, 0x14, 0x58, 0x10, 0xDC, 0x24, 0x19, 0x81, 0xAE, 0xD6, 0xFB, 0x78)
crypt_table_0 = crypt_table_0 .. string.char(0x32, 0x61, 0x0C, 0x29, 0xC4, 0xF6, 0x85, 0xAB, 0x7F, 0x49, 0x4D, 0x88, 0xAD, 0x8C, 0xC3, 0xC1, 0xF3, 0xD8, 0xC8, 0x35, 0xA4, 0xE1, 0x15, 0xDD, 0xFA, 0x6B, 0x53, 0xEF, 0xBD, 0x6E, 0xFF, 0xD3)
crypt_table_0 = crypt_table_0 .. string.char(0x47, 0xD0, 0x57, 0x27, 0xB8, 0x9C, 0xF9, 0x1A, 0x9B, 0xC9, 0xF5, 0x6F, 0x1C, 0xA7, 0x2D, 0x11, 0xB6, 0x69, 0x08, 0x9D, 0x75, 0x1D, 0x96, 0xBF, 0x98, 0x0D, 0xCF, 0xB2, 0xDB, 0xA5, 0xE4, 0x9E)
crypt_table_0 = crypt_table_0 .. string.char(0xF0, 0x26, 0xE0, 0x36, 0x07, 0x48, 0xBE, 0x20, 0x06, 0x83, 0xB1, 0xCB, 0x86, 0x6D, 0x16, 0xBB, 0x0E, 0x1B, 0xF8, 0x8B, 0x68, 0x0F, 0x3A, 0xB5, 0x8D, 0xB0, 0x7C, 0x09, 0x90, 0x04, 0x02, 0xAC)
crypt_table_0 = crypt_table_0 .. string.char(0x2F, 0xD9, 0xEB, 0xC6, 0x4A, 0xC0, 0x95, 0xED, 0xB3, 0x13, 0xF2, 0x03, 0x33, 0xDE, 0x74, 0x80, 0x7A, 0x28, 0x65, 0x64, 0x0A, 0x5B, 0x93, 0x42, 0x23, 0xB4, 0x82, 0x18, 0x70, 0x62, 0x87, 0x22)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x31, 0x6D, 0xB4, 0x5C, 0x97, 0x42, 0x5F, 0x1A, 0x65, 0xEE, 0x52, 0x49, 0xEB, 0xA4, 0x12, 0xAD, 0x19, 0x4C, 0xC1, 0xE7, 0xD6, 0x15, 0xA7, 0xB0, 0x46, 0xA0, 0xD8, 0x58, 0x6C, 0x38)
crypt_table_0 = crypt_table_0 .. string.char(0xAB, 0x02, 0x5B, 0x6B, 0x94, 0x68, 0xB1, 0x7F, 0x4B, 0xB3, 0xC4, 0xF8, 0x93, 0x8C, 0x9B, 0xDC, 0x83, 0x3C, 0x32, 0x5D, 0x62, 0xD3, 0x1B, 0xCC, 0xF9, 0x28, 0x2A, 0x1C, 0x34, 0xE9, 0x84, 0xC9)
crypt_table_0 = crypt_table_0 .. string.char(0x03, 0x2B, 0x5E, 0x30, 0x10, 0x0A, 0x0D, 0x1F, 0xCA, 0x95, 0x0E, 0x71, 0x51, 0x0B, 0x7E, 0x2E, 0xF1, 0xE3, 0x6F, 0x0C, 0xD5, 0x45, 0x43, 0x4D, 0x50, 0xE4, 0xB5, 0x74, 0x53, 0x3E, 0x17, 0x9C)
crypt_table_0 = crypt_table_0 .. string.char(0x41, 0xAA, 0x55, 0x9F, 0x13, 0x2F, 0x59, 0x2D, 0x48, 0x9E, 0xC5, 0x6A, 0x56, 0xF4, 0x7C, 0x2C, 0xF5, 0xCB, 0x08, 0xBC, 0x09, 0x24, 0x3B, 0xAF, 0xEF, 0x4E, 0x7D, 0x67, 0xC6, 0xF6, 0xC0, 0xFF)
crypt_table_0 = crypt_table_0 .. string.char(0xB7, 0x70, 0x77, 0x22, 0xA1, 0xBF, 0xFA, 0x78, 0x47, 0xED, 0xDE, 0x11, 0x33, 0x4A, 0xEA, 0xA3, 0xE6, 0x35, 0x20, 0x8B, 0x75, 0x21, 0x89, 0x66, 0x07, 0xE0, 0x27, 0xD4, 0xAE, 0x1E, 0xBE, 0x26)
crypt_table_0 = crypt_table_0 .. string.char(0xF2, 0x18, 0x63, 0xB8, 0xA8, 0xA5, 0x5A, 0xE5, 0xD9, 0x7A, 0x85, 0xFD, 0x40, 0xC3, 0xBA, 0x3D, 0xB6, 0x72, 0x60, 0x64, 0xD1, 0x29, 0x0F, 0x61, 0x8A, 0x79, 0xD0, 0x1D, 0xDD, 0x8D, 0xBD, 0x8F)
crypt_table_0 = crypt_table_0 .. string.char(0x98, 0x25, 0x05, 0xCE, 0xA6, 0xD7, 0x14, 0x54, 0x9D, 0x6E, 0xF3, 0xCF, 0x39, 0x86, 0x44, 0xCD, 0x82, 0xBB, 0x16, 0xDF, 0xC8, 0x57, 0xF7, 0xEC, 0x80, 0xA9, 0x73, 0x23, 0x87, 0x88, 0xE8, 0xC2)
crypt_table_0 = crypt_table_0 .. string.char(0x3F, 0x8E, 0x4F, 0x92, 0xDB, 0xC7, 0x36, 0xFB, 0xA2, 0x69, 0x3A, 0x06, 0x37, 0x04, 0xD2, 0xFE, 0x7B, 0xDA, 0xB2, 0xF0, 0x81, 0x99, 0xB9, 0xFC, 0x96, 0xE1, 0xE2, 0x90, 0x76, 0xAC, 0x91, 0x9A)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x25, 0x2B, 0x97, 0x8D, 0xEE, 0x2D, 0xB7, 0xF5, 0xCE, 0x44, 0x3C, 0x34, 0xDD, 0xA0, 0xCD, 0xD5, 0x3F, 0xEF, 0xC9, 0x66, 0x3D, 0x1E, 0xFC, 0xD4, 0x22, 0x23, 0x0F, 0x72, 0x06, 0x86)
crypt_table_0 = crypt_table_0 .. string.char(0xFF, 0x9A, 0xE5, 0x20, 0xF4, 0x78, 0xC2, 0x5A, 0x28, 0xEC, 0x47, 0xB2, 0xAC, 0x83, 0xFA, 0x26, 0xD9, 0x45, 0xE7, 0x05, 0x8B, 0x87, 0x5B, 0x9D, 0xB5, 0xE6, 0x91, 0xC5, 0xBD, 0x8E, 0xA1, 0xC7)
crypt_table_0 = crypt_table_0 .. string.char(0xCB, 0x82, 0x96, 0xE2, 0xD6, 0x21, 0xBC, 0xA6, 0xAD, 0xFD, 0x79, 0x2C, 0x4B, 0x37, 0x71, 0x0B, 0x49, 0x1A, 0xC4, 0xAE, 0xAA, 0x3A, 0xED, 0xDC, 0x67, 0x70, 0xB9, 0x59, 0x40, 0x6E, 0xA3, 0x1F)
crypt_table_0 = crypt_table_0 .. string.char(0x4A, 0x10, 0x9E, 0x48, 0x7A, 0x8F, 0xD1, 0x2A, 0xB1, 0x99, 0xDA, 0xE1, 0x5C, 0x69, 0x36, 0xA2, 0xCF, 0x54, 0xB8, 0xC8, 0xB4, 0x88, 0xF7, 0xEA, 0x95, 0x81, 0xCA, 0x1D, 0x7C, 0x58, 0x80, 0x9F)
crypt_table_0 = crypt_table_0 .. string.char(0x4E, 0x51, 0x85, 0x30, 0x93, 0x15, 0x03, 0x1C, 0x07, 0xE8, 0x13, 0x31, 0x63, 0xF9, 0x73, 0x12, 0x90, 0x65, 0x42, 0x24, 0x6D, 0x7B, 0x02, 0x19, 0x0C, 0x8C, 0x5E, 0xE4, 0x3B, 0x39, 0xF2, 0xA5)
crypt_table_0 = crypt_table_0 .. string.char(0x64, 0xD8, 0xF8, 0x9B, 0x08, 0x38, 0x27, 0xDE, 0xBA, 0xD2, 0x68, 0x6F, 0x11, 0xB3, 0xA9, 0xAB, 0x5D, 0x6C, 0x98, 0x29, 0x16, 0x4C, 0xCC, 0x0A, 0x74, 0xDF, 0x2E, 0x18, 0xFE, 0xD3, 0xA4, 0xA8)
crypt_table_0 = crypt_table_0 .. string.char(0x60, 0x7D, 0x09, 0x32, 0x7F, 0x0D, 0xD7, 0x52, 0x33, 0x55, 0x50, 0x84, 0xC3, 0xC6, 0xA7, 0x89, 0xEB, 0xAF, 0x35, 0x41, 0xF3, 0x5F, 0xBB, 0x9C, 0xB0, 0xE3, 0x53, 0x8A, 0x94, 0xBE, 0x3E, 0x6A)
crypt_table_0 = crypt_table_0 .. string.char(0x1B, 0x62, 0x14, 0xD0, 0x6B, 0xFB, 0x46, 0x61, 0xF6, 0xBF, 0x4F, 0x92, 0x57, 0xF0, 0x43, 0x77, 0xF1, 0xC1, 0xC0, 0x0E, 0x4D, 0x17, 0x04, 0xB6, 0x2F, 0x56, 0xDB, 0x76, 0xE0, 0x75, 0xE9, 0x7E)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x21, 0xF4, 0xF0, 0x92, 0x1E, 0x8F, 0xAE, 0xE8, 0xA3, 0xA9, 0xA6, 0x77, 0xDD, 0x8E, 0x7E, 0x91, 0xDF, 0xD4, 0x0C, 0x0D, 0x39, 0x98, 0x81, 0xA5, 0xCD, 0x0B, 0xE1, 0x9D, 0xDE, 0x2E)
crypt_table_0 = crypt_table_0 .. string.char(0xB7, 0x6A, 0xD9, 0x06, 0xBA, 0x02, 0x82, 0xE7, 0x37, 0x3C, 0x29, 0x7F, 0x2C, 0x14, 0xB8, 0x26, 0x7A, 0x97, 0x25, 0x3D, 0x5F, 0xA8, 0xF6, 0xFD, 0xC0, 0xE3, 0x65, 0x90, 0xAB, 0x74, 0xFE, 0x1B)
crypt_table_0 = crypt_table_0 .. string.char(0x45, 0x38, 0x3E, 0xFB, 0x03, 0x1F, 0x60, 0x4F, 0x1D, 0xD5, 0xB6, 0x40, 0xA1, 0xB1, 0x5A, 0x84, 0x8D, 0x2D, 0xC7, 0x0A, 0x72, 0x55, 0x47, 0xD2, 0x80, 0x3A, 0xB2, 0x86, 0xC2, 0x93, 0xD3, 0x99)
crypt_table_0 = crypt_table_0 .. string.char(0x58, 0xE4, 0xBE, 0x24, 0x76, 0x11, 0x36, 0x19, 0xEE, 0xCB, 0x73, 0x88, 0x10, 0x4D, 0x83, 0xCC, 0xD7, 0xDA, 0xAC, 0x59, 0x12, 0xF5, 0xFC, 0xA2, 0x85, 0xDB, 0x71, 0x7B, 0x8C, 0x41, 0x23, 0xC9)
crypt_table_0 = crypt_table_0 .. string.char(0x61, 0x5B, 0xCF, 0x5D, 0xA4, 0xEB, 0xF8, 0xE9, 0xC4, 0x3F, 0x09, 0xAF, 0x4C, 0x68, 0x63, 0xBF, 0xEA, 0xD6, 0x32, 0xE6, 0xB9, 0xE2, 0xF1, 0x95, 0x96, 0x08, 0xE5, 0xA0, 0x57, 0x9C, 0x49, 0xED)
crypt_table_0 = crypt_table_0 .. string.char(0x50, 0xC5, 0x8B, 0xA7, 0xBD, 0x6B, 0xD1, 0x52, 0xBC, 0x0E, 0xC6, 0xEF, 0x1A, 0xB5, 0x4B, 0xF2, 0xCA, 0x9F, 0xD0, 0xFA, 0x6F, 0x7D, 0x31, 0x6D, 0x1C, 0x7C, 0x35, 0xF9, 0x22, 0x79, 0x67, 0x3B)
crypt_table_0 = crypt_table_0 .. string.char(0x20, 0x9A, 0x8A, 0x15, 0x66, 0xF7, 0x53, 0x56, 0xFF, 0x46, 0xCE, 0x6E, 0x64, 0x9B, 0x28, 0x42, 0x17, 0x48, 0x0F, 0xC8, 0x87, 0x94, 0x5C, 0xB3, 0xC3, 0xB0, 0x2F, 0x69, 0xD8, 0xBB, 0xEC, 0x54)
crypt_table_0 = crypt_table_0 .. string.char(0xAA, 0x33, 0xC1, 0x16, 0x44, 0x43, 0x05, 0x89, 0xAD, 0x34, 0xDC, 0x70, 0x18, 0x30, 0x75, 0x2B, 0x5E, 0x2A, 0xF3, 0x51, 0x04, 0x13, 0x62, 0x6C, 0x27, 0x4A, 0xB4, 0x07, 0x78, 0x9E, 0xE0, 0x4E)
crypt_table_0 = crypt_table_0 .. string.char(0x00, 0x01, 0x9B, 0x84, 0x10, 0x89, 0xF5, 0x9A, 0xA4, 0x8A, 0xFA, 0xB6, 0x09, 0x68, 0x71, 0x56, 0x5A, 0x27, 0x65, 0x29, 0x15, 0x95, 0x78, 0x17, 0x73, 0x7A, 0x81, 0xC7, 0xD5, 0x3A, 0xCA, 0x91)
crypt_table_0 = crypt_table_0 .. string.char(0xCC, 0x9C, 0x16, 0x96, 0x41, 0xEC, 0x51, 0xA1, 0x24, 0x72, 0x74, 0x5D, 0x47, 0x03, 0xC6, 0x67, 0xDA, 0xDE, 0xA6, 0x06, 0x2A, 0x87, 0x28, 0xBF, 0x6C, 0x77, 0x48, 0x7B, 0x1C, 0xBB, 0xC2, 0xB3)
crypt_table_0 = crypt_table_0 .. string.char(0xC3, 0x1F, 0xD3, 0x0B, 0xBE, 0x0C, 0x61, 0x97, 0x70, 0x39, 0x3E, 0x40, 0x42, 0x1E, 0x63, 0x2D, 0x93, 0x9D, 0x80, 0xA3, 0xE2, 0x0A, 0xC0, 0xAD, 0x79, 0xEA, 0x7F, 0x11, 0xA7, 0xEE, 0x90, 0xCE)
crypt_table_0 = crypt_table_0 .. string.char(0x36, 0xED, 0x85, 0xB1, 0x57, 0xCD, 0xAE, 0x02, 0x5B, 0xF0, 0x2B, 0xB7, 0x31, 0x4F, 0xFE, 0x4A, 0x21, 0xF4, 0xD0, 0xFD, 0x62, 0x0E, 0xF1, 0x75, 0xBD, 0x6F, 0x38, 0x20, 0x7D, 0x55, 0x2F, 0xDB)
crypt_table_0 = crypt_table_0 .. string.char(0xCF, 0x83, 0x33, 0x44, 0x04, 0x3C, 0x59, 0x76, 0xE6, 0x64, 0xE1, 0x60, 0xB8, 0x52, 0xFC, 0x6D, 0x5E, 0xA8, 0xE7, 0x88, 0xEB, 0xDC, 0xA9, 0x82, 0xD1, 0x6B, 0x98, 0xA5, 0x14, 0xB2, 0xC9, 0xE9)
crypt_table_0 = crypt_table_0 .. string.char(0x8E, 0x66, 0x05, 0x5C, 0x23, 0x8B, 0x30, 0x5F, 0x49, 0x3F, 0xD2, 0x19, 0x7E, 0xB9, 0xE5, 0xC5, 0xC1, 0xBA, 0xAF, 0xA0, 0x92, 0x45, 0x1A, 0xAB, 0xE8, 0xF8, 0xC4, 0x8F, 0x69, 0xE4, 0xD7, 0x9E)
crypt_table_0 = crypt_table_0 .. string.char(0x54, 0x2C, 0xCB, 0x6E, 0x6A, 0xA2, 0xDD, 0x0F, 0x50, 0xB0, 0x35, 0x3B, 0xB5, 0xAA, 0xF2, 0xFF, 0x25, 0x3D, 0x34, 0x1D, 0x8D, 0x37, 0x0D, 0x1B, 0x53, 0x58, 0x26, 0x4B, 0xDF, 0x08, 0xD6, 0xD8)
crypt_table_0 = crypt_table_0 .. string.char(0xF9, 0xC8, 0x32, 0x99, 0xD9, 0x94, 0xD4, 0x9F, 0x7C, 0x4D, 0x07, 0x46, 0xBC, 0xF7, 0x4E, 0x86, 0xFB, 0x22, 0x12, 0x18, 0xF3, 0x43, 0x13, 0x4C, 0x2E, 0xEF, 0xE0, 0xB4, 0x8C, 0xF6, 0xE3, 0xAC)
crypt_table_0 = ByteArray.new(crypt_table_0, true)

local crypt_table_1 = ""
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0x55, 0x27, 0x9F, 0x90, 0x1D, 0x92, 0xB2, 0x2A, 0x37, 0xAB, 0x16, 0x1B, 0x8C, 0xCF, 0xD8, 0xA5, 0x21, 0x35, 0x46, 0x91, 0x71, 0xE3, 0x94, 0xF1, 0xF9, 0xD0, 0x1C, 0x73, 0x6F, 0x26)
crypt_table_1 = crypt_table_1 .. string.char(0x39, 0xDF, 0x4F, 0x03, 0x19, 0x2C, 0xC6, 0xAF, 0xAA, 0x02, 0x86, 0x8A, 0x58, 0x64, 0xF2, 0xA1, 0x4D, 0xDB, 0x38, 0x7A, 0xCB, 0x80, 0x3F, 0xE7, 0x2B, 0x79, 0xD7, 0x34, 0x14, 0xAD, 0x17, 0xCC)
crypt_table_1 = crypt_table_1 .. string.char(0x3D, 0xCE, 0xDC, 0x24, 0x48, 0x33, 0x9D, 0x1F, 0x83, 0x0C, 0x75, 0xF5, 0xD9, 0x22, 0xBF, 0x45, 0x3B, 0xF0, 0x0A, 0x61, 0x98, 0xBE, 0xE4, 0x68, 0xF6, 0x7F, 0x28, 0xD5, 0xEA, 0x2D, 0x1A, 0x8D)
crypt_table_1 = crypt_table_1 .. string.char(0xAC, 0x69, 0xC9, 0xC5, 0x97, 0xC3, 0x49, 0x63, 0xA2, 0x6B, 0x9E, 0x4B, 0x07, 0xC8, 0xE9, 0xE2, 0x95, 0xC0, 0x57, 0xA0, 0x7B, 0x84, 0xA3, 0x76, 0x3E, 0xA7, 0xC4, 0x8F, 0xDD, 0x29, 0x5A, 0xD3)
crypt_table_1 = crypt_table_1 .. string.char(0x59, 0x8B, 0x93, 0x66, 0x05, 0x9B, 0xBB, 0x15, 0xA6, 0x36, 0xB0, 0x25, 0xB5, 0x8E, 0x65, 0x6C, 0x0B, 0x50, 0x96, 0xE0, 0xF4, 0xB7, 0x31, 0xAE, 0xED, 0x18, 0x3A, 0xB8, 0x70, 0x51, 0x42, 0x7D)
crypt_table_1 = crypt_table_1 .. string.char(0xD2, 0x4E, 0xFA, 0xEC, 0x7E, 0xB3, 0x12, 0xBA, 0xB9, 0xB6, 0xD4, 0xFF, 0xF8, 0x44, 0x09, 0xE1, 0x53, 0x9A, 0x5D, 0x11, 0xC2, 0xBC, 0xEF, 0x1E, 0xD6, 0x56, 0xFE, 0x0E, 0xF3, 0xE8, 0x04, 0x62)
crypt_table_1 = crypt_table_1 .. string.char(0x88, 0xB4, 0xB1, 0xEB, 0x4C, 0x5B, 0xE5, 0xEE, 0x23, 0x5F, 0x54, 0x2F, 0x60, 0x6D, 0x99, 0x81, 0x4A, 0x6E, 0xF7, 0x82, 0x2E, 0x5C, 0x08, 0x77, 0xA9, 0x85, 0x52, 0x13, 0x43, 0xFD, 0x20, 0xC7)
crypt_table_1 = crypt_table_1 .. string.char(0xCA, 0x06, 0xC1, 0xCD, 0xDE, 0x87, 0x72, 0xBD, 0x78, 0x0F, 0x5E, 0x10, 0xDA, 0xFB, 0x3C, 0x67, 0x74, 0x0D, 0x47, 0xD1, 0x7C, 0x32, 0x41, 0x89, 0x9C, 0xE6, 0xA4, 0xFC, 0x30, 0x40, 0xA8, 0x6A)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0x61, 0xC5, 0xFC, 0x4C, 0x79, 0x23, 0x02, 0x1E, 0xCF, 0xB8, 0x4A, 0x1F, 0xFF, 0x2A, 0x3D, 0xD4, 0xA5, 0xBC, 0x2D, 0x28, 0xC6, 0x3E, 0xF3, 0x20, 0xA8, 0xBB, 0x07, 0x21, 0x13, 0x8D)
crypt_table_1 = crypt_table_1 .. string.char(0x38, 0xF5, 0xA0, 0xE0, 0x58, 0x1B, 0xCA, 0x52, 0x3B, 0x9A, 0xEC, 0x35, 0x49, 0x39, 0xCD, 0x32, 0xD7, 0x24, 0xC8, 0xED, 0xFB, 0xB0, 0x83, 0x7B, 0xF2, 0xE4, 0x46, 0x96, 0x4D, 0x76, 0x8E, 0x05)
crypt_table_1 = crypt_table_1 .. string.char(0x53, 0x2B, 0xD3, 0x8A, 0x6D, 0xEA, 0xD8, 0xFA, 0x29, 0xD9, 0x22, 0x7E, 0x81, 0xE5, 0xB1, 0x0B, 0x31, 0x0A, 0xF1, 0xF7, 0xE8, 0x08, 0x15, 0x75, 0x0F, 0xB2, 0xEB, 0x99, 0xDF, 0x3F, 0x10, 0xE9)
crypt_table_1 = crypt_table_1 .. string.char(0x33, 0x5B, 0x3A, 0xFE, 0xE3, 0x47, 0xDA, 0xC9, 0x54, 0x89, 0xC4, 0xA6, 0xB7, 0x1A, 0xA2, 0xCE, 0x69, 0x94, 0x85, 0x6E, 0xAE, 0x98, 0xAB, 0x9F, 0xEE, 0x8B, 0xE1, 0xAA, 0x27, 0xC1, 0xAC, 0xD0)
crypt_table_1 = crypt_table_1 .. string.char(0xD1, 0x14, 0x6F, 0x91, 0xF4, 0x0D, 0x82, 0x68, 0x12, 0xBE, 0x90, 0x97, 0x16, 0x70, 0x87, 0xF8, 0x34, 0x2E, 0xDE, 0x84, 0xC7, 0x9C, 0x0E, 0x26, 0xE7, 0x50, 0xAF, 0x5A, 0x71, 0x7A, 0xA9, 0x19)
crypt_table_1 = crypt_table_1 .. string.char(0xFD, 0x78, 0x63, 0x03, 0xE2, 0x64, 0xBD, 0x88, 0x43, 0xCB, 0x04, 0x56, 0x77, 0x09, 0x9D, 0xA1, 0x51, 0x6B, 0x92, 0x30, 0x93, 0xA4, 0x80, 0x37, 0xAD, 0xC0, 0x57, 0x17, 0xB9, 0x95, 0xBF, 0x5F)
crypt_table_1 = crypt_table_1 .. string.char(0x62, 0x59, 0xF9, 0x55, 0x0C, 0x4F, 0x72, 0xD2, 0x1C, 0xDC, 0x48, 0x86, 0x7D, 0xDD, 0x73, 0x45, 0x2C, 0xA7, 0xC3, 0x3C, 0x74, 0x11, 0xB3, 0x67, 0x5E, 0x8F, 0xD6, 0x6A, 0x4B, 0xEF, 0xB5, 0x9E)
crypt_table_1 = crypt_table_1 .. string.char(0xB6, 0x44, 0x42, 0x36, 0xBA, 0x6C, 0x60, 0x40, 0x2F, 0x18, 0x66, 0x1D, 0x25, 0x9B, 0xA3, 0x7C, 0x06, 0x5C, 0x65, 0xCC, 0xF6, 0xD5, 0xDB, 0x41, 0xB4, 0x8C, 0x4E, 0xC2, 0x5D, 0xE6, 0xF0, 0x7F)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0x7A, 0xF9, 0x5D, 0x88, 0x61, 0xF2, 0xC3, 0x49, 0x59, 0x96, 0x9D, 0x84, 0x2B, 0xE5, 0xFB, 0x06, 0x07, 0x0E, 0xE2, 0x62, 0xD0, 0x65, 0x28, 0x34, 0xA9, 0x78, 0x21, 0xF0, 0xDD, 0xF3)
crypt_table_1 = crypt_table_1 .. string.char(0x4F, 0x40, 0x38, 0x85, 0xCE, 0x55, 0xCD, 0xA6, 0x32, 0xC5, 0x33, 0x52, 0x0D, 0x30, 0xCC, 0xE0, 0x8D, 0x97, 0x4B, 0xE3, 0x9C, 0x48, 0xE8, 0x9F, 0xED, 0x4C, 0x04, 0x4A, 0x1D, 0x1E, 0x93, 0x76)
crypt_table_1 = crypt_table_1 .. string.char(0x60, 0xD1, 0x1F, 0xAC, 0xD9, 0xFD, 0xB6, 0x0B, 0x71, 0x9B, 0xD6, 0xDC, 0x5B, 0xC9, 0xBB, 0xD4, 0x90, 0x08, 0xD2, 0x58, 0xAB, 0x42, 0xDE, 0x7F, 0xD8, 0x46, 0xF7, 0x02, 0xB8, 0x74, 0x37, 0x98)
crypt_table_1 = crypt_table_1 .. string.char(0xCB, 0xE4, 0x5E, 0x23, 0xB4, 0xA4, 0xAA, 0x56, 0x11, 0x26, 0x20, 0x0C, 0x5A, 0x53, 0x6E, 0x39, 0xE1, 0xB5, 0xEC, 0x67, 0x10, 0xB2, 0x75, 0x31, 0xC1, 0xF4, 0x8F, 0xEA, 0xFE, 0x80, 0x43, 0x2E)
crypt_table_1 = crypt_table_1 .. string.char(0x69, 0xB1, 0x45, 0xC2, 0x2A, 0xE9, 0x8B, 0xF1, 0x7B, 0x95, 0x1A, 0x6A, 0xA5, 0x68, 0x7E, 0x57, 0xB3, 0xB7, 0x86, 0x36, 0x94, 0x12, 0xC7, 0x27, 0x3A, 0x2D, 0x91, 0xCA, 0x24, 0xD7, 0x5C, 0x3B)
crypt_table_1 = crypt_table_1 .. string.char(0x81, 0xC8, 0xD5, 0x17, 0xC4, 0x22, 0x0A, 0x64, 0x14, 0xC0, 0xFC, 0x4E, 0xBC, 0xBE, 0x1B, 0x92, 0x05, 0x6D, 0x9E, 0x18, 0xE7, 0xAE, 0xEF, 0xBF, 0x44, 0xF6, 0x2F, 0x83, 0x6B, 0x5F, 0x15, 0xB0)
crypt_table_1 = crypt_table_1 .. string.char(0x6F, 0x8A, 0x09, 0x25, 0x8C, 0x66, 0x3E, 0x03, 0xDA, 0x6C, 0xDF, 0xEE, 0xDB, 0x1C, 0x87, 0x0F, 0x2C, 0xA2, 0xBA, 0x4D, 0xFF, 0x8E, 0xC6, 0x77, 0x51, 0xAF, 0xF5, 0x73, 0x35, 0xE6, 0x3F, 0x3D)
crypt_table_1 = crypt_table_1 .. string.char(0x72, 0xB9, 0x79, 0x13, 0x82, 0x47, 0xEB, 0x41, 0x70, 0xF8, 0xCF, 0xBD, 0xA1, 0x99, 0xAD, 0xFA, 0xA7, 0x89, 0x9A, 0x63, 0x7C, 0x19, 0x3C, 0x29, 0xA3, 0x7D, 0xA0, 0xA8, 0x50, 0x54, 0x16, 0xD3)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0x4A, 0xFB, 0xC8, 0x76, 0xE2, 0x13, 0x83, 0x5A, 0x7B, 0x28, 0x7F, 0xA7, 0xB1, 0x22, 0x45, 0xC7, 0x05, 0xE0, 0x62, 0xC1, 0xDF, 0x8B, 0xEC, 0x73, 0x7E, 0xCE, 0xF6, 0x30, 0xB9, 0x8D)
crypt_table_1 = crypt_table_1 .. string.char(0x92, 0x87, 0xAD, 0x38, 0xF0, 0xAB, 0xE9, 0x1A, 0xDB, 0x12, 0x0E, 0x24, 0x6C, 0xA2, 0xEA, 0xFD, 0x44, 0x66, 0xDD, 0x3D, 0xFA, 0x7D, 0xD1, 0x5D, 0x7C, 0x3C, 0xE6, 0xB6, 0x35, 0x2C, 0x26, 0xD3)
crypt_table_1 = crypt_table_1 .. string.char(0x1F, 0xAA, 0xE8, 0x1D, 0xB3, 0xF5, 0x68, 0x3A, 0x25, 0xF2, 0xC0, 0x31, 0xC5, 0x9E, 0x5B, 0x67, 0xFC, 0xA4, 0x80, 0x5C, 0x46, 0xCB, 0xCF, 0x99, 0x5F, 0x19, 0x69, 0x09, 0x0D, 0x95, 0xEB, 0xC3)
crypt_table_1 = crypt_table_1 .. string.char(0xF4, 0x49, 0xEF, 0x3B, 0x6A, 0xC2, 0x08, 0xC6, 0x17, 0x65, 0xDA, 0x1C, 0xA9, 0xA1, 0x36, 0x10, 0xB4, 0x23, 0x82, 0x4B, 0x8E, 0x02, 0xA8, 0x48, 0x56, 0x0A, 0x37, 0x3E, 0x18, 0x1B, 0x4E, 0xDC)
crypt_table_1 = crypt_table_1 .. string.char(0x40, 0x32, 0xA0, 0xF8, 0x1E, 0x55, 0x7A, 0xBA, 0x47, 0xAC, 0x91, 0x34, 0x63, 0x5E, 0xB2, 0x2A, 0x9B, 0x6E, 0x0B, 0xA5, 0xAE, 0xAF, 0xD8, 0x07, 0xED, 0x75, 0x42, 0xF9, 0x3F, 0xC9, 0x16, 0xF3)
crypt_table_1 = crypt_table_1 .. string.char(0x14, 0x94, 0xD0, 0xCA, 0x0F, 0xE4, 0xD2, 0x21, 0x70, 0x64, 0x93, 0x86, 0x11, 0x39, 0xA6, 0x04, 0x15, 0xB8, 0x72, 0x90, 0xA3, 0x2F, 0x77, 0x74, 0x61, 0x4F, 0xFE, 0x96, 0xFF, 0x29, 0x9F, 0xB7)
crypt_table_1 = crypt_table_1 .. string.char(0x50, 0xF1, 0xCD, 0xB0, 0x20, 0x03, 0xC4, 0x78, 0x33, 0x2B, 0xD5, 0x8F, 0xF7, 0xB5, 0xE1, 0x2E, 0x41, 0xE3, 0x4C, 0x06, 0xBB, 0x54, 0x79, 0x98, 0x9A, 0x53, 0xCC, 0x85, 0x8C, 0x43, 0x59, 0x0C)
crypt_table_1 = crypt_table_1 .. string.char(0xDE, 0x89, 0x51, 0x6F, 0x27, 0xD9, 0x6B, 0x2D, 0xD4, 0x6D, 0x8A, 0x97, 0x4D, 0xBD, 0x84, 0xD7, 0xBF, 0xD6, 0xBC, 0x57, 0x52, 0x60, 0xEE, 0xE5, 0x58, 0x9C, 0x71, 0x9D, 0xBE, 0x88, 0xE7, 0x81)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0xF3, 0x82, 0xF7, 0xCE, 0xF8, 0xAE, 0x3F, 0x79, 0x1B, 0xE6, 0x1F, 0x21, 0x4E, 0xA6, 0x50, 0x81, 0xFE, 0xF1, 0xD4, 0xE4, 0x0F, 0x80, 0xAF, 0x60, 0x43, 0xFC, 0x05, 0xEF, 0x94, 0xAD)
crypt_table_1 = crypt_table_1 .. string.char(0x73, 0x85, 0xB5, 0xE3, 0xD8, 0x69, 0xFF, 0xB4, 0xC5, 0x6C, 0x07, 0x15, 0x9B, 0x74, 0x8B, 0x16, 0x0A, 0x11, 0x19, 0xD9, 0x14, 0x64, 0xE1, 0x8C, 0x6D, 0x48, 0x7B, 0x36, 0x68, 0x38, 0xA4, 0x7E)
crypt_table_1 = crypt_table_1 .. string.char(0x29, 0x86, 0xE2, 0x96, 0xD2, 0x7F, 0x58, 0xB0, 0xC3, 0x28, 0xB6, 0xEA, 0x1D, 0x13, 0x8E, 0xBA, 0x10, 0x99, 0x51, 0xF6, 0xA7, 0xB2, 0xCF, 0x75, 0x6E, 0x06, 0xA3, 0xBE, 0x63, 0xBF, 0x84, 0x57)
crypt_table_1 = crypt_table_1 .. string.char(0xDE, 0x61, 0xB1, 0x26, 0x2B, 0x20, 0x62, 0xA5, 0xEC, 0xDF, 0x87, 0x90, 0x72, 0x67, 0x0C, 0x77, 0x41, 0xE5, 0x98, 0x42, 0xFD, 0xBC, 0xC9, 0xB7, 0xA0, 0x3D, 0x4F, 0x18, 0xCB, 0x9C, 0x2D, 0xE9)
crypt_table_1 = crypt_table_1 .. string.char(0x25, 0x09, 0x44, 0xA1, 0x30, 0x8F, 0x2C, 0xAB, 0xF4, 0x8D, 0xF0, 0x5D, 0x5F, 0xFB, 0xD5, 0x04, 0x08, 0x02, 0xD0, 0x4B, 0x91, 0xEE, 0x17, 0xC0, 0xD6, 0x95, 0xED, 0xA2, 0x9F, 0x34, 0xB9, 0xF9)
crypt_table_1 = crypt_table_1 .. string.char(0xC6, 0x7D, 0x93, 0xEB, 0x9A, 0x4D, 0x4A, 0x89, 0x1C, 0x39, 0x52, 0xB8, 0x59, 0x9D, 0xC8, 0x3A, 0x7A, 0xCD, 0x78, 0x5C, 0x0E, 0x3E, 0x32, 0xE0, 0x3C, 0xF5, 0x47, 0x66, 0x76, 0x6A, 0x53, 0x33)
crypt_table_1 = crypt_table_1 .. string.char(0xDD, 0xC2, 0x24, 0x40, 0xC1, 0xCC, 0xF2, 0x1A, 0x5A, 0x5B, 0x49, 0xD7, 0x0B, 0x2F, 0xE7, 0xA9, 0x92, 0xDA, 0x12, 0x0D, 0x97, 0x1E, 0xFA, 0xA8, 0x6B, 0x88, 0x23, 0xAC, 0x7C, 0x56, 0x46, 0xC4)
crypt_table_1 = crypt_table_1 .. string.char(0xDB, 0xAA, 0xD1, 0xDC, 0x45, 0x54, 0xBD, 0x31, 0x4C, 0xCA, 0x5E, 0x65, 0x3B, 0x55, 0x35, 0x27, 0xB3, 0x6F, 0x22, 0xC7, 0x71, 0x03, 0xE8, 0xBB, 0x2E, 0x37, 0x9E, 0x83, 0x2A, 0x70, 0xD3, 0x8A)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0x99, 0xEE, 0x1E, 0xED, 0xF8, 0x47, 0xF9, 0xDD, 0xF1, 0xC1, 0x16, 0x20, 0xEB, 0x9B, 0x80, 0x81, 0x38, 0x9A, 0xD3, 0x97, 0xFE, 0xAA, 0x6F, 0xD6, 0xA2, 0x69, 0x07, 0xCB, 0xDF, 0xD1)
crypt_table_1 = crypt_table_1 .. string.char(0x6C, 0xF7, 0x72, 0x57, 0x4F, 0x83, 0x12, 0x8A, 0x89, 0xEC, 0x74, 0xA4, 0xDE, 0x2B, 0xAF, 0x35, 0x5C, 0x82, 0xEF, 0x31, 0xDB, 0xCF, 0x33, 0x8E, 0xC6, 0x4C, 0x84, 0x54, 0x29, 0xB1, 0xE7, 0x86)
crypt_table_1 = crypt_table_1 .. string.char(0x6A, 0xBC, 0x51, 0x85, 0xD0, 0xA7, 0x5E, 0xDC, 0x18, 0x92, 0x06, 0x45, 0x7E, 0x4D, 0xCD, 0xF2, 0x93, 0xB6, 0x41, 0x4B, 0x3F, 0x76, 0x79, 0x13, 0xFB, 0x5D, 0x8F, 0x2D, 0xDA, 0xB9, 0xD8, 0x56)
crypt_table_1 = crypt_table_1 .. string.char(0x78, 0xFF, 0x02, 0xCA, 0x0F, 0x03, 0x6D, 0x05, 0x96, 0x26, 0x62, 0x98, 0x27, 0x3B, 0x58, 0xA6, 0x68, 0xC8, 0x61, 0xF0, 0x32, 0x5F, 0x15, 0x60, 0x49, 0xB8, 0xF6, 0x17, 0x43, 0xC5, 0x4A, 0x94)
crypt_table_1 = crypt_table_1 .. string.char(0x59, 0x48, 0xEA, 0x7D, 0x7F, 0xB3, 0x5B, 0x3A, 0x22, 0xC4, 0x19, 0x7B, 0x90, 0xE9, 0xD4, 0x6B, 0xA3, 0x42, 0x2F, 0xD9, 0xD7, 0x1B, 0x25, 0xA5, 0xE3, 0x8C, 0xAC, 0xBB, 0x2E, 0xC3, 0x73, 0x2C)
crypt_table_1 = crypt_table_1 .. string.char(0x28, 0x0B, 0x5A, 0x95, 0x09, 0xBF, 0xB2, 0x9F, 0x70, 0xFC, 0x08, 0x88, 0xBA, 0xC9, 0xF4, 0xAE, 0xB5, 0x3D, 0x71, 0xE8, 0xE0, 0x8B, 0x53, 0xAD, 0xFA, 0x0A, 0x46, 0x04, 0x67, 0xD5, 0xB7, 0xF3)
crypt_table_1 = crypt_table_1 .. string.char(0x39, 0xAB, 0x64, 0x66, 0xD2, 0x52, 0xB0, 0xE1, 0xBE, 0x1C, 0x34, 0xCC, 0x0D, 0xA9, 0x9D, 0x7C, 0x1D, 0x40, 0x9E, 0xF5, 0xC2, 0xE4, 0x55, 0x3E, 0x36, 0xFD, 0x8D, 0x9C, 0x24, 0xC0, 0xA0, 0x21)
crypt_table_1 = crypt_table_1 .. string.char(0x30, 0x6E, 0x7A, 0x87, 0x50, 0x37, 0x0C, 0x0E, 0xA8, 0x77, 0x75, 0xE6, 0x65, 0x4E, 0x2A, 0x11, 0xA1, 0x10, 0xC7, 0x1A, 0xE5, 0x44, 0x14, 0xBD, 0xB4, 0x63, 0xCE, 0x91, 0x1F, 0x23, 0x3C, 0xE2)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0x2A, 0x48, 0x4B, 0x99, 0xF1, 0x52, 0xF7, 0x03, 0xF5, 0x45, 0x1A, 0xB3, 0x9B, 0xB0, 0x7A, 0xA3, 0x61, 0x17, 0x0D, 0x04, 0x2C, 0xBA, 0x7F, 0x12, 0xD3, 0x1E, 0x64, 0x3A, 0x8E, 0xE8)
crypt_table_1 = crypt_table_1 .. string.char(0x20, 0x4D, 0x82, 0x66, 0x62, 0x40, 0x25, 0xAF, 0xAD, 0x87, 0x42, 0x35, 0xF3, 0x0F, 0x4A, 0x86, 0xDD, 0x44, 0x6E, 0x95, 0x30, 0xBC, 0x34, 0xFC, 0x3D, 0xA8, 0xFB, 0x23, 0xFA, 0xB4, 0x63, 0x50)
crypt_table_1 = crypt_table_1 .. string.char(0xEE, 0x9D, 0xC0, 0xAB, 0x9C, 0xD2, 0xE6, 0x77, 0x94, 0x72, 0x3E, 0xD5, 0x5A, 0xBD, 0x65, 0x8C, 0x74, 0x32, 0x96, 0x2E, 0x4C, 0x49, 0x54, 0x1B, 0xD7, 0x5C, 0x5E, 0x3B, 0x02, 0xDA, 0x57, 0x0B)
crypt_table_1 = crypt_table_1 .. string.char(0x98, 0x3F, 0x78, 0x11, 0x51, 0xF9, 0xA7, 0xFE, 0xCF, 0x08, 0x7D, 0xE4, 0x3C, 0x75, 0xF4, 0x39, 0x1C, 0xAC, 0x16, 0x21, 0x88, 0xB1, 0x69, 0xDE, 0x0C, 0xDF, 0x24, 0x97, 0xE3, 0x47, 0x8B, 0xD1)
crypt_table_1 = crypt_table_1 .. string.char(0xA4, 0x60, 0x73, 0x6C, 0xF0, 0xD8, 0xF8, 0xFD, 0xD9, 0xC5, 0x4E, 0x9F, 0x6B, 0x85, 0x89, 0x4F, 0xAE, 0x56, 0x14, 0xE2, 0x36, 0xBE, 0xC1, 0x90, 0x0A, 0xC7, 0xEC, 0x81, 0x46, 0xCC, 0x2D, 0xD0)
crypt_table_1 = crypt_table_1 .. string.char(0x9A, 0x79, 0xEA, 0x59, 0xA6, 0x84, 0x31, 0x92, 0xFF, 0x10, 0xB8, 0x8D, 0xA5, 0x13, 0x6A, 0x09, 0xA2, 0x27, 0x28, 0xB9, 0x91, 0xBF, 0xC2, 0xC4, 0xB6, 0x6D, 0x8A, 0x2B, 0xA0, 0xB2, 0xEB, 0xA1)
crypt_table_1 = crypt_table_1 .. string.char(0xCD, 0x18, 0x0E, 0xD4, 0xC3, 0x5F, 0x5B, 0x38, 0x70, 0x83, 0xCB, 0x6F, 0x7E, 0x9E, 0x55, 0xC9, 0xCA, 0x41, 0xF2, 0xCE, 0xEF, 0x67, 0xD6, 0xB7, 0x68, 0x1F, 0x53, 0xC8, 0xE9, 0x7B, 0x26, 0x19)
crypt_table_1 = crypt_table_1 .. string.char(0x76, 0xC6, 0xAA, 0x5D, 0xDB, 0x2F, 0x71, 0x93, 0x7C, 0x05, 0x1D, 0xDC, 0x15, 0x80, 0xE7, 0xF6, 0x37, 0x29, 0x06, 0x22, 0x8F, 0xA9, 0xBB, 0xE5, 0x43, 0xE1, 0x58, 0x07, 0x33, 0xB5, 0xE0, 0xED)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0xCB, 0x92, 0xA6, 0xD4, 0x3C, 0xD0, 0xC0, 0x9C, 0x09, 0x79, 0xCF, 0xB2, 0x4E, 0xC2, 0xFF, 0x6B, 0x75, 0x50, 0x89, 0x02, 0x14, 0xAA, 0xCE, 0x71, 0x5C, 0x0B, 0xE6, 0xA4, 0xC3, 0xAE)
crypt_table_1 = crypt_table_1 .. string.char(0x5A, 0x8C, 0x26, 0xB8, 0x4B, 0xFB, 0x8D, 0x48, 0x6A, 0xD2, 0xBF, 0x9D, 0x7E, 0x4A, 0x31, 0x1E, 0xBE, 0x6F, 0x28, 0x53, 0x40, 0xEE, 0x73, 0x83, 0x2C, 0x19, 0x43, 0xA0, 0x55, 0x27, 0x61, 0x77)
crypt_table_1 = crypt_table_1 .. string.char(0xC1, 0xA1, 0x17, 0xDE, 0x7A, 0x45, 0xE3, 0xAB, 0xB0, 0x8F, 0xF3, 0x68, 0x06, 0x1A, 0x20, 0xE7, 0xD3, 0x7D, 0xE4, 0x51, 0xE9, 0x44, 0x0D, 0xB3, 0xE5, 0x21, 0x0C, 0x86, 0xED, 0x9B, 0x54, 0x18)
crypt_table_1 = crypt_table_1 .. string.char(0x46, 0x2F, 0xFE, 0x13, 0x74, 0x3B, 0xB5, 0x78, 0x11, 0xDB, 0xEF, 0x04, 0x4D, 0x05, 0xA8, 0x99, 0xF6, 0x39, 0xC5, 0x08, 0xF2, 0xD1, 0xA7, 0x7C, 0x93, 0xF5, 0x57, 0xA9, 0x36, 0xDD, 0xCC, 0x52)
crypt_table_1 = crypt_table_1 .. string.char(0xA2, 0x63, 0x64, 0x41, 0x2E, 0xFD, 0x95, 0x80, 0x9F, 0xC8, 0x32, 0xDF, 0x37, 0x30, 0x0A, 0x59, 0x0F, 0x1F, 0xC9, 0xE2, 0x3D, 0xF9, 0x29, 0xC7, 0x1B, 0x4F, 0x9A, 0xA3, 0xE0, 0x8B, 0x7F, 0xB7)
crypt_table_1 = crypt_table_1 .. string.char(0xEA, 0xB4, 0x22, 0xEC, 0xD6, 0x2D, 0x94, 0xF4, 0x12, 0x76, 0x8A, 0xBC, 0x33, 0x6E, 0xBD, 0x49, 0xE1, 0xFC, 0x10, 0x60, 0xBA, 0xDA, 0x6C, 0xEB, 0x5E, 0x35, 0x90, 0x69, 0x3F, 0x97, 0xFA, 0x2B)
crypt_table_1 = crypt_table_1 .. string.char(0x5B, 0x38, 0xCD, 0xB1, 0xB9, 0x58, 0x66, 0x1D, 0x5D, 0x3E, 0xCA, 0x25, 0xD8, 0x91, 0xD9, 0xD7, 0x96, 0xF0, 0x1C, 0x8E, 0x82, 0x34, 0x2A, 0x9E, 0x6D, 0xAC, 0xBB, 0x72, 0xC6, 0x4C, 0x5F, 0xAD)
crypt_table_1 = crypt_table_1 .. string.char(0x7B, 0x88, 0x3A, 0x03, 0x85, 0xA5, 0xE8, 0x0E, 0x84, 0xAF, 0xC4, 0xF8, 0x67, 0xB6, 0xD5, 0x07, 0x62, 0xF7, 0x81, 0x98, 0xF1, 0x70, 0x56, 0xDC, 0x47, 0x87, 0x42, 0x24, 0x23, 0x65, 0x16, 0x15)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0xF9, 0xD6, 0xCB, 0xC1, 0x61, 0x0B, 0x18, 0xA2, 0x27, 0x2F, 0x2A, 0x5A, 0xF1, 0xF6, 0xBC, 0x05, 0xB7, 0x9D, 0x4B, 0x74, 0x88, 0x4A, 0x57, 0x55, 0xC2, 0x99, 0x9A, 0xD3, 0x94, 0x34)
crypt_table_1 = crypt_table_1 .. string.char(0x36, 0xAF, 0x8C, 0x62, 0xDB, 0xFE, 0x24, 0x54, 0x6A, 0xFD, 0x68, 0x9F, 0x5C, 0x66, 0x0F, 0xB6, 0x46, 0x95, 0xEE, 0x93, 0x1B, 0x50, 0xB1, 0xC9, 0xD5, 0x96, 0x04, 0xCD, 0xFB, 0xC0, 0xEB, 0x39)
crypt_table_1 = crypt_table_1 .. string.char(0xC3, 0x85, 0x8D, 0x1D, 0x84, 0x77, 0x83, 0xE4, 0x28, 0x70, 0xA7, 0x1E, 0x43, 0x19, 0x65, 0xF8, 0xCA, 0x25, 0xC7, 0x80, 0x07, 0x10, 0xE3, 0x06, 0xE9, 0x2B, 0xE1, 0xB0, 0x47, 0x72, 0x0D, 0x73)
crypt_table_1 = crypt_table_1 .. string.char(0xB4, 0x08, 0xBB, 0xA9, 0x0A, 0xBF, 0xE2, 0x21, 0x56, 0xB8, 0xDF, 0x2E, 0x6F, 0x87, 0x3A, 0x64, 0xEA, 0xB2, 0x92, 0x52, 0x81, 0x41, 0xA5, 0x7F, 0xA6, 0xA0, 0xF7, 0xD0, 0x8A, 0x1F, 0xAE, 0x49)
crypt_table_1 = crypt_table_1 .. string.char(0x0E, 0xAA, 0x82, 0xAB, 0xD1, 0x33, 0xE0, 0xBE, 0x86, 0x79, 0x91, 0x75, 0xAC, 0x78, 0x69, 0x7B, 0x8F, 0xE7, 0x15, 0x1A, 0x23, 0xE5, 0xF3, 0xDA, 0x16, 0xFF, 0x31, 0x9E, 0xCF, 0xFA, 0x63, 0xF2)
crypt_table_1 = crypt_table_1 .. string.char(0xE8, 0x29, 0xCE, 0x35, 0x4F, 0xCC, 0x13, 0x7A, 0xC6, 0x5F, 0xB3, 0xBD, 0x5D, 0x59, 0xD4, 0x97, 0x3D, 0x30, 0xC8, 0xDD, 0x02, 0x4D, 0x4E, 0x6C, 0xFC, 0x42, 0x12, 0xC5, 0x40, 0x14, 0x4C, 0x17)
crypt_table_1 = crypt_table_1 .. string.char(0x60, 0xD8, 0xA4, 0x32, 0x7E, 0xED, 0x7C, 0x6D, 0xA3, 0x3C, 0x5E, 0x89, 0x67, 0xA1, 0xEC, 0x45, 0x3B, 0x98, 0xEF, 0x8B, 0x9C, 0x90, 0xD7, 0xF5, 0xD9, 0x76, 0x71, 0x26, 0x6E, 0xA8, 0xDC, 0x09)
crypt_table_1 = crypt_table_1 .. string.char(0x37, 0x51, 0x9B, 0x2D, 0x38, 0x1C, 0x3F, 0xE6, 0xF0, 0xDE, 0xB5, 0xF4, 0x53, 0xAD, 0x22, 0x03, 0x7D, 0x5B, 0x44, 0x58, 0x0C, 0xD2, 0x3E, 0xBA, 0x11, 0x20, 0x8E, 0xC4, 0x2C, 0xB9, 0x48, 0x6B)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0xC5, 0xC0, 0xD9, 0xAA, 0x1A, 0x39, 0xA9, 0x1E, 0x87, 0xB9, 0x0F, 0x95, 0x5C, 0x18, 0x96, 0x55, 0xCC, 0xB5, 0x5B, 0xE3, 0x78, 0x90, 0xED, 0x9A, 0xD7, 0x21, 0x3E, 0xDB, 0x41, 0x97)
crypt_table_1 = crypt_table_1 .. string.char(0xFB, 0x5F, 0x88, 0xBA, 0x16, 0xA6, 0x36, 0x99, 0x1B, 0x50, 0x7C, 0x07, 0x8E, 0x9C, 0x2B, 0xDC, 0x57, 0xB2, 0xE9, 0x74, 0x29, 0x80, 0xFF, 0x0C, 0x67, 0x9E, 0x72, 0xC6, 0x59, 0x8B, 0xE1, 0x6F)
crypt_table_1 = crypt_table_1 .. string.char(0x60, 0xD6, 0x92, 0x1F, 0xCB, 0xBD, 0xE0, 0x4C, 0x89, 0x6D, 0x32, 0x8A, 0x52, 0x98, 0xAB, 0x86, 0x69, 0xAF, 0x45, 0xB7, 0xDA, 0x49, 0xB4, 0x2D, 0xE4, 0x3A, 0xD8, 0x38, 0x54, 0xA0, 0xF9, 0x10)
crypt_table_1 = crypt_table_1 .. string.char(0x8D, 0x6E, 0xF2, 0x61, 0x8F, 0xEC, 0x40, 0x7F, 0xDF, 0xCF, 0x06, 0xF0, 0xC2, 0x0D, 0xD4, 0x63, 0xF5, 0x35, 0xBF, 0x37, 0x94, 0xCE, 0x2F, 0x31, 0xA8, 0x47, 0xF8, 0x4E, 0xDD, 0x44, 0xEB, 0x5D)
crypt_table_1 = crypt_table_1 .. string.char(0xF4, 0x2A, 0xF7, 0x02, 0x0A, 0xEE, 0xE7, 0x4B, 0xFC, 0x6B, 0x76, 0x15, 0x51, 0x27, 0x0E, 0xF6, 0xA1, 0x1C, 0x68, 0x20, 0xE6, 0x3B, 0xB3, 0x82, 0x62, 0x6C, 0x81, 0xCD, 0xD3, 0xC4, 0x2C, 0x4F)
crypt_table_1 = crypt_table_1 .. string.char(0xCA, 0xAE, 0xEF, 0x9D, 0x43, 0xDE, 0x79, 0x85, 0x75, 0x3D, 0xF1, 0x24, 0x64, 0x4A, 0x14, 0x70, 0xA7, 0x48, 0xBB, 0x11, 0xA4, 0x28, 0xD1, 0xFA, 0x65, 0x7B, 0xB1, 0x12, 0xAD, 0xC1, 0xC3, 0x4D)
crypt_table_1 = crypt_table_1 .. string.char(0xA5, 0x09, 0x2E, 0x19, 0x58, 0x73, 0x13, 0x33, 0xE8, 0x5A, 0x77, 0x22, 0x91, 0x7A, 0x25, 0x5E, 0xA3, 0x23, 0x0B, 0x03, 0x30, 0xBC, 0x3C, 0xD0, 0xB8, 0xFE, 0xB6, 0x56, 0xC9, 0x42, 0x1D, 0xE2)
crypt_table_1 = crypt_table_1 .. string.char(0x34, 0xB0, 0x46, 0xEA, 0x71, 0x53, 0xF3, 0x83, 0x6A, 0x3F, 0x93, 0x04, 0xAC, 0xC8, 0xC7, 0xD5, 0x8C, 0xD2, 0x7D, 0xBE, 0xA2, 0xE5, 0xFD, 0x9F, 0x17, 0x9B, 0x7E, 0x08, 0x84, 0x05, 0x66, 0x26)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0xB6, 0x5F, 0x94, 0x5A, 0x25, 0x3B, 0x43, 0x59, 0x71, 0xEA, 0x7F, 0x34, 0x83, 0xCE, 0x75, 0x8B, 0xFF, 0xCB, 0x30, 0x92, 0x23, 0xAD, 0x16, 0x4E, 0x9C, 0x4C, 0x0E, 0x79, 0x0A, 0x37)
crypt_table_1 = crypt_table_1 .. string.char(0xB5, 0xA6, 0x42, 0x67, 0x26, 0x78, 0x07, 0xF5, 0x2E, 0x6C, 0xA5, 0x65, 0x5B, 0x50, 0xB0, 0x99, 0x2F, 0xE3, 0x84, 0xB4, 0xCA, 0x29, 0xAA, 0x10, 0x2A, 0xF3, 0x49, 0xB9, 0x5C, 0xE0, 0xE8, 0x93)
crypt_table_1 = crypt_table_1 .. string.char(0xF2, 0x7D, 0x89, 0xDA, 0x33, 0xA3, 0x1A, 0xB7, 0x55, 0x64, 0xDD, 0xFA, 0x35, 0x22, 0xC0, 0xA4, 0x66, 0x4B, 0x24, 0x1B, 0xE5, 0x6A, 0x15, 0xC8, 0xA2, 0x3C, 0x7A, 0xDB, 0xC2, 0x45, 0x3F, 0x03)
crypt_table_1 = crypt_table_1 .. string.char(0x91, 0xD2, 0xEF, 0x69, 0xD0, 0xAE, 0x57, 0xF1, 0xEB, 0x58, 0x63, 0x0D, 0x14, 0x19, 0x08, 0xA9, 0xEE, 0x95, 0xCD, 0x3D, 0x46, 0x68, 0xCC, 0x82, 0xD8, 0xF4, 0x9E, 0x8D, 0x88, 0x6D, 0x96, 0x6F)
crypt_table_1 = crypt_table_1 .. string.char(0xAC, 0x6B, 0x7B, 0xBA, 0x40, 0x2C, 0x04, 0x4D, 0x62, 0x4F, 0xAF, 0xC9, 0xFD, 0x77, 0xF0, 0xD9, 0xDF, 0x1C, 0x13, 0xC4, 0x87, 0x73, 0xCF, 0x51, 0x0C, 0x72, 0x60, 0x9A, 0x1D, 0xE6, 0xA1, 0x09)
crypt_table_1 = crypt_table_1 .. string.char(0x38, 0xF8, 0x80, 0x31, 0x32, 0xDE, 0xD6, 0x8E, 0xB3, 0x86, 0xED, 0x9D, 0xFE, 0x4A, 0xC3, 0xA7, 0xD5, 0x61, 0xF9, 0x5E, 0xC7, 0xE7, 0x41, 0x47, 0x21, 0x1E, 0x7E, 0xA8, 0x02, 0xDC, 0xFB, 0x18)
crypt_table_1 = crypt_table_1 .. string.char(0x3A, 0xF7, 0x9B, 0xA0, 0xE4, 0x48, 0x28, 0x52, 0x9F, 0xE1, 0xD7, 0x27, 0x53, 0x2D, 0x05, 0x3E, 0x12, 0xD4, 0xC5, 0xAB, 0x7C, 0x1F, 0x6E, 0x5D, 0xEC, 0x20, 0x8F, 0xF6, 0x81, 0xE9, 0x0B, 0xB2)
crypt_table_1 = crypt_table_1 .. string.char(0x36, 0x8C, 0x39, 0x44, 0xBC, 0xE2, 0xD1, 0xB1, 0x54, 0xFC, 0x11, 0x06, 0x2B, 0xBE, 0x8A, 0xBB, 0x85, 0x98, 0x90, 0x56, 0x76, 0x74, 0x97, 0xC1, 0xD3, 0x70, 0xBF, 0x0F, 0xBD, 0x17, 0xC6, 0xB8)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0xDE, 0xEB, 0xDD, 0x32, 0xC8, 0xC4, 0xB2, 0xDB, 0xF4, 0x64, 0x82, 0xB9, 0xD0, 0xD5, 0x77, 0xAF, 0x35, 0xE9, 0x75, 0x96, 0xCE, 0x1B, 0xFB, 0x7A, 0xA7, 0xD1, 0xAC, 0xB5, 0x0A, 0x66)
crypt_table_1 = crypt_table_1 .. string.char(0xC7, 0x13, 0xFF, 0xF8, 0x79, 0x73, 0xC1, 0xA3, 0xF1, 0x83, 0x4C, 0x6E, 0x31, 0xAE, 0x19, 0xE0, 0x2A, 0x34, 0x80, 0xEC, 0x4F, 0x93, 0xC3, 0x1C, 0x08, 0x68, 0xD6, 0x3E, 0x57, 0x10, 0x1F, 0x5B)
crypt_table_1 = crypt_table_1 .. string.char(0x69, 0x6A, 0xF7, 0x72, 0x21, 0x70, 0x03, 0xA0, 0xC5, 0x89, 0xE4, 0x45, 0x53, 0x8A, 0x18, 0x12, 0x29, 0x0F, 0x42, 0x9A, 0x50, 0x6F, 0x0E, 0xA2, 0x76, 0x2D, 0x4E, 0xF5, 0x2F, 0x09, 0x40, 0x17)
crypt_table_1 = crypt_table_1 .. string.char(0x0D, 0x81, 0xFD, 0x3D, 0xF3, 0xF2, 0x46, 0x5C, 0xD4, 0xB1, 0x4A, 0x99, 0x74, 0xCD, 0x9D, 0xAB, 0xFC, 0x3B, 0x33, 0x60, 0xEE, 0xB4, 0x1A, 0x65, 0x7F, 0x0B, 0xF0, 0x44, 0xDA, 0x1D, 0x04, 0x88)
crypt_table_1 = crypt_table_1 .. string.char(0xEF, 0x7B, 0xFA, 0xC9, 0x36, 0x86, 0xCC, 0xFE, 0x8B, 0x39, 0x28, 0xD3, 0x8D, 0xD8, 0x11, 0x55, 0xDC, 0x5A, 0x26, 0xF6, 0x54, 0xE6, 0xB6, 0x3C, 0xB8, 0x30, 0x56, 0xA8, 0xA5, 0xB3, 0xBF, 0x4D)
crypt_table_1 = crypt_table_1 .. string.char(0x37, 0x07, 0x49, 0x48, 0x94, 0xBD, 0x02, 0xAD, 0x2B, 0x5D, 0x6C, 0x87, 0xDF, 0x8C, 0x7C, 0x1E, 0xD9, 0xCA, 0xBB, 0xE8, 0xF9, 0xD7, 0xB0, 0x15, 0xA4, 0x5F, 0x3A, 0xCF, 0x71, 0x9C, 0xC6, 0xB7)
crypt_table_1 = crypt_table_1 .. string.char(0xE5, 0x8F, 0x06, 0x8E, 0x84, 0x27, 0xE3, 0x20, 0x92, 0xA9, 0x51, 0xCB, 0x52, 0x23, 0x67, 0xBA, 0xA1, 0x4B, 0x22, 0x9F, 0x61, 0x6D, 0x7D, 0x62, 0x91, 0xE1, 0x24, 0xBC, 0x78, 0x97, 0xED, 0x14)
crypt_table_1 = crypt_table_1 .. string.char(0xC2, 0x95, 0x5E, 0x38, 0xBE, 0x2E, 0x47, 0x16, 0x25, 0x2C, 0x41, 0xE2, 0x3F, 0xE7, 0x6B, 0x9B, 0xC0, 0x43, 0xEA, 0x90, 0x59, 0xAA, 0x85, 0x63, 0xD2, 0xA6, 0x98, 0x7E, 0x05, 0x58, 0x0C, 0x9E)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0x21, 0x40, 0xED, 0xC2, 0xEB, 0x98, 0x72, 0x74, 0x45, 0x4D, 0x53, 0x46, 0x4A, 0xB6, 0x44, 0x8B, 0x10, 0x64, 0xC6, 0x17, 0xD2, 0x5E, 0xA1, 0x12, 0x09, 0x36, 0x3B, 0xBB, 0x9D, 0x47)
crypt_table_1 = crypt_table_1 .. string.char(0x92, 0x95, 0x83, 0xDB, 0x75, 0xC1, 0x9F, 0x9A, 0x39, 0xB5, 0x3A, 0x41, 0x6F, 0x67, 0x4F, 0x65, 0x43, 0x02, 0x32, 0x8C, 0x3C, 0x91, 0xE6, 0xEC, 0x1F, 0xCC, 0xEA, 0x76, 0x31, 0xAF, 0x5D, 0xE0)
crypt_table_1 = crypt_table_1 .. string.char(0xAC, 0x60, 0x07, 0x56, 0xCE, 0x55, 0x1A, 0x88, 0x68, 0x0D, 0x8D, 0x28, 0x13, 0x57, 0x79, 0xE2, 0x58, 0x4C, 0x0C, 0x5C, 0xC7, 0x62, 0x6C, 0xD5, 0x1D, 0x66, 0xA6, 0x22, 0x05, 0x33, 0x42, 0x08)
crypt_table_1 = crypt_table_1 .. string.char(0xB2, 0xB7, 0x34, 0xA2, 0xB3, 0x0A, 0x97, 0x7B, 0x25, 0xE9, 0x6B, 0x23, 0x1E, 0x03, 0xC9, 0x52, 0x81, 0x4B, 0xB1, 0xDA, 0x5B, 0x94, 0xFC, 0x82, 0x87, 0xB9, 0xA9, 0xF0, 0x6E, 0x7A, 0x4E, 0x27)
crypt_table_1 = crypt_table_1 .. string.char(0xD8, 0xF4, 0xD0, 0x30, 0x3E, 0xAA, 0xCD, 0xDC, 0xDD, 0x96, 0xB8, 0x93, 0x2D, 0xBD, 0xE1, 0xBF, 0xFB, 0xFE, 0xE3, 0x2C, 0x24, 0x49, 0xF8, 0x06, 0xC0, 0xF5, 0xFF, 0x2E, 0x5F, 0xC8, 0x69, 0x63)
crypt_table_1 = crypt_table_1 .. string.char(0x1B, 0x84, 0xE8, 0x8F, 0x0F, 0xA5, 0xC4, 0x18, 0xA4, 0xD9, 0x61, 0x20, 0xFD, 0x11, 0x9C, 0x77, 0x19, 0x26, 0xF2, 0x29, 0x04, 0x5A, 0xB0, 0x80, 0xA3, 0xF6, 0xAE, 0xD1, 0x73, 0xBE, 0x9E, 0x85)
crypt_table_1 = crypt_table_1 .. string.char(0x7E, 0x14, 0xDF, 0xAD, 0x2A, 0x6A, 0x7C, 0xE5, 0xD4, 0x3F, 0x48, 0x71, 0x37, 0xCF, 0xC3, 0xCB, 0xBA, 0xB4, 0xEE, 0x35, 0x9B, 0x54, 0x16, 0xC5, 0x1C, 0xA8, 0xF1, 0xE4, 0x2F, 0xBC, 0x8A, 0xD3)
crypt_table_1 = crypt_table_1 .. string.char(0x99, 0xF9, 0xFA, 0x51, 0x59, 0xA7, 0x90, 0x15, 0xDE, 0x3D, 0x8E, 0x0E, 0xD7, 0x89, 0x0B, 0x78, 0xF3, 0x50, 0xA0, 0xCA, 0x6D, 0x70, 0x7D, 0xD6, 0x2B, 0x38, 0x86, 0xE7, 0xF7, 0xAB, 0xEF, 0x7F)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0x96, 0x86, 0xF6, 0x33, 0x1E, 0x88, 0xA4, 0xC2, 0xB7, 0x4F, 0x98, 0xC5, 0xF3, 0x1C, 0x61, 0xAC, 0x8F, 0x8A, 0xE2, 0x85, 0xB4, 0xF5, 0xBB, 0x97, 0x51, 0xE0, 0x87, 0x7B, 0x17, 0x5F)
crypt_table_1 = crypt_table_1 .. string.char(0x23, 0x45, 0x1A, 0x1B, 0x93, 0x02, 0x2F, 0xA6, 0x28, 0xB3, 0x67, 0x03, 0x4B, 0x07, 0xBA, 0xF8, 0x83, 0x8B, 0xC3, 0xC8, 0x0D, 0xD2, 0x6E, 0x4D, 0xA5, 0x9D, 0x55, 0x9C, 0x0C, 0x16, 0xDE, 0x12)
crypt_table_1 = crypt_table_1 .. string.char(0x5C, 0xD3, 0x92, 0xEE, 0x0B, 0x31, 0xE6, 0x2A, 0x63, 0x50, 0x60, 0x4C, 0xB5, 0xF4, 0x80, 0xEA, 0xCA, 0x81, 0xC7, 0xDA, 0x71, 0xC9, 0xF9, 0xEC, 0x7D, 0x5B, 0x27, 0x36, 0x6C, 0xB0, 0x9A, 0xD5)
crypt_table_1 = crypt_table_1 .. string.char(0xC0, 0xE7, 0xE1, 0x8C, 0xA0, 0x91, 0x15, 0x58, 0xAA, 0x6D, 0xDF, 0xE4, 0xB1, 0x94, 0x5D, 0xAB, 0x59, 0x4E, 0x1D, 0x8E, 0xB8, 0xFD, 0xFB, 0xEF, 0x25, 0x4A, 0x64, 0x95, 0x7C, 0xC1, 0xFF, 0xC4)
crypt_table_1 = crypt_table_1 .. string.char(0x7E, 0x79, 0x41, 0x2D, 0xCB, 0x82, 0x1F, 0x35, 0x75, 0xCF, 0xDB, 0x34, 0x99, 0x05, 0x3D, 0x65, 0x90, 0x3A, 0xEB, 0x84, 0xDC, 0x78, 0x42, 0x04, 0xB2, 0x69, 0x21, 0xA3, 0xD7, 0x37, 0x62, 0x7F)
crypt_table_1 = crypt_table_1 .. string.char(0x0F, 0x3E, 0x6F, 0x5E, 0xBE, 0x9F, 0x47, 0xCE, 0xBF, 0xAE, 0x54, 0xAF, 0x2C, 0x48, 0x53, 0xD1, 0xD8, 0x68, 0x2B, 0xAD, 0x74, 0x38, 0xF7, 0x08, 0x72, 0x5A, 0xA8, 0xD6, 0x46, 0x3C, 0xDD, 0xE9)
crypt_table_1 = crypt_table_1 .. string.char(0xF2, 0xF1, 0x26, 0xCC, 0x52, 0x3B, 0xCD, 0x3F, 0x73, 0x14, 0x7A, 0x40, 0xB6, 0x10, 0x0A, 0x70, 0xE3, 0x66, 0xA9, 0xBD, 0x19, 0x11, 0x44, 0xC6, 0xA1, 0x30, 0x6A, 0xFA, 0x57, 0x0E, 0xA7, 0xB9)
crypt_table_1 = crypt_table_1 .. string.char(0xFC, 0x6B, 0x43, 0xD9, 0x9B, 0x22, 0x39, 0x32, 0x89, 0xFE, 0x77, 0xD0, 0x29, 0x56, 0x06, 0x13, 0xED, 0xF0, 0x9E, 0xD4, 0x24, 0x09, 0xE8, 0x76, 0xA2, 0x8D, 0x2E, 0xE5, 0x18, 0x49, 0xBC, 0x20)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0x25, 0x44, 0xF4, 0xE6, 0x23, 0xFB, 0x99, 0x8A, 0x53, 0x1B, 0x14, 0x15, 0xA9, 0xD2, 0x6C, 0x65, 0x74, 0xF5, 0x2D, 0xC3, 0xE3, 0xD0, 0xEC, 0x67, 0xAC, 0x3F, 0xB8, 0x48, 0x06, 0x45)
crypt_table_1 = crypt_table_1 .. string.char(0xC0, 0x02, 0xBC, 0x7E, 0x63, 0x32, 0x2F, 0xF8, 0xCE, 0x2A, 0xF1, 0xEF, 0x2C, 0x51, 0x1F, 0xDA, 0xED, 0xB6, 0x92, 0xE1, 0xE9, 0xBA, 0x66, 0x28, 0x41, 0x16, 0x59, 0xBF, 0x29, 0x33, 0x42, 0x89)
crypt_table_1 = crypt_table_1 .. string.char(0x4B, 0x7D, 0xCF, 0xE5, 0xE4, 0x40, 0xC9, 0x56, 0xD1, 0x9E, 0xF9, 0xAE, 0x8C, 0x6D, 0xFF, 0x47, 0xA0, 0xF3, 0xA7, 0xC6, 0xDF, 0x55, 0xC7, 0x9C, 0x60, 0x73, 0x4E, 0x81, 0xD6, 0x83, 0xF0, 0x34)
crypt_table_1 = crypt_table_1 .. string.char(0x46, 0x80, 0xF6, 0x8E, 0xCC, 0x3A, 0xC4, 0xBE, 0x8D, 0xDB, 0x21, 0xA5, 0xF7, 0xB7, 0xCB, 0xB4, 0xEB, 0x7A, 0x54, 0x6A, 0x3D, 0xEE, 0x64, 0x0D, 0xFC, 0xBD, 0x30, 0x7B, 0xB9, 0xB5, 0x10, 0x2B)
crypt_table_1 = crypt_table_1 .. string.char(0x58, 0x18, 0x26, 0x6E, 0x4F, 0x78, 0x5B, 0xD4, 0x6B, 0xE7, 0xC2, 0xA2, 0x7C, 0x50, 0x0F, 0x07, 0x3B, 0x11, 0x05, 0x5D, 0xD5, 0x97, 0x98, 0x31, 0x17, 0x5F, 0xC1, 0xCD, 0x9D, 0x1D, 0xFD, 0xB1)
crypt_table_1 = crypt_table_1 .. string.char(0x9B, 0x4C, 0x77, 0x0A, 0x84, 0x19, 0x0C, 0xA3, 0x35, 0x0B, 0xE0, 0x3C, 0x72, 0xE8, 0x08, 0x8B, 0xD9, 0x4D, 0x5A, 0xD7, 0xFA, 0xAD, 0x4A, 0x20, 0x2E, 0x94, 0x24, 0xDD, 0xA8, 0xA4, 0x62, 0x8F)
crypt_table_1 = crypt_table_1 .. string.char(0x38, 0xE2, 0x5C, 0xD8, 0x88, 0xA1, 0xAA, 0x52, 0xD3, 0x7F, 0xB0, 0x69, 0x6F, 0x1A, 0xCA, 0x82, 0xB2, 0xA6, 0x57, 0x5E, 0x13, 0x49, 0x91, 0x70, 0xDC, 0x22, 0x71, 0x79, 0xEA, 0x0E, 0x1E, 0x12)
crypt_table_1 = crypt_table_1 .. string.char(0xFE, 0x1C, 0x95, 0x39, 0x61, 0x9A, 0x93, 0x27, 0x09, 0x87, 0x90, 0x85, 0xDE, 0x9F, 0x68, 0xAB, 0x04, 0x96, 0xAF, 0xF2, 0x03, 0x75, 0x36, 0xC5, 0x86, 0xBB, 0xB3, 0x43, 0x76, 0x37, 0x3E, 0xC8)
crypt_table_1 = crypt_table_1 .. string.char(0x00, 0x01, 0x67, 0x2D, 0x84, 0xA2, 0x33, 0xEA, 0xDD, 0x0C, 0x55, 0x43, 0x45, 0xD6, 0x75, 0xC7, 0x04, 0x5B, 0xF2, 0xF6, 0x9C, 0x14, 0x22, 0x17, 0xF3, 0xAB, 0xB6, 0xD7, 0x3C, 0xD3, 0x4D, 0x41)
crypt_table_1 = crypt_table_1 .. string.char(0x7B, 0x70, 0xF1, 0xA4, 0x28, 0xD0, 0xDA, 0x11, 0x36, 0x13, 0x34, 0x6A, 0xC1, 0x4F, 0xF8, 0x7E, 0xA6, 0x6C, 0xE2, 0x82, 0xD2, 0xCA, 0x60, 0xD5, 0x7A, 0x49, 0x1D, 0xCB, 0x85, 0xD1, 0x4A, 0xA9)
crypt_table_1 = crypt_table_1 .. string.char(0x4B, 0x24, 0x4C, 0xF5, 0x83, 0xB5, 0xEB, 0x2C, 0x3A, 0xA8, 0x6F, 0xDB, 0xF7, 0xE9, 0xEE, 0x6D, 0xC8, 0x26, 0x8D, 0xD8, 0xC0, 0x7D, 0x0F, 0x64, 0xD9, 0x86, 0x10, 0x68, 0xA3, 0x2B, 0x90, 0xA7)
crypt_table_1 = crypt_table_1 .. string.char(0x8B, 0x46, 0x74, 0x4E, 0x89, 0x12, 0xA1, 0x2F, 0x0D, 0xBC, 0xC4, 0x99, 0x38, 0x8F, 0xC3, 0x79, 0x48, 0x0E, 0x29, 0x18, 0x2A, 0x77, 0x87, 0x39, 0x16, 0x58, 0x19, 0x3B, 0xE8, 0x7C, 0xAC, 0x5A)
crypt_table_1 = crypt_table_1 .. string.char(0x52, 0x1A, 0x97, 0x81, 0x03, 0x62, 0xEF, 0x35, 0x93, 0x05, 0x09, 0xA5, 0xFC, 0xD4, 0xA0, 0xBB, 0x5E, 0x1F, 0xB4, 0x50, 0xE5, 0x15, 0x23, 0x47, 0x9A, 0xE3, 0x07, 0x02, 0x21, 0x51, 0xBF, 0xE7)
crypt_table_1 = crypt_table_1 .. string.char(0xB3, 0x27, 0xC5, 0x53, 0x08, 0x9B, 0x32, 0x5C, 0x91, 0x96, 0xCD, 0xB7, 0xFF, 0x57, 0x66, 0xB2, 0xC9, 0x63, 0x9D, 0x3F, 0xFB, 0xCC, 0x0B, 0x6B, 0x8C, 0xAD, 0xB1, 0x3D, 0xEC, 0x78, 0x44, 0x37)
crypt_table_1 = crypt_table_1 .. string.char(0x56, 0xB0, 0x3E, 0x40, 0xBA, 0xAF, 0x2E, 0x1B, 0xE1, 0x9E, 0x1E, 0xC2, 0x20, 0x65, 0x5F, 0x80, 0x72, 0x98, 0xAA, 0x42, 0xE6, 0x1C, 0xDE, 0xBE, 0xDF, 0xE4, 0x30, 0x7F, 0x95, 0xC6, 0x31, 0xDC)
crypt_table_1 = crypt_table_1 .. string.char(0xFA, 0x8A, 0x54, 0xFE, 0xBD, 0xAE, 0x88, 0x92, 0xB8, 0x9F, 0x59, 0x94, 0x25, 0x61, 0x5D, 0xF9, 0x69, 0x76, 0xCE, 0xF4, 0x71, 0x06, 0xFD, 0xED, 0xB9, 0xE0, 0x0A, 0xF0, 0x8E, 0x73, 0x6E, 0xCF)
crypt_table_1 = ByteArray.new(crypt_table_1, true)

-- endregion

-- region PangYa packet decryption

local function pangyaClientDecrypt(data, key)
  if key >= 0x10 then
    return nil
  end

  if data:len() < 5 then
    return nil
  end

  local index = key * 256 + data:get_index(0)
  local buffer = ByteArray.new(data:raw(), true)

  buffer:set_index(4, crypt_table_1:get_index(index))
  local i = 8
  while i < data:len() do
    buffer:set_index(i, bitoper(buffer:get_index(i), buffer:get_index(i - 4), XOR))
    i = i + 1
  end

  return buffer:subset(5, buffer:len() - 5)
end

local function pangyaServerDecrypt(data, key)
  if key >= 0x10 then
    return nil
  end

  if data:len() < 8 then
    return nil
  end

  local index = key * 256 + data:get_index(0)
  local buffer = ByteArray.new(data:raw(), true)

  buffer:set_index(7, bitoper(buffer:get_index(7), crypt_table_1:get_index(index), XOR))
  local i = 10
  while i < data:len() do
    buffer:set_index(i, bitoper(buffer:get_index(i), buffer:get_index(i - 4), XOR))
    i = i + 1
  end

  local decompressed = lzoDecompress1x(buffer:subset(8, buffer:len() - 8))

  return decompressed
end

-- endregion

-- region PangYa packet dissector

-- global stream:key mapping
local stream_keys = {}

local function dissectHello(buffer, pinfo, stream_index, tree)
  local key = {}
  key.frame = pinfo.number
  key.srv_port = pinfo.src_port
  key.srv_type = getServerType(pinfo.src_port)

  -- might vary per region, need to look into that :)
  local offset = 8
  if key.srv_type == server_type.LOGIN_SERVER then
    offset = 6
  elseif key.srv_type == server_type.GAME_SERVER then
    offset = 8
  elseif key.srv_type == server_type.MESSAGE_SERVER then
    offset = 8
  end

  key.value = buffer(offset, 1):uint()
  stream_keys[stream_index] = key
  local subtree = tree:add(pangya_protocol, buffer(), "PangYa Hello Packet")
  subtree:add_le(key_field, buffer(offset, 1))
  return pinfo.len
end

-- returns either [key table], true or [hello packet bytes], false
local function getStreamKey(buffer, pinfo, stream_index, tree, offset)
  local key = stream_keys[stream_index]
  if key then
    if offset == 0 and key.frame >= pinfo.number then
      -- appears to be hello packet, maybe earlier than before
      return dissectHello(buffer, pinfo, stream_index, tree), false
    end

    return key, true
  else
    -- hello packet cannot occur at offset, return 0
    if offset > 0 then
      dprint("no key found at " .. pinfo.number .. " in stream " .. stream_index)
      return 0, false
    end

    return dissectHello(buffer, pinfo, stream_index, tree), false
  end
end

local function pangyaDissectPacket(buffer, pinfo, tree, offset)
  local stream_idx_ex = stream_index()
  local key, ok = getStreamKey(buffer, pinfo, stream_idx_ex.value, tree, offset)

  if ok then
    local is_client = pinfo.dst_port == key.srv_port
    local client_server_ch
    if is_client then
      client_server_ch = 'C'
    else
      client_server_ch = 'S'
    end
    if is_client then
      local packet_len = buffer(offset + 1, 2):le_uint() + 4
      if (buffer:len() - offset) < packet_len then
        return (buffer:len() - offset) - packet_len
      end

      local subtree = tree:add(pangya_protocol, buffer(), "PangYa Client Packet")

      -- Basic frame metadata
      subtree:add_le(key_field, key.value):set_generated(true)
      subtree:add(type_field, serverTypeName(key.srv_type)):set_generated(true)
      subtree:add(client_field, true):set_generated(true)
      subtree:add_le(salt_field, buffer(offset, 1))
      subtree:add_le(length_field, buffer(offset + 1, 2), packet_len)
      subtree:add(encrypted_field, buffer(offset + 5, packet_len - 5))

      local decrypted = pangyaClientDecrypt(buffer(offset, packet_len):bytes(), key.value)
      local tvb = ByteArray.tvb(decrypted, "Decrypted Data")
      local suffix = " (" .. tvb:len() .. " bytes, type: " .. ("0x%04x"):format(tvb(0, 2):le_uint()) .. ")"
      subtree:add_le(id_field, tvb(0,2))
      subtree:add(tvb(), "Packet data" .. suffix)
      subtree:append_text(suffix)

      local infopfx = ("[%s%s%04x] "):format(serverTypeShorthand(key.srv_type), client_server_ch, tvb(0, 2):le_uint())
      pinfo.cols.info = infopfx .. tostring(pinfo.cols.info)

      return packet_len
    else
      local packet_len = buffer(offset + 1, 2):le_uint() + 3
      if (buffer:len() - offset) < packet_len then
        return (buffer:len() - offset) - packet_len
      end

      local subtree = tree:add(pangya_protocol, buffer(), "PangYa Server Packet")

      -- Basic frame metadata
      subtree:add_le(key_field, key.value):set_generated(true)
      subtree:add(type_field, serverTypeName(key.srv_type)):set_generated(true)
      subtree:add(server_field, true):set_generated(true)
      subtree:add_le(salt_field, buffer(offset, 1))
      subtree:add_le(length_field, buffer(offset + 1, 2), packet_len)
      subtree:add(encrypted_field, buffer(offset + 8, packet_len - 8))

      local decrypted = pangyaServerDecrypt(buffer(offset, packet_len):bytes(), key.value)
      local tvb = ByteArray.tvb(decrypted, "Decrypted Data")
      local suffix = " (" .. tvb:len() .. " bytes, type: " .. ("0x%04x"):format(tvb(0, 2):uint()) .. ")"
      subtree:add_le(id_field, tvb(0,2))
      subtree:add(tvb(), "Packet data" .. suffix)
      subtree:append_text(suffix)

      local infopfx = ("[%s%s%04x] "):format(serverTypeShorthand(key.srv_type), client_server_ch, tvb(0, 2):le_uint())
      pinfo.cols.info = infopfx .. tostring(pinfo.cols.info)

      return packet_len
    end
  else
    -- in this case key is the number of bytes used in hello.
    return key
  end
end

function pangya_protocol.dissector(buffer, pinfo, tree)
  local length = buffer:len()
  if length == 0 then return end

  pinfo.cols.protocol = pangya_protocol.name
  local subtree = tree:add(pangya_protocol, buffer(), "PangYa Protocol Data")

  local plen = buffer:len()
  local bytes_consumed = 0

  while bytes_consumed < plen do
    local result = pangyaDissectPacket(buffer, pinfo, subtree, bytes_consumed)
    if result > 0 then
      bytes_consumed = result + bytes_consumed
    elseif result == 0 then
      error("failed to dissect packet")
    else
      pinfo.desegment_offset = bytes_consumed
      result = -result
      pinfo.desegment_len = result
      dprint("need more bytes: desegment_offset: " .. bytes_consumed .. ", desegment_len: " .. result)
      return plen
    end
  end

  return bytes_consumed
end

local function enablePlugin()
  local tcp_port = DissectorTable.get("tcp.port")
  for port, _ in pairs(portMapping) do
    tcp_port:add(port, pangya_protocol)
  end
end

local function disablePlugin()
  local tcp_port = DissectorTable.get("tcp.port")
  for port, _ in pairs(portMapping) do
    tcp_port:remove(port, pangya_protocol)
  end
end

enablePlugin()

-- endregion

-- region Preferences

local debug_pref_enum = {
  { 1, "Disabled", debug_level.DISABLED },
  { 2, "Verbose" , debug_level.VERBOSE  },
}

pangya_protocol.prefs.enabled = Pref.bool(
  "Enabled",
  default_settings.enabled,
  "Whether or not the PangYa dissector is enabled"
)

pangya_protocol.prefs.debug_level = Pref.enum(
  "Debug",
  default_settings.debug_level,
  "The debug printing level",
  debug_pref_enum
)

pangya_protocol.prefs.login_server_port = Pref.uint(
  "LoginServer Port",
  default_settings.login_server_port,
  "Additional port to treat as LoginServer"
)

pangya_protocol.prefs.game_server_port = Pref.uint(
  "GameServer Port",
  default_settings.game_server_port,
  "Additional port to treat as GameServer"
)

pangya_protocol.prefs.message_server_port = Pref.uint(
  "MessageServer Port",
  default_settings.message_server_port,
  "Additional port to treat as MessageServer"
)

function pangya_protocol.prefs_changed()
  local need_reload = false

  default_settings.debug_level = pangya_protocol.prefs.debug_level

  if default_settings.login_server_port ~= pangya_protocol.prefs.login_server_port then
    default_settings.login_server_port = pangya_protocol.prefs.login_server_port
    need_reload = true
  end

  if default_settings.game_server_port ~= pangya_protocol.prefs.game_server_port then
    default_settings.game_server_port = pangya_protocol.prefs.game_server_port
    need_reload = true
  end

  if default_settings.message_server_port ~= pangya_protocol.prefs.message_server_port then
    default_settings.message_server_port = pangya_protocol.prefs.message_server_port
    need_reload = true
  end

  if need_reload then
    disablePlugin()
  end

  if default_settings.enabled ~= pangya_protocol.prefs.enabled then
    default_settings.enabled = pangya_protocol.prefs.enabled
    need_reload = true
  end

  setupDebugPrint()
  setupPortMap()

  if need_reload and default_settings.enabled then
    enablePlugin()
  end

  if need_reload then reload() end
end

-- endregion