1 /*

     2 * Copyright (c) 2009 Symbian Foundation Ltd

     3 * This component and the accompanying materials are made available

     4 * under the terms of the License "Eclipse Public License v1.0"

     5 * which accompanies this distribution, and is available

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

     7 *

     8 * Initial Contributors:

     9 * Symbian Foundation Ltd - initial contribution.

    10 * 

    11 * Contributors:

    12 *

    13 * Description:

    14 * Implementation of CTiger class

    15 */

    16 

    17 // INCLUDE FILES

    18 #include <e32std.h>

    19 #include "Tiger.h"

    20 

    21 #define assert(a) __ASSERT_ALWAYS(a,User::Invariant());

    22 

    23 // CONSTANTS

    24 

    25 const float KaspectRatio = 612.0f / 792.0f;

    26 

    27 /*--------------------------------------------------------------*/

    28 

    29 // ============================ MEMBER FUNCTIONS ===============================

    30 

    31 // -----------------------------------------------------------------------------

    32 // CTiger::NewL

    33 //

    34 // The usual Symbian NewL implementation.

    35 // Creates the object, pushes it to cleanup stack and calls ContructL.

    36 // Returns the contructed object or leaves.

    37 // -----------------------------------------------------------------------------

    38 //

    39 

    40 CTiger* CTiger::NewL(TUint aWidth, TUint aHeight)

    41 	{

    42 	/* Symbian 2-phase constructor. Calls both the default

    43 	 C++ constructor and Symbian ConstructL methods */

    44 	CTiger* self = new (ELeave) CTiger(aWidth, aHeight);

    45 	CleanupStack::PushL(self);

    46 	self->ConstructL();

    47 	CleanupStack::Pop();

    48 

    49 	return self;

    50 	}

    51 

    52 // -----------------------------------------------------------------------------

    53 // CTiger::CTiger

    54 //

    55 // C++ constructor. Initializes the size instance variables from arguments.

    56 // -----------------------------------------------------------------------------

    57 //

    58 

    59 CTiger::CTiger(TUint aWidth,TUint aHeight) :

    60 	iScreenWidth(aWidth),iScreenHeight(aHeight)

    61 	{

    62 	}

    63 

    64 // -----------------------------------------------------------------------------

    65 // CTiger::~CTiger

    66 //

    67 // C++ destructor.

    68 // -----------------------------------------------------------------------------

    69 //

    70 

    71 CTiger::~CTiger()

    72 	{

    73 	}

    74 

    75 // -----------------------------------------------------------------------------

    76 // CTiger::ConstructL

    77 //

    78 // 2nd phase constructor.

    79 // -----------------------------------------------------------------------------

    80 //

    81 

    82 void CTiger::ConstructL(void)

    83 	{

    84 	}

    85 

    86 // -----------------------------------------------------------------------------

    87 // CTiger::AppInit

    88 //

    89 // Initializes OpenGL ES, sets the vertex and color arrays and pointers,

    90 // and selects the shading mode.

    91 // -----------------------------------------------------------------------------

    92 //

    93 

    94 void CTiger::AppInit(RWindow& /*aWindow*/, CFbsBitmap* aBitmapToDraw)

    95 	{

    96 	// Initialize viewport and projection.

    97 	SetScreenSize(iScreenWidth, iScreenHeight);

    98 	//render into half-screen dimensions 

    99 	iNativeWindowType.iSize = TSize(iScreenWidth, iScreenHeight);

   100 	

   101 	iBitmapToDraw = aBitmapToDraw;

   102 	init((NativeWindowType) &iNativeWindowType, aBitmapToDraw);

   103 	

   104 	//render now to save time on redraw

   105 	TRect rect(0, 0, iNativeWindowType.iSize.iWidth, iNativeWindowType.iSize.iHeight);

   106 	

   107 	//render now to stop render from taking place on draw which causes ViewSrv 11 panic

   108 	AppRender(iNativeWindowType.iSize);

   109 	}

   110 

   111 

   112 // -----------------------------------------------------------------------------

   113 // CTiger::AppExit

   114 //

   115 // Release any allocations made in AppInit.

   116 // -----------------------------------------------------------------------------

   117 //

   118 

   119 

   120 void CTiger::AppExit(void)

   121 	{

   122 	if(iTiger)

   123 		PS_destruct(iTiger);

   124 	eglMakeCurrent(iEgldisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

   125 	__ASSERT_ALWAYS(eglGetError() == EGL_SUCCESS,User::Invariant());

   126 	eglTerminate(iEgldisplay);

   127 	__ASSERT_ALWAYS(eglGetError() == EGL_SUCCESS,User::Invariant());

   128 	eglReleaseThread();

   129 	}

   130 

   131 void CTiger::PS_destruct(PS* ps)

   132 	{

   133 	int i;

   134 	__ASSERT_ALWAYS(ps,User::Invariant());

   135 	for (i = 0; i < ps->m_numPaths; i++)

   136 		{

   137 		vgDestroyPaint(ps->m_paths[i].m_fillPaint);

   138 		vgDestroyPaint(ps->m_paths[i].m_strokePaint);

   139 		vgDestroyPath(ps->m_paths[i].m_path);

   140 		}

   141 	delete[] ps->m_paths;

   142 	ps->m_paths = NULL;

   143 	delete ps;

   144 	ps = NULL;

   145 

   146 	}

   147 

   148 void CTiger::AppRender(const TRect& aRect, CFbsBitmap* aDst)

   149 	{	

   150 	TDisplayMode dispMode=ENone;

   151 	if (iBitmapToDraw == NULL)

   152 		{

   153 		//drawing tiger

   154 		dispMode = EColor16MA;

   155 		TRAPD(err, render(aRect.Width(), aRect.Height()));

   156 		if (err==KErrNoMemory)

   157 			{

   158 			//check heap metrics		

   159 			RDebug::Printf("If rendering fails with KErrNoMemory then you must modify epoc.ini file ");

   160 			RDebug::Printf("to increase the maximum total heap size e.g. to MegabytesOfFreeMemory 64.");

   161 			RDebug::Printf("The Kronos ref OpenVG seems to use a lot of heap so when both NVG engine");

   162 			RDebug::Printf("and the Tiger app are active it pushes it over limit of 48Mb.");

   163 			}

   164 		}

   165 	else

   166 		{

   167 		//draw bitmap

   168 		dispMode = iBitmapToDraw->DisplayMode();

   169 		renderFromBitmap(aRect.Width(), aRect.Height());

   170 		}

   171 	if(aDst)

   172 		{

   173 		//we want to render into the the aDst CFbsBitmap so set up the native window type for this

   174 		aDst->Create(iNativeWindowType.iSize, dispMode); //how does display mode relate to pixel buffer colour depth coming from OpenVG?#

   175 		iNativeWindowType.iBitmap = aDst;

   176 		

   177 		//swap buffers that will cause actual copy of data into CFbsBitmap

   178 		eglSwapBuffers(iEgldisplay, iEglsurface);

   179 		__ASSERT_ALWAYS(eglGetError() == EGL_SUCCESS,User::Invariant());

   180 		}

   181 	

   182 	//reset

   183 	iNativeWindowType.iBitmap = NULL;

   184 	

   185 	}

   186 

   187 void CTiger::SetScreenSize(TUint aWidth, TUint aHeight)

   188 	{

   189 	iScreenWidth = aWidth;

   190 	iScreenHeight = aHeight;

   191 	}

   192 

   193 ///////////////////////////////////////////////////////////////////////////

   194 

   195 /*

   196  * Copied from ri_package_11\samples\tiger\main.c

   197  */

   198 

   199 void CTiger::render(int w, int h)

   200 	{

   201 	if (iRenderWidth != w || iRenderHeight != h)

   202 		{

   203 		float clearColor[4] =

   204 			{

   205 			1, 1, 1, 1

   206 			};

   207 		float scale = w / (KtigerMaxX - KtigerMinX);

   208 

   209 		eglSwapBuffers(iEgldisplay, iEglsurface); //force EGL to recognize resize

   210 

   211 		vgSetfv(VG_CLEAR_COLOR, 4, clearColor);

   212 		vgClear(0, 0, w, h);

   213 

   214 		vgLoadIdentity();

   215 		vgScale(scale, scale);

   216 		vgTranslate(-KtigerMinX, -KtigerMinY + 0.5f * (h / scale - (KtigerMaxY

   217 				- KtigerMinY)));

   218 

   219 		PS_render(iTiger);

   220 		__ASSERT_ALWAYS(vgGetError() == VG_NO_ERROR,User::Invariant());

   221 

   222 		iRenderWidth = w;

   223 		iRenderHeight = h;

   224 		}

   225 	}

   226 

   227 void CTiger::renderFromBitmap(int w, int h)

   228 	{

   229 	if (iRenderWidth != w || iRenderHeight != h)

   230 		{

   231 		TSize sz = iBitmapToDraw->SizeInPixels();

   232 		float scale = w / (sz.iWidth);

   233 		vgLoadIdentity();

   234 		vgScale(scale, scale);

   235 		vgTranslate(-0.0, -0.0 + 0.5f * (h / scale - (sz.iHeight)));

   236 

   237 		iRenderWidth = w;

   238 		iRenderHeight = h;

   239 

   240 		vgDrawImage(iImage);

   241 		__ASSERT_ALWAYS(vgGetError() == VG_NO_ERROR,User::Invariant());

   242 		

   243 		eglSwapBuffers(iEgldisplay, iEglsurface); //force GL to recognise resize

   244 		__ASSERT_ALWAYS(eglGetError() == EGL_SUCCESS,User::Invariant());

   245 		}

   246 	}

   247 

   248 void CTiger::PS_render(PS* ps)

   249 	{

   250 	int i;

   251 	__ASSERT_ALWAYS(ps,User::Invariant());

   252 	vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);

   253 

   254 	for (i = 0; i < ps->m_numPaths; i++)

   255 		{

   256 		vgSeti(VG_FILL_RULE, ps->m_paths[i].m_fillRule);

   257 		vgSetPaint(ps->m_paths[i].m_fillPaint, VG_FILL_PATH);

   258 

   259 		if (ps->m_paths[i].m_paintMode & VG_STROKE_PATH)

   260 			{

   261 			vgSetf(VG_STROKE_LINE_WIDTH, ps->m_paths[i].m_strokeWidth);

   262 			vgSeti(VG_STROKE_CAP_STYLE, ps->m_paths[i].m_capStyle);

   263 			vgSeti(VG_STROKE_JOIN_STYLE, ps->m_paths[i].m_joinStyle);

   264 			vgSetf(VG_STROKE_MITER_LIMIT, ps->m_paths[i].m_miterLimit);

   265 			vgSetPaint(ps->m_paths[i].m_strokePaint, VG_STROKE_PATH);

   266 			}

   267 

   268 		vgDrawPath(ps->m_paths[i].m_path, ps->m_paths[i].m_paintMode);

   269 		}

   270 	__ASSERT_ALWAYS(vgGetError() == VG_NO_ERROR,User::Invariant());

   271 	}

   272 

   273 PS* CTiger::PS_construct(const char* commands, int commandCount,

   274 		const float* points, int /*pointCount*/)

   275 	{

   276 	PS* ps = new PS;

   277 	assert(ps);

   278 	int p = 0;

   279 	int c = 0;

   280 	int i = 0;

   281 	int paths = 0;

   282 	int maxElements = 0;

   283 	unsigned char* cmd;

   284 	//UNREF(pointCount);

   285 

   286 	while (c < commandCount)

   287 		{

   288 		int elements, e;

   289 		c += 4;

   290 		p += 8;

   291 		elements = (int) points[p++];

   292 		assert(elements> 0);

   293 		if (elements > maxElements)

   294 			maxElements = elements;

   295 		for (e = 0; e < elements; e++)

   296 			{

   297 			switch (commands[c])

   298 				{

   299 				case 'M':

   300 					p += 2;

   301 					break;

   302 				case 'L':

   303 					p += 2;

   304 					break;

   305 				case 'C':

   306 					p += 6;

   307 					break;

   308 				case 'E':

   309 					break;

   310 				default:

   311 					assert(0)

   312 					; //unknown command

   313 				}

   314 			c++;

   315 			}

   316 		paths++;

   317 		}

   318 

   319 	ps->m_numPaths = paths;

   320 	ps->m_paths = new PathData[paths];//(PathData*)malloc(paths * sizeof(PathData));

   321 	cmd = new unsigned char[maxElements];//(unsigned char*)malloc(maxElements);

   322 

   323 	i = 0;

   324 	p = 0;

   325 	c = 0;

   326 	while (c < commandCount)

   327 		{

   328 		int elements, startp, e;

   329 		float color[4];

   330 

   331 		//fill type

   332 		int paintMode = 0;

   333 		ps->m_paths[i].m_fillRule = VG_NON_ZERO;

   334 		switch (commands[c])

   335 			{

   336 			case 'N':

   337 				break;

   338 			case 'F':

   339 				ps->m_paths[i].m_fillRule = VG_NON_ZERO;

   340 				paintMode |= VG_FILL_PATH;

   341 				break;

   342 			case 'E':

   343 				ps->m_paths[i].m_fillRule = VG_EVEN_ODD;

   344 				paintMode |= VG_FILL_PATH;

   345 				break;

   346 			default:

   347 				assert(0)

   348 				; //unknown command

   349 			}

   350 		c++;

   351 

   352 		//stroke

   353 		switch (commands[c])

   354 			{

   355 			case 'N':

   356 				break;

   357 			case 'S':

   358 				paintMode |= VG_STROKE_PATH;

   359 				break;

   360 			default:

   361 				assert(0)

   362 				; //unknown command

   363 			}

   364 		ps->m_paths[i].m_paintMode = (VGPaintMode) paintMode;

   365 		c++;

   366 

   367 		//line cap

   368 		switch (commands[c])

   369 			{

   370 			case 'B':

   371 				ps->m_paths[i].m_capStyle = VG_CAP_BUTT;

   372 				break;

   373 			case 'R':

   374 				ps->m_paths[i].m_capStyle = VG_CAP_ROUND;

   375 				break;

   376 			case 'S':

   377 				ps->m_paths[i].m_capStyle = VG_CAP_SQUARE;

   378 				break;

   379 			default:

   380 				assert(0)

   381 				; //unknown command

   382 			}

   383 		c++;

   384 

   385 		//line join

   386 		switch (commands[c])

   387 			{

   388 			case 'M':

   389 				ps->m_paths[i].m_joinStyle = VG_JOIN_MITER;

   390 				break;

   391 			case 'R':

   392 				ps->m_paths[i].m_joinStyle = VG_JOIN_ROUND;

   393 				break;

   394 			case 'B':

   395 				ps->m_paths[i].m_joinStyle = VG_JOIN_BEVEL;

   396 				break;

   397 			default:

   398 				assert(0)

   399 				; //unknown command

   400 			}

   401 		c++;

   402 

   403 		//the rest of stroke attributes

   404 		ps->m_paths[i].m_miterLimit = points[p++];

   405 		ps->m_paths[i].m_strokeWidth = points[p++];

   406 

   407 		//paints

   408 		color[0] = points[p++];

   409 		color[1] = points[p++];

   410 		color[2] = points[p++];

   411 		color[3] = 1.0f;

   412 		ps->m_paths[i].m_strokePaint = vgCreatePaint();

   413 		vgSetParameteri(ps->m_paths[i].m_strokePaint, VG_PAINT_TYPE,

   414 				VG_PAINT_TYPE_COLOR);

   415 		vgSetParameterfv(ps->m_paths[i].m_strokePaint, VG_PAINT_COLOR, 4, color);

   416 

   417 		color[0] = points[p++];

   418 		color[1] = points[p++];

   419 		color[2] = points[p++];

   420 		color[3] = 1.0f;

   421 		ps->m_paths[i].m_fillPaint = vgCreatePaint();

   422 		vgSetParameteri(ps->m_paths[i].m_fillPaint, VG_PAINT_TYPE,

   423 				VG_PAINT_TYPE_COLOR);

   424 		vgSetParameterfv(ps->m_paths[i].m_fillPaint, VG_PAINT_COLOR, 4, color);

   425 

   426 		//read number of elements

   427 

   428 		elements = (int) points[p++];

   429 		assert(elements> 0);

   430 		startp = p;

   431 		for (e = 0; e < elements; e++)

   432 			{

   433 			switch (commands[c])

   434 				{

   435 				case 'M':

   436 					cmd[e] = VG_MOVE_TO | VG_ABSOLUTE;

   437 					p += 2;

   438 					break;

   439 				case 'L':

   440 					cmd[e] = VG_LINE_TO | VG_ABSOLUTE;

   441 					p += 2;

   442 					break;

   443 				case 'C':

   444 					cmd[e] = VG_CUBIC_TO | VG_ABSOLUTE;

   445 					p += 6;

   446 					break;

   447 				case 'E':

   448 					cmd[e] = VG_CLOSE_PATH;

   449 					break;

   450 				default:

   451 					assert(0)

   452 					; //unknown command

   453 				}

   454 			c++;

   455 			}

   456 

   457 		ps->m_paths[i].m_path = vgCreatePath(

   458 				VG_PATH_FORMAT_STANDARD, VG_PATH_DATATYPE_F, 1.0f, 0.0f, 0, 0,

   459 				(unsigned int) VG_PATH_CAPABILITY_ALL);

   460 		vgAppendPathData(ps->m_paths[i].m_path, elements, cmd, points + startp);

   461 		i++;

   462 		}

   463 	delete[] cmd;

   464 	return ps;

   465 	}

   466 

   467 void CTiger::init(NativeWindowType window, CFbsBitmap* aBitmapToDraw)

   468 	{

   469 	static const EGLint s_configAttribs[] =

   470 		{

   471 				EGL_RED_SIZE,

   472 				8,

   473 				EGL_GREEN_SIZE,

   474 				8,

   475 				EGL_BLUE_SIZE,

   476 				8,

   477 				EGL_ALPHA_SIZE,

   478 				8,

   479 				EGL_LUMINANCE_SIZE,

   480 				EGL_DONT_CARE, //EGL_DONT_CARE

   481 				EGL_SURFACE_TYPE,

   482 				EGL_WINDOW_BIT,

   483 				EGL_SAMPLES,

   484 				1,

   485 				EGL_NONE

   486 		};

   487 	EGLint numconfigs;

   488 

   489 	iEgldisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

   490 	eglInitialize(iEgldisplay, NULL, NULL);

   491 	assert(eglGetError() == EGL_SUCCESS);

   492 	eglBindAPI(EGL_OPENVG_API);

   493 

   494 	eglChooseConfig(iEgldisplay, s_configAttribs, &iEglconfig, 1, &numconfigs);

   495 	assert(eglGetError() == EGL_SUCCESS);

   496 	assert(numconfigs == 1);

   497 

   498 	iEglsurface = eglCreateWindowSurface(iEgldisplay, iEglconfig, window, NULL);

   499 	assert(eglGetError() == EGL_SUCCESS);

   500 	iEglcontext = eglCreateContext(iEgldisplay, iEglconfig, NULL, NULL);

   501 	assert(eglGetError() == EGL_SUCCESS);

   502 	eglMakeCurrent(iEgldisplay, iEglsurface, iEglsurface, iEglcontext);

   503 	assert(eglGetError() == EGL_SUCCESS);

   504 

   505 	if (aBitmapToDraw == NULL)//render tiger image

   506 		iTiger = PS_construct(KtigerCommands, KtigerCommandCount, KtigerPoints,

   507 				KtigerPointCount);

   508 	else

   509 		{

   510 		//render bitmap through OpenVG

   511 		CreateImage(aBitmapToDraw);

   512 		}

   513 	}

   514 

   515 void CTiger::CreateImage(CFbsBitmap* aBitmapToDraw)

   516 	{

   517 	TUint32* address = aBitmapToDraw->DataAddress();

   518 	TSize sz = aBitmapToDraw->SizeInPixels();

   519 

   520 	VGImageFormat dataFormat = VG_sRGB_565;

   521 	VGint width = sz.iWidth;

   522 	VGint height = sz.iHeight;

   523 	VGint dataStride = aBitmapToDraw->DataStride();

   524 

   525 	vgSeti(VG_IMAGE_QUALITY, VG_IMAGE_QUALITY_NONANTIALIASED);

   526 	vgSeti(VG_RENDERING_QUALITY, VG_RENDERING_QUALITY_NONANTIALIASED);

   527 

   528 	//Create VGImage

   529 

   530 	iImage = vgCreateImage(dataFormat, width, height,

   531 			VG_IMAGE_QUALITY_NONANTIALIASED);

   532 	__ASSERT_ALWAYS(vgGetError() == VG_NO_ERROR,User::Invariant());

   533 

   534 	//Load Symbian bitmap into VGImage

   535 	vgImageSubData(iImage, aBitmapToDraw->DataAddress(), dataStride,

   536 			dataFormat, 0, 0, width, height);

   537 	__ASSERT_ALWAYS(vgGetError() == VG_NO_ERROR,User::Invariant());

   538 

   539 	}

   540 

   541 const int KtigerCommandCount = 4151;

   542 const char KtigerCommands[4151] = {

   543 			'F',

   544 			'N',

   545 			'B',

   546 			'M',

   547 			'M',

   548 			'L',

   549 			'L',

   550 			'L',

   551 			'E',

   552 			'F',

   553 			'N',

   554 			'B',

   555 			'M',

   556 			'M',

   557 			'C',

   558 			'C',

   559 			'C',

   560 			'E',

   561 			'N',

   562 			'S',

   563 			'B',

   564 			'M',

   565 			'M',

   566 			'C',

   567 			'C',

   568 			'C',

   569 			'E',

   570 			'F',

   571 			'N',

   572 			'B',

   573 			'M',

   574 			'M',

   575 			'C',

   576 			'C',

   577 			'C',

   578 			'E',

   579 			'N',

   580 			'S',

   581 			'B',

   582 			'M',

   583 			'M',

   584 			'C',

   585 			'C',

   586 			'C',

   587 			'E',

   588 			'F',

   589 			'N',

   590 			'B',

   591 			'M',

   592 			'M',

   593 			'C',

   594 			'C',

   595 			'C',

   596 			'E',

   597 			'N',

   598 			'S',

   599 			'B',

   600 			'M',

   601 			'M',

   602 			'C',

   603 			'C',

   604 			'C',

   605 			'E',

   606 			'F',

   607 			'N',

   608 			'B',

   609 			'M',

   610 			'M',

   611 			'C',

   612 			'C',

   613 			'C',

   614 			'E',

   615 			'N',

   616 			'S',

   617 			'B',

   618 			'M',

   619 			'M',

   620 			'C',

   621 			'C',

   622 			'C',

   623 			'E',

   624 			'F',

   625 			'N',

   626 			'B',

   627 			'M',

   628 			'M',

   629 			'C',

   630 			'C',

   631 			'C',

   632 			'E',

   633 			'N',

   634 			'S',

   635 			'B',

   636 			'M',

   637 			'M',

   638 			'C',

   639 			'C',

   640 			'C',

   641 			'E',

   642 			'F',

   643 			'N',

   644 			'B',

   645 			'M',

   646 			'M',

   647 			'C',

   648 			'C',

   649 			'C',

   650 			'E',

   651 			'N',

   652 			'S',

   653 			'B',

   654 			'M',

   655 			'M',

   656 			'C',

   657 			'C',

   658 			'C',

   659 			'E',

   660 			'F',

   661 			'N',

   662 			'B',

   663 			'M',

   664 			'M',

   665 			'C',

   666 			'C',

   667 			'C',

   668 			'E',

   669 			'N',

   670 			'S',

   671 			'B',

   672 			'M',

   673 			'M',

   674 			'C',

   675 			'C',

   676 			'C',

   677 			'E',

   678 			'F',

   679 			'N',

   680 			'B',

   681 			'M',

   682 			'M',

   683 			'C',

   684 			'C',

   685 			'C',

   686 			'E',

   687 			'N',

   688 			'S',

   689 			'B',

   690 			'M',

   691 			'M',

   692 			'C',

   693 			'C',

   694 			'C',

   695 			'E',

   696 			'F',

   697 			'N',

   698 			'B',

   699 			'M',

   700 			'M',

   701 			'C',

   702 			'C',

   703 			'C',

   704 			'E',

   705 			'N',

   706 			'S',

   707 			'B',

   708 			'M',

   709 			'M',

   710 			'C',

   711 			'C',

   712 			'C',

   713 			'E',

   714 			'F',

   715 			'N',

   716 			'B',

   717 			'M',

   718 			'M',

   719 			'C',

   720 			'C',

   721 			'C',

   722 			'E',

   723 			'N',

   724 			'S',

   725 			'B',

   726 			'M',

   727 			'M',

   728 			'C',

   729 			'C',

   730 			'C',

   731 			'E',

   732 			'F',

   733 			'N',

   734 			'B',

   735 			'M',

   736 			'M',

   737 			'C',

   738 			'C',

   739 			'C',

   740 			'E',

   741 			'N',

   742 			'S',

   743 			'B',

   744 			'M',

   745 			'M',

   746 			'C',

   747 			'C',

   748 			'C',

   749 			'E',

   750 			'F',

   751 			'N',

   752 			'B',

   753 			'M',

   754 			'M',

   755 			'C',

   756 			'C',

   757 			'C',

   758 			'E',

   759 			'N',

   760 			'S',

   761 			'B',

   762 			'M',

   763 			'M',

   764 			'C',

   765 			'C',

   766 			'C',

   767 			'E',

   768 			'F',

   769 			'N',

   770 			'B',

   771 			'M',

   772 			'M',

   773 			'C',

   774 			'C',

   775 			'C',

   776 			'C',

   777 			'C',

   778 			'C',

   779 			'C',

   780 			'C',

   781 			'L',

   782 			'C',

   783 			'L',

   784 			'C',

   785 			'L',

   786 			'C',

   787 			'C',

   788 			'C',

   789 			'C',

   790 			'C',

   791 			'L',

   792 			'C',

   793 			'C',

   794 			'L',

   795 			'C',

   796 			'C',

   797 			'C',

   798 			'C',

   799 			'C',

   800 			'C',

   801 			'C',

   802 			'L',

   803 			'C',

   804 			'C',

   805 			'C',

   806 			'C',

   807 			'C',

   808 			'C',

   809 			'C',

   810 			'C',

   811 			'C',

   812 			'C',

   813 			'C',

   814 			'C',

   815 			'C',

   816 			'C',

   817 			'C',

   818 			'C',

   819 			'C',

   820 			'C',

   821 			'C',

   822 			'C',

   823 			'C',

   824 			'C',

   825 			'C',

   826 			'C',

   827 			'C',

   828 			'C',

   829 			'C',

   830 			'C',

   831 			'C',

   832 			'C',

   833 			'C',

   834 			'L',

   835 			'L',

   836 			'C',

   837 			'C',

   838 			'L',

   839 			'C',

   840 			'C',

   841 			'C',

   842 			'C',

   843 			'L',

   844 			'C',

   845 			'C',

   846 			'C',

   847 			'C',

   848 			'C',

   849 			'C',

   850 			'C',

   851 			'C',

   852 			'C',

   853 			'C',

   854 			'C',

   855 			'C',

   856 			'C',

   857 			'C',

   858 			'C',

   859 			'L',

   860 			'N',

   861 			'S',

   862 			'B',

   863 			'M',

   864 			'M',

   865 			'C',

   866 			'C',

   867 			'C',

   868 			'C',

   869 			'C',

   870 			'C',

   871 			'C',

   872 			'C',

   873 			'L',

   874 			'C',

   875 			'L',

   876 			'C',

   877 			'L',

   878 			'C',

   879 			'C',

   880 			'C',

   881 			'C',

   882 			'C',

   883 			'L',

   884 			'C',

   885 			'C',

   886 			'L',

   887 			'C',

   888 			'C',

   889 			'C',

   890 			'C',

   891 			'C',

   892 			'C',

   893 			'C',

   894 			'L',

   895 			'C',

   896 			'C',

   897 			'C',

   898 			'C',

   899 			'C',

   900 			'C',

   901 			'C',

   902 			'C',

   903 			'C',

   904 			'C',

   905 			'C',

   906 			'C',

   907 			'C',

   908 			'C',

   909 			'C',

   910 			'C',

   911 			'C',

   912 			'C',

   913 			'C',

   914 			'C',

   915 			'C',

   916 			'C',

   917 			'C',

   918 			'C',

   919 			'C',

   920 			'C',

   921 			'C',

   922 			'C',

   923 			'C',

   924 			'C',

   925 			'C',

   926 			'L',

   927 			'L',

   928 			'C',

   929 			'C',

   930 			'L',

   931 			'C',

   932 			'C',

   933 			'C',

   934 			'C',

   935 			'L',

   936 			'C',

   937 			'C',

   938 			'C',

   939 			'C',

   940 			'C',

   941 			'C',

   942 			'C',

   943 			'C',

   944 			'C',

   945 			'C',

   946 			'C',

   947 			'C',

   948 			'C',

   949 			'C',

   950 			'C',

   951 			'L',

   952 			'F',

   953 			'N',

   954 			'B',

   955 			'M',

   956 			'M',

   957 			'C',

   958 			'C',

   959 			'C',

   960 			'C',

   961 			'C',

   962 			'C',

   963 			'L',

   964 			'C',

   965 			'L',

   966 			'C',

   967 			'C',

   968 			'C',

   969 			'C',

   970 			'C',

   971 			'C',

   972 			'C',

   973 			'C',

   974 			'C',

   975 			'C',

   976 			'C',

   977 			'C',

   978 			'L',

   979 			'C',

   980 			'C',

   981 			'C',

   982 			'C',

   983 			'C',

   984 			'C',

   985 			'C',

   986 			'C',

   987 			'C',

   988 			'C',

   989 			'C',

   990 			'C',

   991 			'C',

   992 			'C',

   993 			'C',

   994 			'C',

   995 			'C',

   996 			'C',

   997 			'C',

   998 			'C',

   999 			'E',

  1000 			'N',

  1001 			'S',

  1002 			'B',

  1003 			'M',

  1004 			'M',

  1005 			'C',

  1006 			'C',

  1007 			'C',

  1008 			'C',

  1009 			'C',

  1010 			'C',

  1011 			'L',

  1012 			'C',

  1013 			'L',

  1014 			'C',

  1015 			'C',

  1016 			'C',

  1017 			'C',

  1018 			'C',

  1019 			'C',

  1020 			'C',

  1021 			'C',

  1022 			'C',

  1023 			'C',

  1024 			'C',

  1025 			'C',

  1026 			'L',

  1027 			'C',

  1028 			'C',

  1029 			'C',

  1030 			'C',

  1031 			'C',

  1032 			'C',

  1033 			'C',

  1034 			'C',

  1035 			'C',

  1036 			'C',

  1037 			'C',

  1038 			'C',

  1039 			'C',

  1040 			'C',

  1041 			'C',

  1042 			'C',

  1043 			'C',

  1044 			'C',

  1045 			'C',

  1046 			'C',

  1047 			'E',

  1048 			'F',

  1049 			'N',

  1050 			'B',

  1051 			'M',

  1052 			'M',

  1053 			'C',

  1054 			'C',

  1055 			'C',

  1056 			'C',

  1057 			'L',

  1058 			'C',

  1059 			'C',

  1060 			'C',

  1061 			'C',

  1062 			'C',

  1063 			'C',

  1064 			'C',

  1065 			'C',

  1066 			'C',

  1067 			'C',

  1068 			'C',

  1069 			'L',

  1070 			'F',

  1071 			'N',

  1072 			'B',

  1073 			'M',

  1074 			'M',

  1075 			'C',

  1076 			'C',

  1077 			'C',

  1078 			'C',

  1079 			'C',

  1080 			'C',

  1081 			'C',

  1082 			'C',

  1083 			'L',

  1084 			'C',

  1085 			'C',

  1086 			'C',

  1087 			'C',

  1088 			'L',

  1089 			'C',

  1090 			'C',

  1091 			'C',

  1092 			'E',

  1093 			'F',

  1094 			'N',

  1095 			'B',

  1096 			'M',

  1097 			'M',

  1098 			'C',

  1099 			'C',

  1100 			'C',

  1101 			'C',

  1102 			'C',

  1103 			'C',

  1104 			'C',

  1105 			'C',

  1106 			'L',

  1107 			'C',

  1108 			'C',

  1109 			'C',

  1110 			'C',

  1111 			'L',

  1112 			'C',

  1113 			'C',

  1114 			'C',

  1115 			'E',

  1116 			'F',

  1117 			'N',

  1118 			'B',

  1119 			'M',

  1120 			'M',

  1121 			'C',

  1122 			'C',

  1123 			'C',

  1124 			'C',

  1125 			'C',

  1126 			'C',

  1127 			'C',

  1128 			'C',

  1129 			'L',

  1130 			'C',

  1131 			'C',

  1132 			'C',

  1133 			'C',

  1134 			'L',