import java.io.*;
import java.util.*;

class Files
{
	/* File / Handle */
	public static class RECORD0
	{
		File path;
		File regpath;
		RandomAccessFile desc;

		public static void $COPY$(RECORD0 dst, RECORD0 src)
		{
			dst.path    = src.path;
			dst.regpath = src.regpath;
			dst.desc    = src.desc;
		}

		void SetActive(RECORD1 rider)
			throws
				IOException
		{
			desc.seek(rider.position);
		}
	}

	/* Rider */
	public static class RECORD1
	{
		long position;
		RECORD0 base;
		public boolean[] eof = new boolean[1];
		public int[] res = new int[1];

		public static void $COPY$(RECORD1 dst, RECORD1 src)
		{
			dst.base     = src.base;
			dst.position = src.position;
			dst.eof[0]   = src.eof[0];
			dst.res[0]   = src.res[0];
		}
	}

	public static RECORD0 Old(byte name[])
	{
		File filepath;
		RandomAccessFile filedesc;
		RECORD0 file;

		filepath = new File(SYSTEM.STRING(name));

		if(!filepath.exists() || !filepath.isFile())
		{
			return null;
		}

		try
		{
			filedesc = new RandomAccessFile(filepath, "rw");
		}
		catch(IOException e)
		{
			try
			{
				filedesc = new RandomAccessFile(filepath, "r");
			}
			catch(IOException g)
			{
				return null;
			}
		}

		file = new RECORD0();
		file.path = filepath;
		file.regpath = filepath;
		file.desc = filedesc;
		return file;
	}

	private static String RandomString(int len)
	{
		Random x = new Random();
		String s = new String();
		for(int i = 0; i < len; i++)
		{
			s += (char) (x.nextInt(25) + 65);
		}
		return s;
	}

	public static RECORD0 New(byte name[])
	{
		RandomAccessFile filedesc;
		File filepath;
		File fileregpath;
		String filename;
		RECORD0 file;

		try
		{
			filepath = File.createTempFile(RandomString(8), "tmp");
			fileregpath = new File(SYSTEM.STRING(name));
			filedesc = new RandomAccessFile(filepath, "rw");
		}
		catch(IOException e)
		{
			return null;
		}

		file = new RECORD0();
		file.path = filepath;
		file.regpath = fileregpath;
		file.desc = filedesc;
		return file;
	}

	public static void Register(RECORD0 f)
	{
		f.path.renameTo(f.regpath);
		f.path = f.regpath;
	}

	public static void Close(RECORD0 f)
	{
	}

	public static void Purge(RECORD0 f)
		throws
			IOException
	{
		f.desc.setLength(0);
	}

	public static void Delete(byte name[], short res[], int res$)
	{
		File filepath = new File(SYSTEM.STRING(name));
		res[res$] = (short) (filepath.delete() ? (0) : (1));
	}

	public static void Rename(byte old[], byte _new[], short res[], int res$)
	{
		File oldpath = new File(SYSTEM.STRING(old));
		File newpath = new File(SYSTEM.STRING(_new));
		res[res$] = (short) (oldpath.renameTo(newpath) ? (0) : (1));
	}

	public static int Length(RECORD0 f)
		throws
			IOException
	{
		return (int) f.desc.length();
	}

	public static void GetDate(RECORD0 f, int t[], int t$, int d[], int d$)
	{
		long time = f.path.lastModified();
		Calendar cal = Calendar.getInstance();
		cal.setTimeInMillis(time);
		t[t$] = cal.get(Calendar.HOUR_OF_DAY) * 4096 + cal.get(Calendar.MINUTE) * 64 + cal.get(Calendar.SECOND);
		d[d$] = cal.get(Calendar.YEAR) * 512 + cal.get(Calendar.MONTH) * 32 + cal.get(Calendar.DAY_OF_WEEK);
	}

	public static void Set(RECORD1 r[], int r$, RECORD0 f, int pos)
	{
		RECORD1 rider = r[r$];
		rider.base = f;
		rider.position = pos;
		rider.res[0] = 0;
		rider.eof[0] = false;
	}

	public static int Pos(RECORD1 r[], int r$)
	{
		return (int) r[r$].position;
	}

	public static RECORD0 Base(RECORD1 r[], int r$)
	{
		return r[r$].base;
	}

	public static void Read(RECORD1 r[], int r$, byte x[], int x$)
	{
		RECORD1 rider = r[r$];
		RandomAccessFile desc = rider.base.desc;

		try
		{
			rider.base.SetActive(rider);
			x[x$] = (byte) desc.read();
			rider.position += 1;
		}
		catch(IOException e)
		{
			rider.res[0] = 1;
			rider.eof[0] = true;
		}
	}

	public static void ReadInt(RECORD1 R[], int R$, short x[], int x$)
	{
		RECORD1 rider = R[R$];
		RandomAccessFile desc = rider.base.desc;

		try
		{
			rider.base.SetActive(rider);
			byte[] buf = new byte[2];
			rider.res[0] = desc.read(buf, 0, 2);
			rider.eof[0] = (rider.res[0] != 0);
			x[x$] = (short) (((buf[1] & 0xff) << 8) | (buf[0] & 0xff));
			rider.position += 2 - rider.res[0];
		}
		catch(IOException e)
		{
			rider.res[0] = 2;
			rider.eof[0] = true;
		}
	}

	public static void ReadLInt(RECORD1 R[], int R$, int x[], int x$)
	{
		RECORD1 rider = R[R$];
		RandomAccessFile desc = rider.base.desc;

		try
		{
			rider.base.SetActive(rider);
			byte[] buf = new byte[4];
			rider.res[0] = desc.read(buf, 0, 4);
			rider.eof[0] = (rider.res[0] != 0);
			x[x$] = ((buf[3] & 0xff) << 24) | ((buf[2] & 0xff) << 16) | ((buf[1] & 0xff) << 8) | (buf[0] & 0xff);
			rider.position += 4 - rider.res[0];
		}
		catch(IOException e)
		{
			rider.res[0] = 4;
			rider.eof[0] = true;
		}
	}

	public static void ReadReal(RECORD1 R[], int R$, float x[], int x$)
	{
		RECORD1 rider = R[R$];
		RandomAccessFile desc = rider.base.desc;

		try
		{
			rider.base.SetActive(rider);
			x[x$] = desc.readFloat();
			rider.position += 4;
		}
		catch(IOException e)
		{
			rider.res[0] = 4;
			rider.eof[0] = true;
		}
	}

	public static void ReadLReal(RECORD1 R[], int R$, double x[], int x$)
	{
		RECORD1 rider = R[R$];
		RandomAccessFile desc = rider.base.desc;

		try
		{
			rider.base.SetActive(rider);
			x[x$] = desc.readDouble();
			rider.position += 8;
		}
		catch(IOException e)
		{
			rider.res[0] = 8;
			rider.eof[0] = true;
		}
	}

	public static void ReadNum(RECORD1 R[], int R$, int x[], int x$)
	{
		SYSTEM.TRAP(-3);
	}

	public static void ReadString(RECORD1 R[], int R$, byte x[][], int x$)
	{
		RECORD1 rider = R[R$];
		RandomAccessFile desc = rider.base.desc;

		int i = 0;
		try
		{
			rider.base.SetActive(rider);
			int ch;
			do {
				ch = x[x$][i] = (byte) desc.read();
				i += 1;
			} while(ch != 0);
			rider.position += i;
		}
		catch(IOException e)
		{
			x[x$][i] = 0;
			rider.res[0] = 1;
			rider.eof[0] = true;
		}
	}

	public static void ReadSet(RECORD1 R[], int R$, int x[], int x$)
	{
		ReadLInt(R, R$, x, x$);
	}

	public static void ReadBool(RECORD1 R[], int R$, boolean x[], int x$)
	{
		RECORD1 rider = R[R$];
		RandomAccessFile desc = rider.base.desc;

		try
		{
			rider.base.SetActive(rider);
			int i = desc.read();
			x[x$] = (i != 0);
			rider.position += 1;
		}
		catch(IOException e)
		{
			rider.res[0] = 1;
			rider.eof[0] = true;
		}		
	}

	public static void ReadBytes(RECORD1 r[], int r$, byte x[][], int x$, int n)
	{
		RECORD1 rider = r[r$];
		RandomAccessFile desc = rider.base.desc;

		try
		{
			rider.base.SetActive(rider);
			rider.res[0] = desc.read(x[x$], 0, n);
			rider.eof[0] = (rider.res[0] != 0);
			rider.position += n - rider.res[0];
		}
		catch(IOException e)
		{
			e.printStackTrace();
			rider.res[0] = n;
			rider.eof[0] = true;
		}
	}

	public static void Write(RECORD1 r[], int r$, byte x)
	{
		SYSTEM.TRAP(-3);
	}

	public static void WriteInt(RECORD1 R[], int R$, short x)
	{
		SYSTEM.TRAP(-3);
	}

	public static void WriteLInt(RECORD1 R[], int R$, int x)
	{
		SYSTEM.TRAP(-3);
	}

	public static void WriteReal(RECORD1 R[], int R$, float x)
	{
		SYSTEM.TRAP(-3);
	}

	public static void WriteLReal(RECORD1 R[], int R$, double x)
	{
		SYSTEM.TRAP(-3);
	}

	public static void WriteNum(RECORD1 R[], int R$, int x)
	{
		SYSTEM.TRAP(-3);
	}

	public static void WriteString(RECORD1 R[], int R$, byte x[])
	{
		SYSTEM.TRAP(-3);
	}

	public static void WriteSet(RECORD1 R[], int R$, int x)
	{
		SYSTEM.TRAP(-3);
	}

	public static void WriteBool(RECORD1 R[], int R$, boolean x)
	{
		SYSTEM.TRAP(-3);
	}

	public static void WriteBytes(RECORD1 r[], int r$, byte[][] x, int x$, int n)
	{
		SYSTEM.TRAP(-3);
	}

	public static void BEGIN()
	{

	}
}