# Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

 # All rights reserved.

 # This component and the accompanying materials are made available

 # under the terms of the License "Eclipse Public License v1.0"

 # which accompanies this distribution, and is available

 # at the URL "http://www.eclipse.org/legal/epl-v10.html".

 #

 # Initial Contributors:

 # Nokia Corporation - initial contribution.

 #

 # Contributors:

 #

 # Description:

 # Creates C++ code describing how to decompose, compose and fold each character.

 # Usage:

 # perl -w FoldAndDecompTables.pl < <output-from-UnicodeMaxDecompose>

 # Tables we want to create:

 # A: Ordered list of non-excluded decompositions

 # B: List of folded decompositions matching A

 # C: List of decompositions not listed in A of length > 1

 # D: List of folded decompositions matching C

 # E: List of decompositions of length = 1 whose matching folded decompositions

 # are of length > 1

 # F: List of folded decompositions matching E

 # G: List of decompositions of length = 1 with matching folded decompositions

 # H: List of folded decompostions matching G

 # I: List of folded decompositions that do not have matching decompositions

 # J: List of decompositions (folding and otherwise) of length > 2

 # K: Hash table mapping Unicode value to its folded decomposition value in the

 # concatenated list B-D-F-H-I

 # L: List of hash slots in K matching A (providing a mapping from non-excluded

 # decompositions to Unicode value)

 # [all lengths are of UTF16 strings]

 # 

 #

 use strict;

 #

 # Hash table:

 #

 # Size of hashing table = 1 to the power $LgHashTableSize

 my $LgHashTableSize = 12;

 # Do not change these next two values!

 my $HashTableSize = 1 << $LgHashTableSize;

 my $HashTableBitmaskCpp = sprintf('0x%x', $HashTableSize - 1);

 # Hashing function in Perl: Getting the initial search position

 sub HashStart

 	{

 	return $_[0] & ($HashTableSize - 1);

 	}

 # How far to step through each time

 sub HashStep

 	{

 	my ($code) = @_;

 	$code *= $code >> $LgHashTableSize;

 	return ($code * 2 + 1) & ($HashTableSize - 1);

 	}

 # Make sure input string is all hex numbers separated by single spaces with

 # each hex number having 4 digits and decomposed into UTF16

 sub Normalize

 	{

 	my ($string) = @_;

 	if ($string =~ /^([0-9A-F]{4}( [0-9A-F]{4})*)?$/)

 		{

 		return $string;

 		}

 	my $norm = '';

 	foreach my $elt (split(' ', $string))

 		{

 		if ($elt)

 			{

 			die "'$elt' is not a hex number"

 				unless $elt =~ /[0-9a-fA-F]+/;

 			$norm = $norm.' '

 				unless $norm eq '';

 			$elt = hex $elt;

 			if ($elt < 0x10000)

 				{

 				$norm = $norm.(sprintf('%04X', $elt));

 				}

 			else

 				{

 				# Add a surrogate pair

 				$norm = $norm.(sprintf('%04X %04X',

 					($elt / 0x400) + 0xD7C0, ($elt % 0x400) + 0xDC00));

 				}

 			}

 		}

 	#print STDERR "'$string' normalized to '$norm'\n";

 	return $norm;

 	}

 # First stage:

 # Hash of Unicode values to normalised decomposition and folded strings

 my %Decomp = ();

 my %Folded = ();

 # Mapping from decomposition->char, if not excluded

 my %Composition = ();

 # characters with non-excluded decompositions

 my @IncludedDecomps = ();

 # characters with long (>1 UTF16) excluded decompositions

 my @LongExcludedDecomps = ();

 # characters with singleton decompositions but long folds

 my @ShortDecompsLongFolds = ();

 # characters with singleton folds and singleton

 my @ShortDecompsShortFolds = ();

 # characters with singleton folds but no decomps

 my @ShortFoldsOnly = ();

 # A mapping from decompositions of length greater than two

 # to the code that produced them.

 my %VeryLongDecompositions = ();

 # A list of characters containing all decompositions of length >2 as slices

 my @VeryLongDecompData = ();

 # Mapping from decomposition->index into VeryLongDecompData

 my %VeryLongDecompMap = ();

 # There will be a hash table mapping Unicode values to indices into the other

 # tables. %Index maps the same thing in Perl.

 my %Index = ();

 # %HashTableEntryContents maps the table entries to the Unicode values they

 # contain.

 my %HashTableEntryContents = ();

 # %HashTableEntry maps Unicode value to the entry in the hash table

 my %HashTableEntry = ();

 # Bind a unicode value to an index into the tables

 sub AddHashValue

 	{

 	my ($unicode, $index) = @_;

 	$Index{$unicode} = $index;

 	my $pos = HashStart($unicode);

 	my $step = HashStep($unicode);

 	while (exists $HashTableEntryContents{$pos})

 		{

 		$pos += $step;

 		if ($HashTableSize <= $pos)

 			{

 			$pos %= $HashTableSize;

 			}

 		}

 	$HashTableEntryContents{$pos} = $unicode;

 	$HashTableEntry{$unicode} = $pos;

 	}

 # Bind a whole array to the indices starting from that given as the first

 # argument. Returns the index of the next slot to be filled.

 sub AddListToHash

 	{

 	my ($index, @unicodes) = @_;

 	while (@unicodes)

 		{

 		AddHashValue(shift @unicodes, $index);

 		$index++;

 		}

 	return $index;

 	}

 # put the results of a read line into the data structures

 sub AddCode

 	{

 	my ($code, $excluded, $decomposition, $folded) = @_;

 	return if ($decomposition eq '' && $folded eq '');

 	$Decomp{$code} = $decomposition;

 	$Folded{$code} = $folded;

 	if (!$excluded && $decomposition ne '')

 		{

 		push @IncludedDecomps, $code;

 		$Composition{$decomposition} = $code;

 		}

 	elsif (4 < length $decomposition)

 		{

 		push @LongExcludedDecomps, $code;

 		}

 	elsif (4 < length $folded)

 		{

 		push @ShortDecompsLongFolds, $code;

 		}

 	elsif ($decomposition ne '')

 		{

 		push @ShortDecompsShortFolds, $code;

 		}

 	elsif ($folded ne '')

 		{

 		push @ShortFoldsOnly, $code;

 		}

 	$VeryLongDecompositions{$decomposition} = $code

 		if (9 < length $decomposition);

 	$VeryLongDecompositions{$folded} = $code

 		if (9 < length $folded);

 	}

 if (scalar(@ARGV) != 0)

 	{

 	print (STDERR "Usage:\nperl -w FoldAndDecompTables.pl < <output-from-UnicodeMaxDecompose>\n");

 	exit 1;

 	}

 my $lineNo = 0;

 my $inBlock = 0;

 while(<STDIN>)

 	{

 	$lineNo++;

 	if (/^(1?[0-9a-fA-F]{4,5});([^;]*);.*symbian:(E?);[^;]*;([0-9a-fA-F \t]*);([0-9a-fA-F \t]*)[ \t]*$/i)

 		{

 		my $code = hex $1;

 		my $description = $2;

 		my $excluded = $3;

 		my $decomposition = Normalize($4);

 		my $folded = Normalize($5);

 		die ("Value $1 too large to be Unicode at line $lineNo.")

 			if (0x110000 <= $code);

 		die("Normalisation failed with '$decomposition' at line $lineNo.")

 			unless (length $decomposition) == 0 || (length $decomposition) % 5 == 4;

 		die("Normalisation failed with '$folded' at line $lineNo.")

 			unless (length $folded) == 0 || (length $folded) % 5 == 4;

 		AddCode($code, $excluded, $decomposition, $folded);

 		if ($description =~ /^<.*Last>$/i)

 			{

 			die("End of block without start at line $lineNo!")

 				if !$inBlock;

 			while ($inBlock <= $code)

 				{

 				AddCode($inBlock, $excluded, $decomposition, $folded);

 				$inBlock++;

 				}

 			$inBlock = 0;

 			}

 		elsif ($description =~ /^<.*First>$/i)

 			{

 			die("Block within block at line $lineNo!")

 				if $inBlock;

 			$inBlock = $code + 1;

 			}

 		}

 	elsif (!/^[ \t]*$/)

 		{

 		die("Did not understand line $lineNo.");

 		}

 	}

 # We need to construct the data for the table of decompositions of length > 2.

 foreach my $decomp (sort {length $::b <=> length $::a} keys %VeryLongDecompositions)

 	{

 	if (!exists $VeryLongDecompMap{$decomp})

 		{

 		# Does not already exist

 		my $newPos = scalar @VeryLongDecompData;

 		$VeryLongDecompMap{$decomp} = $newPos;

 		foreach my $code (split(' ', $decomp))

 			{

 			push @VeryLongDecompData, $code;

 			}

 		while ($decomp =~ /^([0-9A-F]{4}( [0-9A-F]{4}){2,}) [0-9A-F]{4}$/)

 			{

 			$decomp = $1;

 			$VeryLongDecompMap{$decomp} = $newPos;

 			}

 		}

 	}

 # We need to sort the codes for included decompositions into lexicographic

 # order of their decompositions.

 # This, luckily, is the same as sorting the strings that represent their

 # decompositions in hex lexicographically.

 @IncludedDecomps = sort {$Decomp{$::a} cmp $Decomp{$::b}} @IncludedDecomps;

 print (STDERR 'Included: ', scalar(@IncludedDecomps), "\nLong: ", scalar(@LongExcludedDecomps));

 print(STDERR "\nLongFolds: ", scalar(@ShortDecompsLongFolds), "\nShort: ", scalar(@ShortDecompsShortFolds));

 print(STDERR "\nShortFoldsOnly: ", scalar(@ShortFoldsOnly), "\nTOTAL: ");

 print STDERR (scalar(@IncludedDecomps) + scalar(@LongExcludedDecomps) + scalar(@ShortDecompsLongFolds) + scalar(@ShortDecompsShortFolds) + scalar(@ShortFoldsOnly));

 print STDERR "\n";

 # Analyse the hash table to find out the maximum and average time

 # taken to find each ASCII character

 my $maxAsciiTime = 0;

 my $totalAsciiTime = 0;

 my $mostDifficultCode = undef;

 my $asciiFoundWithoutStepCount = 0;

 for (32..126)

 	{

 	my $code = $_;

 	my $pos = HashStart($code);

 	my $step = HashStep($code);

 	my $stepCount = 1;

 	if ($HashTableEntry{$code})

 		{

 		my $posRequired = $HashTableEntry{$code};

 		while ($pos != $posRequired)

 			{

 			$pos = ($pos + $step) % $HashTableSize;

 			$stepCount++;

 			}

 		}

 	$totalAsciiTime += $stepCount;

 	if ($maxAsciiTime < $stepCount)

 		{

 		$maxAsciiTime = $stepCount;

 		$mostDifficultCode = $code;

 		}

 	if ($stepCount == 1)

 		{

 		$asciiFoundWithoutStepCount++;

 		}

 	}

 printf (STDERR "Average ASCII search: %f\n", $totalAsciiTime / 95);

 printf (STDERR "Maximum ASCII search %d for %x: '%c'.\n", $maxAsciiTime, $mostDifficultCode, $mostDifficultCode);

 # Now we populate the hash table

 my $index = 0;

 $index = AddListToHash($index, @IncludedDecomps);

 my $hashIndexAfterIncludedDecomps = $index;

 printf (STDERR "after IncludedDecomps index= %d\n", $hashIndexAfterIncludedDecomps);

 $index = AddListToHash($index, @LongExcludedDecomps);

 my $hashIndexAfterLongExcludeDecomps = $index;

 printf (STDERR "after LongExcludedDecomps index= %d\n", $hashIndexAfterLongExcludeDecomps);

 $index = AddListToHash($index, @ShortDecompsLongFolds);

 my $hashIndexAfterShortDecompsLongFolds = $index;

 printf (STDERR "after ShortDecompsLongFolds index= %d\n", $hashIndexAfterShortDecompsLongFolds);

 $index = AddListToHash($index, @ShortDecompsShortFolds);

 my $hashIndexAfterShortDecompsShortFolds = $index;

 printf (STDERR "after ShortDecompsShortFolds index= %d\n", $hashIndexAfterShortDecompsShortFolds);

 $index = AddListToHash($index, @ShortFoldsOnly);

 my $hashIndexAfterShortFoldsOnly = $index;

 printf (STDERR "after ShortFoldsOnly index= %d\n", $hashIndexAfterShortFoldsOnly);

 #

 # Output C++ File

 #

 my $totalBytes = 0;

 print "// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).\n";

 print "// All rights reserved.\n";

 print "// This component and the accompanying materials are made available\n";

 print "// under the terms of the License \"Eclipse Public License v1.0\"\n";

 print "// which accompanies this distribution, and is available\n";

 print "// at the URL \"http://www.eclipse.org/legal/epl-v10.html\".\n";

 print "//\n";

 print "// Initial Contributors:\n";

 print "// Nokia Corporation - initial contribution.\n";

 print "//\n";

 print "// Contributors:\n";

 print "//\n";

 print "// Description:\n";

 print "//\n";

 print "// Fold and decomposition tables.\n";

 print "//\n";

 print "// These tables are linked in the following way:\n";

 print "// KUnicodeToIndexHash is a hash table using double hashing for\n";

 print "// conflict resolution. The functions DecompositionHashStart and\n";

 print "// DecompositionHashStep give the start and step values for accessing\n";

 print "// the table. The first probe is at DecompositionHashStart and each\n";

 print "// subsequent probe is offset by DecompositionHashStep. Probes\n";

 print "// continue until either 0 is found (indicating that the Unicode value\n";

 print "// sought has no decompostion (i.e. decomposes to itself)) or a value\n";

 print "// is found that has the sought Unicode value in its lower 20 bits.\n";

 print "//\n";

 print "// In this latter case, the upper 12 bits contain an index into\n";

 print "// one of the following tables, according to the following rules:\n";

 print "//\n";

 print "// In the case of folding:\n";

 print "// If the Index is less than the length of KNonSingletonFolds / 2,\n";

 print "// it is an index into KNonSingletonFolds. If the Index is\n";

 print "// greater than the length of KNonSingletonFolds / 2, then it is an\n";

 print "// index into KSingletonFolds.\n";

 print "//\n";

 print "// In the case of decomposition:\n";

 print "// If the Index is less than the length of KNonSingletonDecompositions / 2,\n";

 print "// it is an index into KNonSingletonDecompositions. If the Index is\n";

 print "// greater than the length of KNonSingletonDecompositions / 2, then it is an\n";

 print "// index into KSingletonDecompositions.\n";

 print "//\n";

 print "// In summary:\n";

 print "// Let Knsf be the length of KNonSingletonFolds / 2,\n";

 print "// let Knsd be the length of KNonSingletonDecompositions / 2,\n";

 print "// let Ksd be the length of KSingletonDecompositions and\n";

 print "// let Ksf be the length of KSingletonFolds.\n";

 print "// Now if you want to fold a character and you have found\n";

 print "// its index 'i' from the KUnicodeToIndexHash, then;\n";

 print "// if (i < Knsf) then look up\n";

 print "//\t\tKNonSingletonFolds[i * 2] and KNonSingletonFolds[i * 2 + 1]\n";

 print "// else if (Knsf <= i < Knsf + Ksf) look up KSingletonFolds[i - Knsf]\n";

 print "// else there is no fold for this character.\n";

 print "//\n";

 print "// Or if you want to decompose the same character, then;\n";

 print "// if (i < Knsd) then look up KNonSingletonDecompositions[i * 2]\n";

 print "//\t\tand KNonSingletonDecompositions[i * 2 + 1]\n";

 print "// else if (Knsd <= i < Knsd + Ksd) look up KSingletonDecompositions[i - Knsd]\n";

 print "// else there is no decomposition for this character.\n";

 print "//\n";

 print "// Your index into KSingletonDecompositions or KSingletonFolds\n";

 print "// yields a single value which is the decomposition or fold.\n";

 print "//\n";

 print "// The KNonSingletonFolds and KNonSingletonDecomposition\n";

 print "// tables are made up of pairs of values. Each pair is either a pair\n";

 print "// of Unicode values that constitute the fold or decomposition, or\n";

 print "// the first value is KLongD and the second has its top 4 bits as the\n";

 print "// length of the decomposition (or folded decomposition) minus 3,\n";

 print "// and its bottom 12 bits as the index into KLongDecompositions\n";

 print "// of where you can find this decomposition.\n";

 print "//\n";

 print "// KLongDecompositions simply contains UTF-16 (Unicode) for\n";

 print "// all the decomposed and folded sequences longer than 4 bytes long.\n";

 print "\n";

 print "// Hash table mapping unicode values to indices into the other tables\n";

 print "// in use = ".$hashIndexAfterShortFoldsOnly." entries\n";

 print "const unsigned long KUnicodeToIndexHash[$HashTableSize] =\n\t{\n\t";

 my @HashTableOutput;

 for (0..($HashTableSize - 1))

 	{

 	my $v = 0;

 	if (exists $HashTableEntryContents{$_})

 		{

 		$v = $HashTableEntryContents{$_};

 		die ('Did not expect a Unicode value > 0xFFFFF')

 			if 0xFFFFF < $v;

 		$v |= ($Index{$v}) << 20;

 		}

 	push @HashTableOutput, sprintf('0x%08x', $v);

 	$totalBytes += 4;

 	}

 print (shift @HashTableOutput);

 my $valueCount = 0;

 foreach my $v (@HashTableOutput)

 	{

 	print (((++$valueCount & 7) == 0)? ",\n\t" : ', ');

 	print $v;

 	}

 print "\n\t};\n\n";

 print "// Hash table access functions\n";

 print "const int KDecompositionHashBitmask = $HashTableBitmaskCpp;\n\n";

 print "inline int DecompositionHashStart(long a)\n";

 print "\t{\n\treturn a & $HashTableBitmaskCpp;\n\t}\n\n";

 print "inline int DecompositionHashStep(long a)\n";

 print "\t{\n\ta *= a >> $LgHashTableSize;\n";

 print "\treturn ((a<<1) + 1) & $HashTableBitmaskCpp;\n\t}\n\n";

 print "// Table mapping KNonSingletonDecompositions to the hash table entry that\n";

 print "// indexes it\n";

 print "const unsigned short KCompositionMapping[] =\n\t{\n\t";

 for (0..(scalar(@IncludedDecomps - 1)))

 	{

 	if ($_ != 0)

 		{print (($_ & 7) == 0? ",\n\t" : ', ')}

 	printf( '0x%04x', $HashTableEntry{$IncludedDecomps[$_]} );

 	$totalBytes += 2;

 	}

 print "\n\t};\n\n";

 print "// Table containing all the decomposition and folding strings longer\n";

 print "// than 2 UTF16 characters\n";

 print "const unsigned short KLongDecompositions[] =\n\t{\n\t0x";

 for(0..(scalar(@VeryLongDecompData) - 1))

 	{

 	if ($_ != 0)

 		{print (($_ & 7) == 0?",\n\t0x" : ', 0x')}

 	print $VeryLongDecompData[$_];

 	$totalBytes += 2;

 	}

 print "\n\t};\n\n";

 print "// Table containing decompositions longer than one UTF16 character.\n";

 print "// The top of the table contains all compositions, sorted lexicographically.\n";

 print "// Any decompositions of length 2 are in the table as a pair of values,\n";

 print "// decompositions longer than that are represented by a KLongD followed by\n";

 print "// a value whose top four bits indicate the length of the decomposition minus\n";

 print "// three and whose bottom 12 bits indicate an index into the KLongDecompositions\n";

 print "// array where the decomposition starts.\n";

 print "const long KLongD = 0;\n";

 print "// sizeof/2 = ".$hashIndexAfterLongExcludeDecomps."\n";

 print "const unsigned short KNonSingletonDecompositions[] =\n\t{\n\t";

 sub PrintNonsingletonDecompTableEntry

 	{

 	my ($decomp) = @_;

 	if (length $decomp < 10)

 		{

 		if ($decomp =~ /([0-9A-F]{4}) ([0-9A-F]{4})/)

 			{

 			print '0x'.$1.', 0x'.$2;

 			}

 		else

 			{

 			die("$decomp expected to be normalized and of length 1 or 2")

 				if $decomp !~ /[0-9A-F]{4}/;

 			print '0x'.$decomp.', 0xFFFF';

 			}

 		}

 	else

 		{

 		printf ('KLongD, 0x%1X%03X', ((length $decomp) - 14)/5, $VeryLongDecompMap{$decomp});

 		}

 	}

 {my $entryNo = 0;

 foreach my $code (@IncludedDecomps)

 	{

 	if ($entryNo != 0)

 		{print (($entryNo & 3) == 0?",\n\t" : ', ')}

 	PrintNonsingletonDecompTableEntry($Decomp{$code});

 	$entryNo++;

 	$totalBytes += 4;

 	}

 foreach my $code (@LongExcludedDecomps)

 	{

 	print (($entryNo & 3) == 0?",\n\t" : ', ');

 	PrintNonsingletonDecompTableEntry($Decomp{$code});

 	$entryNo++;

 	$totalBytes += 4;

 	}

 }

 print "\n\t};\n\n";

 print "// Table of folded decompositions which either have more than one UTF16, or\n";

 print "// their normal decompositions have more than one UTF16\n";

 print "// sizeof/2 = ".$hashIndexAfterShortDecompsLongFolds."\n";

 print "const unsigned short KNonSingletonFolds[] =\n\t{\n\t";

 {my $entryNo = 0;

 foreach my $code (@IncludedDecomps)

 	{

 	if ($entryNo != 0)

 		{print (($entryNo & 3) == 0?",\n\t" : ', ')}

 	PrintNonsingletonDecompTableEntry($Folded{$code});

 	$entryNo++;

 	$totalBytes += 4;

 	}

 foreach my $code (@LongExcludedDecomps)

 	{

 	print (($entryNo & 3) == 0?",\n\t" : ', ');

 	PrintNonsingletonDecompTableEntry($Folded{$code});

 	$entryNo++;

 	$totalBytes += 4;

 	}

 foreach my $code (@ShortDecompsLongFolds)

 	{

 	print (($entryNo & 3) == 0?",\n\t" : ', ');

 	PrintNonsingletonDecompTableEntry($Folded{$code});

 	$entryNo++;

 	$totalBytes += 4;

 	}

 }

 print "\n\t};\n\n";

 print "// Table of singleton decompositions and characters with singleton folds\n";

 print "// Note for Unicode 5.0:\n";

 print "// Unicode 5.0 contains some non-BMP characters have non-BMP \"singleton\" folds.\n";

 print "// As per the algorithm of this file, the non-BMP character should be stored in \n";

 print "// this table. \"Unsigned short\" is not big enough to hold them. However, this \n";

 print "// \"character\" information is not useful. So we just store 0xFFFF instead. \n";

 print "// Please do check 0xFFFF when access this table. If meet 0xFFFF, that means \n";

 print "// your character has no decomposition.\n";

 print "// See the variable \"ShortDecompsLongFolds\" in FoldAndDecompTables.pl if you \n";

 print "// want to know more.\n";

 print "// sizeof = ".($hashIndexAfterShortDecompsShortFolds-$hashIndexAfterLongExcludeDecomps)."\n";

 print "const unsigned short KSingletonDecompositions[] =\n\t{\n\t0x";

 {my $entryNo = 0;

 foreach my $code (@ShortDecompsLongFolds)

 	{

 	if ($entryNo != 0)

 		{print (($entryNo & 7) == 0?",\n\t0x" : ', 0x')}

 	if (exists $Decomp{$code} && $Decomp{$code} ne '')

 		{

 		print $Decomp{$code};

 		}

 	else

 		{

 		# Don't take these 0xFFFF as character.

 		#printf ('%04X', $code);

 		printf ("FFFF");

 		}

 	$entryNo++;

 	$totalBytes += 4;

 	}

 foreach my $code (@ShortDecompsShortFolds)

 	{

 	if ($entryNo != 0)

 		{print (($entryNo & 7) == 0?",\n\t0x" : ', 0x')}

 	print $Decomp{$code};

 	$entryNo++;

 	$totalBytes += 4;

 	}

 }

 print "\n\t};\n\n";

 print "// Table of singleton folds\n";

 print "// sizeof = ".($hashIndexAfterShortFoldsOnly-$hashIndexAfterShortDecompsLongFolds)."\n";

 print "const unsigned short KSingletonFolds[] =\n\t{\n\t0x";

 {my $entryNo = 0;

 foreach my $code (@ShortDecompsShortFolds)

 	{

 	if ($entryNo != 0)

 		{print (($entryNo & 7) == 0?",\n\t0x" : ', 0x')}

 	print $Folded{$code};

 	$entryNo++;

 	$totalBytes += 4;

 	}

 foreach my $code (@ShortFoldsOnly)

 	{

 	print (($entryNo & 7) == 0?",\n\t0x" : ', 0x');

 	print $Folded{$code};

 	$entryNo++;

 	$totalBytes += 4;

 	}

 }

 print "\n\t};\n";

 print "\n// Total size: $totalBytes bytes\n";

 print STDERR $totalBytes, " bytes\n";