extensible hashing

      Extensible Hashing

A. First Edition
This is just for fun and also for a kind of compensation for my course comp451 for which I spent too little of 
time on. After finishing the course, I began to realize that in database they actually have almost all operations
for a mini operating system. Therefore, almost all kinds of data structure, algorithm need to be applied here.
B.The problem
In DBMS, hash table is extensively used and I believe every computer science student know what it

is. However, hashing is intuitively simple as long as you find a good hash function. But the nature

of hashing is a trade of speed and space. i.e. Using more space to speed up searching. For all

kinds of "trade", you definitely need a limit, otherwise you go bankrupted, like China, like USA.:)

Dynamic hashing is to solve this space problem: do not allocate huge space for small number of

data. Instead the space is allocate when needed.

C.The idea of program
 

Suppose you keep a hash array in your main memory and the array stores the pointers to bucket in disk where your

data is stored in those buckets. Originally you have two empty bucket, each bucket with capacity of two records.

You also have a so-called "global depth" and "local depth". (I learned this term during my final and I strongly

believed that these two term never appear in our textbook or lecture. And in Concordia, this is the real

education for real world, so they ask you questions from Stanford by downloading them from internet. At least

this is what I heard. )

When inserting a key, you have five scenarios:

a) The key exists, why do you want to insert?

b) The hash array doesn't store any bucket for your key. Then you simply create new bucket.

c) The bucket exists and is not full, just insert record into bucket.

d) The bucket is full but the local depth is smaller than global depth. Split bucket and re-distribute old

records into two bucket. After that re-try inserting.

e) The bucket is full and local depth is the same as global depth. Just expand hash array by doubling its size.

Now you can try d).

 

There is little detail about my text book <database systems, the complete book> which gives theoretical idea

rather then real pseudo-code. For example, for expanding the hash array. The author asks to add one more bit

at least significant position: w0, w1. This is no good. Real programmer would choose to add most significant bit

position: 0w,1w. because 0w is exactly same as w. Therefore you don't have to shift your array. Another reason

I don't want this methods is like this: suppose my key is clustered from least significant direction which is

very common for real life, then my hash table would have to expand to very large for only a few records. Of

course, you can always argue that my hash function should not allow this happen. But in real world, you are more

likely encountering series numbers starting from 0,1,2,....

D.The major functions
 
E.Further improvement
This seems to be rather a simple program but it really takes me for a couple of days. On one hand, I am playing 
the game day and night with confused mind after my crazy finals. On the other hand, I didn't think very clearly
about the details of extensible hashing until I am facing the reality. Once more I am convinced that "unless you
are fully clear about the exact details of an algorithm or structure, you will surely be stuck somewhere for your
programming." In other words, programming is almost the most sure way of testing your understanding of algorithm.
However, for me even I programmed for some problem, still there is something unclear. For example, the dynamic 
programming is a hell for me. I should practise more.
F.File listing
1. hash.cpp
 
file name: hash.cpp
//actually this is extensible hash, instead of linear hash
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


const int MaxHashNumber=0x0fff;
const int BucketSize=2;//assume there is two data in one bucket
const int MaxRecordDataSize=10;
const int EmptyKey=-1;

struct Record
{
	int key;
	char word[MaxRecordDataSize];//null terminated
};


struct Bucket
{
	Record records[BucketSize];
	int length;//length is the local bit used in record's key
	void display();
};

class Hash
{
private:
	//int blocks[MaxHashNumber];
	Bucket* hashArray[MaxHashNumber];
	int mask;
	int length;//length of bits used, from least significent bit.
	int size;//size of array
	void initialize();
	int hashFunction(int number, int keyLength);
	bool doInsert(int index, int number);
	void expand();
	int getMask(int len);
	Bucket* createBucket();
	void splitBucket(int index);
	Bucket* findBucket(int number);
	void writeRecord(int number, Bucket* bucket, int recNo);
	void organizePointer(int newKey, Bucket* bucketPtr, int curLength);
public:
	Hash();
	~Hash();
	Record* findRecord(int number);
	void insert(int number);
	void display();
};


class Dictionary
{
private:
	Hash hash;
	int calcKey(char* word);
public:
	void readFile(char* fileName);
	void insert(char* word);
	bool find(char* word);
	void display();
};


int main()
{
	Hash H;

	Dictionary D;
	D.readFile("nick.txt");
	D.display();
	printf("this is silly test\n\n\n");
	printf("can you find word of 'Remarks'?\n");
	if (D.find("Remarks"))
	{
		printf("yes\n");
	}
	else
	{
		printf("no\n");
	}
	printf("can you find word of 'remarks'?\n");
	if (D.find("remarks"))
	{
		printf("yes\n");
	}
	else
	{
		printf("no\n");
	}

	return 0;
}

void Dictionary::display()
{
	hash.display();
}

void Dictionary::readFile(char* fileName)
{
	char buffer[MaxRecordDataSize];
	FILE* stream;
	char ch;
	if ((stream=fopen(fileName, "r"))==NULL)
	{
		printf("cannot open file %s\n", fileName);
	}
	else
	{
		while (true)
		{
			for (int i=0; i<MaxRecordDataSize-1; i++)
			{
				ch=fgetc(stream);
				if (feof(stream))
				{
					buffer[i]='\0';
					insert(buffer);
					fclose(stream);
					return;
				}
				if (ch==' '||ch==10||ch==13||ch=='\n')
				{
					buffer[i]='\0';
					if (i!=0)
					{
						insert(buffer);
					}
					break;
				}

				buffer[i]=ch;
			}
			
		}
	}
}




int Dictionary::calcKey(char* word)
{
	int result=0;
	int index=0;
	while (word[index]!='\0')
	{
		result<<=1;
		result+=word[index];
		index++;
	}
	return result;
}

void Dictionary::insert(char* word)
{
	int theKey;
	Record* record;
	theKey=calcKey(word);
	record=hash.findRecord(theKey);
	if (record!=NULL)
	{
		if (strcmp(record->word, word)!=0)
		{
			printf("key conflict of %s with %s of key %d\n", word, record->word, theKey);
		}
		else
		{
			printf("repeat inserting same data %s\n", word);
		}
	}
	else
	{
		hash.insert(theKey);
		record=hash.findRecord(theKey);
		strcpy(record->word, word);
	}
}

bool Dictionary::find(char* word)
{
	int theKey;
	Record* record;
	theKey=calcKey(word);
	record=hash.findRecord(theKey);
	if (record==NULL)
	{
		return false;
	}
	else
	{
		return strcmp(word, record->word)==0;
	}
}




void Bucket::display()
{
	printf("length=%d\n", length);
	for (int i=0; i<BucketSize; i++)
	{
		if (records[i].key!=EmptyKey)
		{
			printf("record #%d: key=%d, data=%s\n", i, records[i].key, records[i].word);
		}
		else
		{
			printf("record #%d: emtpy record\n", i);
		}
	}
}


Hash::~Hash()
{
	for (int i=0; i<size; i++)
	{
		//delete hashArray[i];
	}
}

Bucket* Hash::findBucket(int number)
{
	int index;
	index=hashFunction(number, length);
	return hashArray[index];
}

void Hash::splitBucket(int index)
{
	Bucket* oldBucket, *newBucket;
	int singleMask=1;//1000,0000,0000,0000
	int oldIndex=0, newIndex=0;
	
	
	oldBucket=hashArray[index];
	
	newBucket=createBucket();
	
	
	for (int i=0; i<hashArray[index]->length; i++)
	{
		singleMask<<=1;
	}
		

	//re-distribute records in two buckets, 'i'th bit is 1, go to new, 
	while (oldIndex<BucketSize)
	{
		if (oldBucket->records[oldIndex].key&singleMask)//non-zero
		{
			newBucket->records[newIndex]=oldBucket->records[oldIndex];//member copy
			oldBucket->records[oldIndex].key=EmptyKey;
			newIndex++;
		}
		oldIndex++;
	}
	oldBucket->length++;
	newBucket->length=oldBucket->length;
	for (i=0; i<size; i++)
	{
		if (hashArray[i]==oldBucket)
		{
			if (i&singleMask)
			{
				hashArray[i]=newBucket;
			}
			else
			{
				hashArray[i]=oldBucket;
			}
		}
	}
					
}

Bucket* Hash::createBucket()
{
	Bucket* result=new Bucket;
	for (int i=0; i<BucketSize; i++)
	{
		result->records[i].key=EmptyKey;
	}
	result->length=length;//always equal current 
	return result;
}

void Hash::writeRecord(int number, Bucket* bucket, int recNo)
{
	bucket->records[recNo].key=number;
	itoa(number, bucket->records[recNo].word, 10);
}

void Hash::display()
{
	for (int i=0; i<size; i++)
	{
		if (hashArray[i]!=NULL)
		{
			printf("HashArray[%d]:\n", i);
			hashArray[i]->display();
		}
	}
}

Hash::Hash()
{
	initialize();
}

void Hash::initialize()
{
	for (int i=0; i<MaxHashNumber; i++)
	{
		hashArray[i]=NULL;		
	}	
	length=1;
	size=2;//2 to the power of 1??necessary??
	mask=getMask(length);
	/*
	hashArray[0]=new Bucket;
	hashArray[1]=new Bucket;
	hashArray[0]->key=hashArray[1]->key=-1;
	hashArray[0]->length=hashArray[1]->length=1;
	*/
	hashArray[0]=hashArray[1]=NULL;
}

int Hash::getMask(int len)
{
	//int one=1;//starting with a '1'
	int mask=0;
	//finding the first one small or equal MaxHashNumber
	/*
	while (one>MaxHashNumber)
	{
		one>>=1;
	}
	
	mask=one;
	*/
	for (int i=0; i<len; i++)
	{
		mask<<=1;
		mask+=1;
	}
	return mask;
}


int Hash::hashFunction(int number, int keyLength)
{
	int result;	
	result=number%MaxHashNumber;
	//only do it when expanding
	//mask=getMask(keyLength);
	return mask&result;
}

bool Hash::doInsert(int index, int number)
{
	if (hashArray[index]==NULL)
	{
		hashArray[index]=createBucket();
		writeRecord(number, hashArray[index], 0);
		return true;
	}
	else
	{
		for (int i=0; i<BucketSize; i++)
		{
			if (hashArray[index]->records[i].key==EmptyKey)
			{
				writeRecord(number, hashArray[index], i);
				return true;
			}
		}
		//full
		if (hashArray[index]->length<length)
		{
			splitBucket(index);
		}
		else
		{
			expand();			
		}
		//don't try here as recursion costs more
		//insert(number);//try again
	}
	return false;

	/*
	int oldKey, oldLength;
	int newIndex;
	//can insert here
	if (hashArray[index].key==-1)
	{
		//it is empty so, we can insert;
		hashArray[index].key=number;
		hashArray[index].length=length;
	}
	else
	{
		//have to move the old one
		oldKey=hashArray[index].key;
		oldLength=hashArray[index].length;
		while (oldLength<length)
		{
			//we can expand
			oldLength++;		
			newIndex=hashFunction(oldKey, oldLength);
			if (newIndex!=index)
			{
				//find another bucket for the old guy
				hashArray[index].key=number;
				hashArray[index].length=keyLength;
				break;
			}
		}
		if (oldLength<length)
		{
			//find newIndex for old index
			insertKey(newIndex, oldKey, oldLength);
		}
		else
		{
			//the current length is running out
			expand();
			insert(number);//again
		}
	}
	*/
}

//my version of expand is to add '0' and '1' bit at the most significent bit position
void Hash::expand()
{
	int index;
	int singleMask=1;
	//note here, length is not incremented yet
	for (int i=0; i<length; i++)
	{
		singleMask<<=1;
	}
	for (i=0; i<size; i++)
	{		
		index=i|singleMask;
		
		if (index>=MaxHashNumber)
		{
			printf("cannot expand hash array any more\n");
			exit(2);
		}
		hashArray[index]=hashArray[i];		
	}
	length++;	
	mask=getMask(length);
	size*=2;
}

Record* Hash::findRecord(int number)
{
	int index;
	index=hashFunction(number, length);
	if (hashArray[index]==NULL)
	{
		return NULL;
	}
	else
	{
		for (int i=0; i<BucketSize; i++)
		{
			if (hashArray[index]->records[i].key==number)
			{
				return hashArray[index]->records+i;
			}
		}
	}
	return NULL;
}



//assume each block contains one single record,
void Hash::insert(int number)
{
	int index;
	if (findRecord(number)!=NULL)
	{
		printf("cannot insert an existed number\n");		
	}
	else
	{
		do
		{
			index=hashFunction(number, length);
		}
		while (!doInsert(index, number));
	}
}
	






 


How to run?
1.The following is the input file "nick.txt".
ifstream::open
void open( const char* szName, int nMode = ios::in, int nProt = filebuf::openprot );

Parameters

szName

The name of the file to be opened during construction.

nMode

An integer containing bits defined as ios enumerators that can be combined with the OR ( | ) operator. See the ifstream 
constructor for a list of the enumerators. The ios::in mode is implied.

nProt

The file protection specification; defaults to the static integer filebuf::openprot. See the ifstream constructor for a 
list of the other allowed values.

Remarks

Opens a disk file and attaches it to the stream¨s filebuf object. If the filebuf object is already attached to an open 
file, or if a filebuf call fails, the ios::failbit is set. If the file is not found, then the ios::failbit is set only if 
the ios::nocreate mode was used.

ifstream Overview | Input Stream Classes

See Also filebuf::open, ifstream::ifstream, ifstream::close, ifstream::is_open, ios::flags

2.The following is the running result.


repeat inserting same data int
repeat inserting same data =
repeat inserting same data nMode
key conflict of rs with to of key 343
repeat inserting same data be
repeat inserting same data the
key conflict of OR with An of key 240
repeat inserting same data the
repeat inserting same data of
repeat inserting same data the
repeat inserting same data The
repeat inserting same data nProt
repeat inserting same data The
repeat inserting same data file
repeat inserting same data to
repeat inserting same data the
repeat inserting same data integer
repeat inserting same data See
repeat inserting same data the
repeat inserting same data ifstream
repeat inserting same data or
repeat inserting same data for
repeat inserting same data a
repeat inserting same data list
repeat inserting same data of
repeat inserting same data the
repeat inserting same data a
repeat inserting same data file
repeat inserting same data to
repeat inserting same data the
repeat inserting same data the
repeat inserting same data filebuf
repeat inserting same data is
repeat inserting same data to
repeat inserting same data or
repeat inserting same data a
repeat inserting same data filebuf
repeat inserting same data the
repeat inserting same data is
repeat inserting same data If
repeat inserting same data the
repeat inserting same data file
repeat inserting same data is
repeat inserting same data the
repeat inserting same data bit
repeat inserting same data is
key conflict of set with not of key 778
repeat inserting same data if
repeat inserting same data the
repeat inserting same data mode
repeat inserting same data ifstream
repeat inserting same data |
repeat inserting same data See
repeat inserting same data s
HashArray[0]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[1]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[2]:
length=7
record #0: key=26300, data=ios::in,
record #1: key=3074, data=char*
HashArray[3]:
length=6
record #0: key=13632, data=integer
record #1: emtpy record
HashArray[4]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[5]:
length=9
record #0: key=6660, data=found,
record #1: emtpy record
HashArray[6]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[8]:
length=6
record #0: key=3336, data=open(
record #1: key=6727, data=during
HashArray[10]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[11]:
length=8
record #0: key=11785, data=Remarks
record #1: key=26629, data=attaches
HashArray[12]:
length=6
record #0: key=3340, data=open,
record #1: emtpy record
HashArray[13]:
length=6
record #0: key=1293, data=Also
record #1: key=141, data=);
HashArray[14]:
length=7
record #0: key=1550, data=ion.
record #1: emtpy record
HashArray[15]:
length=6
record #0: key=1551, data=bits
record #1: emtpy record
HashArray[16]:
length=7
record #0: key=2576, data=:open
record #1: key=28058, data=openprot
HashArray[17]:
length=7
record #0: key=785, data=was
record #1: key=1553, data=file
HashArray[18]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[20]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[21]:
length=6
record #0: key=13970, data=szName,
record #1: key=1557, data=disk
HashArray[22]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[23]:
length=6
record #0: key=343, data=to
record #1: emtpy record
HashArray[24]:
length=6
record #0: key=27218, data=implied.
record #1: emtpy record
HashArray[26]:
length=6
record #0: key=24405, data=Overview
record #1: emtpy record
HashArray[28]:
length=6
record #0: key=732, data=rs.
record #1: key=10202, data=:close,
HashArray[29]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[30]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[31]:
length=8
record #0: key=6686, data=object
record #1: emtpy record
HashArray[32]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[33]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[34]:
length=6
record #0: key=1698, data=void
record #1: emtpy record
HashArray[36]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[37]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[38]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[39]:
length=6
record #0: key=103, data=g
record #1: emtpy record
HashArray[40]:
length=6
record #0: key=40, data=(
record #1: key=744, data=for
HashArray[41]:
length=6
record #0: key=297, data=be
record #1: key=41, data=)
HashArray[42]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[44]:
length=7
record #0: key=44, data=,
record #1: key=1708, data=with
HashArray[45]:
length=6
record #0: key=13418, data=object.
record #1: emtpy record
HashArray[46]:
length=6
record #0: key=110, data=n
record #1: key=7085, data=static
HashArray[47]:
length=6
record #0: key=6894, data=opened
record #1: emtpy record
HashArray[48]:
length=7
record #0: emtpy record
record #1: key=304, data=an
HashArray[49]:
length=6
record #0: key=3121, data=nMode
record #1: key=12846, data=defined
HashArray[50]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[51]:
length=7
record #0: key=14000, data=values.
record #1: key=1587, data=name
HashArray[52]:
length=7
record #0: key=26414, data=combined
record #1: key=6963, data=szName
HashArray[53]:
length=6
record #0: key=309, data=as
record #1: key=757, data=ios
HashArray[54]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[56]:
length=7
record #0: emtpy record
record #1: key=312, data=if
HashArray[58]:
length=6
record #0: key=3258, data=const
record #1: key=3194, data=nProt
HashArray[60]:
length=7
record #0: key=700, data=can
record #1: emtpy record
HashArray[61]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[62]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[64]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[65]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[66]:
length=7
record #0: key=1602, data=set.
record #1: emtpy record
HashArray[67]:
length=6
record #0: key=13632, data=integer
record #1: emtpy record
HashArray[68]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[69]:
length=7
record #0: key=325, data=is
record #1: emtpy record
HashArray[70]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[72]:
length=6
record #0: key=3336, data=open(
record #1: key=6727, data=during
HashArray[73]:
length=7
record #0: key=25795, data=defaults
record #1: emtpy record
HashArray[74]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[75]:
length=7
record #0: key=13128, data=ios::in
record #1: emtpy record
HashArray[76]:
length=6
record #0: key=3340, data=open,
record #1: emtpy record
HashArray[77]:
length=6
record #0: key=1293, data=Also
record #1: key=141, data=);
HashArray[78]:
length=7
record #0: key=3150, data=file,
record #1: key=718, data=bit
HashArray[79]:
length=6
record #0: key=1551, data=bits
record #1: emtpy record
HashArray[80]:
length=7
record #0: key=336, data=or
record #1: key=13005, data=already
HashArray[81]:
length=7
record #0: key=1617, data=mode
record #1: emtpy record
HashArray[82]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[83]:
length=8
record #0: key=2899, data=Opens
record #1: emtpy record
HashArray[84]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[85]:
length=6
record #0: key=13970, data=szName,
record #1: key=1557, data=disk
HashArray[86]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[87]:
length=6
record #0: key=343, data=to
record #1: emtpy record
HashArray[88]:
length=6
record #0: key=27218, data=implied.
record #1: emtpy record
HashArray[90]:
length=6
record #0: key=24405, data=Overview
record #1: emtpy record
HashArray[91]:
length=7
record #0: key=3419, data=tion;
record #1: key=6362, data=fails,
HashArray[92]:
length=6
record #0: key=732, data=rs.
record #1: key=10202, data=:close,
HashArray[93]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[94]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[96]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[97]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[98]:
length=6
record #0: key=1698, data=void
record #1: emtpy record
HashArray[99]:
length=8
record #0: key=13152, data=filebuf
record #1: emtpy record
HashArray[100]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[101]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[102]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[103]:
length=6
record #0: key=103, data=g
record #1: emtpy record
HashArray[104]:
length=6
record #0: key=40, data=(
record #1: key=744, data=for
HashArray[105]:
length=6
record #0: key=297, data=be
record #1: key=41, data=)
HashArray[106]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[108]:
length=7
record #0: key=3436, data=other
record #1: emtpy record
HashArray[109]:
length=6
record #0: key=13418, data=object.
record #1: emtpy record
HashArray[110]:
length=6
record #0: key=110, data=n
record #1: key=7085, data=static
HashArray[111]:
length=6
record #0: key=6894, data=opened
record #1: emtpy record
HashArray[112]:
length=7
record #0: key=240, data=An
record #1: key=1648, data=open
HashArray[113]:
length=6
record #0: key=3121, data=nMode
record #1: key=12846, data=defined
HashArray[114]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[115]:
length=7
record #0: key=115, data=s
record #1: key=10993, data=Classes
HashArray[116]:
length=7
record #0: key=756, data=int
record #1: key=6131, data=Stream
HashArray[117]:
length=6
record #0: key=309, data=as
record #1: key=757, data=ios
HashArray[118]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[120]:
length=7
record #0: key=248, data=If
record #1: key=1656, data=then
HashArray[121]:
length=7
record #0: key=27123, data=ifstream
record #1: key=1529, data=eate
HashArray[122]:
length=6
record #0: key=3258, data=const
record #1: key=3194, data=nProt
HashArray[123]:
length=7
record #0: key=635, data=See
record #1: emtpy record
HashArray[124]:
length=7
record #0: key=124, data=|
record #1: key=26614, data=attached
HashArray[125]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[126]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[128]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[129]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[130]:
length=7
record #0: key=26300, data=ios::in,
record #1: key=3074, data=char*
HashArray[131]:
length=6
record #0: key=13632, data=integer
record #1: emtpy record
HashArray[132]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[133]:
length=8
record #0: key=645, data=The
record #1: emtpy record
HashArray[134]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[136]:
length=6
record #0: key=3336, data=open(
record #1: key=6727, data=during
HashArray[138]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[140]:
length=6
record #0: key=3340, data=open,
record #1: emtpy record
HashArray[141]:
length=6
record #0: key=1293, data=Also
record #1: key=141, data=);
HashArray[142]:
length=7
record #0: key=1550, data=ion.
record #1: emtpy record
HashArray[143]:
length=6
record #0: key=1551, data=bits
record #1: emtpy record
HashArray[144]:
length=7
record #0: key=2576, data=:open
record #1: key=28058, data=openprot
HashArray[145]:
length=7
record #0: key=785, data=was
record #1: key=1553, data=file
HashArray[146]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[148]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[149]:
length=6
record #0: key=13970, data=szName,
record #1: key=1557, data=disk
HashArray[150]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[151]:
length=6
record #0: key=343, data=to
record #1: emtpy record
HashArray[152]:
length=6
record #0: key=27218, data=implied.
record #1: emtpy record
HashArray[154]:
length=6
record #0: key=24405, data=Overview
record #1: emtpy record
HashArray[156]:
length=6
record #0: key=732, data=rs.
record #1: key=10202, data=:close,
HashArray[157]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[158]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[160]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[161]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[162]:
length=6
record #0: key=1698, data=void
record #1: emtpy record
HashArray[164]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[165]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[166]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[167]:
length=6
record #0: key=103, data=g
record #1: emtpy record
HashArray[168]:
length=6
record #0: key=40, data=(
record #1: key=744, data=for
HashArray[169]:
length=6
record #0: key=297, data=be
record #1: key=41, data=)
HashArray[170]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[172]:
length=7
record #0: key=44, data=,
record #1: key=1708, data=with
HashArray[173]:
length=6
record #0: key=13418, data=object.
record #1: emtpy record
HashArray[174]:
length=6
record #0: key=110, data=n
record #1: key=7085, data=static
HashArray[175]:
length=6
record #0: key=6894, data=opened
record #1: emtpy record
HashArray[176]:
length=7
record #0: emtpy record
record #1: key=304, data=an
HashArray[177]:
length=6
record #0: key=3121, data=nMode
record #1: key=12846, data=defined
HashArray[178]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[179]:
length=7
record #0: key=14000, data=values.
record #1: key=1587, data=name
HashArray[180]:
length=7
record #0: key=26414, data=combined
record #1: key=6963, data=szName
HashArray[181]:
length=6
record #0: key=309, data=as
record #1: key=757, data=ios
HashArray[182]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[184]:
length=7
record #0: emtpy record
record #1: key=312, data=if
HashArray[186]:
length=6
record #0: key=3258, data=const
record #1: key=3194, data=nProt
HashArray[188]:
length=7
record #0: key=700, data=can
record #1: emtpy record
HashArray[189]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[190]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[192]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[193]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[194]:
length=7
record #0: key=1602, data=set.
record #1: emtpy record
HashArray[195]:
length=6
record #0: key=13632, data=integer
record #1: emtpy record
HashArray[196]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[197]:
length=7
record #0: key=325, data=is
record #1: emtpy record
HashArray[198]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[200]:
length=6
record #0: key=3336, data=open(
record #1: key=6727, data=during
HashArray[201]:
length=7
record #0: key=25795, data=defaults
record #1: emtpy record
HashArray[202]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[203]:
length=7
record #0: key=13128, data=ios::in
record #1: emtpy record
HashArray[204]:
length=6
record #0: key=3340, data=open,
record #1: emtpy record
HashArray[205]:
length=6
record #0: key=1293, data=Also
record #1: key=141, data=);
HashArray[206]:
length=7
record #0: key=3150, data=file,
record #1: key=718, data=bit
HashArray[207]:
length=6
record #0: key=1551, data=bits
record #1: emtpy record
HashArray[208]:
length=7
record #0: key=336, data=or
record #1: key=13005, data=already
HashArray[209]:
length=7
record #0: key=1617, data=mode
record #1: emtpy record
HashArray[210]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[212]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[213]:
length=6
record #0: key=13970, data=szName,
record #1: key=1557, data=disk
HashArray[214]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[215]:
length=6
record #0: key=343, data=to
record #1: emtpy record
HashArray[216]:
length=6
record #0: key=27218, data=implied.
record #1: emtpy record
HashArray[218]:
length=6
record #0: key=24405, data=Overview
record #1: emtpy record
HashArray[219]:
length=7
record #0: key=3419, data=tion;
record #1: key=6362, data=fails,
HashArray[220]:
length=6
record #0: key=732, data=rs.
record #1: key=10202, data=:close,
HashArray[221]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[222]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[224]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[225]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[226]:
length=6
record #0: key=1698, data=void
record #1: emtpy record
HashArray[228]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[229]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[230]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[231]:
length=6
record #0: key=103, data=g
record #1: emtpy record
HashArray[232]:
length=6
record #0: key=40, data=(
record #1: key=744, data=for
HashArray[233]:
length=6
record #0: key=297, data=be
record #1: key=41, data=)
HashArray[234]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[236]:
length=7
record #0: key=3436, data=other
record #1: emtpy record
HashArray[237]:
length=6
record #0: key=13418, data=object.
record #1: emtpy record
HashArray[238]:
length=6
record #0: key=110, data=n
record #1: key=7085, data=static
HashArray[239]:
length=6
record #0: key=6894, data=opened
record #1: emtpy record
HashArray[240]:
length=7
record #0: key=240, data=An
record #1: key=1648, data=open
HashArray[241]:
length=6
record #0: key=3121, data=nMode
record #1: key=12846, data=defined
HashArray[242]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[243]:
length=7
record #0: key=115, data=s
record #1: key=10993, data=Classes
HashArray[244]:
length=7
record #0: key=756, data=int
record #1: key=6131, data=Stream
HashArray[245]:
length=6
record #0: key=309, data=as
record #1: key=757, data=ios
HashArray[246]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[248]:
length=7
record #0: key=248, data=If
record #1: key=1656, data=then
HashArray[249]:
length=7
record #0: key=27123, data=ifstream
record #1: key=1529, data=eate
HashArray[250]:
length=6
record #0: key=3258, data=const
record #1: key=3194, data=nProt
HashArray[251]:
length=7
record #0: key=635, data=See
record #1: emtpy record
HashArray[252]:
length=7
record #0: key=124, data=|
record #1: key=26614, data=attached
HashArray[253]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[254]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[256]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[257]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[258]:
length=7
record #0: key=26300, data=ios::in,
record #1: key=3074, data=char*
HashArray[259]:
length=6
record #0: key=13632, data=integer
record #1: emtpy record
HashArray[260]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[261]:
length=9
record #0: key=773, data=the
record #1: key=13058, data=allowed
HashArray[262]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[264]:
length=6
record #0: key=3336, data=open(
record #1: key=6727, data=during
HashArray[266]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[267]:
length=8
record #0: key=11785, data=Remarks
record #1: key=26629, data=attaches
HashArray[268]:
length=6
record #0: key=3340, data=open,
record #1: emtpy record
HashArray[269]:
length=6
record #0: key=1293, data=Also
record #1: key=141, data=);
HashArray[270]:
length=7
record #0: key=1550, data=ion.
record #1: emtpy record
HashArray[271]:
length=6
record #0: key=1551, data=bits
record #1: emtpy record
HashArray[272]:
length=7
record #0: key=2576, data=:open
record #1: key=28058, data=openprot
HashArray[273]:
length=7
record #0: key=785, data=was
record #1: key=1553, data=file
HashArray[274]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[276]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[277]:
length=6
record #0: key=13970, data=szName,
record #1: key=1557, data=disk
HashArray[278]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[279]:
length=6
record #0: key=343, data=to
record #1: emtpy record
HashArray[280]:
length=6
record #0: key=27218, data=implied.
record #1: emtpy record
HashArray[282]:
length=6
record #0: key=24405, data=Overview
record #1: emtpy record
HashArray[284]:
length=6
record #0: key=732, data=rs.
record #1: key=10202, data=:close,
HashArray[285]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[286]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[287]:
length=8
record #0: key=6686, data=object
record #1: emtpy record
HashArray[288]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[289]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[290]:
length=6
record #0: key=1698, data=void
record #1: emtpy record
HashArray[292]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[293]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[294]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[295]:
length=6
record #0: key=103, data=g
record #1: emtpy record
HashArray[296]:
length=6
record #0: key=40, data=(
record #1: key=744, data=for
HashArray[297]:
length=6
record #0: key=297, data=be
record #1: key=41, data=)
HashArray[298]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[300]:
length=7
record #0: key=44, data=,
record #1: key=1708, data=with
HashArray[301]:
length=6
record #0: key=13418, data=object.
record #1: emtpy record
HashArray[302]:
length=6
record #0: key=110, data=n
record #1: key=7085, data=static
HashArray[303]:
length=6
record #0: key=6894, data=opened
record #1: emtpy record
HashArray[304]:
length=7
record #0: emtpy record
record #1: key=304, data=an
HashArray[305]:
length=6
record #0: key=3121, data=nMode
record #1: key=12846, data=defined
HashArray[306]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[307]:
length=7
record #0: key=14000, data=values.
record #1: key=1587, data=name
HashArray[308]:
length=7
record #0: key=26414, data=combined
record #1: key=6963, data=szName
HashArray[309]:
length=6
record #0: key=309, data=as
record #1: key=757, data=ios
HashArray[310]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[312]:
length=7
record #0: emtpy record
record #1: key=312, data=if
HashArray[314]:
length=6
record #0: key=3258, data=const
record #1: key=3194, data=nProt
HashArray[316]:
length=7
record #0: key=700, data=can
record #1: emtpy record
HashArray[317]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[318]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[320]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[321]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[322]:
length=7
record #0: key=1602, data=set.
record #1: emtpy record
HashArray[323]:
length=6
record #0: key=13632, data=integer
record #1: emtpy record
HashArray[324]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[325]:
length=7
record #0: key=325, data=is
record #1: emtpy record
HashArray[326]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[328]:
length=6
record #0: key=3336, data=open(
record #1: key=6727, data=during
HashArray[329]:
length=7
record #0: key=25795, data=defaults
record #1: emtpy record
HashArray[330]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[331]:
length=7
record #0: key=13128, data=ios::in
record #1: emtpy record
HashArray[332]:
length=6
record #0: key=3340, data=open,
record #1: emtpy record
HashArray[333]:
length=6
record #0: key=1293, data=Also
record #1: key=141, data=);
HashArray[334]:
length=7
record #0: key=3150, data=file,
record #1: key=718, data=bit
HashArray[335]:
length=6
record #0: key=1551, data=bits
record #1: emtpy record
HashArray[336]:
length=7
record #0: key=336, data=or
record #1: key=13005, data=already
HashArray[337]:
length=7
record #0: key=1617, data=mode
record #1: emtpy record
HashArray[338]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[339]:
length=8
record #0: key=2899, data=Opens
record #1: emtpy record
HashArray[340]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[341]:
length=6
record #0: key=13970, data=szName,
record #1: key=1557, data=disk
HashArray[342]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[343]:
length=6
record #0: key=343, data=to
record #1: emtpy record
HashArray[344]:
length=6
record #0: key=27218, data=implied.
record #1: emtpy record
HashArray[346]:
length=6
record #0: key=24405, data=Overview
record #1: emtpy record
HashArray[347]:
length=7
record #0: key=3419, data=tion;
record #1: key=6362, data=fails,
HashArray[348]:
length=6
record #0: key=732, data=rs.
record #1: key=10202, data=:close,
HashArray[349]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[350]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[352]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[353]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[354]:
length=6
record #0: key=1698, data=void
record #1: emtpy record
HashArray[355]:
length=8
record #0: key=13152, data=filebuf
record #1: emtpy record
HashArray[356]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[357]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[358]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[359]:
length=6
record #0: key=103, data=g
record #1: emtpy record
HashArray[360]:
length=6
record #0: key=40, data=(
record #1: key=744, data=for
HashArray[361]:
length=6
record #0: key=297, data=be
record #1: key=41, data=)
HashArray[362]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[364]:
length=7
record #0: key=3436, data=other
record #1: emtpy record
HashArray[365]:
length=6
record #0: key=13418, data=object.
record #1: emtpy record
HashArray[366]:
length=6
record #0: key=110, data=n
record #1: key=7085, data=static
HashArray[367]:
length=6
record #0: key=6894, data=opened
record #1: emtpy record
HashArray[368]:
length=7
record #0: key=240, data=An
record #1: key=1648, data=open
HashArray[369]:
length=6
record #0: key=3121, data=nMode
record #1: key=12846, data=defined
HashArray[370]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[371]:
length=7
record #0: key=115, data=s
record #1: key=10993, data=Classes
HashArray[372]:
length=7
record #0: key=756, data=int
record #1: key=6131, data=Stream
HashArray[373]:
length=6
record #0: key=309, data=as
record #1: key=757, data=ios
HashArray[374]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[376]:
length=7
record #0: key=248, data=If
record #1: key=1656, data=then
HashArray[377]:
length=7
record #0: key=27123, data=ifstream
record #1: key=1529, data=eate
HashArray[378]:
length=6
record #0: key=3258, data=const
record #1: key=3194, data=nProt
HashArray[379]:
length=7
record #0: key=635, data=See
record #1: emtpy record
HashArray[380]:
length=7
record #0: key=124, data=|
record #1: key=26614, data=attached
HashArray[381]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[382]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[384]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[385]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[386]:
length=7
record #0: key=26300, data=ios::in,
record #1: key=3074, data=char*
HashArray[387]:
length=6
record #0: key=13632, data=integer
record #1: emtpy record
HashArray[388]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[389]:
length=8
record #0: key=645, data=The
record #1: emtpy record
HashArray[390]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[392]:
length=6
record #0: key=3336, data=open(
record #1: key=6727, data=during
HashArray[394]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[396]:
length=6
record #0: key=3340, data=open,
record #1: emtpy record
HashArray[397]:
length=6
record #0: key=1293, data=Also
record #1: key=141, data=);
HashArray[398]:
length=7
record #0: key=1550, data=ion.
record #1: emtpy record
HashArray[399]:
length=6
record #0: key=1551, data=bits
record #1: emtpy record
HashArray[400]:
length=7
record #0: key=2576, data=:open
record #1: key=28058, data=openprot
HashArray[401]:
length=7
record #0: key=785, data=was
record #1: key=1553, data=file
HashArray[402]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[404]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[405]:
length=6
record #0: key=13970, data=szName,
record #1: key=1557, data=disk
HashArray[406]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[407]:
length=6
record #0: key=343, data=to
record #1: emtpy record
HashArray[408]:
length=6
record #0: key=27218, data=implied.
record #1: emtpy record
HashArray[410]:
length=6
record #0: key=24405, data=Overview
record #1: emtpy record
HashArray[412]:
length=6
record #0: key=732, data=rs.
record #1: key=10202, data=:close,
HashArray[413]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[414]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[416]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[417]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[418]:
length=6
record #0: key=1698, data=void
record #1: emtpy record
HashArray[420]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[421]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[422]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[423]:
length=6
record #0: key=103, data=g
record #1: emtpy record
HashArray[424]:
length=6
record #0: key=40, data=(
record #1: key=744, data=for
HashArray[425]:
length=6
record #0: key=297, data=be
record #1: key=41, data=)
HashArray[426]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[428]:
length=7
record #0: key=44, data=,
record #1: key=1708, data=with
HashArray[429]:
length=6
record #0: key=13418, data=object.
record #1: emtpy record
HashArray[430]:
length=6
record #0: key=110, data=n
record #1: key=7085, data=static
HashArray[431]:
length=6
record #0: key=6894, data=opened
record #1: emtpy record
HashArray[432]:
length=7
record #0: emtpy record
record #1: key=304, data=an
HashArray[433]:
length=6
record #0: key=3121, data=nMode
record #1: key=12846, data=defined
HashArray[434]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[435]:
length=7
record #0: key=14000, data=values.
record #1: key=1587, data=name
HashArray[436]:
length=7
record #0: key=26414, data=combined
record #1: key=6963, data=szName
HashArray[437]:
length=6
record #0: key=309, data=as
record #1: key=757, data=ios
HashArray[438]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[440]:
length=7
record #0: emtpy record
record #1: key=312, data=if
HashArray[442]:
length=6
record #0: key=3258, data=const
record #1: key=3194, data=nProt
HashArray[444]:
length=7
record #0: key=700, data=can
record #1: emtpy record
HashArray[445]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[446]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[448]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[449]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[450]:
length=7
record #0: key=1602, data=set.
record #1: emtpy record
HashArray[451]:
length=6
record #0: key=13632, data=integer
record #1: emtpy record
HashArray[452]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[453]:
length=7
record #0: key=325, data=is
record #1: emtpy record
HashArray[454]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[456]:
length=6
record #0: key=3336, data=open(
record #1: key=6727, data=during
HashArray[457]:
length=7
record #0: key=25795, data=defaults
record #1: emtpy record
HashArray[458]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[459]:
length=7
record #0: key=13128, data=ios::in
record #1: emtpy record
HashArray[460]:
length=6
record #0: key=3340, data=open,
record #1: emtpy record
HashArray[461]:
length=6
record #0: key=1293, data=Also
record #1: key=141, data=);
HashArray[462]:
length=7
record #0: key=3150, data=file,
record #1: key=718, data=bit
HashArray[463]:
length=6
record #0: key=1551, data=bits
record #1: emtpy record
HashArray[464]:
length=7
record #0: key=336, data=or
record #1: key=13005, data=already
HashArray[465]:
length=7
record #0: key=1617, data=mode
record #1: emtpy record
HashArray[466]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[468]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[469]:
length=6
record #0: key=13970, data=szName,
record #1: key=1557, data=disk
HashArray[470]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[471]:
length=6
record #0: key=343, data=to
record #1: emtpy record
HashArray[472]:
length=6
record #0: key=27218, data=implied.
record #1: emtpy record
HashArray[474]:
length=6
record #0: key=24405, data=Overview
record #1: emtpy record
HashArray[475]:
length=7
record #0: key=3419, data=tion;
record #1: key=6362, data=fails,
HashArray[476]:
length=6
record #0: key=732, data=rs.
record #1: key=10202, data=:close,
HashArray[477]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[478]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
HashArray[480]:
length=5
record #0: key=1504, data=call
record #1: key=0, data=
HashArray[481]:
length=5
record #0: key=97, data=a
record #1: key=1665, data=only
HashArray[482]:
length=6
record #0: key=1698, data=void
record #1: emtpy record
HashArray[484]:
length=5
record #0: key=324, data=of
record #1: key=708, data=and
HashArray[485]:
length=6
record #0: emtpy record
record #1: emtpy record
HashArray[486]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[487]:
length=6
record #0: key=103, data=g
record #1: emtpy record
HashArray[488]:
length=6
record #0: key=40, data=(
record #1: key=744, data=for
HashArray[489]:
length=6
record #0: key=297, data=be
record #1: key=41, data=)
HashArray[490]:
length=5
record #0: key=778, data=not
record #1: emtpy record
HashArray[492]:
length=7
record #0: key=3436, data=other
record #1: emtpy record
HashArray[493]:
length=6
record #0: key=13418, data=object.
record #1: emtpy record
HashArray[494]:
length=6
record #0: key=110, data=n
record #1: key=7085, data=static
HashArray[495]:
length=6
record #0: key=6894, data=opened
record #1: emtpy record
HashArray[496]:
length=7
record #0: key=240, data=An
record #1: key=1648, data=open
HashArray[497]:
length=6
record #0: key=3121, data=nMode
record #1: key=12846, data=defined
HashArray[498]:
length=5
record #0: key=3442, data=used.
record #1: emtpy record
HashArray[499]:
length=7
record #0: key=115, data=s
record #1: key=10993, data=Classes
HashArray[500]:
length=7
record #0: key=756, data=int
record #1: key=6131, data=Stream
HashArray[501]:
length=6
record #0: key=309, data=as
record #1: key=757, data=ios
HashArray[502]:
length=4
record #0: key=326, data=it
record #1: key=1654, data=that
HashArray[504]:
length=7
record #0: key=248, data=If
record #1: key=1656, data=then
HashArray[505]:
length=7
record #0: key=27123, data=ifstream
record #1: key=1529, data=eate
HashArray[506]:
length=6
record #0: key=3258, data=const
record #1: key=3194, data=nProt
HashArray[507]:
length=7
record #0: key=635, data=See
record #1: emtpy record
HashArray[508]:
length=7
record #0: key=124, data=|
record #1: key=26614, data=attached
HashArray[509]:
length=5
record #0: key=61, data==
record #1: emtpy record
HashArray[510]:
length=5
record #0: key=1630, data=list
record #1: key=2846, data=Input
this is silly test


can you find word of 'Remarks'?
yes
can you find word of 'remarks'?
no
 







                                 back.gif (341 bytes)       up.gif (335 bytes)         next.gif (337 bytes)