feh-bin 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7b1192b0d08d2e5e744017670cdf9150336f200cad3f737296eb8d4b64a2d519
+  data.tar.gz: 39922afca016513a3eb2abf02516e4f48e8ac5253757330ca262a5e86611cb22
+SHA512:
+  metadata.gz: 4a2ef24ab21d7b3ae3ddd0463ef633f71980e9eca9cdc1b7b8f66f0d0a35ff8f0f07278fe77727a736cca2ce07bf0730e42cd42d5b317964eb7b00fc9ca4dd5f
+  data.tar.gz: 1085fcd820135ebcfc7ea0b3a750fcdc3ff564d19f2f8b892d003d211b6cb21a1d607f65b11fcf5c764436a2e27cf1ff3595e48bdffed66a369472b485c4744c

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in feh-bin.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    feh-bin (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.11.3)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  feh-bin!
+  minitest (~> 5.0)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.16.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Quinton Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,21 @@
+# feh-bin
+
+Conversion routines for Fire Emblem Heroes asset files.
+
+## Example
+
+```ruby
+require 'feh-bin'
+
+Dir.glob('assets/Common/SRPGMap/*.bin.lz').each do |fname|
+  IO.binwrite(fname.sub(/.lz$/, ''), Feh::Bin.decompress(IO.binread(fname)).pack('c*'))
+end
+```
+
+## Testing
+
+A fuzz test is available at `fuzz/fuzz_feh_bin.rb` that tests the compression-decompression round trip using [FuzzBert](https://rubygems.org/gems/fuzzbert).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new(:test) do |t|
+  t.description = 'Run unit tests'
+  t.libs << 'lib'
+  t.test_files = FileList['spec/**/*_spec.rb']
+end

data/bin/feh_bin_lz

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'feh/bin'
+
+DESC = "Fire Emblem Heroes assets converter
+Usage: #{File.basename(__FILE__)} <files>...
+
+Files ending in .bin.lz are converted to .bin; all other files are converted
+into .bin.lz."
+
+abort DESC if ARGV.empty? || ARGV.include?('-?') || ARGV.include?('--help')
+
+ARGV.each do |fname|
+  begin
+    buf = IO.binread(fname)
+    if fname.end_with?('.bin.lz')
+      outname = File.expand_path(
+        File.basename(fname).sub(/\.lz$/, ''), File.dirname(fname))
+      puts "Decompressing #{fname} -> #{outname}..."
+      res = Feh::Bin.decompress(buf)
+      raise RuntimeError, res.to_s if res.is_a?(Symbol)
+      IO.binwrite(outname, res.pack('c*'))
+    else
+      outname = File.expand_path(
+        File.basename(fname, '.*') + '.bin.lz', File.dirname(fname))
+      puts "Compressing #{fname} -> #{outname}..."
+      res = Feh::Bin.compress(buf)
+      raise RuntimeError, res.to_s if res.is_a?(Symbol)
+      IO.binwrite(outname, res.pack('c*'))
+    end
+  rescue RuntimeError => e
+    STDERR.puts "Error! (#{e})"
+  rescue Errno::ENOENT
+    STDERR.puts "#{fname} not found!"
+  end
+end

data/feh-bin.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "feh/bin/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "feh-bin"
+  spec.version       = Feh::Bin::VERSION
+  spec.authors       = ["Quinton Miller"]
+  spec.email         = ["nicetas.c@gmail.com"]
+
+  spec.summary       = "Conversion routines for Fire Emblem Heroes asset files"
+  spec.description   = "Functions to compress and decompress binary asset files from Fire Emblem Heroes"
+  spec.homepage      = "https://github.com/HertzDevil/feh-bin"
+  spec.license       = "MIT"
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extra_rdoc_files = ['README.md']
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/lib/feh/bin.rb

@@ -0,0 +1,76 @@
+require 'feh/bin/version'
+
+require 'feh/bin/lz11'
+
+module Feh
+  module Bin
+    # Decompresses a .bin.lz file.
+    # @param buf [Array<Integer>, String] content of the .bin.lz file
+    # @return [Array<Integer>] content of the decompressed asset data
+    # @return [Symbol] error code if the input is not a valid .bin.lz file
+    def self.decompress(buf)
+      buf = buf.bytes if buf.is_a?(String)
+      read_bin_lz(buf)
+#      buf = read_bin_lz(buf)
+#      return buf if buf.is_a?(Symbol)
+#      LZ11.new(buf).decompress
+    end
+
+    # Compresses data into a .bin.lz file.
+    # @param buf [Array<Integer>, String] content of the data to compress
+    # @return [Array<Integer>] content of the .bin.lz file
+    # @return [Symbol] error code if the input is not a valid data buffer
+    def self.compress(buf)
+      buf = buf.bytes if buf.is_a?(String)
+      buf = LZ11.new(buf).compress
+      return buf if buf.is_a?(Symbol)
+      write_bin_lz(buf)
+    end
+
+    # Unpacks a Fire Emblem Heroes .bin.lz file.
+    # @param buf [Array<Integer>, String] content of the .bin.lz file
+    # @return [Array<Integer>] content of the unpacked LZ11 archive
+    # @return [Symbol] error code if the input is not a valid .bin.lz file
+    def self.read_bin_lz(buf)
+      buf = buf.bytes if buf.is_a?(String)
+      header = buf.shift(4)
+      xorseed = header[1] | (header[2] << 8) | (header[3] << 16)
+      if (header.first & 0xFF) == 0x17 && (buf.first & 0xFF) == 0x11
+        xorkey = [0x8083 * xorseed].pack('<I').bytes
+        (4...buf.size).step(4).each do |i|
+          4.times {|j| buf[i + j] ^= xorkey[j]}
+          4.times {|j| xorkey[j] ^= buf[i + j]}
+        end
+        LZ11.new(buf).decompress
+      elsif header.first == 0x04 && xorseed == buf.size
+        xorkey = [0x8083 * xorseed].pack('<I').bytes
+        (0...buf.size).step(4).each do |i|
+          4.times {|j| buf[i + j] ^= xorkey[j]}
+          4.times {|j| xorkey[j] ^= buf[i + j]}
+        end
+        buf
+      else
+        :invalid_archive
+      end
+    end
+
+    # Packs a Fire Emblem Heroes .bin.lz file.
+    # @param buf [Array<Integer>, String] content of an LZ11 archive
+    # @return [Array<Integer>] content of the packed .bin.lz file
+    # @return [Symbol] error code if the input is not a valid LZ11 archive
+    def self.write_bin_lz(buf)
+      buf = buf.bytes if buf.is_a?(String)
+      bytes = LZ11.new(buf).compress
+      return bytes if bytes.is_a?(Symbol)
+      bytes += [0] * ((-bytes.size) % 4)
+      xorseed = buf.size
+      header = [xorseed * 0x100 + 0x17].pack('<I').bytes
+      xorkey = [0x8083 * xorseed].pack('<I').bytes
+      4.times {|j| bytes[4 + j] ^= xorkey[j]}
+      (8...bytes.size).step(4).each do |i|
+        4.times {|j| bytes[i + j] ^= bytes[i - 4 + j]}
+      end
+      header + bytes
+    end
+  end
+end

data/lib/feh/bin/array_istream.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require 'forwardable'
+
+module Feh module Bin
+  # Single-pass input array stream that reads little-endian integers.
+  class ArrayIStream
+    extend Forwardable
+
+    # @!attribute [r] size
+    #   @return [Integer] the size of the underlying array stream
+    def_delegators :@buf, :[], :size
+
+    # @return [Integer] the number of bytes read so far
+    attr_reader :bytes_read
+
+    # Initializes the stream.
+    # @param buffer [Array<Integer>] an array of byte values between 0 and 255
+    # @raise [ArgumentError] if *arr* is not a byte array
+    def initialize(buffer)
+      raise ArgumentError, 'Input is not a byte array' unless
+        buffer.is_a?(Array) &&
+        buffer.all? {|x| x.is_a?(Integer) && x.between?(0, 255)}
+      @buf = buffer
+      @bytes_read = 0
+    end
+
+    # Attempts to read an unsigned 8-bit integer.
+    # @return [Integer] the integer read
+    # @return [nil] if not enough bytes remaining are present to form an integer
+    def u8
+      return nil if @bytes_read > @buf.size - 1
+      x = @buf[@bytes_read]
+      @bytes_read += 1
+      x
+    end
+
+    # Attempts to read an unsigned 16-bit integer.
+    # @return [Integer] the integer read
+    # @return [nil] if not enough bytes remaining are present to form an integer
+    def u16
+      return nil if @bytes_read > @buf.size - 2
+      x = @buf[@bytes_read]
+      x |= @buf[@bytes_read + 1] << 8
+      @bytes_read += 2
+      x
+    end
+
+    # Attempts to read an unsigned 32-bit integer.
+    # @return [Integer] the integer read
+    # @return [nil] if not enough bytes remaining are present to form an integer
+    def u32
+      return nil if @bytes_read > @buf.size - 4
+      x = @buf[@bytes_read]
+      x |= @buf[@bytes_read + 1] << 8
+      x |= @buf[@bytes_read + 2] << 16
+      x |= @buf[@bytes_read + 3] << 24
+      @bytes_read += 4
+      x
+    end
+
+    # Returns the unread bytes of the stream.
+    # @return [Array<Integer>] An array of unread bytes.
+    def remaining
+      @buf[@bytes_read..-1]
+    end
+  end
+end end

data/lib/feh/bin/array_ostream.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'forwardable'
+
+module Feh module Bin
+  # Single-pass output array stream that writes little-endian integers.
+  class ArrayOStream
+
+    # @return [Array<Integer>] the stream content
+    def buf
+      @buf.dup
+    end
+
+    # @return [Integer] the number of bytes written so far
+    def bytes_written
+      @buf.size
+    end
+
+    # Initializes the stream.
+    def initialize
+      @buf = []
+    end
+
+    # Writes an unsigned 8-bit integer.
+    # @param x [Integer] integer value to write
+    # @return [ArrayOStream] self
+    def u8(x)
+      write [x & 0xFF]
+    end
+
+    # Writes an unsigned 16-bit integer.
+    # @param x [Integer] integer value to write
+    # @return [ArrayOStream] self
+    def u16(x)
+      write [x & 0xFF, (x >> 8) & 0xFF]
+    end
+
+    # Writes an unsigned 32-bit integer.
+    # @param x [Integer] integer value to write
+    # @return [ArrayOStream] self
+    def u32(x)
+      write [x & 0xFF, (x >> 8) & 0xFF, (x >> 16) & 0xFF, (x >> 24) & 0xFF]
+    end
+
+    # Writes an array of bytes.
+    # @param arr [Array<Integer>] an array of byte values
+    # @return [ArrayOStream] self
+    # @raise [ArgumentError] if *arr* is not a byte array
+    def write(arr)
+      raise ArgumentError, 'Input is not a byte array' unless
+        arr.is_a?(Array) &&
+        arr.all? {|x| x.is_a?(Integer) && x.between?(0, 255)}
+      write2(arr)
+    end
+
+  private
+    def write2(arr)
+      @buf += arr
+      self
+    end
+  end
+end end

data/lib/feh/bin/lz11.rb

@@ -0,0 +1,229 @@
+#!/usr/bin/env ruby
+
+require 'forwardable'
+require 'feh/bin/array_istream'
+require 'feh/bin/array_ostream'
+
+module Feh module Bin
+  # Converter for the LZ11 archive format used in Fire Emblem Heroes.
+  # Ported from DSDecmp.
+  class LZ11
+    # @return [ArrayIStream] the input buffer of the converter.
+    attr_reader :buf
+
+    # Initializes the LZ11 converter.
+    # @param buffer [Array<Integer>] byte array containing the data to convert
+    def initialize(buffer)
+      @buf = ArrayIStream.new(buffer)
+    end
+
+    # Decompresses an LZ11 archive.
+    # @return [Array<Integer>] byte array representing the decompressed content
+    #   of the input archive
+    # @return [Symbol] error code if the input is not a valid LZ11 archive
+    def decompress
+      header = buf.u32
+      return :invalid_data if (header & 0xFF) != 0x11
+      decompressedSize = header >> 8
+      decompressedSize = buf.u32 if decompressedSize == 0
+
+      bufferLength = 0x1000
+      buffer = Array.new(bufferLength)
+      bufferOffset = 0
+
+      flags = 0
+      mask = 1
+
+      outbuf = []
+      until outbuf.size >= decompressedSize
+        if mask == 1
+          flags = buf.u8
+          return :stream_too_short if flags.nil?
+          mask = 0x80
+        else
+          mask >>= 1
+        end
+
+        if (flags & mask) > 0
+          byte1 = buf.u8
+          return :stream_too_short if byte1.nil?
+
+          length = byte1 >> 4
+          disp = -1
+          case length
+          when 0
+            byte2 = buf.u8
+            byte3 = buf.u8
+            return :stream_too_short if byte3.nil?
+            length = (((byte1 & 0x0F) << 4) | (byte2 >> 4)) + 0x11
+            disp = (((byte2 & 0x0F) << 8) | byte3) + 0x1
+          when 1
+            byte2 = buf.u8
+            byte3 = buf.u8
+            byte4 = buf.u8
+            return :stream_too_short if byte4.nil?
+            length = (((byte1 & 0x0F) << 12) | (byte2 << 4) | (byte3 >> 4)) + 0x111
+            disp = (((byte3 & 0x0F) << 8) | byte4) + 0x1
+          else
+            byte2 = buf.u8
+            return :stream_too_short if byte2.nil?
+            length = ((byte1 & 0xF0) >> 4) + 0x1
+            disp = (((byte1 & 0x0F) << 8) | byte2) + 0x1
+          end
+
+          return :invalid_data if disp > outbuf.size
+
+          bufIdx = bufferOffset + bufferLength - disp
+          length.times do
+            next_byte = buffer[bufIdx % bufferLength]
+            bufIdx += 1
+            outbuf << next_byte
+            buffer[bufferOffset] = next_byte
+            bufferOffset = (bufferOffset + 1) % bufferLength
+          end
+        else
+          next_byte = buf.u8
+          return :stream_too_short if next_byte.nil?
+          outbuf << next_byte
+          buffer[bufferOffset] = next_byte
+          bufferOffset = (bufferOffset + 1) % bufferLength
+        end
+      end
+
+      outbuf
+    end
+
+    # Compresses a byte buffer.
+    # This function is not required to produce exactly the same results as
+    # existing archives in Fire Emblem Heroes when given the same inputs.
+    # @return [Array<Integer>] byte array representing the compressed LZ11
+    #   archive
+    # @return [Symbol] error code if the input is too large or empty
+    def compress
+      return :input_too_short if buf.size < 2
+      return :input_too_large if buf.size > 0xFFFFFF
+
+      outstream = ArrayOStream.new
+        .u8(0x11).u16(buf.size).u8(buf.size >> 16)
+
+      outbuffer = [8 * 4 + 1] * 33
+      outbuffer[0] = 0
+      bufferlength = 1
+      bufferedBlocks = 0
+      readBytes = 0
+      while readBytes < buf.size
+        if bufferedBlocks == 8
+          outstream.write(outbuffer[0, bufferlength])
+          outbuffer[0] = 0
+          bufferlength = 1
+          bufferedBlocks = 0
+        end
+
+        oldLength = [readBytes, 0x1000].min
+        disp, length = occurrence_length(readBytes,
+          [buf.size - readBytes, 0x10110].min, readBytes - oldLength, oldLength)
+        if length < 3
+          outbuffer[bufferlength] = buf[readBytes]
+          readBytes += 1
+          bufferlength += 1
+        else
+          readBytes += length
+          outbuffer[0] |= (1 << (7 - bufferedBlocks)) & 0xFF
+          case
+          when length > 0x110
+            outbuffer[bufferlength] = 0x10
+            outbuffer[bufferlength] |= ((length - 0x111) >> 12) & 0x0F
+            bufferlength += 1
+            outbuffer[bufferlength] = ((length - 0x111) >> 4) & 0xFF
+            bufferlength += 1
+            outbuffer[bufferlength] = ((length - 0x111) << 4) & 0xF0
+          when length > 0x10
+            outbuffer[bufferlength] = 0x00
+            outbuffer[bufferlength] |= ((length - 0x111) >> 4) & 0x0F
+            bufferlength += 1
+            outbuffer[bufferlength] = ((length - 0x111) << 4) & 0xF0
+          else
+            outbuffer[bufferlength] = ((length - 1) << 4) & 0xF0
+          end
+          outbuffer[bufferlength] |= ((disp - 1) >> 8) & 0x0F
+          bufferlength += 1
+          outbuffer[bufferlength] = (disp - 1) & 0xFF
+          bufferlength += 1
+        end
+
+        bufferedBlocks += 1
+      end
+
+      if bufferedBlocks > 0
+        outstream.write(outbuffer[0, bufferlength])
+      end
+
+      outstream.buf
+    end
+
+  private
+    def occurrence_length(newPtr, newLength, oldPtr, oldLength, minDisp = 1)
+      disp = 0
+      return [disp, 0] if newLength == 0
+      oldRange = buf[oldPtr, newLength + oldLength - minDisp - 1]
+      newArray = buf[newPtr, newLength]
+
+      j = 0
+      k = 0
+      t = [-1]
+      pos = 1
+      cnd = 0
+      while pos < newArray.size
+        if newArray[pos] == newArray[cnd]
+          t[pos] = t[cnd]
+          pos += 1
+          cnd += 1
+        else
+          t[pos] = cnd
+          cnd = t[cnd]
+          while cnd >= 0 && newArray[pos] != newArray[cnd]
+            cnd = t[cnd]
+          end
+          pos += 1
+          cnd += 1
+        end
+      end
+      t[pos] = cnd
+
+      maxLength = 0
+      while j < oldRange.size && j - k < oldLength - minDisp
+        if newArray[k] == oldRange[j]
+          j += 1
+          k += 1
+          if k > maxLength
+            maxLength = k
+            disp = oldLength - (j - k)
+            break if maxLength == newLength
+          end
+        else
+          k = t[k]
+          if k < 0
+            j += 1
+            k += 1
+          end
+        end
+      end
+
+#      currentLengths = Array.new(oldLength - minDisp) do |i|
+#        oldArray = oldRange[i, newLength]
+#        p [oldArray, newArray]
+#        oldArray.zip(newArray).take_while {|x, y| x == y}.size
+#      end
+#      maxLength = 0
+#      currentLengths.each_with_index do |currentLength, i|
+#        if currentLength > maxLength
+#          maxLength = currentLength
+#          disp = oldLength - i
+#          break if maxLength == newLength
+#        end
+#      end
+
+      [disp, maxLength]
+    end
+  end
+end end

data/lib/feh/bin/version.rb

@@ -0,0 +1,6 @@
+module Feh
+  module Bin
+    # Version number.
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: feh-bin
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Quinton Miller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Functions to compress and decompress binary asset files from Fire Emblem
+  Heroes
+email:
+- nicetas.c@gmail.com
+executables:
+- feh_bin_lz
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/feh_bin_lz
+- feh-bin.gemspec
+- lib/feh/bin.rb
+- lib/feh/bin/array_istream.rb
+- lib/feh/bin/array_ostream.rb
+- lib/feh/bin/lz11.rb
+- lib/feh/bin/version.rb
+homepage: https://github.com/HertzDevil/feh-bin
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Conversion routines for Fire Emblem Heroes asset files
+test_files: []