--~ package.path = [[.\dfns_jvwg_ysaf\?.lua;]] .. package.path
--~ package.cpath = [[.\dfns_jvwg_ysaf\?.dll;]] .. package.cpath
local 字集码互转库 = require("u8_to_a")
local d_5 = {}
--~ function _G.历排(o1_11, u1, u2, u3, u4)
  --~ local k1_8
  --~ local k1_11
  --~ k1_11 = {}
  --~ for u5 = 1, #o1_11 do
    --~ k1_8 = u1(o1_11[u5], u2, u3, u4)
    --~ if k1_8 then
      --~ k1_11[#k1_11 + 1] = k1_8
      --~ end
    --~ end
  --~ return k1_11
  --~ end
--~ function _G.历文(u1, u2, u3, u4)
  --~ local k1_9
  --~ k1_9 = {}
  --~ for u5 in u2(u1, u3, u4) do
    --~ k1_9[#k1_9 + 1] = u5
    --~ end
  --~ return k1_9
  --~ end
--~ local 简件系库 = require("lfs")
--~ require(字集码互转库.u8_to_a("程语_月_基类_字串_内置库_加多"))
--~ 程语_月_标准库_仿照_加多_多编码_大字集_通用
function d_5.导入库_通用大字集态_八位态(modname)
  return require(字集码互转库.u8_to_a(modname))
  end
--~ local 
do
  local h1 = 0
  function _G.递增示()
    h1 = h1 + 1
    print(h1)
    end
  end
--~ do
--~ local h1 = os.execute
--~ function _G.os.execute(command)
--~ return h1(字集码互转库.u2a(command))
--~ end
--~ end
function d_5.读件(u1, u2)
  local h1
  local k1_3
  k1_3 = io.open(u1, u2 or "r")
  h1 = k1_3:read("a")
  k1_3:flush()
  k1_3:close()
  return h1
  end
function d_5.读件排(o1_9, u1)
  local k1_9
  k1_9 = {}
  for u2 = 1, #o1_9 do
    k1_9[#k1_9 + 1] = d_5.读件(o1_9[u2], u1)
    end
  return k1_9
  end
function d_5.写件(u1, u2, u3)
  local k1_3
  k1_3 = io.open(u1, u3 or "w")
  k1_3:write(u2)
  k1_3:flush()
  k1_3:close()
  end
function d_5.写件_一维(u1, o1_9, u2, u3)
  local h1 = table.concat(o1_9, "\n")
  if u3 then
    h1 = u3(h1)
    end
  d_5.写件(u1, h1, u2)
  end
function d_5.删制表符(u1)
  return u1:gsub("\t", "")
  end
--~ function d_5.删空白字(u1)
--~ return u1:gsub("%s", "")
--~ end
--~ function d_5.删空格与制表符(u1)
--~ u1 = d_5.删空格(u1)
--~ return d_5.删制表符(u1)
--~ end
function d_5.文转排(text)
  local lines = {}
  for line in text:gmatch("[^\n]+") do
    table.insert(lines, line)
    end
  return lines
  end
--~ function d_5.删前缀(u1, u2)
--~ if u1:find(u2, 1, true) then
--~ return u1:sub(#u2 + 1)
--~ end
--~ end
--~ function d_5.删后缀(u1, u2)
--~ if u1:find(u2, -1, true) then
--~ return u1:sub(1, #u1 - #u2)
--~ end
--~ end
--~ function d_5.删空行_不虑首末态(u1)
--~ return u1:gsub("\n+", "\n")
--~ end
--~ function d_5.删空行(u1)
--~ u1 = d_5.删空行_不虑首末态(u1)
--~ u1 = d_5.删前缀(u1, "\n")
--~ return d_5.删后缀(u1, "\n")
--~ end
function d_5.删空格(u1)
  return u1:gsub(" ", "")
  end
function d_5.筛排(o1_9, u1, u2, u3)
  local k1_8
  local k1_9
  k1_9 = {}
  for u4 = 1, #o1_9 do
    k1_8 = u1(o1_9[u4], u2, u3)
    if k1_8 then
      k1_9[#k1_9 + 1] = k1_8
      end
    end
  return k1_9
  end
--~ function d_5.筛文(u1, u2, u3)
--~ local k1_9
--~ k1_9 = {}
--~ for u4 in u2(u1, u3) do
--~ k1_9[#k1_9 + 1] = u4
--~ end
--~ return k1_9
--~ end
--~ function d_5.判文(u1, u2, u3, u4)
--~ if u1:find(u2 or ".", u3, u4) then
--~ return u1
--~ end
--~ end
--~ function d_5.筛件径(u1, u2)
  --~ local k1_9
  --~ k1_9 = d_5.筛文(u1, 简件系库.dir)
  --~ k1_9 = d_5.筛排(k1_9, d_5.加前缀, u1 .. "/")
  --~ k1_9 = d_5.筛排(k1_9, d_5.判文, u2)
  --~ return d_5.筛排(k1_9, d_5.在前后加英文双引号)
  --~ end
--~ function d_5.筛单行等式(u1)
--~ return 常用库.捕排(string.gmatch, u1, "[^\n= \t]+")
--~ end
--~ function d_5.捕非空单行(u1)
--~ return 常用库.捕排(string.gmatch, u1, "[^\n]+[\n]?")
--~ end
--~ function d_5.捕非空单行(u1)
--~ return 常用库.捕排(string.gmatch, u1, "[^\n]+[\n]?")
--~ end
function d_5.排转对(o1_12, u1)
  local k1_5
  local k1_11
  k1_11 = {}
  for u2 = 1, #o1_12, u1 + 1 do
    k1_5 = {}
    for u3 = 1, u1 do
      k1_5[u3] = o1_12[u2 + u3]
      end
    k1_11[o1_12[u2]] = k1_5
    end
  return k1_11
  end
--~ function d_5.加前缀(u1, u2)
--~ return u2 .. u1
--~ end
--~ function d_5.加后缀(u1, u2)
--~ return u1 .. u2
--~ end
function d_5.filterLinesWithCharacter(text, character)
  local result = {}
  local lines = d_5.文转排(text)
  -- 遍历每一行，检查是否包含目标字符
  for i, line in ipairs(lines) do
    if line:find(character, 1, true) then
      table.insert(result, line)
      end
    end
  return result
  end
--~ function d_5.办令(u1)
  --~ print(u1)
  --~ os.execute(u1)
  --~ end
--~ function d_5.在前后加英文双引号(u1)
--~ return [["]] .. u1 .. [["]]
--~ end
--~ function d_5.筛单行等式_左右值态(u1)
--~ local k1_11
--~ k1_11 = {}
--~ for u2 in k1_11:gmatch("[^\n= \t]+") do
--~ table.insert(k1_11, u2)
--~ end
--~ return u2
--~ end
return d_5

local ffi = require("ffi")
local s = {}
ffi.cdef([[
typedef unsigned int UINT;
typedef unsigned long DWORD;
typedef wchar_t WCHAR;
typedef WCHAR* LPWSTR;
typedef wchar_t* LPCWCH;
typedef char CHAR;
typedef CHAR* LPSTR;
typedef const char* LPCCH;
typedef int BOOL;
typedef BOOL* LPBOOL;
int MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCCH lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar);
int WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWCH lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cchMultiByte, LPCCH lpDefaultChar, LPBOOL pfUsedDefaultChar);
]])
s.CP_ACP = 0
s.CP_UTF8 = 65001
--~ 算机_基统_窗群
function s.m2w(input, u1)
  local wlen = ffi.C.MultiByteToWideChar(u1 or s.CP_ACP, 0, input, #input, nil, 0)
  local wstr = ffi.new("wchar_t[?]", wlen + 1)
  ffi.C.MultiByteToWideChar(u1 or s.CP_ACP, 0, input, #input, wstr, wlen)
  return wstr, wlen
end
function s.w2m(wstr, wlen, u1)
  local len = ffi.C.WideCharToMultiByte(u1 or s.CP_ACP, 0, wstr, wlen or -1, nil, 0, nil, nil)
  local str = ffi.new("char[?]", len)
  ffi.C.WideCharToMultiByte(u1 or s.CP_ACP, 0, wstr, wlen or -1, str, len, nil, nil)
  return ffi.string(str, len)
end
--~ 通用大字集_八位
function s.u8_to_a(input)
  return s.w2m(s.m2w(input, s.CP_UTF8))
end
function s.a_to_u8(input)
  local h1, h2 = s.m2w(input)
  return s.w2m(h1, h2, s.CP_UTF8)
end
return s

local s = {}
local 简文件库 = require("lfs")
local ffi = require("ffi")
--~ 排
--~ 办排中值的能
--~ 入参2
--~ 入参3
--~ 入参4
function s.历排(u1_0, u1, u2, u3, u4)
  local h1_0
  --~ 集排
  h1_0 = {}
  for u5 = 1, #u1_0 do
    h1_0[#h1_0 + 1] = u1(u1_0[u5], u2, u3, u4)
    end
  return h1_0
  end
--~ 文
--~ 历文的能
--~ 入参2
--~ 入参3
function s.历文(u1, u2, u3, u4)
  local h1_0
  --~ 集排
  h1_0 = {}
  for u5 in u2(u1, u3, u4) do
    h1_0[#h1_0 + 1] = u5
    end
  return h1_0
  end
--~ 排
--~ 能
function s.历排取一(u1_0, u1)
  local h1
  for u2 = 1, #u1_0 do
    --~ 值
    h1 = s.历排取一的模(h1, u1_0[u2], u1)
    end
  return h1
  end
--~ 值
--~ 排中值
function s.历排取一的模(u1, u2, u3)
  if u1 == nil then
    return u2
  elseif u3(u1, u2) then
    return u2
  else
    return u1
    end
  end
--~ 对
--~ 能
function s.历对取一(u1_0, u1)
  local h1, h2
  for u2, u2_0 in pairs(u1_0) do
    --~ 键
    --~ 值
    h1, h2 = s.历对取一的模(h1, h2, u2, u2_0, u1)
    end
  return h1, h2
  end
function s.历对取一的模(u1, u2, u3, u4, u5)
  if u1 == nil then
    return u3, u4
  elseif u5(u1, u2, u3, u4) then
    return u3, u4
  else
    return u1, u2
    end
  end
function s.历对(u1_0, u1, u2)
  local h1
  local h1_0, h2_0
  --~ 对
  h1_0 = {}
  for u3, u2_0 in pairs(u1_0) do
    --~ 键
    --~ 值
    h1, h2_0 = u1(u3, u2_0, u2)
    if h1 then
      h1_0[h1] = h2_0
    else
      end
    end
  return h1_0
  end
--~ 排中值
--~ 值类
--~ 办值的能
function s.操类(u1_0, u1, u2)
  if type(u1_0) == u1 then
    return u2(u1_0)
  else
    return u1_0
    end
  end
--~ 排中文
--~ 入参2
--~ 入参3
--~ 入参4
function s.全筛文(u1, u2, u3, u4)
  print(4)
  if string.find(u1, u2, u3, u4) then
    return u1
    end
  end
--~ 文
--~ 前缀
function s.加前缀(u1, u2)
  return (u2 or "") .. u1
  end
--~ 文
--~ 后缀
function s.加后缀(u1, u2)
  return u1 .. (u2 or "")
  end
--~ 令
function s.办令(u1)
  print(u1)
  os.execute(u1)
  end
--~ 文
--~ 前缀
function s.全筛前缀(u1, u2)
  if string.sub(u1, 1, #u2) == u2 then
    return u1
    end
  end
--~ 文
--~ 后缀
function s.全筛后缀(u1, u2)
  if string.sub(u1, -#u2) == u2 then
    return u1
    end
  end
--~ 目对
function s.用令行工具操文件(u1_0)
  local k1_9
  --~ 令行排
  k1_9 = s.历文(u1_0.文件目, 简文件库.dir)
  k1_9 = s.历排(k1_9, s.全筛后缀, u1_0.文件类)
  for u1 = 1, #k1_9 do
    k1_9[u1] = s.加前缀(k1_9[u1], u1_0.文件目)
    k1_9[u1] = s.加前缀(k1_9[u1], [["]])
    k1_9[u1] = s.加后缀(k1_9[u1], [["]])
    k1_9[u1] = s.加前缀(k1_9[u1], u1_0.令行前缀)
    s.办令(k1_9[u1])
    end
  end
--~ 文件路
--~ 式
function s.读文件(u1, u2)
  local h1
  local k1_3
  --~ 文件
  k1_3 = io.open(u1, u2 or "r")
  --~ 文
  h1 = k1_3:read("a")
  k1_3:flush()
  k1_3:close()
  return h1
  end
--~ 常量排
function s.加对限(u1_0)
  table.insert(u1_0, 1, "local h1_0 = {}")
  table.insert(u1_0, "return h1_0")
  return table.concat(u1_0, "\n")
  end
--~ 文
--~ 文件路
--~ 式
function s.写文件(u1, u2, u3)
  local k1_3
  --~ 文件
  k1_3 = io.open(u2, u3 or "w")
  k1_3:write(u1)
  k1_3:flush()
  k1_3:close()
  end
--~ 文
function s.删左右空白(u1)
  u1 = string.gsub(u1, "^%s+", "")
  return string.gsub(u1, "%s+$", "")
  end
--~ 对
--~ 对
function s.连两对(u1_0, u2_0)
  for u3_0, u4_0 in pairs(u2_0) do
    u1_0[u3_0] = u4_0
    end
  return u1_0
  end
--~ 键
--~ 值
function s.修对类(u1_0, u2_0)
  if tonumber(u1_0) then
    return tonumber(u1_0), u2_0
  else
    return u1_0, u2_0
    end
  end
do
  --~ 加数
  local h1 = 0
  function s.递增()
    h1 = h1 + 1
    return h1
    end
  end
--~ 左加数
--~ 右加数
function s.加法(u1, u2)
  return u1 + u2
  end
--~ 左减数
--~ 右减数
function s.减法(u1, u2)
  return u1 - u2
  end
--~ 左乘数
--~ 右乘数
function s.乘法(u1, u2)
  return u1 * u2
  end
--~ 左除数
--~ 右除数
function s.除法(u1, u2)
  return u1 / u2
  end
--~ 左数
--~ 右数
function s.位和(u1, u2)
  return bit.band(u1, u2)
  end
--~ 数
--~ 右移几位
function s.位右移(u1, u2)
  return bit.rshift(u1, u2)
  end
--~ 键
--~ 最大值
--~ 键
--~ 值
function s.筛对中最大值(u1, u2, u3, u4)
  if u2 < u4 then
    return true
    end
  end
--~ 最短键
--~ 值
--~ 键
--~ 值
function s.筛对中最短键(u1, u2, u3, u4)
  if #u1 > #u3 then
    return true
    end
  end
--~ 最短文
--~ 值
function s.筛排中最短文(u1, u2)
  if #u1 > #u2 then
    return true
    end
  end
--~ 内数
function s.to_uint64(u1)
  local uint64_pointer = ffi.new("uint64_t[1]", u1)
  return uint64_pointer[0]
  end
--~ 键
--~ 值
--~ 要找的值
function s.全等筛对中值(u1, u2, u3)
  if u2 == u3 then
    return u1, u2
  else
    end
  end
return s

local 字集库 = require("u8_to_a")
local 档库 = require("lsqlite3")
local 文库 = require(字集库.u8_to_a("算机_程语_月_基类_文"))
local 对库 = require(字集库.u8_to_a("算机_程语_月_基类_表_对"))
local s = {}
local 卡档
--~ 卡编
function s.取卡对(u1)
  local h1_0, h2_0
  --~ 卡文对
  h1_0 = s.取卡文(u1)
  --~ 卡数据对
  h2_0 = s.取卡数据(u1)
  return 对库.连两对(h1_0, h2_0)
  end
--~ 卡编
function s._取卡对(u1, u2)
  for o1_4 in 卡档:nrows(文库.连(u2, u1)) do
    return o1_4
    end
  end
do
  local h1
  --~ 模
  h1 = "select * from texts where id = "
  --~ 卡编
  function s.取卡文(u1)
    return s._取卡对(u1, h1)
    end
  end
do
  local h1
  --~ 模
  h1 = "select * from datas where id = "
  --~ 卡编
  function s.取卡数据(u1)
    return s._取卡对(u1, h1)
    end
  end
--~ 卡档路
function s.启卡档(u1)
  卡档 = 档库.open(u1)
  end
return s

local 字集库 = require("u8_to_a")
local 位算库 = require(字集库.u8_to_a("算机_程语_月_基类_数_位算"))
local s = {}
local TYPE_MONSTER = 0x1
local TYPE_SPELL = 0x2
local TYPE_TRAP = 0x4
local TYPE_EFFECT = 0x20
local TYPE_PENDULUM = 0x1000000
local 有效果卡的类排 = {
TYPE_SPELL
, TYPE_TRAP
, TYPE_EFFECT
}
local 无效果灵摆怪兽排 = {
  28363749 --火蛋白石头龙头领
  , 19474136 --曼陀林草龙
  , 17390179 --闪光之骑士
  , 83980492 --铜锣龙
  }
--~ 卡对
function s.筛有效果卡(u1_0)
  for u1 = 1, #有效果卡的类排 do
    if 位算库.位和(有效果卡的类排[u1], u1_0.type) == 0 then
    else
      return u1_0
      end
    end
  if 位算库.位和(TYPE_PENDULUM, u1_0.type) == 0 then
  else
    if 无效果灵摆怪兽排[u1_0.id] then
    else
      return u1_0
      end
    end
  end
--~ 卡对
function s.筛怪兽卡(u1_0)
  if 位算库.位和(TYPE_MONSTER, u1_0.type) == 0 then
  else
    return u1_0
    end
  end
--~ 卡对
function s.筛攻击力(u1_0)
  return u1_0.atk
  end
return s

local d_2 = {}
--~ 传参_参数数量
function d_2.二个参数(u1, u2, u3, u4)
  return u1(u2(u3), u2(u4))
  end
function d_2.三个参数(u1, u2, u3, u4, u5)
  return u1(u2(u3), u2(u4), u2(u5))
  end
function d_2.四个参数(u1, u2, u3, u4, u5, u6)
  return u1(u2(u3), u2(u4), u2(u5), u2(u6))
  end
return d_2

--~ local 历排库 = 常用库.导入库_通用大字集态_八位态("程序语言_月_基础类型_序排_逐一")
local d_4 = {}
--~ 加
function d_4.加前缀(u1, u2)
  return (u2 or "") .. u1
  end
function d_4.加后缀(u1, u2)
  return u1 .. (u2 or "")
  end
--~ 加_分_确保
--~ function d_4.加前缀_确保态(u1, u2, u3)
--~ 筛文库.返全文(u1, )
--~ local h1
--~ h1 = d_4.删前缀(u1, u2, u3)
--~ return u2 .. u1
--~ end
--~ function d_4.加前缀与后缀(u1, u2, u3)
  --~ u1 = d_4.加后缀(u1, u3)
  --~ return d_4.加前缀(u1, u2)
  --~ end
--~ function d_4.逐一加前缀(u1, u2)
  --~ return 历排库.处理后返回新排(u1, d_4.加前缀, u2)
  --~ end
--~ function d_4.逐一加前缀与后缀(u1, u2, u3)
  --~ return 历排库.处理后返回新排(u1, d_4.加前缀与后缀, u2, u3)
  --~ end
--~ function d_4.逐一在前后加上英文双引号(u1)
  --~ return 历排库.处理后返回新排(u1, d_4.在前后加英文双引号)
  --~ end
--~ 删
--~ function d_4.删前缀_基态(u1, u2)
  --~ if u1:startswith(u2) then
    --~ return u1:sub(#u2 + 1)
    --~ end
  --~ end
--~ function d_4.删后缀_基态(u1, u2)
  --~ if u1:endswith(u2) then
    --~ return u1:sub(1, #u1 - #u2)
    --~ end
  --~ end
--~ 场景_令行窗_件径
--~ function d_4.在前后加英文双引号(u1)
  --~ return d_4.加前缀与后缀(u1, [["]], [["]])
  --~ end
return d_4

local d_2 = {}
function d_2.单行注(u1)
  return u1:gsub("%-%-[^\n]*", "")
  end
return d_2

function string:lstrip()
  return self:gsub("^%s+", "")
  end
function string:rstrip()
  return self:gsub("%s+$", "")
  end
function string:strip()
  local h1
  h1 = self:lstrip()
  return h1:rstrip()
  end
function string:startswith(text)
  if self:sub(1, #text) == text then
    return self
    end
  end
function string:endswith(text)
  if self:sub(-#text) == text then
    return self
    end
  end

local d_3 = {}
--~ 加
function d_3.加始缀_基态(u1, u2)
  return u2 .. u1
  end
function d_3.加终缀_基态(u1, u2)
  return u1 .. u2
  end
--~ 加_分_确保
--~ function d_3.加前缀_确保态(u1, u2, u3)
--~ 筛文库.返全文(u1, )
--~ local h1
--~ h1 = d_3.删前缀(u1, u2, u3)
--~ return u2 .. u1
--~ end
--~ 减
function d_3.减始缀_基态(u1, u2)
  if u1:startswith(u2) then
    return u1:sub(#u2 + 1)
    end
  end
function d_3.减终缀_基态(u1, u2)
  if u1:endswith(u2) then
    return u1:sub(1, #u1 - #u2)
    end
  end
return d_3

function string:lstrip()
  return self:gsub("^%s+", "")
  end
function string:rstrip()
  return self:gsub("%s+$", "")
  end
function string:strip()
  local h1
  h1 = self:lstrip()
  return h1:rstrip()
  end
function string:startswith(text)
  local size = text:len()
  if self:sub(1, size) == text then
    return self
    end
  end
function string:endswith(text)
  if self:sub(-#text) == text then
    return self
    end
  end

local d_2 = {}
function d_2.空格与制表符(u1)
  return u1:gsub("[ \t]", "")
  end
return d_2

local d_3 = {}
--~ 加
function d_3.加前缀_基态(u1, u2)
  return u2 .. u1
  end
function d_3.加始缀_基态(u1, u2)
  return u2 .. u1
  end
function d_3.加后缀_基态(u1, u2)
  return u1 .. u2
  end
function d_3.加终缀_基态(u1, u2)
  return u1 .. u2
  end
--~ 加_分_确保
--~ function d_3.加前缀_确保态(u1, u2, u3)
--~ 筛文库.返全文(u1, )
--~ local h1
--~ h1 = d_3.删前缀(u1, u2, u3)
--~ return u2 .. u1
--~ end
function d_3.加前缀与后缀_基态(u1, u2, u3)
  return u2 .. u1 .. (u3 or "")
  end
function d_3.加始缀与终缀_基态(u1, u2, u3)
  return u2 .. u1 .. (u3 or "")
  end
--~ 删
function d_3.删前缀_基态(u1, u2)
  if u1:startswith(u2) then
    return u1:sub(#u2 + 1)
    end
  end
function d_3.减始缀_基态(u1, u2)
  if u1:startswith(u2) then
    return u1:sub(#u2 + 1)
    end
  end
function d_3.删后缀_基态(u1, u2)
  if u1:endswith(u2) then
    return u1:sub(1, #u1 - #u2)
    end
  end
function d_3.减终缀_基态(u1, u2)
  if u1:endswith(u2) then
    return u1:sub(1, #u1 - #u2)
    end
  end
--~ 场景_令行窗_件径
function d_3.在前后加英文双引号_基态(u1)
  return [["]] .. u1 .. [["]]
  end
function d_3.在始终加英文双引号_基态(u1)
  return [["]] .. u1 .. [["]]
  end
return d_3

local 字集库 = require("u8_to_a")
local 历文库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_历_基类_文_取全"))
local 文件系库 = require("lfs")
local 历排库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_历_基类_表_排_取全"))
local 后缀库 = require(字集库.u8_to_a("算机_程语_月_基类_文_后缀"))
local 前缀库 = require(字集库.u8_to_a("算机_程语_月_基类_文_前缀"))
local s = {}
--~ 目对
function s.办文件(u1_0)
  local h1_0
  --~ 令行排
  h1_0 = 历文库.历文(u1_0.文件目, 文件系库.dir)
  h1_0 = 历排库.历排(h1_0, 后缀库.全筛后缀, u1_0.文件类)
  h1_0 = 历排库.历排(h1_0, 前缀库.加前缀, u1_0.文件目)
  h1_0 = 历排库.历排(h1_0, 前缀库.加前缀, [["]])
  h1_0 = 历排库.历排(h1_0, 后缀库.加后缀, [["]])
  h1_0 = 历排库.历排(h1_0, 前缀库.加前缀, u1_0.令行前缀)
  历排库.历排(h1_0, s.办令)
  end
--~ 令
function s.办令(u1)
  print(u1)
  os.execute(u1)
  end
return s

local io = io
local s = {}
--~ 文
--~ 文件路
--~ 式
function s.写文件(u1, u2, u3)
  local h1_3
  --~ 文件
  h1_3 = io.open(u2, u3 or "w")
  h1_3:write(u1)
  h1_3:flush()
  h1_3:close()
  end
return s

local io = io
local s = {}
--~ 文件路
--~ 式
function s.读文件(u1, u2)
  local h1
  local h1_3
  --~ 文件
  h1_3 = io.open(u1, u2 or "r")
  --~ 文
  h1 = h1_3:read("a")
  h1_3:flush()
  h1_3:close()
  return h1
  end
return s

local ffi = require("ffi")
local s = {}
--~ 内数
function s.to_uint64(u1)
  local uint64_pointer = ffi.new("uint64_t[1]", u1)
  return uint64_pointer[0]
  end
return s

local 字集库 = require("u8_to_a")
local 基算库 = require(字集库.u8_to_a("算机_程语_月_基类_数_基算"))
local math = math
local string = string
local s = {}
-- 指数
--~ 左加数
--~ 右加数
function s.指数(u1, u2, u3)
  local h1
  if u3 then
    --~ 指数次
    h1 = 基算库.除法(u2, u3)
    return u1 ^ h1
  else
    return u1 ^ u2
    end
  end
-- 指数次
--~ 数
--~ 指数底
function s.指数次(u1, u2)
  local h1
  --~ 指数次
  h1 = math.log(u1) / math.log(u2)
  return h1
  end
--~ 数
function s.二底指数次(u1)
  local h1
  --~ 指数次
  _, h1 = math.frexp(u1)
  return h1
  end
-- 向大取整和向小取整
--~ 数
function s.向小取整(u1)
  return math.floor(u1)
  end
-- 几位整数和几位小数
--~ 数
--~ 几位整数
function s.几位整数(u1, u2)
  return string.format("%0" .. u2 .. "d", u1)
  end
--~ 数
--~ 几位小数
function s.几位小数(u1, u2)
  return string.format("%." .. u2 .. "f", u1)
  end
-- 正数与负数
--~ 数
function s.正数(u1)
  if u1 >= 0 then
    return u1
  else
    return -u1
    end
  end
--~ 数
function s.负数(u1)
  if u1 >= 0 then
    return -u1
  else
    return u1
    end
  end
-- 递加
do
  local h1_0
  --~ 数表
  h1_0 = {}
  function s.递加(u1)
    if h1_0[u1] then
    else
      h1_0[u1] = 0
      end
    h1_0[u1] = h1_0[u1] + 1
    return h1_0[u1]
    end
  end
-- 最值
function s.最大值()
  return math.huge
  end
function s.最小值()
  local h1
  --~ 最大值
  h1 = s.最大值()
  return s.负数(h1)
  end
--~ 数
function s.是否最值(u1)
  if u1 == s.最大值()
  or u1 == s.最小值() then
    return true
  else
    end
  end
--~ 数
function s.是否无效值(u1)
  if u1 == u1 then
  else
    return true
    end
  end
--~ 数
function s.是否错值(u1)
  local h1, h2
  --~ 是否最值
  h1 = s.是否最值(u1)
  --~ 是否无效值
  h2 = s.是否无效值(u1)
  return h1 or h2
  end
return s

local bit = bit
local s = {}
-- 和与或
--~ 左数
--~ 右数
function s.位和(u1, u2)
  return bit.band(u1, u2)
  end
-- 左移与右移
--~ 数
--~ 右移几位
function s.位右移(u1, u2)
  return bit.rshift(u1, u2)
  end
return s

local s = {}
-- 加减
--~ 左加数
--~ 右加数
function s.加法(u1, u2)
  return u1 + u2
  end
--~ 左减数
--~ 右减数
function s.减法(u1, u2)
  return u1 - u2
  end
-- 乘除
--~ 左乘数
--~ 右乘数
function s.乘法(u1, u2)
  return u1 * u2
  end
--~ 左除数
--~ 右除数
function s.除法(u1, u2)
  return u1 / u2
  end
-- 向外与向内
--~ 左加数
--~ 右加数
function s.向外加(u1, u2)
  if u1 >= 0 then
    return s.加法(u1, u2)
  else
    return s.减法(u1, u2)
    end
  end
return s

local string = string
local s = {}
function s.连(u1, u2, u3, u4, u5, u6, u7, u8, u9)
  return u1 .. (u2 or "") .. (u3 or "") .. (u4 or "") .. (u5 or "") .. (u6 or "") .. (u7 or "") .. (u8 or "") .. (u9 or "")
  end
--~ 排中文
--~ 入参2
--~ 入参3
--~ 入参4
function s.全筛文(u1, u2, u3, u4)
  --~ print(4)
  if string.find(u1, u2, u3, u4) then
    return u1
    end
  end
return s

local string = string
local s = {}
-- 加与删
--~ 文
--~ 前缀
function s.加前缀(u1, u2)
  return (u2 or "") .. u1
  end
-- 全筛
--~ 文
--~ 前缀
function s.全筛前缀(u1, u2)
  if string.sub(u1, 1, #u2) == u2 then
    return u1
    end
  end
return s

local string = string
local s = {}
-- 加与删
--~ 文
--~ 后缀
function s.加后缀(u1, u2)
  return u1 .. (u2 or "")
  end
-- 全筛
--~ 文
--~ 后缀
function s.全筛后缀(u1, u2)
  if string.sub(u1, -#u2) == u2 then
    return u1
    end
  end
return s

local s = {}
-- 启
--~ 文
--~ 历文的能
--~ 入参2
--~ 入参3
function s.历文(u1, u2, u3, u4)
  local h1_0
  --~ 集排
  h1_0 = {}
  for u5 in u2(u1, u3, u4) do
    h1_0[#h1_0 + 1] = u5
    end
  return h1_0
  end
return s

local s = {}
-- 启
--~ 对
--~ 能
function s.历对(u1_0, u1)
  local h1, h2
  for u2, u3 in pairs(u1_0) do
    --~ 键
    --~ 值
    h1, h2 = s.模(h1, h2, u2, u3, u1)
    end
  return h1, h2
  end
-- 模
--~ 键
--~ 值
--~ 对中键
--~ 对中值
--~ 能
function s.模(u1, u2, u3, u4, u5)
  if u1 == nil then
    return u3, u4
  elseif u5(u1, u2, u3, u4) then
    return u3, u4
  else
    return u1, u2
    end
  end
-- 最短
--~ 最短键
--~ 值
--~ 键
--~ 值
function s._筛最短键(u1, u2, u3, u4)
  if #u1 > #u3 then
    return true
    end
  end
--~ 对
function s.筛最短键(u1_0)
  return s.历对(u1_0, s._筛最短键)
  end
-- 最大
--~ 键
--~ 最大值
--~ 键
--~ 值
function s._筛最大值(u1, u2, u3, u4)
  if u2 < u4 then
    return true
    end
  end
--~ 对
function s.筛最大值(u1_0)
  return s.历对(u1_0, s._筛最大值)
  end
return s

local s = {}
-- 全与局
--~ 对
--~ 能
--~ 入参3
function s.历对(u1_0, u1, u2)
  local h1, h2
  local h1_0
  --~ 对
  h1_0 = {}
  for u3, u4 in pairs(u1_0) do
    --~ 键
    --~ 值
    h1, h2 = u1(u3, u4, u2)
    if h1 then
      h1_0[h1] = h2
    else
      end
    end
  return h1_0
  end
--~ 对
--~ 能
--~ 入参2
--~ 入参3
function s.历值(u1_0, u1, u2, u3)
  local h1_0
  --~ 对
  h1_0 = {}
  for u4, u5 in pairs(u1_0) do
    h1_0[u4] = u1(u5, u2, u3)
    end
  return h1_0
  end
--~ 键
--~ 值
--~ 要找的值
function s.全等筛值(u1, u2, u3)
  if u2 == u3 then
    return u1, u2
  else
    end
  end
return s

local s = {}
-- 启
--~ 排
--~ 能
function s.历排(u1_0, u1)
  local h1
  for u2 = 1, #u1_0 do
    --~ 值
    h1 = s.模(h1, u1_0[u2], u1)
    end
  return h1
  end
-- 模
--~ 值
--~ 排中值
function s.模(u1, u2, u3)
  if u1 == nil then
    return u2
  elseif u3(u1, u2) then
    return u2
  else
    return u1
    end
  end
-- 最短
--~ 最短文
--~ 值
function s._筛最短文(u1, u2)
  if #u1 > #u2 then
    return true
    end
  end
--~ 排
function s.筛最短文(u1_0)
  return s.历排(u1_0, s._筛最短文)
  end
return s

local s = {}
-- 返旧与返新与不返
-- 排数
--~ 排
--~ 办排中值的能
--~ 入参2
--~ 入参3
--~ 入参4
function s.历排(u1_0, u1, u2, u3, u4)
  local h1_0
  --~ 集排
  h1_0 = {}
  for u5 = 1, #u1_0 do
    h1_0[#h1_0 + 1] = u1(u1_0[u5], u2, u3, u4)
    end
  return h1_0
  end
--~ 排
--~ 排
--~ 办排中值的能
--~ 入参3
--~ 入参4
--~ 入参5
function s.历二排(u1_0, u2_0, u1, u2, u3, u4)
  local h1_0
  --~ 集排
  h1_0 = {}
  for u5 = 1, #u1_0 do
    h1_0[#h1_0 + 1] = u1(u1_0[u5], u2_0[u5], u2, u3, u4)
    end
  return h1_0
  end
--~ 排
--~ 排
--~ 排
--~ 办排中值的能
--~ 入参4
--~ 入参5
--~ 入参6
function s.历三排(u1_0, u2_0, u3_0, u1, u2, u3, u4)
  local h1_0
  --~ 集排
  h1_0 = {}
  for u5 = 1, #u1_0 do
    h1_0[#h1_0 + 1] = u1(u1_0[u5], u2_0[u5], u3_0[u5], u2, u3, u4)
    end
  return h1_0
  end
return s

local s = {}
-- 启
--~ 排
--~ 办排中值的能
--~ 入参2
--~ 入参3
function s.历排(u1_0, u1, u2, u3, u4)
  local h1
  --~ 和
  h1 = u1_0[1] or 0
  for u5 = 2, #u1_0 do
    h1 = u1(h1, u2(u1_0[u5], u3, u4))
    end
  return h1
  end
return s

local s = {}
-- 启
-- 启
--~ 排
--~ 办排中值的能
--~ 入参2
--~ 入参3
--~ 入参4
function s.历排(u1_0, u1, u2, u3, u4)
  local h1
  --~ 和
  h1 = 0
  for u5 = 1, #u1_0 do
    h1 = h1 + u1(u1_0[u5], u2, u3, u4)
    end
  return h1
  end
return s

local s = {}
-- 启
--~ 值
--~ 值类
--~ 办值的能
function s.操类(u1, u2, u3)
  if type(u1) == u2 then
    return u3(u1)
  else
    return u1
    end
  end
return s

local s = {}
-- 数量
--~ 入参1
function s.一参(u1)
  return u1
  end
--~ 入参1
--~ 入参2
function s.二参(u1, u2)
  return u1, u2
  end
return s

local 字集库 = require("u8_to_a")
local 返参库 = require(字集库.u8_to_a("算机_程语_月_基类_能_返参"))
local 历对库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_历_基类_表_对_取全"))
local s = {}
-- 连对
--~ 对
--~ 对
function s.连两对(u1_0, u2_0)
  local h1_0
  --~ 合对
  h1_0 = 历对库.历对(u1_0, 返参库.二参)
  for u1, u2 in pairs(u2_0) do
    h1_0[u1] = u2
    end
  return h1_0
  end
-- 对长
--~ 对
function s.对长(u1_0)
  local h1
  --~ 对长
  h1 = 0
  for _ in pairs(u1_0) do
    h1 = h1 + 1
    end
  return h1
  end
return s

local 字集库 = require("u8_to_a")
local 历排取联库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_历_基类_表_排_取联"))
local 返参库 = require(字集库.u8_to_a("算机_程语_月_基类_能_返参"))
local 基算库 = require(字集库.u8_to_a("算机_程语_月_基类_数_基算"))
local 历排库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_历_基类_表_排_取全"))
local 数库 = require(字集库.u8_to_a("算机_程语_月_基类_数"))
local s = {}
--~ 排
function s.总和(u1_0)
  return 历排取联库.历排(u1_0, 基算库.加法, 返参库.一参)
  end
--~ 排
function s.均值(u1_0)
  local h1
  --~ 总和
  h1 = s.总和(u1_0)
  return 基算库.除法(h1, #u1_0)
  end
--~ 排
--~ 标准值
function s.方差(u1_0, u1)
  local h1, h2
  local h1_0
  --~ 标准值
  h1 = u1 or s.均值(u1_0)
  --~ 排，用于算方差
  h1_0 = 历排库.历排(u1_0, 基算库.减法, h1)
  h1_0 = 历排库.历排(h1_0, 数库.指数, 2)
  --~ 方差
  h2 = 基算库.除法(s.总和(h1_0), #h1_0)
  return h2
  end
--~ 排
--~ 标准值
function s.标准差(u1_0, u1)
  local h1
  --~ 方差
  h1 = s.方差(u1_0, u1)
  return 数库.指数(h1, 1, 2)
  end
--~ 排
--~ 标准值
function s.均差(u1_0, u1)
  local h1, h2
  local h1_0
  --~ 标准值
  h1 = u1 or s.均值(u1_0)
  --~ 排，用于算均差
  h1_0 = 历排库.历排(u1_0, 基算库.减法, h1)
  h1_0 = 历排库.历排(h1_0, 数库.正数)
  --~ 均差
  h2 = 基算库.除法(s.总和(h1_0), #h1_0)
  return h2
  end
return s

local 字集库 = require("u8_to_a")
local 文库 = require(字集库.u8_to_a("算机_程语_月_基类_文"))
local string = string
local s = {}
-- 单行注与多行注
--~ 文
function s.删注(u1)
  u1 = s.删多行注(u1)
  return s.删单行注(u1)
  end
do
  local h1
  --~ 模
  h1 = 文库.连("%-%-", "%[", "(=*)", "%[", ".-", "%]", "%1", "%]")
  --~ 文
  function s.删多行注(u1)
    return string.gsub(u1, h1, "")
    end
  end
do
  local h1
  --~ 模
  h1 = 文库.连("%-%-", "[^\n]*")
  --~ 文
  function s.删单行注(u1)
    return string.gsub(u1, h1, "")
    end
  end
return s

package.path = [[.\lua_lib\?.lua;]] .. package.path
package.cpath = [[.\lua_lib\?.dll;]] .. package.cpath
local 字集库 = require("u8_to_a")
local 文件系库 = require("lfs")
local 基算库 = require(字集库.u8_to_a("算机_程语_月_基类_数_基算"))
local 前缀库 = require(字集库.u8_to_a("算机_程语_月_基类_文_前缀"))
local 文库 = require(字集库.u8_to_a("算机_程语_月_基类_文"))
local 后缀库 = require(字集库.u8_to_a("算机_程语_月_基类_文_后缀"))
local 历排库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_历_基类_表_排_取全"))
local 历对库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_历_基类_表_对_取全"))
local 历文库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_历_基类_文_取全"))
local 数库 = require(字集库.u8_to_a("算机_程语_月_基类_数"))
local 基类库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_基类"))
local 筛卡库 = require(字集库.u8_to_a("游戏王_则拟器_原版_残局_卡_全筛"))
local 卡档库 = require(字集库.u8_to_a("游戏王_则拟器_原版_卡档"))
local 排算库 = require(字集库.u8_to_a("算机_程语_月_基类_表_排_基类_数"))
local 删注库 = require(字集库.u8_to_a("算机_程语_月_注_删_不虑字串"))
local 读文件库 = require(字集库.u8_to_a("算机_基统_窗群_文件系_小文件_读"))
local 写文件库 = require(字集库.u8_to_a("算机_基统_窗群_文件系_小文件_写"))
local string = string
local os = os
local table = table
local s = {}
--~ 卡对排
function s.筛有效果卡(u1_0)
  return 历排库.历排(u1_0, 筛卡库.筛有效果卡)
  end
--~ 卡编排
function s.取卡对_一维(u1_0)
  return 历排库.历排(u1_0, 卡档库.取卡对)
  end
do
  local h1, h2, h3
  --~ 非空单行，且无换行符
  h1 = "[^\n]+"
  --~ 卡编所在函式
  h2 = "Debug%.AddCard.+"
  --~ 卡编
  h3 = "[0-9]+"
  --~ 文
  function s.局筛卡编(u1)
    local h1_0
    --~ 卡编排
    h1_0 = 历文库.历文(u1, string.gmatch, h1)
    h1_0 = 历排库.历排(h1_0, string.match, h2)
    return 历排库.历排(h1_0, string.match, h3)
    end
  end
do
  local h1, h2, h3, h4
  --~ 非空单行，且无换行符
  h1 = "[^\n]+"
  --~ 玩家讯所在函式
  h2 = "Debug%.SetPlayerInfo.+"
  --~ 玩家编号
  h3 = "[0-9]+"
  --~ 玩家血量
  h4 = "[0-9]+"
  --~ 文
  function s.局筛血(u1)
    local h1_0
    --~ 血排
    h1_0 = 历文库.历文(u1, string.gmatch, h1)
    h1_0 = 历排库.历排(h1_0, string.match, h2)
    h1_0 = 历排库.历排(h1_0, string.gsub, h3, "", 1)
    return 历排库.历排(h1_0, string.match, h4)
    end
  end
do
  local h1, h2, h3
  --~ 非空单行，且无换行符
  h1 = "[^\n]+"
  --~ 残局讯所在函式
  h2 = 文库.连("Debug", "%.", "ReloadFieldBegin", ".+")
  --~ 则数
  h3 = "[0-9]"
  --~ 文
  function s.局筛则数(u1)
    local h4
    local h1_0
    --~ 则数排
    h1_0 = 历文库.历文(u1, string.gmatch, h1)
    h1_0 = 历排库.历排(h1_0, string.match, h2)
    --~ 则数
    h4 = string.match(h1_0[1], h3)
    assert(h4, u1)
    return h4 or 5
    end
  end
--~ 卡对排
--~ 血排
function s.荐名(u1_0, u2_0)
  local h1, h2, h3
  local h1_0
  --~ 攻击力排
  h1_0 = 历排库.历排(u1_0, 筛卡库.筛怪兽卡)
  h1_0 = 历排库.历排(h1_0, 筛卡库.筛攻击力)
  --~ 总攻
  h1 = 排算库.总和(h1_0)
  --~ 总血
  h2 = 排算库.总和(u2_0)
  --~ 荐名
  h3 = 基算库.除法(h1, h2)
  h3 = 数库.指数次(h3, 2)
  if 数库.是否错值(h3) then
    return 0
  else
    h3 = 数库.几位小数(h3, 1)
    return tostring(基算库.乘法(h3, 1000))
    end
  end
--~ 文件
--~ 编号
--~ 文件路
function s.察编号(u1, u2, u3)
  local h1
  h1 = string.gsub(u1, 文库.连("Debug", "%.", "SetAIName", "[^\n]+"), 文库.连([[Debug.SetAIName("]], u2, [[")]]))
  if h1 == u1 then
  else
    写文件库.写文件(h1, u3)
    end
  end
--~ 目对
function s.残局改名(u1_0)
  local h1_0, h2_0, h3_0, h4_0, h5_0, h6_0, h7_0, h8_0, h9_0
  local h10_0, h11_0, h12_0
  --~ 文件名排
  h1_0 = 历文库.历文(u1_0.文件目, 文件系库.dir)
  h1_0 = 历排库.历排(h1_0, 后缀库.全筛后缀, ".lua")
  --~ 文件排
  h2_0 = 历排库.历排(h1_0, 后缀库.全筛后缀, ".lua")
  h2_0 = 历排库.历排(h2_0, 前缀库.加前缀, u1_0.文件目)
  h2_0 = 历排库.历排(h2_0, 读文件库.读文件)
  h2_0 = 历排库.历排(h2_0, 删注库.删注)
  --~ 则数排
  h3_0 = 历排库.历排(h2_0, s.局筛则数)
  --~ 各文件的卡编排
  h4_0 = 历排库.历排(h2_0, s.局筛卡编)
  --~ 各文件的卡对排
  h5_0 = 历排库.历排(h4_0, s.取卡对_一维)
  --~ 有效果卡的卡对排
  h6_0 = 历排库.历排(h5_0, s.筛有效果卡)
  --~ 有效果卡的张数排
  h7_0 = 历排库.历排(h6_0, table.maxn)
  --~ 血排
  h11_0 = 历排库.历排(h2_0, s.局筛血)
  --~ 荐名排
  h8_0 = 历排库.历二排(h6_0, h11_0, s.荐名)
  --~ 新名排
  h9_0 = 历排库.历排(h1_0, string.gsub, 字集库.u8_to_a(文库.连("　", ".+")), "")
  --~ 编号排
  h10_0 = 历排库.历排(h1_0, string.gsub, 字集库.u8_to_a(文库.连("　", ".+")), "")
  h9_0 = 历排库.历排(h9_0, string.gsub, 文库.连("%.", "lua", "$"), "")
  for u1 = 1, #h1_0 do
    h9_0[u1] = 文库.连(字集库.a_to_u8(u1_0.文件目), 字集库.a_to_u8(h9_0[u1]), "　", h3_0[u1], "_", 数库.几位整数(h7_0[u1], 2))
    if h8_0[u1] == 0 then
      h9_0[u1] = 文库.连(h9_0[u1], ".", "lua")
    else
      h9_0[u1] = 文库.连(h9_0[u1], "_", h8_0[u1], ".", "lua")
      end
    end
  h1_0 = 历排库.历排(h1_0, 前缀库.加前缀, u1_0.文件目)
  h9_0 = 历排库.历排(h9_0, 字集库.u8_to_a)
  历排库.历二排(h1_0, h9_0, os.rename)
  h10_0 = 历排库.历排(h10_0, 字集库.a_to_u8)
  --~ 文排
  h12_0 = 历排库.历排(h9_0, 读文件库.读文件)
  历排库.历三排(h12_0, h10_0, h9_0, s.察编号)
  end
s.目对 = {
  ["文件目"] = "../single/"
  , ["卡档路"] = [[D:\install\YGOPro\cards.cdb]]
  }
s.目对 = 历对库.历值(s.目对, 基类库.操类, "string", 字集库.u8_to_a)
卡档库.启卡档(s.目对.卡档路)
s.残局改名(s.目对)

package.path = [[.\lua_lib\?.lua;]] .. package.path
package.cpath = [[.\lua_lib\?.dll;]] .. package.cpath
local 字集库 = require("u8_to_a")
local 历对库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_历_基类_表_对_取全"))
local 基类库 = require(字集库.u8_to_a("算机_程语_月_基类_能_传能_基类"))
local 令行库 = require(字集库.u8_to_a("算机_基统_窗群_令行_无窗"))
local s = {}
s.目对 = {
  ["文件目"] = [[../single/]]
  , ["文件类"] = ".lua"
  , ["令行前缀"] = [[stylua --indent-type Spaces  --indent-width 2 --collapse-simple-statement Never ]]
  }
s.目对 = 历对库.历值(s.目对, 基类库.操类, "string", 字集库.u8_to_a)
令行库.办文件(s.目对)
return s

1_ 何谓二解
「二解」指比原残局作者所定血量高的解残局之法。
例如，原血100，而你打了200，则200之法为二解。
普况下，残局所设血量是目前最优解的解局血量。
例如，残局所设血量为100，那你就不能打出200了。
若现二解，则残局所设血量需改了。
例如，原血100，而你打了200，则应把100改为200。
一些残局作者为减「血量对玩家的压迫感」或「诱玩家解局」或求血量好看，会降残局血量。
例如，QB在多局中用「伤害瘦身」。
在这类之设下，残局会自然而然有大量二解。
例如，原血100，而你可以打150，或200，或300等。
「伤害瘦身」是把血量减半，而100减半就成50了，于是QB的加了「伤害瘦身」的局在血量上会有尾之50，但他嫌50不好看，便抹去了。
他的行是主动用次优解甚至更次解去换最优解的血量，在客观上让局与实战更相似了。
例如，原血100，但改成了50。
实战是求不全知博弈下的最优解，而残局则是求全知博弈下的最优解。
例如，实战中，我不知对方卡组中有何卡，卡按何序所排，但在残局中，我全知此况。
残局血量降后，所打血量与实战最优解相似。
实战难复制，而残局可复制。
例如，我打了一「实战」后，后面就打不出这「实战」了，我打了一「残局」后，后面仍可打出这「残局」。
残局可以复制，故残局最优解是可求的，而若残局作者把血定少了，则更优解难出。
例如，一局的最优解是1000血，而作者设了500，我若打了600，虽超出作者所设，但作者不改血，则我在600止步，于是我与作者两人皆不知该局可打1000血。
实战能让玩家十死无生，而残局即使再难，他也有解，会给玩家留九死一生之望。
持望的残局玩家，将在残局做淋漓尽致的反击。
此即「长风破浪会有时，直挂云帆济沧海」。
在这一程中，将有怪思路涌现，很有可能会出二解。
有一种残局制法是迅摆好一大堆的相关卡，然后残局作者用测局来获最优解局血量，典型的代表者例如无名，幽厉。
据无名说，有了「编残局器」后，局面很快就能摆好，但测局却需费远比摆残局多的时间。
这一法，其实指明了残局的重点应是测局，进一步说，应是二解，再本质上说，是残局解法认知的进步。
残局作者把血定多，才能倒逼玩家技强。
例如，原血100，而玩家只能打到50，经思与测后，玩家打到100。
「文章本天成，妙手偶得之」，残局作者应是因局而定血，而非错定。
残局作者并不需尽善尽美，只需做到有解即可。

1_ 可借残局来提实战之力吗
普残局与实战不同。
「历来一般的残局都是就残局而言残局，又称之为“排局”。
意指系由人们随意安排而制成的残局，并非双方临局走出来的现场局面。」
练残局，则提残局技，练实战，则提实战技。
应不把残局与实战过度挂钩。
若为定式残局，则可提实战之力。
例如，将「三眼怪」后展基式制为残局，加以练，则实战亦强。

1_ 残局有几则
残局有三则，一则是「大师3」，一则是「新大师」，一则是「大师2020」。
「大师3」的参数是3，「新大师」的参数是4，「大师2020」的参数是5。
从「新大师」时始引入「连接怪兽」，并限灵摆之力。
若残局中有卡可能涉到「连接怪兽」，则最低的则之参数将为4。
在「新大师」中，「额外卡组的怪兽」只能在「连接怪兽的箭头指向处」或者额外怪兽区出场。
「新大师」是 3 则中最严格的则，一些残局会特意将则设为新大师，以求在不增卡数的前提下提难度。
相比于「新大师」，「大师 2020 」废了「新大师」对「额外卡组怪兽」的过度之限，但仍留对灵摆的限。
注意，只有从额外卡组出场的怪兽才能进到额外怪兽区。
大师 2020 大部兼容大师 3，但不一定要用大师 2020 替大师 3。
一些大师 3 残局需用大师 3 的优质灵摆位或 5 怪兽格子的挤格子战术，故不适宜用大师 2020，因此它们应停在大师 3 。

1_ 残局的对方有几种
对方有三种。
_ 卡少
_ 卡多但呆
_ 卡多且有互动
卡多但呆，例如对方后场五张「光之护封剑」，或对方后场五张「魔法筒」。

1_ 残局难度怎样
制局者，若欲难，则可极难，若欲易，则可极易。
但我观玩局者怨，大都言难。
但局分难易，若玩局者寻易局，而解之，则易，若寻难局，而解之，则难。
我觉印卡局大都难。
事先声明，残局难度其实是主观的事，但又有各种客观的外象。
在论残局难度之前，需给残局难度锚定一个客观之标，以使论具准绳。
难有三个释义，分别是，不好，复杂，做到的可能性小。
那从可能入手，由频率逼近概率，假定每个残局是唯一解态，则应是，若残局的操作变数态越多，则残局难度越高。
残局的操作变数态按理可穷举，但现没软件可做到。
因此，这一思路卒。
但由此可看出，难度主要在可的量，在从诸可中找到那一个唯一解。
那进一步想，将残局难度与可的量相锚定真的可行吗。
假定要在十亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿亿由零正向加一的正整数中找到符开区间(1, 3)的数，会有几人说难呢。
我感只要是细细了过并还记得开区间概思的人，应说不难（不虑像「棉花」那种话与实脱钩的言）。