Initial commit

.gitattributes

@@ -0,0 +1,63 @@
+###############################################################################
+# Set default behavior to automatically normalize line endings.
+###############################################################################
+* text=auto
+
+###############################################################################
+# Set default behavior for command prompt diff.
+#
+# This is need for earlier builds of msysgit that does not have it on by
+# default for csharp files.
+# Note: This is only used by command line
+###############################################################################
+#*.cs     diff=csharp
+
+###############################################################################
+# Set the merge driver for project and solution files
+#
+# Merging from the command prompt will add diff markers to the files if there
+# are conflicts (Merging from VS is not affected by the settings below, in VS
+# the diff markers are never inserted). Diff markers may cause the following 
+# file extensions to fail to load in VS. An alternative would be to treat
+# these files as binary and thus will always conflict and require user
+# intervention with every merge. To do so, just uncomment the entries below
+###############################################################################
+#*.sln       merge=binary
+#*.csproj    merge=binary
+#*.vbproj    merge=binary
+#*.vcxproj   merge=binary
+#*.vcproj    merge=binary
+#*.dbproj    merge=binary
+#*.fsproj    merge=binary
+#*.lsproj    merge=binary
+#*.wixproj   merge=binary
+#*.modelproj merge=binary
+#*.sqlproj   merge=binary
+#*.wwaproj   merge=binary
+
+###############################################################################
+# behavior for image files
+#
+# image files are treated as binary by default.
+###############################################################################
+#*.jpg   binary
+#*.png   binary
+#*.gif   binary
+
+###############################################################################
+# diff behavior for common document formats
+# 
+# Convert binary document formats to text before diffing them. This feature
+# is only available from the command line. Turn it on by uncommenting the 
+# entries below.
+###############################################################################
+#*.doc   diff=astextplain
+#*.DOC   diff=astextplain
+#*.docx  diff=astextplain
+#*.DOCX  diff=astextplain
+#*.dot   diff=astextplain
+#*.DOT   diff=astextplain
+#*.pdf   diff=astextplain
+#*.PDF   diff=astextplain
+#*.rtf   diff=astextplain
+#*.RTF   diff=astextplain

.gitignore

@@ -0,0 +1,245 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+[Xx]64/
+[Xx]86/
+[Bb]uild/
+bld/
+[Bb]in/
+[Oo]bj/
+
+# Visual Studio 2015 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# DNX
+project.lock.json
+artifacts/
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+
+# TODO: Un-comment the next line if you do not want to checkin 
+# your web deploy settings because they may include unencrypted
+# passwords
+#*.pubxml
+*.publishproj
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/packages/repositories.config
+# NuGet v3's project.json files produces more ignoreable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Microsoft Azure ApplicationInsights config file
+ApplicationInsights.config
+
+# Windows Store app package directory
+AppPackages/
+BundleArtifacts/
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+[Ss]tyle[Cc]op.*
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.pfx
+*.publishsettings
+node_modules/
+orleans.codegen.cs
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# LightSwitch generated files
+GeneratedArtifacts/
+ModelManifest.xml
+
+# Paket dependency manager
+.paket/paket.exe
+
+# FAKE - F# Make
+.fake/

Hack.Xenosaga.sln

@@ -0,0 +1,22 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.40629.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Hack.Xenosaga", "Hack.Xenosaga\Hack.Xenosaga.csproj", "{3FE1E3A5-A55A-4D1A-ACDD-85A9EE5B9D5B}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{3FE1E3A5-A55A-4D1A-ACDD-85A9EE5B9D5B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3FE1E3A5-A55A-4D1A-ACDD-85A9EE5B9D5B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3FE1E3A5-A55A-4D1A-ACDD-85A9EE5B9D5B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3FE1E3A5-A55A-4D1A-ACDD-85A9EE5B9D5B}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Hack.Xenosaga/Common/Functions.cs

@@ -0,0 +1,55 @@
+using System;
+using System.IO;
+
+namespace Hack.Xenosaga.Common
+{
+    public class Functions
+    {
+        public static void usage()
+        {
+            Console.WriteLine("xenosaga <option> <file> [regroup]");
+            Console.WriteLine("  option   : -l = List files from index");
+            Console.WriteLine("             -u = Unpack files from index");
+            Console.WriteLine("             -p = Pack files from index");
+            Console.WriteLine("  file    : Index file (the first one of each decade : xenosaga.00, xenosaga.10, xenosaga.20...)");
+            Console.WriteLine("  regroup : true to regroup all files in only one (ex: 11, 12, 13 in 11) ; false or empty (default) to keep the same system of increment files");
+        }
+
+        public static bool checkArgs(string[] args, out Variables.stArgs listArgs)
+        {
+            listArgs = new Variables.stArgs();
+
+            if (args.Length != 2 && args.Length != 3)
+            {
+                Console.WriteLine("Incorrect number of parameter!");
+                return false;
+            }
+
+            if (args[0] != "-l" && args[0] != "-p" && args[0] != "-u")
+            {
+                Console.WriteLine("Incorrect parameter 1!");
+                return false;
+            }
+
+            if (!File.Exists(args[1]))
+            {
+                Console.WriteLine("Incorrect parameter 2 : unknown file");
+                return false;
+            }
+
+            if (args.Length == 3 && (args[2] != "true" && args[2] != "false"))
+            {
+                Console.WriteLine("Incorrect parameter 3!");
+                return false;
+            }
+
+            listArgs.option = args[0];
+            listArgs.filename = args[1];
+            if (args.Length == 3)
+                listArgs.regroup = args[2] == "true" ? true : false;
+
+            return true;
+        }
+
+    }
+}

Hack.Xenosaga/Common/PathElement.cs

@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+
+namespace Hack.Xenosaga.Common
+{
+    public class listPathElement
+    {
+        private pathElement p_root;
+        private List<pathElement> p_index;
+        private Dictionary<string, pathElement> p_mappedIndex;
+
+        public listPathElement()
+        {
+            p_root = new pathElement(true) { Name = "" };
+            p_index = new List<pathElement>();
+            p_mappedIndex = new Dictionary<string, pathElement>();
+
+            addToIndex(p_root);
+        }
+
+        public void addToIndex(pathElement entry)
+        {
+            if (p_mappedIndex.ContainsKey(entry.FullPath))
+                throw new Exception(String.Format("Entry {0} already exists", entry.FullPath));
+
+            p_mappedIndex.Add(entry.FullPath, entry);
+            p_index.Add(entry);
+        }
+
+        public IEnumerable<pathElement> getEntries()
+        {
+            foreach (pathElement entry in p_index)
+                yield return entry;
+        }
+
+        public pathElement Root
+        {
+            get { return p_root; }
+            set { p_root = value; }
+        }
+
+        private static int CompareElementBySector(pathElement A, pathElement B)
+        {
+            if (A.Sector == B.Sector)
+                return 0;
+            else if (A.Sector > B.Sector)
+                return 1;
+            else if (A.Sector < B.Sector)
+                return -1;
+            else
+                return 0;
+        }
+
+        private static int CompareElementById(pathElement A, pathElement B)
+        {
+            if (A.Id == B.Id)
+                return 0;
+            else if (A.Id > B.Id)
+                return 1;
+            else if (A.Id < B.Id)
+                return -1;
+            else
+                return 0;
+        }
+
+        public void SortBySector()
+        {
+            p_index.Sort(CompareElementBySector);
+        }
+
+        public void SortById()
+        {
+            p_index.Sort(CompareElementById);
+        }
+    }
+
+    public class pathElement
+    {
+        private int p_id;
+        private bool p_isDirectory;
+        private bool p_isCompressed;
+        private string p_name;
+        private UInt32 p_position;
+        private UInt32 p_sector;
+        private UInt32 p_sizeIn;
+        private UInt32 p_sizeOut;
+        private string p_fullPath;
+        private int p_level;
+        private pathElement p_parent;
+        private List<pathElement> p_entries;
+
+        public pathElement(bool isDirectory)
+        {
+            p_parent = null;
+            p_isDirectory = isDirectory;
+
+            if (isDirectory)
+                p_entries = new List<pathElement>();
+        }
+
+        public IEnumerable<pathElement> getEntries()
+        {
+            foreach (pathElement entry in p_entries)
+                yield return entry;
+        }
+
+        public void addEntry(pathElement entry)
+        {
+            entry.Parent = this;
+            p_entries.Add(entry);
+        }
+
+        private void computeFullPath()
+        {
+            p_fullPath = p_isDirectory ? p_name + "/" : p_name;
+            pathElement parent = p_parent;
+            while (parent != null)
+            {
+                p_fullPath = parent.Name + "/" + p_fullPath;
+                parent = parent.Parent;
+            }
+        }
+
+        public int Id
+        {
+            get { return p_id; }
+            set { p_id = value; }
+        }
+
+        public int Level
+        {
+            get { return p_level; }
+            set { p_level = value; }
+        }
+
+        public string Name
+        {
+            get { return p_name; }
+            set { p_name = value; }
+        }
+
+        public UInt32 Position
+        {
+            get { return p_position; }
+            set { p_position = value; }
+        }
+
+        public UInt32 Sector
+        {
+            get { return p_sector; }
+            set { p_sector = value; }
+        }
+
+        public UInt32 SizeIn
+        {
+            get { return p_sizeIn; }
+            set { p_sizeIn = value; }
+        }
+
+        public UInt32 SizeOut
+        {
+            get { return p_sizeOut; }
+            set { p_sizeOut = value; }
+        }
+
+        public pathElement Parent
+        {
+            get { return p_parent; }
+            private set { p_parent = value; }
+        }
+
+        public bool IsDirectory
+        {
+            get { return p_isDirectory; }
+            private set { p_isDirectory = value; }
+        }
+
+        public bool IsCompressed
+        {
+            get { return p_isCompressed; }
+            set { p_isCompressed = value; }
+        }
+
+        public string FullPath
+        {
+            get
+            {
+                if (p_fullPath == null)
+                    computeFullPath();
+
+                return p_fullPath;
+            }
+        }
+
+    }
+
+}

Hack.Xenosaga/Common/Variables.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Hack.Xenosaga.Common
+{
+    public class Variables
+    {
+        public struct stArgs
+        {
+            public string option;
+            public string filename;
+            public bool regroup;
+        }
+
+        public const string dirUnpack = "01-UNPACK/";
+        public const string dirExtract = "02-EXTRACT/";
+        public const string dirInsert = "03-INSERT/";
+        public const string dirPack = "04-PACK/";
+    }
+}

Hack.Xenosaga/Hack.Xenosaga.csproj

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{3FE1E3A5-A55A-4D1A-ACDD-85A9EE5B9D5B}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Hack.Xenosaga</RootNamespace>
+    <AssemblyName>Xenosaga</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\Build\bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+    <BaseIntermediateOutputPath>..\Build\obj</BaseIntermediateOutputPath>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\Build\bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <BaseIntermediateOutputPath>..\Build\obj</BaseIntermediateOutputPath>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject>Hack.Xenosaga.Xenosaga</StartupObject>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Common\Functions.cs" />
+    <Compile Include="Common\PathElement.cs" />
+    <Compile Include="Common\Variables.cs" />
+    <Compile Include="Process\Unpack.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Xenosaga.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

Hack.Xenosaga/Process/Unpack.cs

@@ -0,0 +1,476 @@
+using System;
+using System.IO;
+using System.Diagnostics;
+using System.Text;
+using Hack.Xenosaga.Common;
+
+namespace Hack.Xenosaga.Process
+{
+    class Unpack
+    {
+        private static BinaryWriter _bw;
+        private const string _listExtension = ".lst";
+        private const string _copyright = "Hacked by BahaBulle (c)2016\0";
+        private const int _sectorSize = 0x800;
+        private const int _maxSizeFile = 0x40000000;
+        
+        private struct element
+        {
+            public bool isDirectory;
+            public bool isCompressed;
+            public byte level;
+            public string name;
+            public UInt32 sector;
+            public UInt32 position;
+            public UInt32 sizeIn;
+            public UInt32 sizeOut;
+        }
+
+
+        #region Private methods
+
+        private static int getIdFile(UInt32 position, int indexSize)
+        {
+            double d = (position - indexSize) / _maxSizeFile;
+
+            return (int)Math.Floor(d) + 1;
+        }
+
+        private static bool readElement(BinaryReader br, ref element e)
+        {
+            byte size = br.ReadByte();
+            if (size == 0)
+                return false;
+
+            if ((size & 0x80) != 0)
+            {
+                size -= 2;
+                e.isDirectory = true;
+                e.level = br.ReadByte();
+                e.name = Encoding.ASCII.GetString(br.ReadBytes(size & 0x7F));
+            }
+            else
+            {
+                size--;
+                e.isDirectory = false;
+                e.level = 0;
+                e.name = Encoding.ASCII.GetString(br.ReadBytes(size & 0x3F));
+                e.sector = br.ReadUInt16() + (uint)br.ReadByte() * 0x10000;
+                e.position = e.sector * _sectorSize;
+                e.sizeIn = br.ReadUInt32();
+                if ((size & 0x40) != 0)
+                {
+                    e.sizeOut = br.ReadUInt16() + (uint)br.ReadByte() * 0x10000;
+                    e.isCompressed = true;
+                }
+                else
+                {
+                    e.sizeOut = e.sizeIn;
+                    e.isCompressed = false;
+                }
+            }
+
+            return true;
+        }
+
+        private static byte readIndex(string asIndexName, listPathElement path)
+        {
+            byte bIndexNbSector = 0;
+            int num = 0;
+            int level;
+
+            using (BinaryReader brIndex = new BinaryReader(File.Open(asIndexName, FileMode.Open)))
+            {
+                pathElement current = new pathElement(true);
+
+                bIndexNbSector = brIndex.ReadByte();
+
+                element e = new element();
+                while (readElement(brIndex, ref e))
+                {
+                    level = e.level;
+
+                    while (e.level-- > 0)
+                        current = current.Parent;
+
+                    pathElement entry = new pathElement(e.isDirectory) { Name = e.name, Position = e.position, Sector = e.sector, SizeIn = e.sizeIn, SizeOut = e.sizeOut, Id = num++, Level = level, IsCompressed = e.isCompressed };
+                    current.addEntry(entry);
+                    path.addToIndex(entry);
+
+                    if (e.isDirectory)
+                        current = entry;
+                }
+            }
+
+            return bIndexNbSector;
+        }
+
+        private static void writeIndex(string as_file, byte ai_nbSector, listPathElement index)
+        {
+            index.SortById();
+
+            using (BinaryWriter bwIndex = new BinaryWriter(File.Open(Variables.dirPack + as_file, FileMode.Create)))
+            {
+                bwIndex.Write(ai_nbSector);
+
+                foreach (pathElement entryPath in index.getEntries())
+                {
+                    if (entryPath.Name != "")
+                    {
+                        if (entryPath.IsDirectory)
+                        {
+                            bwIndex.Write((byte)(entryPath.Name.Length + 0x82));
+                            bwIndex.Write((byte)entryPath.Level);
+                            bwIndex.Write(entryPath.Name.ToCharArray());
+                        }
+                        else
+                        {
+                            if (entryPath.IsCompressed)
+                                bwIndex.Write((byte)(entryPath.Name.Length + 0x41));
+                            else
+                                bwIndex.Write((byte)(entryPath.Name.Length + 1));
+
+                            bwIndex.Write(entryPath.Name.ToCharArray());
+                            bwIndex.Write((UInt16)entryPath.Sector);
+                            bwIndex.Write((byte)(entryPath.Sector / 0x10000));
+                            bwIndex.Write((UInt32)entryPath.SizeIn);
+
+                            if (entryPath.IsCompressed)
+                            {
+                                bwIndex.Write((UInt16)entryPath.SizeOut);
+                                bwIndex.Write((byte)(entryPath.SizeOut / 0x10000));
+                            }
+                        }
+                    }
+                }
+
+                bwIndex.Write((byte)0);
+
+                int size = (int)bwIndex.BaseStream.Length;
+                padding(bwIndex, ref size);
+            }
+        }
+
+        private static void padding(BinaryWriter a_bw, ref int size)
+        {
+            char[] hack = _copyright.ToCharArray();
+
+            int id = 0;
+            while (size % _sectorSize != 0)
+            {
+                a_bw.Write(hack[id++]);
+                size++;
+
+                if (id >= hack.Length)
+                    id = 0;
+            }
+        }
+
+        private static int AddFileToStream(string pathname, ref int num, BinaryReader br, int size, bool regroup)
+        {
+            if (_bw == null)
+                _bw = new BinaryWriter(File.Open(string.Format("{0}{1:00}", pathname, num), FileMode.Create));
+            
+            long pos = _bw.BaseStream.Position;
+            int size_rest = _maxSizeFile - (int)_bw.BaseStream.Length;
+
+            if (!regroup && size > size_rest)
+            {
+                _bw.Write(br.ReadBytes(size_rest), 0, size_rest);
+                _bw.Close();
+                _bw.Dispose();
+
+                num++;
+                _bw = new BinaryWriter(File.Open(string.Format("{0}{1:00}", pathname, num), FileMode.Create));
+
+                _bw.Write(br.ReadBytes(size - size_rest), 0, size - size_rest);
+            }
+            else
+                _bw.Write(br.ReadBytes(size), 0, size);
+
+            padding(_bw, ref size);
+
+            return size;
+        }
+
+        #endregion
+
+        #region Public methods
+
+        public static void unpackIsoFiles(string indexName)
+        {
+            BinaryReader br = null;
+            byte bIndexNbSector = 0;
+            int numFileIndex;
+            int numFileOpen = -1;
+            int iIndexSize = 0;
+            string fileNameBase = Path.GetFileNameWithoutExtension(indexName);
+
+            int.TryParse(Path.GetExtension(indexName).Substring(1), out numFileIndex);
+            string directoryName = Variables.dirUnpack + string.Format("{0:D2}", numFileIndex);
+
+            listPathElement index = new listPathElement();
+
+            Console.WriteLine("Traitement de l'index {0}", indexName);
+
+            // Lecture de l'index
+            try
+            {
+                bIndexNbSector = readIndex(indexName, index);
+                index.SortBySector();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("  (EE) Erreur lors de la lecture de l'index : {0}", ex.Message);
+                return;
+            }
+
+            iIndexSize = bIndexNbSector * _sectorSize;
+
+            try
+            {
+                foreach (pathElement entryPath in index.getEntries())
+                {
+                    if (!entryPath.IsDirectory)
+                    {
+                        Console.WriteLine("    Ecriture du fichier {0}", entryPath.FullPath);
+                        Directory.CreateDirectory(directoryName + Path.GetDirectoryName(entryPath.FullPath));
+
+                        int id = getIdFile(entryPath.Position, iIndexSize) + numFileIndex;
+
+                        double pos = (entryPath.Position - iIndexSize) % _maxSizeFile;
+
+                        if (numFileOpen == -1 || numFileOpen != id)
+                        {
+                            if (br != null)
+                            {
+                                br.Close();
+                                br.Dispose();
+                            }
+
+                            br = new BinaryReader(File.Open(string.Format("{0}.{1:D2}", fileNameBase, id), FileMode.Open));
+                            numFileOpen = id;
+                        }
+
+                        br.BaseStream.Seek((int)pos, SeekOrigin.Begin);
+
+                        int size_rest = (int)br.BaseStream.Length - (int)pos;
+                        using (BinaryWriter bw = new BinaryWriter(File.Open(directoryName + entryPath.FullPath, FileMode.Create)))
+                        {
+                            if (size_rest >= entryPath.SizeIn)
+                                bw.Write(br.ReadBytes((int)entryPath.SizeIn));
+                            else
+                            {
+                                bw.Write(br.ReadBytes(size_rest));
+                                int num = id + 1;
+
+                                if (br != null)
+                                {
+                                    br.Close();
+                                    br.Dispose();
+                                }
+
+                                br = new BinaryReader(File.Open(string.Format("{0}.{1:D2}", fileNameBase, num), FileMode.Open));
+                                numFileOpen = num;
+
+                                bw.Write(br.ReadBytes((int)entryPath.SizeIn - size_rest));
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("  (EE) Erreur lors de l'extraction des fichiers : {0}", ex.Message);
+                return;
+            }
+        }
+
+        public static void packIsoFiles(string indexName, bool regroup)
+        {
+            BinaryReader br = null;
+            byte bIndexNbSector = 0;
+            long l_sector = 0;
+            long l_position = 0;
+            int iIndexSize = 0;
+            int numFileIndex;
+            int numFileWrite = -1;
+            int idSave = -1;
+            string fileNameBase = Path.GetFileNameWithoutExtension(indexName);
+
+            int.TryParse(Path.GetExtension(indexName).Substring(1), out numFileIndex);
+            
+            listPathElement index = new listPathElement();
+
+            Console.WriteLine("Traitement de l'index {0}", indexName);
+
+            // Lecture de l'index
+            try
+            {
+                bIndexNbSector = readIndex(indexName, index);
+                index.SortBySector();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("  (EE) Erreur lors de la lecture de l'index : {0}", ex.Message);
+                return;
+            }
+
+            l_sector += bIndexNbSector;
+            iIndexSize = bIndexNbSector * _sectorSize;
+            l_position += iIndexSize;
+
+            numFileWrite = numFileIndex + 1;
+            try
+            {
+                string s_pathname = string.Format("{0}{1}.", Variables.dirPack, fileNameBase);
+                Directory.CreateDirectory(Variables.dirPack);
+
+                foreach (pathElement entryPath in index.getEntries())
+                {
+                    if (!entryPath.IsDirectory)
+                    {
+                        long size = 0;
+
+                        if (File.Exists(Variables.dirInsert + entryPath.Name))
+                        {
+                            Console.WriteLine("    Insertion du fichier {0}", entryPath.FullPath);
+
+                            using (BinaryReader brFile = new BinaryReader(File.Open(Variables.dirInsert + entryPath.Name, FileMode.Open)))
+                            {
+                                size = brFile.BaseStream.Length;
+
+                                if (entryPath.IsCompressed)
+                                {
+                                    // Compression du fichier
+                                    entryPath.SizeIn = (UInt32)size;
+                                    //entryPath.SizeOut = entryPath.SizeIn;
+                                }
+                                else
+                                {
+                                    entryPath.SizeIn = (UInt32)size;
+                                    //entryPath.SizeOut = entryPath.SizeIn;
+                                }
+
+                                int size_new = AddFileToStream(s_pathname, ref numFileWrite, brFile, (int)size, regroup);
+
+                                entryPath.Position = (UInt32)l_position;
+                                entryPath.Sector = entryPath.Position / _sectorSize;
+                                l_position += size_new;
+                            }
+                        }
+                        else
+                        {
+                            Console.WriteLine("    Copie du fichier {0}", entryPath.FullPath);
+
+                            size = entryPath.SizeIn;
+
+                            int id = getIdFile(entryPath.Position, iIndexSize) + numFileIndex;
+
+                            double pos = (entryPath.Position - iIndexSize) % _maxSizeFile;
+
+                            int size_new = 0;
+
+                            if (br != null && id != idSave)
+                            {
+                                br.Close();
+                                br.Dispose();
+                                br = null;
+                            }
+
+                            if (br == null)
+                            {
+                                br = new BinaryReader(File.Open(string.Format("{0}.{1:D2}", fileNameBase, id), FileMode.Open));
+                                idSave = id;
+                            }
+
+                            br.BaseStream.Seek((int)pos, SeekOrigin.Begin);
+
+                            int size_rest = (int)br.BaseStream.Length - (int)pos;
+
+                            if (size_rest >= size)
+                                size_new = AddFileToStream(s_pathname, ref numFileWrite, br, (int)size, regroup);
+                            else
+                            {
+                                int sizeTemp = AddFileToStream(s_pathname, ref numFileWrite, br, size_rest, regroup);
+                                int num = id + 1;
+                                size_new = sizeTemp;
+
+                                if (br != null)
+                                {
+                                    br.Close();
+                                    br.Dispose();
+                                }
+
+                                br = new BinaryReader(File.Open(string.Format("{0}.{1:D2}", fileNameBase, num), FileMode.Open));
+                                idSave = num;
+
+                                sizeTemp = AddFileToStream(s_pathname, ref numFileWrite, br, (int)entryPath.SizeIn - size_rest, regroup);
+                                size_new += sizeTemp;
+                            }
+
+                            entryPath.Position = (UInt32)l_position;
+                            entryPath.Sector = entryPath.Position / _sectorSize;
+                            l_position += size_new;
+                        }
+                    }
+                }
+
+                _bw.Close();
+                _bw.Dispose();
+
+                writeIndex(indexName, bIndexNbSector, index);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("(EE) Erreur lors de l'insertion des fichiers : {0}", ex.Message);
+                return;
+            }
+        }
+
+        public static void listFiles(string indexName)
+        {
+            byte bIndexNbSector = 0;
+            int iIndexSize;
+            int numFile;
+            int.TryParse(Path.GetExtension(indexName).Substring(1), out numFile);
+
+            listPathElement index = new listPathElement();
+
+            Console.WriteLine("Traitement de l'index {0}", indexName);
+
+            try
+            {
+                Directory.CreateDirectory(Variables.dirUnpack);
+
+                using (StreamWriter sw = new StreamWriter(string.Format("{0}{1}{2}", Variables.dirUnpack, indexName, _listExtension)))
+                {
+                    TextWriterTraceListener twtl_trace = new TextWriterTraceListener(sw);
+                    Trace.Listeners.Add(twtl_trace);
+
+                    bIndexNbSector = readIndex(indexName, index);
+                    index.SortBySector();
+                    iIndexSize = bIndexNbSector * _sectorSize;
+
+                    foreach (pathElement entryPath in index.getEntries())
+                    {
+                        if (!entryPath.IsDirectory)
+                        {
+                            double d = (entryPath.Position - iIndexSize) / _maxSizeFile;
+                            int id = (int)Math.Floor(d) + 1;
+
+                            Trace.WriteLine(string.Format("{0,-36}Sector={1,-15}SizeIn={2,-15}SizeOut={3,-15}File=xenosaga.{4:D2}", entryPath.FullPath, entryPath.Sector, entryPath.SizeIn, entryPath.SizeOut, id + numFile));
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("  (EE) Erreur lors de la lecture de l'index : {0}", ex.Message);
+                return;
+            }
+        }
+
+        #endregion
+    }
+}

Hack.Xenosaga/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Les informations générales relatives à un assembly dépendent de 
+// l'ensemble d'attributs suivant. Changez les valeurs de ces attributs pour modifier les informations
+// associées à un assembly.
+[assembly: AssemblyTitle("Hack.Xenosaga")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Hack.Xenosaga")]
+[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// L'affectation de la valeur false à ComVisible rend les types invisibles dans cet assembly 
+// aux composants COM.  Si vous devez accéder à un type dans cet assembly à partir de 
+// COM, affectez la valeur true à l'attribut ComVisible sur ce type.
+[assembly: ComVisible(false)]
+
+// Le GUID suivant est pour l'ID de la typelib si ce projet est exposé à COM
+[assembly: Guid("e34b0f4d-db94-4f48-aed4-1b4fd63075ae")]
+
+// Les informations de version pour un assembly se composent des quatre valeurs suivantes :
+//
+//      Version principale
+//      Version secondaire 
+//      Numéro de build
+//      Révision
+//
+// Vous pouvez spécifier toutes les valeurs ou indiquer les numéros de build et de révision par défaut 
+// en utilisant '*', comme indiqué ci-dessous :
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Hack.Xenosaga/Xenosaga.cs

@@ -0,0 +1,34 @@
+using Hack.Xenosaga.Common;
+using Hack.Xenosaga.Process;
+
+namespace Hack.Xenosaga
+{
+    class Xenosaga
+    {
+        public static void Main(string[] args)
+        {
+            Variables.stArgs listArgs;
+
+            if (!Functions.checkArgs(args, out listArgs))
+            {
+                Functions.usage();
+                return;
+            }
+
+            switch (listArgs.option)
+            {
+                case "-l":
+                    Unpack.listFiles(listArgs.filename);
+                    break;
+
+                case "-p":
+                    Unpack.packIsoFiles(listArgs.filename, listArgs.regroup);
+                    break;
+
+                case "-u":
+                    Unpack.unpackIsoFiles(listArgs.filename);
+                    break;
+            }
+        }
+    }
+}

LICENSE

@@ -0,0 +1,340 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {description}
+    Copyright (C) {year}  {fullname}
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  {signature of Ty Coon}, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
+

README.md

@@ -0,0 +1,9 @@
+Tool dedicated to isohacking for Xenosaga on Playstation 2
+
+Usage :
+xenosaga <option> <file> [regroup]
+  option   : -l = List files from index
+             -u = Unpack files from index
+             -p = Pack files from index
+  file    : Index file (the first one of each decade : xenosaga.00, xenosaga.10, xenosaga.20...)
+  regroup : true to regroup all files in only one (ex: 11, 12, 13 in 11) ; false or empty (default) to keep the same system of increment files