// par1.c
// Copyright : 2024-11-30 Yutaka Sawada
// License : GPL

#ifndef _UNICODE
#define _UNICODE
#endif
#ifndef UNICODE
#define UNICODE
#endif
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0601	// Windows 7 or later
#endif

#include <stdio.h>

#include <windows.h>
#include <imagehlp.h>

#include "common1.h"
#include "phmd5.h"
#include "md5_1.h"
#include "ini.h"
#include "par1.h"
#include "version.h"

/*
Fast Galois Field Arithmetic Library in C/C++
Copright (C) 2007 James S. Plank
*/
#include "gf8.h"

/*
// 行列の表示用関数
void galois_print_matrix(int *matrix, int rows, int cols)
{
	int i, j;
	printf("\n");
	for (i = 0; i < rows; i++) {
		for (j = 0; j < cols; j++) {
			printf("%4d", matrix[i*cols+j]);
		}
		printf("\n");
	}
}
*/

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*
gflib の行列作成用関数や行列の逆変換用の関数を元にして、
計算のやり方を PAR 1.0 用に修正する。

par-v1.1.tar.gz に含まれる rs.doc
Dummies guide to Reed-Solomon coding. を参考にする

解説ではパリティ計算用の行列の要素、掛ける値は
F(i,j) = i^(j-1) ・・・ i の (j-1) 乗
ソース・ブロックは i = 1～N で、
パリティ・ブロックは j = 1～M になってる。

実際に計算する関数では
ソース・ブロックが i = 0 ～ cols - 1 で、
パリティ・ブロックが j = 0 ～ rows - 1 なので、

理論のF(i,j) = F(i+1, j+1) = (i+1) ^ (j+1-1) = (i+1) ^ j
・・・ (i+1) の j 乗
*/

// PAR 1.0 のパリティ作成用の行列
int * make_encode_matrix(
	int rows,	// 横行、パリティのブロック数
	int cols,	// 縦列、ソースのブロック数
	int first)	// 最初のパリティ・ブロック番号
{
	int *mat, i, j;

	mat = malloc(sizeof(int) * rows * cols);
	if (mat == NULL){
		printf("malloc, %d\n", sizeof(int) * rows * cols);
		return NULL;
	}

	for (j = 0; j < rows; j++){
		for (i = 0; i < cols; i++)
			mat[cols * j + i] = galois_power(i + 1, first + j);
	}

	return mat;
}

/*
失われたソース・ブロックの数 = 利用するパリティ・ブロックの数を縦行とし、
ソース・ブロックの数を横列とする長方形の行列を作る。

例えば、ソース・ブロックを A, B, C, D, E 、
そのパリティ・ブロックを X, Y, Z とする。
その場合の関係式は次のようになる。

1: 1*A xor 1*B xor 1*C xor  1*D xor  1*E = X
2: 1*A xor 2*B xor 3*C xor  4*D xor  5*E = Y
3: 1*A xor 4*B xor 5*C xor 16*D xor 17*E = Z

これは PARファイルを作成する際の行列と同じ。
   1   1   1   1   1
   1   2   3   4   5
   1   4   5  16  17

ここで、B, C, D の三ブロックが失われて、それぞれを X, Y, Z で補うなら、
その状態は次のような関係式になる。

1: 1*A xor 1*B xor 1*C xor  1*D xor  1*E = 0*A xor 1*X xor 0*Y xor 0*Z xor 0*E
2: 1*A xor 2*B xor 3*C xor  4*D xor  5*E = 0*A xor 0*X xor 1*Y xor 0*Z xor 0*E
3: 1*A xor 4*B xor 5*C xor 16*D xor 17*E = 0*A xor 0*X xor 0*Y xor 1*Z xor 0*E

左：パリティ・ブロックの係数
   1   1   1   1   1
   1   2   3   4   5
   1   4   5  16  17

右：そのパリティ・ブロックがどのソース・ブロックの位置にくるか
   0   1   0   0   0
   0   0   1   0   0
   0   0   0   1   0

ここでまず、存在するソース・ブロックの列を 0にする。

1: 0*A xor 1*B xor 1*C xor  1*D xor 0*E = 1*A xor 1*X xor 0*Y xor 0*Z xor  1*E
2: 0*A xor 2*B xor 3*C xor  4*D xor 0*E = 1*A xor 0*X xor 1*Y xor 0*Z xor  5*E
3: 0*A xor 4*B xor 5*C xor 16*D xor 0*E = 1*A xor 0*X xor 0*Y xor 1*Z xor 17*E

左：ソース・ブロックが存在した所が 0になる
   0   1   1   1   0
   0   2   3   4   0
   0   4   5  16   0

右：逆にこちらではソース・ブロックが存在した所が反転する
   1   1   0   0   1
   1   0   1   0   5
   1   0   0   1  17

Gaussian Elimination (ガウスの消去法) で元の左の行列を右のに変換する

各行で 0でない値を探して、それが 1になるように、何倍かする。
まずは 1行目：

1: 0*A xor 1*B xor 1*C xor  1*D xor 0*E = 1*A xor 1*X xor 0*Y xor 0*Z xor  1*E
1 行目の 2列目は 1なのでそのまま。

他の行の同じ列に 0でない値があれば、それを 0にするために、
行を何倍かしたものを XOR する

2: 0*A xor 2*B xor 3*C xor  4*D xor 0*E = 1*A xor 0*X xor 1*Y xor 0*Z xor  5*E
2 行目の 2列目は 2なので、1行目の各値を 2倍したものを XOR する。

3: 0*A xor 4*B xor 5*C xor 16*D xor 0*E = 1*A xor 0*X xor 0*Y xor 1*Z xor 17*E
3 行目の 2列目は 4なので、1行目の各値を 4倍したものを XOR する。

1: 0*A xor 1*B xor 1*C xor  1*D xor 0*E = 1*A xor 1*X xor 0*Y xor 0*Z xor  1*E
2: 0*A xor 0*B xor 1*C xor  6*D xor 0*E = 3*A xor 2*X xor 1*Y xor 0*Z xor  7*E
3: 0*A xor 0*B xor 1*C xor 20*D xor 0*E = 5*A xor 4*X xor 0*Y xor 1*Z xor 21*E

次は 2行目：

2: 0*A xor 0*B xor 1*C xor  6*D xor 0*E = 3*A xor 2*X xor 1*Y xor 0*Z xor  7*E
2 行目の 3列目は 1なのでそのまま。

1: 0*A xor 1*B xor 1*C xor  1*D xor 0*E = 1*A xor 1*X xor 0*Y xor 0*Z xor  1*E
1 行目の 3列目は 1なので、1行目の各値をそのまま XOR する。

3: 0*A xor 0*B xor 1*C xor 20*D xor 0*E = 5*A xor 4*X xor 0*Y xor 1*Z xor 21*E
3 行目の 3列目は 1なので、1行目の各値をそのまま XOR する。

1: 0*A xor 1*B xor 0*C xor  7*D xor 0*E = 2*A xor 3*X xor 1*Y xor 0*Z xor  6*E
2: 0*A xor 0*B xor 1*C xor  6*D xor 0*E = 3*A xor 2*X xor 1*Y xor 0*Z xor  7*E
3: 0*A xor 0*B xor 0*C xor 18*D xor 0*E = 6*A xor 6*X xor 1*Y xor 1*Z xor 18*E

次は 3行目：

3: 0*A xor 0*B xor 0*C xor 18*D xor 0*E = 6*A xor 6*X xor 1*Y xor 1*Z xor 18*E
3 行目の 4列目は 18なので、18で割る

1: 0*A xor 1*B xor 0*C xor  7*D xor 0*E = 2*A xor 3*X xor 1*Y xor 0*Z xor  6*E
1 行目の 4列目は 7なので、1行目の各値を 7倍したものを XOR する。

2: 0*A xor 0*B xor 1*C xor  6*D xor 0*E = 3*A xor 2*X xor 1*Y xor 0*Z xor  7*E
2 行目の 4列目は 6なので、1行目の各値を 6倍したものを XOR する。

1: 0*A xor 1*B xor 0*C xor 0*D xor 0*E =   3*A xor   2*X xor 123*Y xor 122*Z xor 1*E
2: 0*A xor 0*B xor 1*C xor 0*D xor 0*E = 184*A xor 185*X xor 187*Y xor 186*Z xor 1*E
3: 0*A xor 0*B xor 0*C xor 1*D xor 0*E = 186*A xor 186*X xor 192*Y xor 192*Z xor 1*E

左：元の右の行列と同じになってる
   0   1   0   0   0
   0   0   1   0   0
   0   0   0   1   0

右：これが失われたソース・ブロックを復元するための行列となる
   3   2 123 122   1
 184 185 187 186   1
 186 186 192 192   1
*/

// 復元用の行列を作る、十分な数のパリティ・ブロックが必要
int * make_decode_matrix(
	int parity_max,	// 本来のパリティ・ブロックの数
	int rows,		// 横行、行列の縦サイズ、失われたソース・ブロックの数 = 利用するパリティ・ブロック数
	int cols,		// 縦列、行列の横サイズ、本来のソース・ブロック数
	int *exist,		// どのブロックが存在するか
	int *id)		// 失われたソース・ブロックをどのパリティ・ブロックで代用したか
{
	int *mat_max, *mat_l, *mat_r;
	int factor, row_start, row_start2, col_find, i, j, k;

	// 失われたソース・ブロックをどのパリティ・ブロックで代用するか
	j = 0;
	for (i = 0; i < cols; i++){
		id[i] = i;
		if (exist[i] == 0){ // ソース・ブロックが存在しない所
			while (j < parity_max){
				if (exist[cols + j] != 0){ // その番号のパリティ・ブロックが存在すれば
					id[i] = cols + j;
					j++;
					break;
				} else {
					j++;
				}
			}
			if (id[i] < cols){
				printf("\nneed more parity volume\n");
				return NULL; // パリティ・ブロックの数が足りなければ
			}
		}
	}

	// 全てのパリティ・ブロックが存在すると仮定した行列を作る
	mat_max = make_encode_matrix(parity_max, cols, 0);
	if (mat_max == NULL)
		return NULL;

	// 存在して利用するパリティ・ブロックだけの行列を作る
	mat_l = malloc(sizeof(int) * rows * cols);
	if (mat_l == NULL) {
		free(mat_max);
		printf("malloc, %d\n", sizeof(int) * rows * cols);
		return NULL;
	}
	j = 0;
	for (i = 0; i < cols; i++){
		if (id[i] >= cols){
			for (k = 0; k < cols; k++)
				mat_l[cols * j + k] = mat_max[cols * (id[i] - cols) + k];
			j++;
		}
	}
	free(mat_max);
	//printf("\nLeft :\n");
	//galois_print_matrix(mat_l, rows, cols);

	// 失われたソース・ブロックと代用するパリティ・ブロックの位置を表す行列を作る
	mat_r = (int *)calloc(rows * cols, sizeof(int));
	if (mat_r == NULL){
		free(mat_l);
		printf("calloc, %d\n", sizeof(int) * rows * cols);
		return NULL;
	}
	j = 0;
	for (i = 0; i < cols; i++){
		if (id[i] >= cols){
			// j = 行番号
			// id[i] = その行を補ったパリティ・ブロックの番号
			// i = その行のソース・ブロック番号
			mat_r[cols * j + i] = 1;
			j++;
		}
	}
	//printf("\nRight :\n");
	//galois_print_matrix(mat_r, rows, cols);

	// mat_l の存在するソース・ブロックの列を 0 にするような値で XOR する
	for (i = 0; i < cols; i++){
		if (exist[i] != 0){ // ソース・ブロックが存在する列
			for (j = 0; j < rows; j++){ // 行ごとに
				factor = mat_l[cols * j + i]; // j 行の i 列の値
				mat_l[cols * j + i] = 0; // mat_l[cols * j + i] ^= factor; と同じ
				mat_r[cols * j + i] ^= factor;
			}
		}
	}
	//printf("\nErase source block :\n");
	//galois_print_matrix(mat_l, rows, cols);
	//printf("\n");
	//galois_print_matrix(mat_r, rows, cols);

	// Gaussian Elimination
	for (j = 0; j < rows; j++){
		row_start = cols * j; // その行の開始位置

		// mat_l の各行ごとに最初の 0でない値を探す
		for (col_find = 0; col_find < cols; col_find++){
			if (mat_l[row_start + col_find] != 0)
				break;
		}
		if (col_find == cols){ // 見つからなければ、その行列の逆行列を計算できない
			printf("\nmatrix is not invertible\n");
			k = 0;
			for (i = 0; i < cols; i++){
				if (id[i] >= cols){
					if (k == j){
						printf(" parity volume %u is useless\n", (1 + id[i] - cols));
						break;
					}
					k++;
				}
			}
			free(mat_l);
			free(mat_r);
			return NULL;
		}
		factor = mat_l[row_start + col_find]; // col_find 列に 0 ではない値を発見
		if (factor != 1){ // factor が 1でなければ、1にする為に factor で割る
			for (k = 0; k < cols; k++){
				mat_l[row_start + k] = galois_multtable_divide(mat_l[row_start + k], factor);
				mat_r[row_start + k] = galois_multtable_divide(mat_r[row_start + k], factor);
			}
		}

		// 別の行の同じ col_find 列が 0以外なら、その値を 0にするために、
		// j 行を何倍かしたものを XOR する
		for (i = 0; i < rows; i++){
			if (i == j)
				continue; // 同じ行はとばす
			row_start2 = cols * i; // その行の開始位置
			factor = mat_l[row_start2 + col_find]; // i 行の col_find 列の値
			if (factor != 0){ // 0でなければ
				// 先の計算により、j 行の col_find 列の値は必ず 1なので、この factor が倍率になる
				if (factor == 1){ // 倍率が 1なら、単純に XOR するだけ
					for (k = 0; k < cols; k++){
						mat_l[row_start2 + k] ^= mat_l[row_start + k];
						mat_r[row_start2 + k] ^= mat_r[row_start + k];
					}
				} else {
					for (k = 0; k < cols; k++){
						mat_l[row_start2 + k] ^= galois_multtable_multiply(mat_l[row_start + k], factor);
						mat_r[row_start2 + k] ^= galois_multtable_multiply(mat_r[row_start + k], factor);
					}
				}
			}
		}

		//printf("\nDivide & Eliminate :\n");
		//galois_print_matrix(mat_l, rows, cols);
		//printf("\n");
		//galois_print_matrix(mat_r, rows, cols);
	}

	free(mat_l);
	return mat_r;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#define CHUNK_SIZE 65536

typedef struct {
	HANDLE hFile;	// ファイル・ハンドル
	__int64 size;	// ファイルの残りサイズ
} file_ctx;

// リード・ソロモン符号を使ってエンコードする
int rs_encode(
	int source_num,		// ソース・ブロックの数
	__int64 block_size,	// ブロック・サイズ (最大ファイル・サイズ)
	int parity_num,		// パリティ・ブロックの数
	int first_num,		// 最初のパリティ・ブロック番号
	file_ctx *files,
	HANDLE *par_hFile,
	PHMD5 *par_md5)
{
	unsigned char *buffer, *block = NULL;
	int err = 0, i, j;
	int *mat = NULL, factor;
	unsigned int io_size, unit_size, len, rv;
	unsigned int k, offset, length, chunk_count;
	unsigned int time_last, prog_num = 0, prog_base;
	__int64 block_left;
//unsigned int time1;

	// 利用できるメモリー量を調べる
	io_size = get_mem_size(block_size * (__int64)(source_num + parity_num));
	if (io_size > 1048576 * 2)
		io_size -= (parity_num * source_num) * 4 + 1048576; // 行列に必要なメモリーとスタック用に 1MB
	if (io_size < 1048576)
		io_size = 1048576;
	io_size /= source_num + 1;	// 何個分必要か

	// ブロック・サイズより大きい、またはブロック・サイズ自体が小さい場合は
	if (((__int64)io_size >= block_size) || (block_size <= 4096)){
		io_size = (unsigned int)block_size;	// ブロック・サイズと同じにする
	} else {	// ブロック・サイズを 2の乗数サイズの断片に分割する
		// 断片化する場合でもブロック数が多いと 256 * 4096 = 1MB は使う
		__int64 fragment_size = 4096;	// 最低サイズ
		while (fragment_size * 2 <= (__int64)io_size)
			fragment_size *= 2;
		io_size = (unsigned int)fragment_size;
	}
	io_size = (io_size + 3) & 0xFFFFFFFC;	// 4の倍数にする
	unit_size = io_size + HASH_SIZE;		// チェックサムの分だけ増やす
	prog_base = (unsigned int)((block_size + (__int64)io_size - 1) / (__int64)io_size) * parity_num;	// 全体の断片の個数
	//printf("io_size = %d, prog_base = %d\n", io_size, prog_base);

	block_left = block_size;
	if (galois_create_mult_tables() < 0){
		printf("galois_create_mult_tables\n");
		return 1;
	}

	// 作業バッファーを確保する
	block = malloc(unit_size * (source_num + 1));
	if (block == NULL){
		printf("malloc, %d\n", unit_size * (source_num + 1));
		err = 1;
		goto error_end;
	}
	buffer = block + unit_size;

	// パリティ計算用の行列演算の準備をする
	mat = make_encode_matrix(parity_num, source_num, first_num); // 変換行列
	if (mat == NULL){
		err = 1;
		goto error_end;
	}
	//galois_print_matrix(mat, parity_num, source_num);

	// chunk がキャッシュに収まるようにすれば速くなる！ (ストリップマイニングという最適化手法)
	// CPU L2キャッシュ・サイズが 256KB として、1/4 なら 64KB
	// chunk サイズが 2**16 なので分割数は 1～65536 の範囲になる
	chunk_count = (unit_size + CHUNK_SIZE - 1) / CHUNK_SIZE;
	//printf("split count = %d, chunk size = %d\n", chunk_count, CHUNK_SIZE);

//time1 = GetTickCount();
	// バッファー・サイズごとにパリティ・ブロックを作成する
	time_last = GetTickCount();
	while (block_left > 0){
		// バッファーにソース・ファイルの内容を読み込む
		for (i = 0; i < source_num; i++){
			if (files[i].size > 0){
				if (files[i].size < io_size){
					len = (unsigned int)(files[i].size);
				} else {
					len = io_size;
				}
				files[i].size -= len;
				if (!ReadFile(files[i].hFile, buffer + (unit_size * i), len, &rv, NULL) || (len != rv)){
					print_win32_err();
					printf("ReadFile, data file %d\n", i);
					err = 1;
					goto error_end;
				}
				if (len < io_size)
					memset(buffer + (unit_size * i + len), 0, io_size - len);
				// ソース・ブロックのチェックサムを計算する
				checksum4(buffer + (unit_size * i), buffer + (unit_size * i + io_size), io_size);
			} else {
				// ソース・ブロックの値が全て 0 なら、チェックサムも 0 になる。
				memset(buffer + (unit_size * i), 0, unit_size);
			}
		}
		// バッファーに読み込んだサイズ
		if (block_left < io_size){
			len = (unsigned int)block_left;
		} else {
			len = io_size;
		}
		block_left -= len;

		// パリティ・ブロックごとに
		for (i = 0; i < parity_num; i++){
			/*	without strip mining
			memset(block, 0, unit_size);	// パリティ・ブロックを 0で埋める
			// ソース・ブロックごとにパリティを追加していく
			for (j = 0; j < source_num; j++){
				factor = mat[i * source_num + j];
				if (factor == 1){
					galois_region_xor(buffer + (unit_size * j), block, unit_size);
				} else if (factor != 0){
					galois_region_multiply(buffer + (unit_size * j), block, unit_size, factor);
				}
			}
			*/
			length = CHUNK_SIZE;
			for (k = 0; k < chunk_count; k++){	// chunk の番号
				offset = k * CHUNK_SIZE;
				if (offset + length >= unit_size){	// 最後の chunk なら
					length = unit_size - offset;
					k = chunk_count;
				}

				memset(block + offset, 0, length);	// パリティ・ブロックを 0で埋める
				// ソース・ブロックごとにパリティを追加していく
				for (j = 0; j < source_num; j++){
					factor = mat[i * source_num + j];
					if (factor == 1){
						galois_region_xor(buffer + (unit_size * j + offset), block + offset, length);
					} else if (factor != 0){
						galois_region_multiply(buffer + (unit_size * j + offset), block + offset, length, factor);
					}
				}
			}

			// 経過表示
			prog_num++;
			if (GetTickCount() - time_last >= UPDATE_TIME){
				if (print_progress((prog_num * 1000) / prog_base)){
					err = 2;
					goto error_end;
				}
				time_last = GetTickCount();
			}

			// パリティ・ブロックのチェックサムを検証する
			checksum4(block, (unsigned char *)&rv, io_size);
			if (memcmp(block + io_size, &rv, HASH_SIZE) != 0){
				printf("checksum mismatch, parity volume %d\n", i);
				err = 1;
				goto error_end;
			}
			Phmd5Process(&(par_md5[i]), block, len); // ハッシュ値を計算する
			// リカバリ・ファイルへ書き込む
			if (!WriteFile(par_hFile[i], block, len, &rv, NULL)){
				print_win32_err();
				printf("WriteFile, parity volume %d\n", first_num + 1 + i);
				err = 1;
				goto error_end;
			}
		}
	}
	print_progress_done();	// 改行して行の先頭に戻しておく
//time1 = GetTickCount() - time1;
//printf("encode %u.%03u sec\n", time1 / 1000, time1 % 1000);

error_end:
	if (block)
		free(block);
	if (mat)
		free(mat);
	// gflib のテーブルを解放する
	galois_free_tables();
	return err;
}

// リード・ソロモン符号を使ってデコードする
int rs_decode(
	int source_num,		// 本来のソース・ブロックの数
	int block_lost,		// 失われたソース・ブロックの数
	__int64 block_size,	// ブロック・サイズ (最大ファイル・サイズ)
	int parity_max,		// 本来のパリティ・ブロックの数
	int *exist,			// そのブロックが存在するか
	file_ctx *files)
{
	unsigned char *buffer, *block = NULL;
	int err = 0, i, j;
	int *mat = NULL, *id = NULL, factor;
	int block_recover;
	unsigned int io_size, unit_size, len, rv, len2;
	unsigned int k, offset, length, chunk_count;
	unsigned int time_last, prog_num = 0, prog_base;
	__int64 block_left;

	// 利用できるメモリー量を調べる
	io_size = get_mem_size(block_size * (__int64)(source_num + block_lost));
	io_size -= (block_lost * source_num * 8) + (parity_max * source_num * 4) + (source_num * 4);
	io_size -= 1048576; // 行列に必要なメモリーとスタック用に 1MB
	if (io_size < 1048576)
		io_size = 1048576;
	io_size /= source_num + 1;	// 何個分必要か

	// ブロック・サイズより大きい、またはブロック・サイズ自体が小さい場合は
	if (((__int64)io_size >= block_size) || (block_size <= 4096)){
		io_size = (unsigned int)block_size;	// ブロック・サイズと同じにする
	} else {	// ブロック・サイズを 2の乗数サイズの断片に分割する
		// 断片化する場合でもブロック数が多いと 256 * 4096 = 1MB は使う
		__int64 fragment_size = 4096;	// 最低サイズ
		while (fragment_size * 2 <= (__int64)io_size)
			fragment_size *= 2;
		io_size = (unsigned int)fragment_size;
	}
	io_size = (io_size + 3) & 0xFFFFFFFC;	// 4の倍数にする
	unit_size = io_size + HASH_SIZE;		// チェックサムの分だけ増やす
	prog_base = (unsigned int)((block_size + (__int64)io_size - 1) / (__int64)io_size) * block_lost;	// 全体の断片の個数
	//printf("io_size = %d\n", io_size);

	block_left = block_size;
	if (galois_create_mult_tables() < 0){
		printf("galois_create_mult_tables\n");
		return 1;
	}

	// 作業バッファーを確保する
	block = malloc(unit_size * (source_num + 1));
	if (block == NULL){
		printf("malloc, %d\n", unit_size * (source_num + 1));
		err = 1;
		goto error_end;
	}
	buffer = block + unit_size;

	// パリティ計算用の行列演算の準備をする
	id = malloc(sizeof(int) * source_num);
	if (id == NULL){
		printf("malloc, %d\n", sizeof(int) * source_num);
		err = 1;
		goto error_end;
	}

	mat = make_decode_matrix(parity_max, block_lost, source_num, exist, id);
	if (mat == NULL){
		err = 1;
		goto error_end;
	}
	//galois_print_matrix(mat, block_lost, source_num);
	//for (i = 0; i < source_num; i++)
	//	printf("id[%d] = %d\n", i, id[i]);

	// chunk サイズが 2**16 なので分割数は 1～65536 の範囲になる
	chunk_count = (unit_size + CHUNK_SIZE - 1) / CHUNK_SIZE;

	// バッファー・サイズごとにソース・ブロックを復元する
	time_last = GetTickCount();
	while (block_left > 0){
		// バッファーにソース・ファイルとリカバリ・ファイルの内容を読み込む
		for (i = 0; i < source_num; i++){
			//printf("%d: id = %d, exist = %d, size = %I64u \n", i, id[i], exist[id[i]], files[id[i]].size);
			if (files[id[i]].size > 0){
				if (files[id[i]].size < io_size){
					len = (unsigned int)(files[id[i]].size);
				} else {
					len = io_size;
				}
				files[id[i]].size -= len;
				if (!ReadFile(files[id[i]].hFile, buffer + (unit_size * i), len, &rv, NULL)){
					print_win32_err();
					printf("ReadFile, data file %d\n", id[i]);
					err = 1;
					goto error_end;
				} else if (len != rv){
					printf("ReadFile, data file %d, %d, %d\n", id[i], len, rv);
					err = 1;
					goto error_end;
				}
				if (len < io_size)
					memset(buffer + (unit_size * i + len), 0, io_size - len);
				// ソース・ブロックのチェックサムを計算する
				checksum4(buffer + (unit_size * i), buffer + (unit_size * i + io_size), io_size);
			} else {
				// ソース・ブロックの値が全て 0 なら、チェックサムも 0 になる。
				memset(buffer + (unit_size * i), 0, unit_size);
			}
		}
		// バッファーに読み込んだサイズ
		if (block_left < io_size){
			len = (unsigned int)block_left;
		} else {
			len = io_size;
		}
		block_left -= len;

		// 失われたソース・ブロックごとに
		block_recover = 0;
		for (i = 0; i < source_num; i++){
			if (id[i] >= source_num){ // パリティ・ブロックで補った部分
				/*	without strip mining
				memset(block, 0, unit_size);	// ソース・ブロックを 0で埋める
				// 失われたソース・ブロックを復元していく
				for (j = 0; j < source_num; j++) {
					factor = mat[source_num * block_recover + j];
					if (factor == 1){
						galois_region_xor(buffer + (unit_size * j), block, unit_size);
					} else if (factor != 0){
						galois_region_multiply(buffer + (unit_size * j), block, unit_size, factor);
					}
				}
				*/
				length = CHUNK_SIZE;
				for (k = 0; k < chunk_count; k++){	// chunk の番号
					offset = k * CHUNK_SIZE;
					if (offset + length >= unit_size){	// 最後の chunk なら
						length = unit_size - offset;
						k = chunk_count;
					}

					memset(block + offset, 0, length);	// ソース・ブロックを 0で埋める
					// 失われたソース・ブロックを復元していく
					for (j = 0; j < source_num; j++) {
						factor = mat[source_num * block_recover + j];
						if (factor == 1){
							galois_region_xor(buffer + (unit_size * j + offset), block + offset, length);
						} else if (factor != 0){
							galois_region_multiply(buffer + (unit_size * j + offset), block + offset, length, factor);
						}
					}
				}

				// 経過表示
				prog_num++;
				if (GetTickCount() - time_last >= UPDATE_TIME){
					if (print_progress((prog_num * 1000) / prog_base)){
						err = 2;
						goto error_end;
					}
					time_last = GetTickCount();
				}

				// 復元されたソース・ブロックのチェックサムを検証する
				checksum4(block, (unsigned char *)&rv, io_size);
				if (memcmp(block + io_size, &rv, HASH_SIZE) != 0){
					printf("checksum mismatch, recovered data file %d\n", i);
					err = 1;
					goto error_end;
				}
				block_recover++;
				// ソース・ファイルに書き込むサイズ
				if (files[i].size < len){
					len2 = (unsigned int)(files[i].size);
				} else {
					len2 = len;
				}
				files[i].size -= len2;
				// ソース・ファイルへ書き込む
				if (!WriteFile(files[i].hFile, block, len2, &rv, NULL)){
					print_win32_err();
					printf("WriteFile, data file %d\n", i);
					err = 1;
					goto error_end;
				}
			}
		}
	}
	print_progress_done();	// 改行して行の先頭に戻しておく

error_end:
	if (block)
		free(block);
	if (id)
		free(id);
	if (mat)
		free(mat);
	// gflib のテーブルを解放する
	galois_free_tables();
	return err;
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

// PAR 1.0 のヘッダーを作成する
int set_header(
	unsigned char *buf,
	file_ctx *files,	// ソース・ブロックのハンドルとサイズ
	int source_num,		// ソース・ブロックの数
	int file_num,		// ソース・ファイルの数
	wchar_t *list_buf,	// ソース・ファイルのリスト
	int list_len)		// ファイル・リストの文字数
{
	unsigned char hash[16], hash16[16], set_hash[16 * 256];
	unsigned char hash0[16] = {0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
							0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e};
	wchar_t file_path[MAX_LEN], *file_name;
	int i, off, list_off, len, num = 0;
	__int64 file_size, total_file_size, prog_now;
	WIN32_FILE_ATTRIBUTE_DATA AttrData;

	memset(buf, 0, 96);
	// Identification String
	buf[0] = 'P';
	buf[1] = 'A';
	buf[2] = 'R';
	// Version Number
	i = 0x00010000; // PAR 1.0
	memcpy(buf + 8, &i, 4);
	// "program"-"version"-"subversion"-"subsubversion".
	buf[12] = PRODUCT_VERSION & 0xF;		// subsubversion
	buf[13] = (PRODUCT_VERSION >> 4) & 0xF;	// subversion
	buf[14] = PRODUCT_VERSION >> 8;			// version, ちなみに par-cmdline の最終バージョンは 0.9.0 ?
	buf[15] = 2;	// program, 1=Mirror, 2=PAR, 3=SmartPar, 0&4～=Unknown client
	// control hash の 16バイトは最後に書き込む
	// set hash の 16バイトは後で書き込む
	// volume number はパリティ・ブロックごとに変更する
	// number of files
	memcpy(buf + 56, &file_num, 4);
	// start offset of the file list
	buf[64] = 0x60;
	// file list size の 8バイトは後で書き込む
	// start offset of the data の 8バイトは後で書き込む
	// data size はパリティ・ブロックならブロック・サイズを書き込む

	// 合計ファイル・サイズを求める
	total_file_size = 0;
	prog_now = 0;
	list_off = 0;
	while (list_off < list_len){
		// ファイル名を取得する
		file_name = list_buf + list_off;	// サブ・ディレクトリを含まないのでそのまま使う
		list_off += wcslen(file_name) + 1;

		wcscpy(file_path, base_dir);
		wcscat(file_path, file_name);
		if (!GetFileAttributesEx(file_path, GetFileExInfoStandard, &AttrData)){
			print_win32_err();
			printf_cp("cannot open input file, %s\n", file_name);
			return 0;
		}
		file_size = ((__int64)(AttrData.nFileSizeHigh) << 32) | (__int64)(AttrData.nFileSizeLow);
		total_file_size += file_size;
	}

	// ここから file list
	off = 0x0060;
	list_off = 0;
	while (list_off < list_len){
		// ファイル名を取得する
		file_name = list_buf + list_off;	// サブ・ディレクトリを含まないのでそのまま使う
		len = wcslen(file_name);
		list_off += (len + 1);
		len *= 2;	// 文字数からバイト数にする

		// entry size
		i = 0x38 + len;
		memcpy(buf + off, &i, 4);
		memset(buf + off + 4, 0, 4);
		off += 8;
		// status field
		wcscpy(file_path, base_dir);
		wcscat(file_path, file_name);
		if (!GetFileAttributesEx(file_path, GetFileExInfoStandard, &AttrData)){
			print_win32_err();
			printf_cp("cannot open input file, %s\n", file_name);
			return 0;
		}
		file_size = ((__int64)(AttrData.nFileSizeHigh) << 32) | (__int64)(AttrData.nFileSizeLow);
		if (file_size > 0){
			i = 1;
		} else {
			i = 0; // 空のファイルはパリティ計算に含めない
		}
		memcpy(buf + off, &i, 4);
		memset(buf + off + 4, 0, 4);
		off += 8;
		// size
		memcpy(buf + off, &file_size, 8);
		off += 8;
		// MD5 hash
		if (file_size > 0){
			// パリティ・ブロック計算用に開く
			files[num].size = file_size;
			files[num].hFile = CreateFile(file_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
			if (files[num].hFile == INVALID_HANDLE_VALUE){
				print_win32_err();
				printf_cp("cannot open input file, %s\n", file_name);
				return 0;
			}
			// MD5 を計算する
			i = file_md5_total(files[num].hFile, file_size, hash, hash16, total_file_size, &prog_now);
			if (i != 0){
				if (i < 0)
					return i;
				printf_cp("file_md5_total, %s\n", file_name);
				return 0;
			}
		} else {
			memcpy(hash, hash0, 16);
		}
		memcpy(buf + off, hash, 16);
		off += 16;
		if (file_size > 0)
			memcpy(set_hash + (num * 16), hash, 16);
		// 16k MD5 hash
		if (file_size > 16384)
			memcpy(hash, hash16, 16);
		memcpy(buf + off, hash, 16);
		off += 16;
		// filename
		memcpy(buf + off, file_name, len);
		off += len;

		if (file_size > 0)
			num++;
	}

	// set hash をここで書き込む
	data_md5(set_hash, source_num * 16, hash);
	memcpy(buf + 32, hash, 16);
	// file list size をここで書き込む
	i = off - 96;
	memcpy(buf + 72, &i, 4);
	// start offset of the data をここで書き込む
	memcpy(buf + 80, &off, 4);

	// 最後にファイルのハッシュ値を計算する
	data_md5(buf + 32, off - 32, hash);
	memcpy(buf + 16, hash, 16);

	return off;
}

// インデックス・ファイルを作り直す
int recreate_par(
	wchar_t *file_path,		// PAR ファイルのパス
	unsigned char *pxx_buf,	// PXX ファイルのヘッダー
	unsigned char *buf)		// 作業バッファー
{
	unsigned char hash[16];
	int data_off, rv;
	HANDLE hFileWrite;

	// start offset of the data を読み取る
	memcpy(&data_off, pxx_buf + 80, 4);
	memcpy(buf, pxx_buf, data_off); // ヘッダー部分をコピーする

	// volume number を 0にする
	memset(buf + 48, 0, 8);
	// data size を 0にする
	memset(buf + 88, 0, 8);
	// control hash を計算しなおす
	data_md5(buf + 32, data_off - 32, hash);
	memcpy(buf + 16, hash, 16);

	// ファイルに書き込む
	hFileWrite = CreateFile(file_path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hFileWrite == INVALID_HANDLE_VALUE)
		return 1;
	if (!WriteFile(hFileWrite, buf, data_off, &rv, NULL)){
		CloseHandle(hFileWrite);
		return 1;
	}
	CloseHandle(hFileWrite);
	return 0;
}

// PAR 1.0 のヘッダーから値を読み取る
int get_header(
	wchar_t *file_name,
	HANDLE hFile,
	unsigned char *buf,
	int buf_size,
	unsigned char *set_hash,	// NULL でなければ set hash、同じ構成の PXX かどうかを識別するため
	int *volume_num,			// リカバリ・ファイルの番号
	int *file_num,				// ソース・ファイルの数
	int *list_off,				// ソース・ファイルのリストの開始位置
	int *list_size,				// ソース・ファイルのリストのサイズ
	int *data_off,				// ソースの開始位置
	__int64 *data_size)			// ソースのサイズ
{
	unsigned char hash[16];
	int i;
	unsigned int rv, meta_data[7];

	if (buf_size <= 96)
		return 1;

	// ファイルの先頭に戻す
	if (SetFilePointer(hFile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER){
		print_win32_err();
		return 1;
	}

	// ヘッダー部分を読み込む
	if (!ReadFile(hFile, buf, buf_size, &rv, NULL)){
		print_win32_err();
		printf("ReadFile, header\n");
		return 1;
	}

	// Identification String
	memcpy(&i, buf, 4);
	if (i != 5390672) // 'P' + 'A' * 256 + 'R' * 65536
		return 1;
	memcpy(&i, buf + 4, 4);
	if (i != 0)
		return 1;
	// Version Number
	memcpy(&i, buf + 8, 4);
	if ((i & 0xffff0000) != 0x00010000) // PAR v1.** にだけ対応する
		return 1;

	// 完全なリカバリ・ファイルを見つけた後だけ、検査結果を探す
	if (list_size == NULL){
		i = check_ini_state(0x10FF, meta_data, hFile);
		if (i == -2){	// 記録が無い、または状態が変化してる
			// control hash
			if (rv = file_md5_from32(file_name, hFile, hash))
				return rv;
			i = 0;
			if (memcmp(hash, buf + 16, 16) != 0)
				i = 1;
			// 今回の検査結果を書き込む
			write_ini_state(0x10FF, meta_data, i);
		}
		if (i != 0)
			return 1;

	} else {
		// control hash
		if (rv = file_md5_from32(file_name, hFile, hash))
			return rv;
		if (memcmp(hash, buf + 16, 16) != 0)
			return 1;
	}

	// set hash
	if (set_hash != NULL)
		memcpy(set_hash, buf + 32, 16);
	// volume number
	if (volume_num != NULL)
		memcpy(volume_num, buf + 48, 4);
	// number of files
	if (file_num != NULL)
		memcpy(file_num, buf + 56, 4);
	// start offset of the file list
	if (list_off != NULL)
		memcpy(list_off, buf + 64, 4);
	// file list size
	if (list_size != NULL)
		memcpy(list_size, buf + 72, 4);
	// start offset of the data
	if (data_off != NULL)
		memcpy(data_off, buf + 80, 4);
	// data size
	if (data_size != NULL)
		memcpy(data_size, buf + 88, 8);

	return 0;
}

// ファイル・リストからブロック数を読み取る
int get_source_num(
	unsigned char *buf,
	__int64 *block_size)
{
	int i, off, file_num, entry_size, status, source_num = 0;
	__int64 file_size;

	// number of files
	memcpy(&file_num, buf + 56, 4);
	// start offset of the file list
	memcpy(&off, buf + 64, 4);

	for (i = 0; i < file_num; i++){
		// entry size
		memcpy(&entry_size, buf + off, 4);
		// status field
		memcpy(&status, buf + (off + 8), 4);
		if ((status & 1) == 1){
			source_num++;
			// file size
			memcpy(&file_size, buf + (off + 16), 8);
			if (file_size > *block_size)
				*block_size = file_size;
		}

		off += entry_size;
	}

	printf("%3d \r", source_num);
	return source_num;
}

// コメントを読み取る
static void read_comment(
	wchar_t *par_comment,
	unsigned char *buf,
	int len)
{
	if (par_comment[0] != 0)
		return;

	if (len >= COMMENT_LEN * 2)
		len = (COMMENT_LEN - 1) * 2;
	memcpy(par_comment, buf, len);
	len /= 2;	// 文字数にする
	par_comment[len] = 0;	// 末尾を null 文字にする
	for (len = 0; len < COMMENT_LEN; len++){	// 表示する前に sanitalize する
		if (par_comment[len] == 0){
			break;
		} else if ((par_comment[len] <= 31) || (par_comment[len] == 127)){	// 制御文字を消す
			par_comment[len] = ' ';
		}
	}
}

// リカバリ・ファイルを作成する
int par1_create(
	int switch_p,			// インデックス・ファイルを作らない
	int source_num,			// ソース・ブロックの数
	__int64 block_size,		// ブロック・サイズ (最大ファイル・サイズ)
	int parity_num,			// パリティ・ブロックの数
	int first_vol,			// 最初のリカバリ・ファイル番号
	int file_num,			// ソース・ファイルの数
	wchar_t *list_buf,		// ソース・ファイルのリスト
	int list_len,			// ファイル・リストの文字数
	wchar_t *par_comment)	// コメント
{
	unsigned char *header_buf = NULL;
	wchar_t recovery_base[MAX_LEN];
	int err = 0, i;
	int int4, buf_size;
	unsigned int rv;
	HANDLE *par_hFile = NULL;
	file_ctx *files = NULL;
	PHMD5 *par_md5 = NULL;

	buf_size = 0x0060 + (0x0038 * file_num) + (list_len * 2); // 最大サイズ分確保しておく
	header_buf = malloc(buf_size);
	if (header_buf == NULL){
		printf("malloc, %d\n", buf_size);
		err = 1;
		goto error_end;
	}

	files = malloc(sizeof(file_ctx) * source_num);
	if (files == NULL){
		printf("malloc, %d\n", sizeof(file_ctx) * source_num);
		err = 1;
		goto error_end;
	}
	for (i = 0; i < source_num; i++)
		files[i].hFile = NULL;

	int4 = sizeof(HANDLE) * parity_num;
	if (int4 == 0)
		int4 = sizeof(HANDLE);
	par_hFile = malloc(int4);
	if (par_hFile == NULL){
		printf("malloc, %d\n", int4);
		err = 1;
		goto error_end;
	}
	par_hFile[0] = NULL;
	for (i = 1; i < parity_num; i++)
		par_hFile[i] = NULL;

	if (parity_num > 0){
		par_md5 = malloc(sizeof(PHMD5) * parity_num);
		if (par_md5 == NULL){
			printf("malloc, %d\n", sizeof(PHMD5) * parity_num);
			err = 1;
			goto error_end;
		}
		for (i = 0; i < parity_num; i++)
			Phmd5Begin(&(par_md5[i]));
	}

	printf("\n");
	print_progress_text(0, "Computing file hash");

	// ヘッダーを作成する
	buf_size = set_header(header_buf, files, source_num, file_num, list_buf, list_len);
	if (buf_size <= 0){
		if (buf_size < 0){
			err = 2;
		} else {
			err = 1;
		}
		goto error_end;
	}

	if (switch_p == 0){	// インデックス・ファイルを作るなら
		// コメントがあるならヘッダーを修正する
		if (int4 = wcslen(par_comment) * 2)
			memcpy(header_buf + 88, &int4, 4);

		// リカバリ・ファイル (*.PAR) を書き込む
		par_hFile[0] = CreateFile(recovery_file, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		if (par_hFile[0] == INVALID_HANDLE_VALUE){
			print_win32_err();
			printf_cp("cannot create file, %s\n", recovery_file);
			par_hFile[0] = NULL;
			err = 1;
			goto error_end;
		}
		if (!WriteFile(par_hFile[0], header_buf, buf_size, &rv, NULL)){
			print_win32_err();
			printf("WriteFile, index file\n");
			err = 1;
			goto error_end;
		}
		// コメントがあるならコメントも書き込む
		if (int4 = wcslen(par_comment) * 2){
			if (!WriteFile(par_hFile[0], par_comment, int4, &int4, NULL)){
				print_win32_err();
				printf("WriteFile, index file\n");
				err = 1;
				goto error_end;
			}
			// MD5を計算しなおす
			if (err = file_md5_from32(NULL, par_hFile[0], header_buf + 16)){
				if (err == 1)
					printf("file_md5_from32\n");
				goto error_end;
			}
			if (SetFilePointer(par_hFile[0], 16, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER){
				print_win32_err();
				err = 1;
				goto error_end;
			}
			if (!WriteFile(par_hFile[0], header_buf + 16, 16, &rv, NULL)){
				print_win32_err();
				printf("WriteFile, index file\n");
				err = 1;
				goto error_end;
			}
		}
		CloseHandle(par_hFile[0]);
		par_hFile[0] = NULL;
	}
	print_progress_done();
	if (parity_num == 0) // パリティ・ブロックを作らない場合はここで終わる
		goto creation_end;

	// ソース・ファイルから読み込む準備をする
	for (i = 0; i < source_num; i++){
		if (SetFilePointer(files[i].hFile, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER){
			print_win32_err();
			err = 1;
			goto error_end;
		}
	}

	// リカバリ・ファイル (*.PXX) の名前の基
	wcscpy(recovery_base, recovery_file);
	int4 = wcslen(recovery_base);
	recovery_base[int4 - 1] = 0;
	recovery_base[int4 - 2] = 0;
	print_progress_text(0, "Creating parity volume");

	// リカバリ・ファイル (*.PXX) に書き込む準備をする
	memcpy(header_buf + 88, &block_size, 8); // ブロック・サイズにする
	for (i = 0; i < parity_num; i++){
		int4 = first_vol + i;	// 作成する parity volume の番号にする
		swprintf(recovery_file, MAX_LEN, L"%s%02d", recovery_base, int4);
		par_hFile[i] = CreateFile(recovery_file, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		if (par_hFile[i] == INVALID_HANDLE_VALUE){
			print_win32_err();
			par_hFile[i] = NULL;
			printf_cp("cannot create file, %s\n", recovery_file);

			// これまでに作ったリカバリ・ファイルを削除する
			if (switch_p == 0){
				wcscpy(recovery_file, recovery_base);
				wcscat(recovery_file, L"ar");
				DeleteFile(recovery_file);
			}
			for (int4 = 0; int4 < i; int4++){
				CloseHandle(par_hFile[int4]);
				par_hFile[int4] = NULL;
				swprintf(recovery_file, MAX_LEN, L"%s%02d", recovery_base, first_vol + int4);
				DeleteFile(recovery_file); // 途中までのリカバリ・ファイルを削除する
			}

			err = 1;
			goto error_end;
		}

		// ヘッダーを書き込む
		memcpy(header_buf + 48, &int4, 2); // volume number にする
		if (!WriteFile(par_hFile[i], header_buf, buf_size, &rv, NULL)){
			print_win32_err();
			printf("WriteFile, parity volume %d\n", int4);
			err = 1;
			goto error_end;
		}
		// ヘッダー部分からのハッシュ値を計算しかけておく
		Phmd5Process(&(par_md5[i]), header_buf + 32, buf_size - 32);
	}

	// パリティ・ブロックを作成する
	if (err = rs_encode(source_num, block_size, parity_num, first_vol - 1, files, par_hFile, par_md5)){
		if (err == 2){ // キャンセルされたのなら、作業中のファイルを削除する
			if (switch_p == 0){
				wcscpy(recovery_file, recovery_base);
				wcscat(recovery_file, L"ar");
				DeleteFile(recovery_file);
			}
			for (i = 0; i < parity_num; i++){
				CloseHandle(par_hFile[i]);
				par_hFile[i] = NULL;
				swprintf(recovery_file, MAX_LEN, L"%s%02d", recovery_base, first_vol + i);
				DeleteFile(recovery_file); // 途中までのリカバリ・ファイルを削除する
			}
		}
		goto error_end;
	}

	// リカバリ・ファイル (*.PXX) の MD5を計算しなおす
	for (i = 0; i < parity_num; i++){
		Phmd5End(&(par_md5[i])); // ハッシュ値の計算終了
		memcpy(header_buf + 16, par_md5[i].hash, 16);
		if (SetFilePointer(par_hFile[i], 16, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER){
			print_win32_err();
			err = 1;
			goto error_end;
		}
		if (!WriteFile(par_hFile[i], header_buf + 16, 16, &rv, NULL)){
			print_win32_err();
			printf("WriteFile, parity volume %d\n", i);
			err = 1;
			goto error_end;
		}
	}

creation_end:
	printf("\nCreated successfully\n");
error_end:
	if (list_buf)
		free(list_buf);
	if (header_buf)
		free(header_buf);
	if (par_md5)
		free(par_md5);
	if (files){
		for (i = 0; i < source_num; i++){
			if (files[i].hFile != NULL)
				CloseHandle(files[i].hFile);
		}
		free(files);
	}
	if (par_hFile){
		for (i = 0; i < parity_num; i++){
			if (par_hFile[i] != NULL)
				CloseHandle(par_hFile[i]);
		}
		free(par_hFile);
	}
	return err;
}

// ソース・ファイルの破損や欠損を調べる
int par1_verify(
	int switch_b,			// 既存のファイルを別名にしてどかす
	int switch_p,			// インデックス・ファイルを作り直す
	wchar_t *par_comment)	// コメント
{
	char ascii_buf[MAX_LEN * 3], ascii_buf2[MAX_LEN * 3];
	unsigned char *header_buf = NULL, *header_buf2 = NULL, hash[16], set_hash[16];
	wchar_t file_name[MAX_LEN], file_path[MAX_LEN], find_path[MAX_LEN];
	wchar_t par_char[] = L"AR";
	int err = 0, i, j, bad_flag, find_flag, parity_flag, par_flag, exist[99];
	int len, dir_len, base_len, buf_size, entry_size, entry_size2, blk;
	int volume_num, volume_max, file_num, list_off, list_size, data_off;
	int buf_size2, volume_num2, file_num2, list_off2, data_off2;
	int parity_num, source_num, block_lost = 0, need_repair = 0, recovery_lost = 0;
	unsigned int rv, meta_data[7];
	__int64 file_size, file_size2, data_size, block_size = 0, total_file_size;
	HANDLE hFile = NULL, hFind;
	WIN32_FIND_DATA FindData;

	// リカバリ・ファイルの名前
	wcscpy(file_path, recovery_file);
	len = wcslen(file_path);
	file_path[len - 2] = 0; // 末尾の2文字を消去する
	if (file_path[len - 3] == 'p'){
		par_char[0] = 'a';
		par_char[1] = 'r';
	}
	// ディレクトリの長さ
	dir_len = len - 3;
	while (dir_len >= 0){
		if ((file_path[dir_len] == '\\') || (file_path[dir_len] == '/'))
			break;
		dir_len--;
	}
	dir_len++;
	base_len = wcslen(base_dir);

	// リカバリ・ファイルの一覧を表示する
	printf("PAR File list :\n");
	printf("         Size :  Filename\n");
	total_file_size = 0;
	parity_num = 0;
	volume_max = 0;
	for (i = 0; i <= 99; i++){
		if (i == 0){
			swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char);
			blk = 0;
		} else {
			swprintf(find_path, MAX_LEN, L"%s%02d", file_path, i);
			blk = 1;
		}
		// ファイルを開くことができるか、サイズを取得できるかを確かめる
		hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
		if (hFile == INVALID_HANDLE_VALUE){
			continue;
		}
		// ファイルのサイズを取得する
		if (!GetFileSizeEx(hFile, (PLARGE_INTEGER)&file_size)){
			CloseHandle(hFile);
			continue;
		}
		CloseHandle(hFile);
		total_file_size += file_size;
		parity_num++;
		volume_max = i;
		// リカバリ・ファイルの名前
		utf16_to_cp(find_path + dir_len, ascii_buf);
		printf("%13I64d : \"%s\"\n", file_size, ascii_buf);
	}
	hFile = NULL;
	printf("\nPAR File total size\t: %I64d\n", total_file_size);
	printf("PAR File possible count\t: %d\n\n", parity_num);

	// 指定されたリカバリ・ファイルを開く
	hFile = CreateFile(recovery_file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
	if (hFile == INVALID_HANDLE_VALUE){
		print_win32_err();
		printf("valid file is not found\n");
		err = 1;
		goto error_end;
	}
	// ファイルのサイズを取得する
	if (!GetFileSizeEx(hFile, (PLARGE_INTEGER)&file_size)){
		print_win32_err();
		err = 1;
		goto error_end;
	}

	// ヘッダー用のバッファーを確保する
	buf_size = 0x0060 + ((0x0038 + (260 * 2)) * 256) + (COMMENT_LEN * 2); // 最大サイズ
	if ((__int64)buf_size > file_size)
		buf_size = (unsigned int)file_size;
	header_buf = malloc(buf_size);
	if (header_buf == NULL){
		printf("malloc, %d\n", buf_size);
		err = 1;
		goto error_end;
	}

	// PAR や PXX ファイルとして正しいかを調べる
	par_flag = 0;
	par_comment[0] = 0;
	for (i = 0; i < 99; i++)
		exist[i] = -1;
	if (rv = get_header(NULL, hFile, header_buf, buf_size, set_hash,
			&volume_num, &file_num, &list_off, &list_size, &data_off, &data_size)){
		if (rv == 2){	// キャンセル
			err = 2;
			goto error_end;
		}
		volume_num = -1;
		par_flag |= 2;
	} else {
		// 各ブロックが存在するかを記録していく
		j = get_source_num(header_buf, &block_size);
		check_ini_file(set_hash, j);	// 前回の検査結果が存在するかどうか
		if (volume_num == 0){
			par_flag |= 1;
			rv = (int)data_size;
			if (buf_size < (int)data_size)
				rv = buf_size;
			if (rv > 1)
				read_comment(par_comment, header_buf + data_off, rv);
		}
	}
	CloseHandle(hFile);
	hFile = NULL;

	// 他のリカバリ・ファイルのヘッダー用のバッファーを確保する
	if (volume_num == -1){
		buf_size2 = 0x0060 + ((0x0038 + (260 * 2)) * 256) + (COMMENT_LEN * 2); // 最大サイズ
	} else {
		buf_size2 = 0x0060 + ((0x0038 + (260 * 2)) * file_num);
	}
	header_buf2 = malloc(buf_size2);
	if (header_buf2 == NULL){
		printf("malloc, %d\n", buf_size2);
		err = 1;
		goto error_end;
	}

	// 他のリカバリ・ファイルも調べる
	printf("Loading PAR File:\n");
	printf(" Block Status   :  Filename\n");
	fflush(stdout);
	parity_num = 0;
	for (i = 0; i <= 99; i++){
		if (err = cancel_progress())	// キャンセル処理
			goto error_end;
		if (i == 0){
			swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char);
			blk = 0;
		} else {
			swprintf(find_path, MAX_LEN, L"%s%02d", file_path, i);
			blk = 1;
		}
		utf16_to_cp(find_path + dir_len, ascii_buf);

		// 既にチェック済みなら
		if ((_wcsicmp(recovery_file + dir_len, find_path + dir_len) == 0) && (volume_num != -1)){
			if ((volume_num > 0) && (volume_num <= 99)){
				if (exist[volume_num - 1] == -1)	// 係数が重複してるのは使えない
					parity_num++;
				exist[volume_num - 1] = i;
				if (volume_max < volume_num)
					volume_max = volume_num;
			}
			if ((par_flag & 2) != 0){
				printf(" 0 / %d Damaged  : \"%s\"\n", blk, ascii_buf);
				recovery_lost++;
			} else if (i == volume_num){
				printf(" %d / %d Good     : \"%s\"\n", blk, blk, ascii_buf);
			} else {
				blk = (volume_num > 0) ? 1 : 0;
				printf(" %d / %d Misnamed : \"%s\"\n", blk, blk, ascii_buf);
				recovery_lost++;	// リカバリ・ファイルの破損は修復必要とは判定しない
			}
			continue;
		}

		// ファイルを開く
		hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
		if (hFile == INVALID_HANDLE_VALUE)
			continue;
		// PAR や PXX ファイルとして正しいかを調べる
		bad_flag = 0;
		if (volume_num == -1){
			if (rv = get_header(find_path + dir_len, hFile, header_buf, buf_size, set_hash,
					&volume_num, &file_num, &list_off, &list_size, &data_off, &data_size)){
				if (rv == 2){	// キャンセル
					err = 2;
					goto error_end;
				}
				volume_num = -1;
				bad_flag = 1;
			} else {
				j = get_source_num(header_buf, &block_size);
				check_ini_file(set_hash, j);	// 前回の検査結果が存在するかどうか
				if (volume_num == 0){
					par_flag |= 1;
					rv = (int)data_size;
					if (buf_size < (int)data_size)
						rv = buf_size;
					if (rv > 1)
						read_comment(par_comment, header_buf + data_off, (int)data_size);
				} else if (volume_num <= 99){
					parity_num++;
					exist[volume_num - 1] = i;
					if (volume_max < volume_num)
						volume_max = volume_num;
				}
				if (i != volume_num){	// ブロック番号と拡張子が異なるなら
					bad_flag = 3;
					blk = (volume_num > 0) ? 1 : 0;
				}
			}
		} else {
			if (rv = get_header(find_path + dir_len, hFile, header_buf2, buf_size2, hash,
					&volume_num2, &file_num2, &list_off2, NULL, &data_off2, &data_size)){
				if (rv == 2){	// キャンセル
					err = 2;
					goto error_end;
				}
				bad_flag = 1;
			} else { // 同じ構成の PXX かを確認する
				if (memcmp(hash, set_hash, 16) != 0)
					bad_flag = 2;
				if ((file_num2 != file_num) || (list_off2 != list_off) || (data_off2 != data_off))
					bad_flag = 2;
				if ((block_size) && (volume_num2 > 0)){
					if (data_size != block_size)
						bad_flag = 2;
				}
				if (!bad_flag){
					if (volume_num2 == 0){
						par_flag |= 1;
						rv = (int)data_size;
						if (buf_size2 < (int)data_size)
							rv = buf_size2;
						if (rv > 1)
							read_comment(par_comment, header_buf2 + data_off2, rv);
					} else if (volume_num2 <= 99){
						if (exist[volume_num2 - 1] == -1)	// 係数が重複してるのは使えない
							parity_num++;
						exist[volume_num2 - 1] = i;
						if (volume_max < volume_num2)
							volume_max = volume_num2;
					}
					if (i != volume_num2){	// ブロック番号と拡張子が異なるなら
						bad_flag = 3;
						blk = (volume_num2 > 0) ? 1 : 0;
					}
				}
			}
		}
		switch (bad_flag){
		case 0:
			printf(" %d / %d Good     : \"%s\"\n", blk, blk, ascii_buf);
			break;
		case 1:
			printf(" 0 / %d Damaged  : \"%s\"\n", blk, ascii_buf);
			recovery_lost++;
			break;
		case 2:
			printf(" %d / %d Useless  : \"%s\"\n", blk, blk, ascii_buf);
			recovery_lost++;
			break;
		case 3:
			printf(" %d / %d Misnamed : \"%s\"\n", blk, blk, ascii_buf);
			recovery_lost++;	// リカバリ・ファイルの破損は修復必要とは判定しない
			break;
		}
		CloseHandle(hFile);
		hFile = NULL;

		fflush(stdout);
	}

	if (volume_num == -1){ // Recovery Set が見つからなければここで終わる
		printf("valid file is not found\n");
		err = 1;
		goto error_end;
	}
	// セット・ハッシュとプログラムのバージョンを表示する
	printf("\nSet Hash: ");
	print_hash(set_hash);
	memcpy(&rv, header_buf + 12, 4);
	printf("\nCreator : ");
	switch (rv >> 24){
	case 1:	// Mirror
		printf("Mirror");
		break;
	case 2:	// PAR
		printf("PAR");
		break;
	case 3:	// SmartPar
		printf("SmartPar");
		break;
	default:
		printf("Unknown client %d", rv >> 24);
	}
	printf(" version %d.%d.%d\n", (rv >> 16) & 0xFF, (rv >> 8) & 0xFF, rv & 0xFF);
	if ((par_comment[0] != 0) && (!utf16_to_cp(par_comment, ascii_buf)))
		printf("Comment : %s\n", ascii_buf); // コメントをユニコードから戻せた場合だけ表示する

	if (((par_flag & 1) == 0) && (switch_p)){ // PAR ファイルを作り直す
		swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char);
		get_temp_name(find_path, file_name);
		if (recreate_par(file_name, header_buf, header_buf2) == 0){
			if (replace_file(find_path, file_name, switch_b) == 0){	// 破損したPARファイルが存在するならどかす
				utf16_to_cp(find_path + dir_len, ascii_buf);
				printf("\nRestored file :\n");
				printf("         Size :  Filename\n");
				printf("%13u : \"%s\"\n", data_off, ascii_buf);
			} else {
				DeleteFile(file_name);
			}
		}
	}
	free(header_buf2);
	header_buf2 = NULL;
	printf("\nParity Volume count\t: %d\n", volume_max);
	printf("Parity Volume found\t: %d\n", parity_num);
	fflush(stdout);

	// ファイル・リストを表示する
	printf("\nInput File list : %d\n", file_num);
	printf("         Size B :  Filename\n");
	total_file_size = 0;
	source_num = 0;
	list_off2 = list_off;
	for (i = 0; i < file_num; i++){
		// entry size
		memcpy(&entry_size, header_buf + list_off2, 4);
		// status field
		memcpy(&parity_flag, header_buf + (list_off2 + 8), 2);
		parity_flag &= 0x01; // bit 0 = file is saved in the parity volume set
		if (parity_flag){
			source_num++;
			blk = 1;
		} else {
			blk = 0;
		}
		// size
		memcpy(&data_size, header_buf + (list_off2 + 16), 8);
		total_file_size += data_size;
		// filename
		len = (entry_size - 56) / 2;
		if (len >= MAX_LEN)
			len = MAX_LEN - 1;
		memcpy(file_name, header_buf + (list_off2 + 56), len * 2);
		file_name[len] = 0;
		utf16_to_cp(file_name, ascii_buf);
		// ファイル名が有効かどうか確かめる
		j = sanitize_filename(file_name);
		if (j != 0){
			if (j == 16){
				printf("filename is not valied, %s\n", ascii_buf);
				err = 1;
				goto error_end;
			}
			utf16_to_cp(file_name, ascii_buf);
		}
		printf("%13I64u %d : \"%s\"\n", data_size, blk, ascii_buf);
		list_off2 += entry_size; // 次のエントリー位置にずらす
	}
	printf("\nData File count : %d\n", source_num);
	printf("Max file size\t: %I64d\n", block_size);
	printf("Total data size : %I64d\n", total_file_size);

	// ソース・ファイルが存在していて正しいかを調べる
	printf("\nVerifying Input File   :\n");
	printf("         Size Status   :  Filename\n");
	fflush(stdout);
	for (i = 0; i < file_num; i++){
		if (err = cancel_progress())	// キャンセル処理
			goto error_end;
		find_flag = bad_flag = parity_flag = 0;

		// entry size
		memcpy(&entry_size, header_buf + list_off, 4);
		// status field
		memcpy(&parity_flag, header_buf + (list_off + 8), 2);
		parity_flag &= 0x01; // bit 0 = file is saved in the parity volume set
		// size
		memcpy(&data_size, header_buf + (list_off + 16), 8);
		file_size = 0;
		// filename
		len = (entry_size - 56) / 2;
		if (len >= MAX_LEN)
			len = MAX_LEN - 1;
		memcpy(file_name, header_buf + (list_off + 56), len * 2);
		file_name[len] = 0;
		utf16_to_cp(file_name, ascii_buf);
		// ファイル名が有効かどうか確かめる
		wcscpy(file_path, file_name);
		j = sanitize_filename(file_path);
		if (j != 0){
			wcscpy(file_name, file_path);
			utf16_to_cp(file_name, ascii_buf);
		}
		// ファイル名を基準ディレクトリに追加してパスにする
		if (base_len + wcslen(file_name) >= MAX_LEN - ADD_LEN){
			printf("filename is too long\n");
			err = 1;
			goto error_end;
		}
		wcscpy(file_path, base_dir);
		wcscpy(file_path + base_len, file_name);

		// ファイルが存在するか
		hFile = CreateFile(file_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
		if (hFile != INVALID_HANDLE_VALUE){ // ファイルが存在するなら内容を確認する
			// 検査結果の記録があるかどうか
			bad_flag = check_ini_state(i, meta_data, hFile);
			memcpy(&file_size, meta_data, 8);
			if (bad_flag == -1){	// ファイル・サイズが不明なら消失扱いにする
				bad_flag = 1;
			} else if (bad_flag == -2){	// 検査結果が無かった場合
				bad_flag = 0;
				if (file_size >= data_size){ // 末尾にゴミが付いてないか調べる
					if (file_size > data_size)
						bad_flag = 2;
					if (data_size > 0){ // 16k MD5 hash が一致するか確かめる
						if (file_md5_16k(hFile, data_size, hash)){
							bad_flag = 1;
						} else if (memcmp(hash, header_buf + (list_off + 40), 16) != 0){
							bad_flag = 1;
						} else if (data_size > 16384){ // MD5 hash が一致するか確かめる
							if (rv = file_md5(file_name, hFile, data_size, hash)){
								if (rv == 2){
									err = 2;
									goto error_end;
								}
								bad_flag = 1;
							} else if (memcmp(hash, header_buf + (list_off + 24), 16) != 0){
								bad_flag = 1;
							}
							// 16k MD5 hash が一致した時だけ検査結果を記録する
							write_ini_state(i, meta_data, bad_flag);
						}
					}
				} else if (file_size < data_size){
					bad_flag = 1;
				}
			}
			CloseHandle(hFile);
			hFile = NULL;
			if (!bad_flag)
				find_flag = 3;
		}

		// ファイルが存在しないか、不完全だった場合は、サイズとハッシュ値で検索する
		if ((data_size) && ((hFile == INVALID_HANDLE_VALUE) || (bad_flag))){
			wcscpy(find_path, base_dir);
			wcscpy(find_path + base_len, L"*");
			hFind = FindFirstFile(find_path, &FindData);
			if (hFind != INVALID_HANDLE_VALUE){
				do {
					if ((FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0){ // フォルダは無視する
						find_flag = 1;
						file_size2 = ((__int64)(FindData.nFileSizeHigh) << 32) | (__int64)(FindData.nFileSizeLow);
						if (file_size2 != data_size){ // ファイル・サイズが一致しなければ
							find_flag = 0;
						} else { // ファイル名がリスト上にあれば除外する
							memcpy(&list_off2, header_buf + 64, 4);
							for (j = 0; j < file_num; j++){
								// entry size
								memcpy(&entry_size2, header_buf + list_off2, 4);
								// filename
								len = (entry_size2 - 56) / 2;
								if (len >= MAX_LEN)
									len = MAX_LEN - 1;
								memcpy(file_name, header_buf + (list_off2 + 56), len * 2);
								file_name[len] = 0;
								sanitize_filename(file_name);
								if (_wcsicmp(file_name, FindData.cFileName) == 0){
									find_flag = 0;
									break;
								}
								list_off2 += entry_size2; // 次のエントリー位置にずらす
							}
						}
						// リスト上に無くてファイル・サイズが一致すれば
						if ((find_flag != 0) && (base_len + wcslen(FindData.cFileName) < MAX_LEN)){
							wcscpy(find_path + base_len, FindData.cFileName);
							hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
							if (hFile != INVALID_HANDLE_VALUE){
								j = check_ini_state(i, meta_data, hFile);
								if (j == -2){	// 検査結果が無かった場合
									if (data_size > 0){ // 16k MD5 hash が一致するか確かめる
										if (file_md5_16k(hFile, data_size, hash)){
											find_flag = 0;
										} else if (memcmp(hash, header_buf + (list_off + 40), 16) != 0){
											find_flag = 0;
										} else if (data_size > 16384){ // MD5 hash が一致するか確かめる
											j = 0;
											if (rv = file_md5(FindData.cFileName, hFile, data_size, hash)){
												if (rv == 2){
													err = 2;
													goto error_end;
												}
												find_flag = 0;
												j = 1;
											} else if (memcmp(hash, header_buf + (list_off + 24), 16) != 0){
												find_flag = 0;
												j = 1;
											}
											// 16k MD5 hash が一致した時だけ検査結果を記録する
											write_ini_state(i, meta_data, j);
										}
									}
								} else if (j != 0){	// 完全以外なら
									find_flag = 0;
								}
								CloseHandle(hFile);
								hFile = NULL;
								if (find_flag){ // 異なる名前だが同じ内容のファイルを発見した
									utf16_to_cp(FindData.cFileName, ascii_buf2);
									break;
								}
							} else {
								find_flag = 0;
							}
						}
					}
				} while (FindNextFile(hFind, &FindData)); // 次のファイルを検索する
				FindClose(hFind);
			}
		}
		if (find_flag == 3){
			printf("            = Complete : \"%s\"\n", ascii_buf);
		} else if (find_flag == 1){
			need_repair++;
			if (bad_flag){
				printf("%13I64u Damaged~ : \"%s\"\n", file_size, ascii_buf);
			} else {
				printf("            - Missing~ : \"%s\"\n", ascii_buf);
			}
			printf("%13I64u Misnamed : \"%s\"\n", data_size, ascii_buf2);
		} else if (bad_flag == 2){
			need_repair++;
			printf("%13I64u Appended : \"%s\"\n", file_size, ascii_buf);
		} else if (bad_flag){
			if (parity_flag)
				block_lost++;
			if (data_size == 0)
				need_repair++;
			printf("%13I64u Damaged  : \"%s\"\n", file_size, ascii_buf);
		} else {
			if (parity_flag)
				block_lost++;
			if (data_size == 0)
				need_repair++;
			printf("            - Missing  : \"%s\"\n", ascii_buf);
		}

		fflush(stdout);
		list_off += entry_size; // 次のエントリー位置にずらす
	}
	printf("\nData File lost\t: %d\n\n", block_lost);
	if ((block_lost == 0) && (need_repair == 0))
		printf("All Files Complete\n");
	if (recovery_lost > 0){	// 不完全なリカバリ・ファイルがあるなら
		err = 256;
		printf("%d PAR File(s) Incomplete\n", recovery_lost);
	}

	// 修復する必要があるかどうか
	if ((block_lost > 0) || (need_repair > 0)){
		err |= 4;
		if (need_repair > 0){
			printf("Ready to rename %d file(s)\n", need_repair);
			err |= 32;
		}
		if (block_lost > 0){
			if (block_lost > parity_num){
				printf("Need %d more volume(s) to repair %d file(s)\n", block_lost - parity_num, block_lost);
				err |= 8;
			} else {
				printf("Ready to repair %d file(s)\n", block_lost);
				err |= 128;
			}
		}
	}

error_end:
	close_ini_file();
	if (hFile != NULL)
		CloseHandle(hFile);
	if (header_buf)
		free(header_buf);
	if (header_buf2)
		free(header_buf2);
	return err;
}

// ソース・ファイルの破損や欠損を修復する
int par1_repair(
	int switch_b,			// 既存のファイルを別名にしてどかす
	int switch_p,			// インデックス・ファイルを作り直す
	wchar_t *par_comment)	// コメント
{
	char ascii_buf[MAX_LEN * 3], ascii_buf2[MAX_LEN * 3];
	unsigned char *header_buf = NULL, *header_buf2 = NULL, hash[16], set_hash[16];
	wchar_t file_name[MAX_LEN * 2], file_path[MAX_LEN], find_path[MAX_LEN * 2];
	wchar_t par_char[] = L"AR";
	int err = 0, i, j, bad_flag, find_flag, parity_flag, par_flag, exist[256];
	int len, dir_len, base_len, buf_size, entry_size, entry_size2, blk;
	int volume_num, volume_max, file_num, list_off, list_size, data_off;
	int buf_size2, volume_num2, file_num2, list_off2, data_off2;
	int parity_num, source_num, block_lost = 0, need_repair = 0, recovery_lost = 0;
	int parity_max, block_max;
	unsigned int rv, meta_data[7];
	__int64 file_size, file_size2, data_size, block_size = 0, total_file_size;
	HANDLE hFile = NULL, hFind;
	WIN32_FIND_DATA FindData;
	file_ctx *files = NULL, *tmp_p;

	// リカバリ・ファイルの名前
	wcscpy(file_path, recovery_file);
	len = wcslen(file_path);
	file_path[len - 2] = 0; // 末尾の2文字を消去する
	if (file_path[len - 3] == 'p'){
		par_char[0] = 'a';
		par_char[1] = 'r';
	}
	// ディレクトリの長さ
	dir_len = len - 3;
	while (dir_len >= 0){
		if ((file_path[dir_len] == '\\') || (file_path[dir_len] == '/'))
			break;
		dir_len--;
	}
	dir_len++;
	base_len = wcslen(base_dir);

	// リカバリ・ファイルの一覧を表示する
	printf("PAR File list :\n");
	printf("         Size :  Filename\n");
	total_file_size = 0;
	parity_num = 0;
	volume_max = 0;
	for (i = 0; i <= 99; i++){
		if (i == 0){
			swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char);
			blk = 0;
		} else {
			swprintf(find_path, MAX_LEN, L"%s%02d", file_path, i);
			blk = 1;
		}
		// ファイルを開くことができるか、サイズを取得できるかを確かめる
		hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
		if (hFile == INVALID_HANDLE_VALUE){
			continue;
		}
		// ファイルのサイズを取得する
		if (!GetFileSizeEx(hFile, (PLARGE_INTEGER)&file_size)){
			CloseHandle(hFile);
			continue;
		}
		CloseHandle(hFile);
		total_file_size += file_size;
		parity_num++;
		volume_max = i;
		// リカバリ・ファイルの名前
		utf16_to_cp(find_path + dir_len, ascii_buf);
		printf("%13I64d : \"%s\"\n", file_size, ascii_buf);
	}
	hFile = NULL;
	printf("\nPAR File total size\t: %I64d\n", total_file_size);
	printf("PAR File possible count\t: %d\n\n", parity_num);

	// 指定されたリカバリ・ファイルを開く
	hFile = CreateFile(recovery_file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
	if (hFile == INVALID_HANDLE_VALUE){
		print_win32_err();
		printf("valid file is not found\n");
		err = 1;
		goto error_end;
	}
	// ファイルのサイズを取得する
	if (!GetFileSizeEx(hFile, (PLARGE_INTEGER)&file_size)){
		print_win32_err();
		err = 1;
		goto error_end;
	}

	// ヘッダー用のバッファーを確保する
	buf_size = 0x0060 + ((0x0038 + (260 * 2)) * 256) + (COMMENT_LEN * 2); // 最大サイズ
	if ((__int64)buf_size > file_size)
		buf_size = (unsigned int)file_size;
	header_buf = malloc(buf_size);
	if (header_buf == NULL){
		printf("malloc, %d\n", buf_size);
		err = 1;
		goto error_end;
	}

	// PAR や PXX ファイルとして正しいかを調べる
	parity_max = 0;
	par_flag = 0;
	par_comment[0] = 0;
	for (i = 0; i < 256; i++)
		exist[i] = -1;
	if (rv = get_header(NULL, hFile, header_buf, buf_size, set_hash,
			&volume_num, &file_num, &list_off, &list_size, &data_off, &data_size)){
		if (rv == 2){	// キャンセル
			err = 2;
			goto error_end;
		}
		volume_num = -1;
		par_flag |= 2;
	} else {
		// 各ブロックが存在するかを記録していく
		block_max = get_source_num(header_buf, &block_size);
		check_ini_file(set_hash, block_max);	// 前回の検査結果が存在するかどうか
		if (volume_num == 0){
			par_flag |= 1;
			rv = (int)data_size;
			if (buf_size < (int)data_size)
				rv = buf_size;
			if (rv > 1)
				read_comment(par_comment, header_buf + data_off, rv);
		}
	}
	CloseHandle(hFile);
	hFile = NULL;

	// 他のリカバリ・ファイルのヘッダー用のバッファーを確保する
	if (volume_num == -1){
		buf_size2 = 0x0060 + ((0x0038 + (260 * 2)) * 256) + (COMMENT_LEN * 2); // 最大サイズ
	} else {
		buf_size2 = 0x0060 + ((0x0038 + (260 * 2)) * file_num);
	}
	header_buf2 = malloc(buf_size2);
	if (header_buf2 == NULL){
		printf("malloc, %d\n", buf_size2);
		err = 1;
		goto error_end;
	}

	// 他のリカバリ・ファイルも調べる
	printf("Loading PAR File:\n");
	printf(" Block Status   :  Filename\n");
	fflush(stdout);
	parity_num = 0;
	for (i = 0; i <= 99; i++){
		if (err = cancel_progress())	// キャンセル処理
			goto error_end;
		if (i == 0){
			swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char);
			blk = 0;
		} else {
			swprintf(find_path, MAX_LEN, L"%s%02d", file_path, i);
			blk = 1;
		}
		utf16_to_cp(find_path + dir_len, ascii_buf);

		// 既にチェック済みなら
		if ((_wcsicmp(recovery_file + dir_len, find_path + dir_len) == 0) && (volume_num != -1)){
			if ((volume_num > 0) && (volume_num <= 99)){
				if (exist[block_max + volume_num - 1] == -1)	// 係数が重複してるのは使えない
					parity_num++;
				if (parity_max < volume_num)
					parity_max = volume_num;
				if (block_max + volume_num <= 256)
					exist[block_max + volume_num - 1] = i;
				if (volume_max < volume_num)
					volume_max = volume_num;
			}
			if ((par_flag & 2) != 0){
				printf(" 0 / %d Damaged  : \"%s\"\n", blk, ascii_buf);
				recovery_lost++;
			} else if (i == volume_num){
				printf(" %d / %d Good     : \"%s\"\n", blk, blk, ascii_buf);
			} else {
				blk = (volume_num > 0) ? 1 : 0;
				printf(" %d / %d Misnamed : \"%s\"\n", blk, blk, ascii_buf);
				recovery_lost++;	// リカバリ・ファイルの破損は修復必要とは判定しない
			}
			continue;
		}

		// ファイルを開く
		hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
		if (hFile == INVALID_HANDLE_VALUE)
			continue;
		// PAR や PXX ファイルとして正しいかを調べる
		bad_flag = 0;
		if (volume_num == -1){
			if (rv = get_header(find_path + dir_len, hFile, header_buf, buf_size, set_hash,
					&volume_num, &file_num, &list_off, &list_size, &data_off, &data_size)){
				if (rv == 2){	// キャンセル
					err = 2;
					goto error_end;
				}
				volume_num = -1;
				bad_flag = 1;
			} else {
				block_max = get_source_num(header_buf, &block_size);
				check_ini_file(set_hash, block_max);	// 前回の検査結果が存在するかどうか
				if (volume_num == 0){
					par_flag |= 1;
					rv = (int)data_size;
					if (buf_size < (int)data_size)
						rv = buf_size;
					if (rv > 1)
						read_comment(par_comment, header_buf + data_off, (int)data_size);
				} else if (volume_num <= 99){
					parity_num++;
					if (parity_max < volume_num)
						parity_max = volume_num;
					if (block_max + volume_num <= 256)
						exist[block_max + volume_num - 1] = i;
					if (volume_max < volume_num)
						volume_max = volume_num;
				}
				if (i != volume_num){ // ブロック番号と拡張子が異なるなら
					bad_flag = 3;
					blk = (volume_num > 0) ? 1 : 0;
				}
			}
		} else {
			if (rv = get_header(find_path + dir_len, hFile, header_buf2, buf_size2, hash,
					&volume_num2, &file_num2, &list_off2, NULL, &data_off2, &data_size)){
				if (rv == 2){	// キャンセル
					err = 2;
					goto error_end;
				}
				bad_flag = 1;
			} else { // 同じ構成の PXX かを確認する
				if (memcmp(hash, set_hash, 16) != 0)
					bad_flag = 2;
				if ((file_num2 != file_num) || (list_off2 != list_off) || (data_off2 != data_off))
					bad_flag = 2;
				if ((block_size) && (volume_num2 > 0)){
					if (data_size != block_size)
						bad_flag = 2;
				}
				if (!bad_flag){
					if (volume_num2 == 0){
						par_flag |= 1;
						rv = (int)data_size;
						if (buf_size2 < (int)data_size)
							rv = buf_size2;
						if (rv > 1)
							read_comment(par_comment, header_buf2 + data_off2, rv);
					} else if (volume_num2 <= 99){
						if (exist[block_max + volume_num2 - 1] == -1)	// 係数が重複してるのは使えない
							parity_num++;
						// 各ブロックが存在するかを記録していく
						if (parity_max < volume_num2)
							parity_max = volume_num2;
						if (block_max + volume_num2 <= 256)
							exist[block_max + volume_num2 - 1] = i;
						if (volume_max < volume_num2)
							volume_max = volume_num2;
					}
					if (i != volume_num2){ // ブロック番号と拡張子が異なるなら
						bad_flag = 3;
						blk = (volume_num2 > 0) ? 1 : 0;
					}
				}
			}
		}
		switch (bad_flag){
		case 0:
			printf(" %d / %d Good     : \"%s\"\n", blk, blk, ascii_buf);
			break;
		case 1:
			printf(" 0 / %d Damaged  : \"%s\"\n", blk, ascii_buf);
			recovery_lost++;
			break;
		case 2:
			printf(" %d / %d Useless  : \"%s\"\n", blk, blk, ascii_buf);
			recovery_lost++;
			break;
		case 3:
			printf(" %d / %d Misnamed : \"%s\"\n", blk, blk, ascii_buf);
			recovery_lost++;	// リカバリ・ファイルの破損は修復必要とは判定しない
			break;
		}
		CloseHandle(hFile);
		hFile = NULL;

		fflush(stdout);
	}

	if (volume_num == -1){ // Recovery Set が見つからなければここで終わる
		printf("valid file is not found\n");
		err = 1;
		goto error_end;
	}
	// セット・ハッシュとプログラムのバージョンを表示する
	printf("\nSet Hash: ");
	print_hash(set_hash);
	memcpy(&rv, header_buf + 12, 4);
	printf("\nCreator : ");
	switch (rv >> 24){
	case 1:	// Mirror
		printf("Mirror");
		break;
	case 2:	// PAR
		printf("PAR");
		break;
	case 3:	// SmartPar
		printf("SmartPar");
		break;
	default:
		printf("Unknown client %d", rv >> 24);
	}
	printf(" version %d.%d.%d\n", (rv >> 16) & 0xFF, (rv >> 8) & 0xFF, rv & 0xFF);
	if ((par_comment[0] != 0) && (!utf16_to_cp(par_comment, ascii_buf)))
		printf("Comment : %s\n", ascii_buf); // コメントをユニコードから戻せた場合だけ表示する

	if (((par_flag & 1) == 0) && (switch_p)){ // PAR ファイルを作り直す
		swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char);
		get_temp_name(find_path, file_name);
		if (recreate_par(file_name, header_buf, header_buf2) == 0){
			if (replace_file(find_path, file_name, switch_b) == 0){	// 破損したPARファイルが存在するならどかす
				utf16_to_cp(find_path + dir_len, ascii_buf);
				printf("\nRestored file :\n");
				printf("         Size :  Filename\n");
				printf("%13u : \"%s\"\n", data_off, ascii_buf);
			} else {
				DeleteFile(file_name);
			}
		}
	}
	free(header_buf2);
	header_buf2 = NULL;
	printf("\nParity Volume count\t: %d\n", volume_max);
	printf("Parity Volume found\t: %d\n", parity_num);
	fflush(stdout);

	// リカバリ・ファイルを開く
	len = sizeof(file_ctx) * (block_max + parity_max);
	files = malloc(len);
	if (files == NULL){
		printf("malloc, %d\n", len);
		err = 1;
		goto error_end;
	}
	for (i = 0; i < (block_max + parity_max); i++)
		files[i].hFile = NULL;
	for (i = block_max; i < (block_max + parity_max); i++){
		if (exist[i] != -1){ // リカバリ・ファイルが存在するなら
			if (exist[i] == 0){
				swprintf(find_path, MAX_LEN, L"%s%s", file_path, par_char);
			} else {
				swprintf(find_path, MAX_LEN, L"%s%02d", file_path, exist[i]);
			}
			files[i].hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
			if (files[i].hFile == INVALID_HANDLE_VALUE){
				exist[i] = 0;
				continue;
			}
			// ファイル・サイズを取得する
			if (!GetFileSizeEx(files[i].hFile, (PLARGE_INTEGER)&file_size2)){
				exist[i] = 0;
				continue;
			}
			files[i].size = file_size2;
			files[i].size -= data_off;
			//printf("%d: off = %d, size = %I64u \n", i, data_off, files[i].size);
			// 開始位置をリード・ソロモン符号のデータの所にしておく
			if (SetFilePointer(files[i].hFile, data_off, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER){
				exist[i] = 0;
				continue;
			}
			exist[i] = 1;
		} else {
			exist[i] = 0;
		}
	}
	for (i = 0; i < block_max; i++)
		exist[i] = 0;

	// ファイル・リストを表示する
	printf("\nInput File list : %d\n", file_num);
	printf("         Size B :  Filename\n");
	total_file_size = 0;
	source_num = 0;
	list_off2 = list_off;
	for (i = 0; i < file_num; i++){
		// entry size
		memcpy(&entry_size, header_buf + list_off2, 4);
		// status field
		memcpy(&parity_flag, header_buf + (list_off2 + 8), 2);
		parity_flag &= 0x01; // bit 0 = file is saved in the parity volume set
		if (parity_flag){
			source_num++;
			blk = 1;
		} else {
			blk = 0;
		}
		// size
		memcpy(&data_size, header_buf + (list_off2 + 16), 8);
		total_file_size += data_size;
		// filename
		len = (entry_size - 56) / 2;
		if (len >= MAX_LEN)
			len = MAX_LEN - 1;
		memcpy(file_name, header_buf + (list_off2 + 56), len * 2);
		file_name[len] = 0;
		utf16_to_cp(file_name, ascii_buf);
		// ファイル名が有効かどうか確かめる
		j = sanitize_filename(file_name);
		if (j != 0){
			if (j == 16){
				printf("filename is not valied, %s\n", ascii_buf);
				err = 1;
				goto error_end;
			}
			utf16_to_cp(file_name, ascii_buf);
		}
		printf("%13I64u %d : \"%s\"\n", data_size, blk, ascii_buf);
		list_off2 += entry_size; // 次のエントリー位置にずらす
	}
	printf("\nData File count : %d\n", source_num);
	printf("Max file size\t: %I64d\n", block_size);
	printf("Total data size : %I64d\n", total_file_size);

	// ソース・ファイルが存在していて正しいかを調べる
	printf("\nVerifying Input File   :\n");
	printf("         Size Status   :  Filename\n");
	fflush(stdout);
	source_num = 0;
	for (i = 0; i < file_num; i++){
		if (err = cancel_progress())	// キャンセル処理
			goto error_end;
		find_flag = bad_flag = parity_flag = 0;

		// entry size
		memcpy(&entry_size, header_buf + list_off, 4);
		// status field
		memcpy(&parity_flag, header_buf + (list_off + 8), 2);
		parity_flag &= 0x0001; // bit 0 = file is saved in the parity volume set
		if (parity_flag)
			source_num++;
		// size
		memcpy(&data_size, header_buf + (list_off + 16), 8);
		file_size = 0;
		// filename
		len = (entry_size - 56) / 2;
		if (len >= MAX_LEN)
			len = MAX_LEN - 1;
		memcpy(file_name, header_buf + (list_off + 56), len * 2);
		file_name[len] = 0;
		utf16_to_cp(file_name, ascii_buf);
		// ファイル名が有効かどうか確かめる
		wcscpy(file_path, file_name);
		j = sanitize_filename(file_path);
		if (j != 0){
			wcscpy(file_name, file_path);
			utf16_to_cp(file_name, ascii_buf);
		}
		// ファイル名を基準ディレクトリに追加してパスにする
		if (base_len + wcslen(file_name) >= MAX_LEN - ADD_LEN){
			printf("filename is too long\n");
			err = 1;
			goto error_end;
		}
		wcscpy(file_path, base_dir);
		wcscpy(file_path + base_len, file_name);

		// ファイルが存在するか
		hFile = CreateFile(file_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
		if (hFile != INVALID_HANDLE_VALUE){ // ファイルが存在するなら内容を確認する
			// 検査結果の記録があるかどうか
			bad_flag = check_ini_state(i, meta_data, hFile);
			memcpy(&file_size, meta_data, 8);
			if (bad_flag == -1){	// ファイル・サイズが不明なら消失扱いにする
				bad_flag = 1;
			} else if (bad_flag == -2){	// 検査結果が無かった場合
				bad_flag = 0;
				if (file_size >= data_size){ // 末尾にゴミが付いてないか調べる
					if (file_size > data_size)
						bad_flag = 2;
					if (data_size > 0){ // 16k MD5 hash が一致するか確かめる
						if (file_md5_16k(hFile, data_size, hash)){
							bad_flag = 1;
						} else if (memcmp(hash, header_buf + (list_off + 40), 16) != 0){
							bad_flag = 1;
						} else if (data_size > 16384){ // MD5 hash が一致するか確かめる
							if (rv = file_md5(file_name, hFile, data_size, hash)){
								if (rv == 2){
									err = 2;
									goto error_end;
								}
								bad_flag = 1;
							} else if (memcmp(hash, header_buf + (list_off + 24), 16) != 0){
								bad_flag = 1;
							}
							// 16k MD5 hash が一致した時だけ検査結果を記録する
							write_ini_state(i, meta_data, bad_flag);
						}
					}
				} else if (file_size < data_size){
					bad_flag = 1;
				}
			}
			CloseHandle(hFile);
			hFile = NULL;
			if (!bad_flag){
				find_flag = 3;
				if (parity_flag)
					exist[source_num - 1] = 1;
			}
		}

		// ファイルが存在しないか、不完全だった場合は、サイズとハッシュ値で検索する
		if ((data_size) && ((hFile == INVALID_HANDLE_VALUE) || (bad_flag))){
			wcscpy(find_path, base_dir);
			wcscpy(find_path + base_len, L"*");
			hFind = FindFirstFile(find_path, &FindData);
			if (hFind != INVALID_HANDLE_VALUE){
				do {
					if ((FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0){ // フォルダは無視する
						find_flag = 1;
						file_size2 = ((__int64)(FindData.nFileSizeHigh) << 32) | (__int64)(FindData.nFileSizeLow);
						if (file_size2 != data_size){ // ファイル・サイズが一致しなければ
							find_flag = 0;
						} else { // ファイル名がリスト上にあれば除外する
							memcpy(&list_off2, header_buf + 64, 4);
							for (j = 0; j < file_num; j++){
								// entry size
								memcpy(&entry_size2, header_buf + list_off2, 4);
								// filename
								len = (entry_size2 - 56) / 2;
								if (len >= MAX_LEN)
									len = MAX_LEN - 1;
								memcpy(file_name, header_buf + (list_off2 + 56), len * 2);
								file_name[len] = 0;
								sanitize_filename(file_name);
								if (_wcsicmp(file_name, FindData.cFileName) == 0){
									find_flag = 0;
									break;
								}
								list_off2 += entry_size2; // 次のエントリー位置にずらす
							}
						}
						// リスト上に無くてファイル・サイズが一致すれば
						if ((find_flag != 0) && (base_len + wcslen(FindData.cFileName) < MAX_LEN)){
							wcscpy(find_path + base_len, FindData.cFileName);
							hFile = CreateFile(find_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
							if (hFile != INVALID_HANDLE_VALUE){
								j = check_ini_state(i, meta_data, hFile);
								if (j == -2){	// 検査結果が無かった場合
									if (data_size > 0){ // 16k MD5 hash が一致するか確かめる
										if (file_md5_16k(hFile, data_size, hash)){
											find_flag = 0;
										} else if (memcmp(hash, header_buf + (list_off + 40), 16) != 0){
											find_flag = 0;
										} else if (data_size > 16384){ // MD5 hash が一致するか確かめる
											j = 0;
											if (rv = file_md5(FindData.cFileName, hFile, data_size, hash)){
												if (rv == 2){
													err = 2;
													goto error_end;
												}
												find_flag = 0;
												j = 1;
											} else if (memcmp(hash, header_buf + (list_off + 24), 16) != 0){
												find_flag = 0;
												j = 1;
											}
											// 16k MD5 hash が一致した時だけ検査結果を記録する
											write_ini_state(i, meta_data, j);
										}
									}
								} else if (j != 0){	// 完全以外なら
									find_flag = 0;
								}
								CloseHandle(hFile);
								hFile = NULL;
								if (find_flag){ // 異なる名前だが同じ内容のファイルを発見した
									utf16_to_cp(FindData.cFileName, ascii_buf2);
									// ファイル名を修正する
									if (replace_file(file_path, find_path, switch_b) == 0){
										find_flag = 2;
//									} else {
//										printf("cannot rename to %s\n", ascii_buf);
//										err = 1;
//										goto error_end;
									}
									break;
								}
							} else {
								find_flag = 0;
							}
						}
					}
				} while (FindNextFile(hFind, &FindData)); // 次のファイルを検索する
				FindClose(hFind);
			}
		}
		if (find_flag == 3){
			printf("            = Complete : \"%s\"\n", ascii_buf);
		} else if (find_flag == 1){
			need_repair++;
			need_repair |= 0x40000000;	// 修復失敗の印
			if (bad_flag){
				printf("%13I64u Failed~  : \"%s\"\n", file_size, ascii_buf);
			} else {
				printf("            - Failed   : \"%s\"\n", ascii_buf);
			}
			printf("%13I64u Misnamed : \"%s\"\n", data_size, ascii_buf2);
		} else if (find_flag == 2){
			need_repair += 0x10001;	// 修復できた数を記録する
			if (parity_flag)
				exist[source_num - 1] = 1;
			printf("%13I64u Restored : \"%s\"\n", data_size, ascii_buf);
		} else if (bad_flag == 2){
			if (shorten_file(file_path, data_size, switch_b) != 0)	// ファイルを小さくする
				bad_flag = 1;
			need_repair++;
			if (bad_flag == 2){	// 修復 (縮小) できたら
				need_repair += 0x10000;	// 上位 16-bit に修復できた数を記録する
				if (parity_flag)
					exist[source_num - 1] = 1;
				printf("%13I64u Restored : \"%s\"\n", data_size, ascii_buf);
			} else {	// 修復できなかったなら
				if (parity_flag)
					block_lost++;
				printf("%13I64u Appended : \"%s\"\n", file_size, ascii_buf);
			}
		} else if (bad_flag){
			bad_flag = 1;
			if (data_size == 0){	// サイズが 0ならすぐに復元できる
				need_repair++;
				hFile = CreateFile(file_path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
				if (hFile != INVALID_HANDLE_VALUE){
					bad_flag = 0;
					need_repair += 0x10000;	// 上位 16-bit に修復できた数を記録する
				}
				CloseHandle(hFile);
				hFile = NULL;
			}
			if (bad_flag){
				if (parity_flag)
					block_lost++;
				printf("%13I64u Damaged  : \"%s\"\n", file_size, ascii_buf);
			} else {
				if (parity_flag)
					exist[source_num - 1] = 1;
				printf("%13I64u Restored : \"%s\"\n", data_size, ascii_buf);
			}
		} else {
			bad_flag = 1;
			if (data_size == 0){ // サイズが 0ならすぐに復元できる
				need_repair++;
				hFile = CreateFile(file_path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
				if (hFile != INVALID_HANDLE_VALUE){
					bad_flag = 0;
					need_repair += 0x10000;	// 上位 16-bit に修復できた数を記録する
				}
				CloseHandle(hFile);
				hFile = NULL;
			}
			if (bad_flag){
				if (parity_flag)
					block_lost++;
				printf("            - Missing  : \"%s\"\n", ascii_buf);
			} else {
				if (parity_flag)
					exist[source_num - 1] = 1;
				printf("%13I64u Restored : \"%s\"\n", data_size, ascii_buf);
			}
		}

		if (parity_flag){
			// ソース・ファイルを開く
			if (exist[source_num - 1]){ // ソース・ブロックが存在するなら
				files[source_num - 1].hFile = CreateFile(file_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
				if (files[source_num - 1].hFile == INVALID_HANDLE_VALUE){
					exist[source_num - 1] = 0;
				} else {
					if (!GetFileSizeEx(files[source_num - 1].hFile, (PLARGE_INTEGER)&file_size2)){
						exist[source_num - 1] = 0;
					} else {
						files[source_num - 1].size = file_size2;
					}
				}
			} else { // 破損してる、または存在しないなら
				get_temp_name(file_path, find_path); // 修復中のテンポラリ・ファイル
				files[source_num - 1].hFile = CreateFile(find_path, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
				if (files[source_num - 1].hFile == INVALID_HANDLE_VALUE){
					print_win32_err();
					printf_cp("cannot create file, %s\n", find_path);
					err = 1;
					goto error_end;
				}
				files[source_num - 1].size = data_size; 
			}
			//printf("%d: exist = %d, size = %I64u \n", source_num - 1, exist[source_num - 1], files[source_num - 1].size);
		}

		fflush(stdout);
		list_off += entry_size; // 次のエントリー位置にずらす
	}
	printf("\nData File lost\t: %d\n\n", block_lost);

	// 修復に必要なパリティ・ブロックの数が少なくて済むなら最大値を調節する
	if (block_lost < parity_num){
		volume_num = 0;
		len = block_max + parity_max;
		for (i = block_max; i < len; i++){
			if (exist[i]){
				volume_num++;
				if (volume_num > block_lost){
					volume_num--;
					exist[i] = 0;
					CloseHandle(files[i].hFile);
					files[i].hFile = NULL;
				} else {
					parity_max = 1 + i - block_max;
				}
			}
		}
		len = sizeof(file_ctx) * (block_max + parity_max);
		tmp_p = (file_ctx *)realloc(files, len);
		if (tmp_p == NULL){
			printf("realloc, %d\n", len);
			err = 1;
			goto error_end;
		} else {
			files = tmp_p;
		}
	}

	if ((block_lost == 0) && (need_repair == 0))
		printf("All Files Complete\n");
	if (recovery_lost > 0){	// 不完全なリカバリ・ファイルがあるなら
		err = 256;
		printf("%d PAR File(s) Incomplete\n", recovery_lost);
	}

	// 修復する必要があるかどうか
	if (block_lost == 0){
		if (need_repair > 0){
			need_repair &= 0x3FFFFFFF;
			printf("Restored file count\t: %d\n\n", need_repair >> 16);
			need_repair = (need_repair & 0xFFFF) - (need_repair >> 16);
			if (need_repair == 0){	// 全て修復できたのなら
				printf("Repaired successfully\n");
				err |= 16;
			} else {
				printf("Failed to repair %d file(s)\n", need_repair);
				err |= 16 | 4;
			}
		}
		goto error_end;
	} else {
		if (need_repair > 0){
			printf("Restored file count\t: %d\n\n", (need_repair >> 16) & 0x3FFF);
			if (need_repair & 0x40000000){
				need_repair = (need_repair & 0xFFFF) - ((need_repair >> 16) & 0x3FFF);
				printf("Failed to repair %d file(s)\n", block_lost + need_repair);
				err |= 16 | 4;
				goto error_end;
			}
			need_repair &= 0x3FFFFFFF;
			need_repair = (need_repair & 0xFFFF) - (need_repair >> 16);
		}
		if (block_lost > parity_num){
			printf("Need %d more volume(s) to repair %d file(s)\n", block_lost - parity_num, block_lost);
			err |= 8 | 4;
			goto error_end;
		} else {
			printf("Ready to repair %d file(s)\n", block_lost);
		}
	}

	// 失われたブロックを復元する
	printf("\n");
	print_progress_text(0, "Recovering data");
	if (err = rs_decode(block_max, block_lost, block_size, parity_max, exist, files)){
		goto error_end;
	}

	// 正しく修復できたか確かめる
	printf("\nVerifying repair: %d\n", block_lost);
	printf(" Status   :  Filename\n");
	fflush(stdout);
	wcscpy(file_path, base_dir);
	find_flag = 0;
	source_num = 0;
	memcpy(&list_off, header_buf + 64, 4);
	for (i = 0; i < file_num; i++){
		bad_flag = 0;

		// entry size
		memcpy(&entry_size, header_buf + list_off, 4);
		// status field
		memcpy(&parity_flag, header_buf + (list_off + 8), 2);
		parity_flag &= 0x0001; // bit 0 = file is saved in the parity volume set
		// size
		memcpy(&data_size, header_buf + (list_off + 16), 8);
		// filename
		len = (entry_size - 56) / 2;
		if (len >= MAX_LEN)
			len = MAX_LEN - 1;
		memcpy(file_name, header_buf + (list_off + 56), len * 2);
		file_name[len] = 0;
		utf16_to_cp(file_name, ascii_buf);
		sanitize_filename(file_name);

		// ファイル名を基準ディレクトリに追加してパスにする
		wcscpy(file_path + base_len, file_name);

		//printf("%d : list_off = %d, exist = %d \n", i, list_off, exist[source_num]);
		// 修復したファイルのハッシュ値を計算する
		if (parity_flag){
			if (exist[source_num] == 0){
				if (file_md5(file_name, files[source_num].hFile, data_size, hash)){
					bad_flag = 1;
				} else {
					for (j = 0; j < 16; j++){
						if (hash[j] != header_buf[list_off + 24 + j]){
							bad_flag = 1;
							break;
						}
					}
				}
				CloseHandle(files[source_num].hFile);
				files[source_num].hFile = NULL;
				get_temp_name(file_path, find_path);
				if (bad_flag){ // 失敗
					DeleteFile(find_path); // テンポラリ・ファイルを削除する
					printf(" Failed   : \"%s\"\n", ascii_buf);
				} else { // 復元成功
					if (replace_file(file_path, find_path, switch_b) == 0){	// 修復したファイルを戻す
						block_lost--;
						find_flag++;
						printf(" Repaired : \"%s\"\n", ascii_buf);
					} else {	// ファイルを戻せなかった場合は、テンポラリ・ファイルを残した方がいいかも？
						// まあ PAR2 と違ってすぐに修復できるから、削除してもよさそう。
						DeleteFile(find_path); // テンポラリ・ファイルを削除する
						printf(" Locked   : \"%s\"\n", ascii_buf);
					}
				}
				fflush(stdout);
			}
			source_num++;
		}

		list_off += entry_size; // 次のエントリー位置にずらす
	}
	printf("\nRepaired file count\t: %d\n\n", find_flag);

	err = 16;
	if (block_lost + need_repair == 0){	// 全て修復できたなら
		printf("Repaired successfully\n");
	} else {
		printf("Failed to repair %d file(s)\n", block_lost + need_repair);
		err |= 4;
	}
	if (recovery_lost > 0)
		err |= 256;

error_end:
	close_ini_file();
	if (files){
		// エラーが発生したら、作業中のファイルを削除する
		source_num = 0;
		memcpy(&list_off, header_buf + 64, 4);
		for (i = 0; i < file_num; i++){
			// entry size
			memcpy(&entry_size, header_buf + list_off, 4);
			// status field
			memcpy(&parity_flag, header_buf + (list_off + 8), 2);
			parity_flag &= 0x0001; // bit 0 = file is saved in the parity volume set
			// filename
			len = (entry_size - 56) / 2;
			if (len >= MAX_LEN)
				len = MAX_LEN - 1;
			memcpy(file_name, header_buf + (list_off + 56), len * 2);
			file_name[len] = 0;
			sanitize_filename(file_name);

			// ファイル名を基準ディレクトリに追加してパスにする
			wcscpy(file_path + base_len, file_name);

			if (parity_flag){
				if ((exist[source_num] == 0) && (files[source_num].hFile)){
					CloseHandle(files[source_num].hFile);
					files[source_num].hFile = NULL;
					get_temp_name(file_path, find_path);
					DeleteFile(find_path); // テンポラリ・ファイルを削除する
				}
				source_num++;
			}

			list_off += entry_size; // 次のエントリー位置にずらす
		}
		for (i = 0; i < (source_num + parity_max); i++){
			if (files[i].hFile != NULL)
				CloseHandle(files[i].hFile);
		}
		free(files);
	}
	if (hFile != NULL)
		CloseHandle(hFile);
	if (header_buf)
		free(header_buf);
	if (header_buf2)
		free(header_buf2);
	return err;
}

// ソース・ファイルの一覧を表示する
int par1_list(
	int switch_h,				// ハッシュ値も表示する
	wchar_t *par_comment)		// コメント
{
	char ascii_buf[MAX_LEN * 3];
	unsigned char *header_buf = NULL, hash[16];
	wchar_t file_name[MAX_LEN];
	int err = 0, i, parity_flag;
	int len, buf_size, entry_size, blk;
	int volume_num, file_num, list_off, list_size, data_off;
	int source_num = 0;
	__int64 file_size, data_size, block_size = 0;
	HANDLE hFile = NULL;

	// 指定されたリカバリ・ファイルを開く
	hFile = CreateFile(recovery_file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
	if (hFile == INVALID_HANDLE_VALUE){
		print_win32_err();
		printf("cannot open PAR file\n");
		err = 1;
		goto error_end;
	}

	// ファイルのサイズを取得する
	if (!GetFileSizeEx(hFile, (PLARGE_INTEGER)&file_size)){
		print_win32_err();
		err = 1;
		goto error_end;
	}

	// ヘッダー用のバッファーを確保する
	buf_size = 0x0060 + ((0x0038 + (260 * 2)) * 256) + (COMMENT_LEN * 2); // 最大サイズ
	if ((__int64)buf_size > file_size)
		buf_size = (unsigned int)file_size;
	header_buf = malloc(buf_size);
	if (header_buf == NULL){
		printf("malloc, %d\n", buf_size);
		err = 1;
		goto error_end;
	}

	// PAR や PXX ファイルとして正しいかを調べる
	if (err = get_header(NULL, hFile, header_buf, buf_size, hash,
			&volume_num, &file_num, &list_off, &list_size, &data_off, &data_size)){
		if (err != 2)	// キャンセル以外なら
			printf("valid file is not found\n");
		goto error_end;
	} else {
		if ((volume_num == 0) && (data_size > 0)){ // コメントがある
			len = (int)data_size;
			if (buf_size < (int)data_size)
				len = buf_size;
			if (len > 1)
				read_comment(par_comment, header_buf + data_off, len);
			if (!utf16_to_cp(par_comment, ascii_buf))
				printf("Comment : %s\n", ascii_buf); // コメントをユニコードから戻せた場合だけ表示する
		}
	}
	CloseHandle(hFile);
	hFile = NULL;

	printf("Input File list : %d\n", file_num);
	if (switch_h){
		printf("         Size B             MD5 Hash             :  Filename\n");
	} else {
		printf("         Size B :  Filename\n");
	}
	// ソース・ファイルの情報を表示する
	for (i = 0; i < file_num; i++){
		// entry size
		memcpy(&entry_size, header_buf + list_off, 4);
		// status field
		memcpy(&parity_flag, header_buf + (list_off + 8), 2);
		parity_flag &= 0x01; // bit 0 = file is saved in the parity volume set
		if (parity_flag){
			source_num++;
			blk = 1;
		} else {
			blk = 0;
		}
		// size
		memcpy(&file_size, header_buf + (list_off + 16), 8);
		if (file_size > block_size)
			block_size = file_size;
		// hash
		memcpy(hash, header_buf + (list_off + 40), 16);
		// filename
		len = (entry_size - 56) / 2;
		if (len >= MAX_LEN)
			len = MAX_LEN - 1;
		memcpy(file_name, header_buf + (list_off + 56), len * 2);
		file_name[len] = 0;
		utf16_to_cp(file_name, ascii_buf);

		// 項目番号、ソース・ブロックかどうか、ファイル・サイズ、MD5ハッシュ値、ファイル名
		if (switch_h){
			printf("%13I64u %d ", file_size, blk);
			print_hash(hash);
			printf(" : \"%s\"\n", ascii_buf);
		} else {
			printf("%13I64u %d : \"%s\"\n", file_size, blk, ascii_buf);
		}

		list_off += entry_size; // 次のエントリー位置にずらす
	}

	// 調べた結果を表示する
	printf("\nData File count : %d\n", source_num);
	printf("Max file size\t: %I64u\n", block_size);
	printf("\nListed successfully\n");
error_end:
	if (header_buf)
		free(header_buf);
	if (hFile != NULL)
		CloseHandle(hFile);
	return err;
}

// CRC-32 チェックサムを使って自分自身の破損を検出する
int par1_checksum(wchar_t *uni_buf)	// 作業用
{
	unsigned int crc, chk, chk2;
	unsigned int len, tmp, i;
	unsigned char *pAddr, *p;
	HANDLE hFile, hMap;

	// 実行ファイルのパスを取得する
	tmp = GetModuleFileName(NULL, uni_buf, MAX_LEN);
	if ((tmp == 0) || (tmp >= MAX_LEN))
		return 1;
	//printf("%S\n", uni_buf);

	// 実行ファイルの PE checksum と CRC-32 を検証する
	hFile = CreateFile(uni_buf, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
	if (hFile == INVALID_HANDLE_VALUE){
		print_win32_err();
		return 1;
	}
	len = GetFileSize(hFile, &chk2);
	if (len == INVALID_FILE_SIZE)
		return 1;
	hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, chk2, len, NULL);
	if (hMap == NULL){
		CloseHandle(hFile);
		return 1;
	}
	pAddr = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, len);
	if (pAddr == NULL){
		CloseHandle(hMap);
		CloseHandle(hFile);
		return 1;
	}
	if (CheckSumMappedFile(pAddr, len, &chk2, &chk) == NULL){	// PE checksum
		UnmapViewOfFile(pAddr);
		CloseHandle(hMap);
		CloseHandle(hFile);
		return 1;
	}
	crc = 0xFFFFFFFF;
	p = pAddr;
	while (len--){
		tmp = (*p++);
		for (i = 0; i < 8; i++){
			if ((tmp ^ crc) & 1){
				crc = (crc >> 1) ^ 0xEDB88320;
			} else {
				crc = crc >> 1;
			}
			tmp = tmp >> 1;
		}
	}
	crc ^= 0xFFFFFFFF;
	UnmapViewOfFile(pAddr);
	CloseHandle(hMap);
	CloseHandle(hFile);

	if (chk != chk2)
		return 2;
	if (crc != 0x11111111)
		return 3;
	return 0;
}

