[Jderobot-admin] jderobot-r1026 - in trunk: . src/stable/components/rgbdCalibrator src/stable/libs src/stable/libs/visionlib src/stable/libs/visionlib/cvFast

eperdices en jderobot.org eperdices en jderobot.org
Mie Oct 9 16:42:28 CEST 2013


Author: eperdices
Date: 2013-10-09 16:41:27 +0200 (Wed, 09 Oct 2013)
New Revision: 1026

Added:
   trunk/src/stable/libs/visionlib/cvBlob/
   trunk/src/stable/libs/visionlib/cvFast/
   trunk/src/stable/libs/visionlib/cvFast/CMakeLists.txt
   trunk/src/stable/libs/visionlib/cvFast/cvfast.cpp
   trunk/src/stable/libs/visionlib/cvFast/cvfast.h
Removed:
   trunk/src/stable/libs/cvBlob/
   trunk/src/stable/libs/visionlib/cvfast.cpp
   trunk/src/stable/libs/visionlib/cvfast.h
Modified:
   trunk/CMakeLists.txt
   trunk/src/stable/components/rgbdCalibrator/viewer.cpp
   trunk/src/stable/libs/visionlib/CMakeLists.txt
   trunk/src/stable/libs/visionlib/image.h
   trunk/src/stable/libs/visionlib/linesDetection.h
   trunk/src/stable/libs/visionlib/visionlib.h
Log:
Created cvFast and cvBlob inside visionlib.



Modified: trunk/CMakeLists.txt
===================================================================
--- trunk/CMakeLists.txt	2013-10-09 14:02:09 UTC (rev 1025)
+++ trunk/CMakeLists.txt	2013-10-09 14:41:27 UTC (rev 1026)
@@ -113,7 +113,12 @@
 	INSTALL (FILES ${lib} DESTINATION /usr/local/lib/jderobot)
 ENDFOREACH(lib)
 
+FILE(GLOB LIB_FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/stable/libs/visionlib/*/*.so)
+FOREACH (lib ${LIB_FILES})
+	INSTALL (FILES ${lib} DESTINATION /usr/local/lib/jderobot)
+ENDFOREACH(lib)
 
+
 FILE(GLOB_RECURSE HEADERS_FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/stable/libs/*.h)
 FOREACH(currentSourceFile ${HEADERS_FILES})
     string(REGEX REPLACE ".*/(.*/).*.h" "\\1" new_source1 ${currentSourceFile})

Modified: trunk/src/stable/components/rgbdCalibrator/viewer.cpp
===================================================================
--- trunk/src/stable/components/rgbdCalibrator/viewer.cpp	2013-10-09 14:02:09 UTC (rev 1025)
+++ trunk/src/stable/components/rgbdCalibrator/viewer.cpp	2013-10-09 14:41:27 UTC (rev 1026)
@@ -24,7 +24,7 @@
 #include <Ice/Ice.h>
 #include <IceUtil/IceUtil.h>
 #include <boost/filesystem.hpp>
-#include "../../libs/cvBlob/cvblob.h"
+#include <visionlib/cvBlob/cvblob.h>
 
 #define DEGTORAD     (3.14159264 / 180.0)
 #define DEBUG TRUE

Modified: trunk/src/stable/libs/visionlib/CMakeLists.txt
===================================================================
--- trunk/src/stable/libs/visionlib/CMakeLists.txt	2013-10-09 14:02:09 UTC (rev 1025)
+++ trunk/src/stable/libs/visionlib/CMakeLists.txt	2013-10-09 14:41:27 UTC (rev 1026)
@@ -1,10 +1,13 @@
+list_subdirectories( LIST_LIBS ${CMAKE_CURRENT_SOURCE_DIR} 1)
 
-add_subdirectory (colorspaces)
+FOREACH (libs ${LIST_LIBS})
+        ADD_SUBDIRECTORY (${libs})
+ENDFOREACH()
 
-SET( SOURCE_FILES cvfast.cpp geometry.cpp image.cpp linesDetection.cpp)
+SET( SOURCE_FILES geometry.cpp image.cpp linesDetection.cpp)
 include_directories( ${LIBS_DIR}/)
 add_library (visionlib  SHARED ${SOURCE_FILES})
-TARGET_LINK_LIBRARIES(visionlib progeo)
+TARGET_LINK_LIBRARIES(visionlib progeo cvfast)
 
 
 

Added: trunk/src/stable/libs/visionlib/cvFast/CMakeLists.txt
===================================================================
--- trunk/src/stable/libs/visionlib/cvFast/CMakeLists.txt	                        (rev 0)
+++ trunk/src/stable/libs/visionlib/cvFast/CMakeLists.txt	2013-10-09 14:41:27 UTC (rev 1026)
@@ -0,0 +1,4 @@
+SET(cvFast_CVFAST cvfast.cpp)
+add_library(cvfast SHARED ${cvFast_CVFAST})
+TARGET_LINK_LIBRARIES(cvfast ${OPENGL_LIBRARIES})
+

Copied: trunk/src/stable/libs/visionlib/cvFast/cvfast.cpp (from rev 1023, trunk/src/stable/libs/visionlib/cvfast.cpp)
===================================================================
--- trunk/src/stable/libs/visionlib/cvFast/cvfast.cpp	                        (rev 0)
+++ trunk/src/stable/libs/visionlib/cvFast/cvfast.cpp	2013-10-09 14:41:27 UTC (rev 1026)
@@ -0,0 +1,6104 @@
+#include <opencv/cvaux.h>
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <stdio.h>
+
+//Definitions for corner detectors.
+//These are internal functions and should not be called directly.
+//Input checking is only done in cvCornerFast
+
+
+CvPoint* icvFast9Detect(const unsigned char* im, int xsize, int ysize, int stride, int b, int* ret_num_corners);
+int* icvFast9Score(const unsigned char* i, int stride, CvPoint* corners, int num_corners, int b);
+
+/*CvPoint* icvFast10Detect(const unsigned char* im, int xsize, int ysize, int stride, int b, int* ret_num_corners);
+int* icvFast10Score(const unsigned char* i, int stride, CvPoint* corners, int num_corners, int b);
+
+CvPoint* icvFast11Detect(const unsigned char* im, int xsize, int ysize, int stride, int b, int* ret_num_corners);
+int* icvFast11Score(const unsigned char* i, int stride, CvPoint* corners, int num_corners, int b);
+
+CvPoint* icvFast12Detect(const unsigned char* im, int xsize, int ysize, int stride, int b, int* ret_num_corners);
+int* icvFast12Score(const unsigned char* i, int stride, CvPoint* corners, int num_corners, int b);*/
+
+/* This defines non-strict maxima */
+#define Compare(X, Y) ((X)>=(Y))
+
+/* This is a fast, integer only, sparse nonmaximal suppression. */
+/* probably only useful for FAST corner detection */
+CvPoint* icvFastNonmaxSuppression(const CvPoint* corners, const int* scores, int num_corners, int* ret_num_nonmax)
+{
+	int num_nonmax=0;
+	int last_row;
+	int* row_start;
+	int i, j;
+	CvPoint* ret_nonmax;
+	const int sz = (int)num_corners; 
+
+	/*Point above points (roughly) to the pixel above the one of interest, if there
+    is a feature there.*/
+	int point_above = 0;
+	int point_below = 0;
+
+	
+	if(num_corners < 1)
+	{
+		*ret_num_nonmax = 0;
+		return 0;
+	}
+
+	ret_nonmax = (CvPoint*)malloc(num_corners * sizeof(CvPoint));
+
+	/* Find where each row begins
+	   (the corners are output in raster scan order). A beginning of -1 signifies
+	   that there are no corners on that row. */
+	last_row = corners[num_corners-1].y;
+	row_start = (int*)malloc((last_row+1)*sizeof(int));
+
+	for(i=0; i < last_row+1; i++)
+		row_start[i] = -1;
+	
+	{
+		int prev_row = -1;
+		for(i=0; i< num_corners; i++)
+			if(corners[i].y != prev_row)
+			{
+				row_start[corners[i].y] = i;
+				prev_row = corners[i].y;
+			}
+	}
+	
+	
+	
+	for(i=0; i < sz; i++)
+	{
+		int score = scores[i];
+		CvPoint pos = corners[i];
+			
+		/*Check left */
+		if(i > 0)
+			if(corners[i-1].x == pos.x-1 && corners[i-1].y == pos.y && Compare(scores[i-1], score))
+				continue;
+			
+		/*Check right*/
+		if(i < (sz - 1))
+			if(corners[i+1].x == pos.x+1 && corners[i+1].y == pos.y && Compare(scores[i+1], score))
+				continue;
+			
+		/*Check above (if there is a valid row above)*/
+		if(pos.y != 0 && row_start[pos.y - 1] != -1) 
+		{
+			/*Make sure that current point_above is one
+			  row above.*/
+			if(corners[point_above].y < pos.y - 1)
+				point_above = row_start[pos.y-1];
+			
+			/*Make point_above point to the first of the pixels above the current point,
+			  if it exists.*/
+			for(; corners[point_above].y < pos.y && corners[point_above].x < pos.x - 1; point_above++)
+			{}
+			
+			
+			for(j=point_above; corners[j].y < pos.y && corners[j].x <= pos.x + 1; j++)
+			{
+				int x = corners[j].x;
+				if( (x == pos.x - 1 || x ==pos.x || x == pos.x+1) && Compare(scores[j], score))
+					goto cont;
+			}
+			
+		}
+			
+		/*Check below (if there is anything below)*/
+		if(pos.y != last_row && row_start[pos.y + 1] != -1 && point_below < sz) /*Nothing below*/
+		{
+			if(corners[point_below].y < pos.y + 1)
+				point_below = row_start[pos.y+1];
+			
+			/* Make point below point to one of the pixels belowthe current point, if it
+			   exists.*/
+			for(; point_below < sz && corners[point_below].y == pos.y+1 && corners[point_below].x < pos.x - 1; point_below++)
+			{}
+
+			for(j=point_below; j < sz && corners[j].y == pos.y+1 && corners[j].x <= pos.x + 1; j++)
+			{
+				int x = corners[j].x;
+				if( (x == pos.x - 1 || x ==pos.x || x == pos.x+1) && Compare(scores[j],score))
+					goto cont;
+			}
+		}
+		
+		ret_nonmax[num_nonmax++] = corners[i];
+		cont:
+			;
+	}
+
+	free(row_start);
+	*ret_num_nonmax = num_nonmax;
+	return ret_nonmax;
+}
+
+
+CVAPI(void)
+cvCornerFast(cv::Mat &src, int threshold, int N, int nonmax_suppression, int* ret_number_of_corners, CvPoint** ret_corners, int ** scores)
+{
+	CV_FUNCNAME( "cvCornerFast" );
+
+	int rows, cols, stride;
+	uchar* data;
+	
+	CvPoint *corners=0, *nonmax_corners=0;
+	int num_corners=0, num_nonmax=0;
+	*scores=0;
+
+	CvMat stub;
+
+    __CV_BEGIN__;
+
+	//if(!input_image)
+  //      CV_ERROR( CV_StsNullPtr, "" );
+
+	if(!ret_number_of_corners)
+        CV_ERROR( CV_StsNullPtr, "" );
+
+	if( N < 9 || N > 12)
+        CV_ERROR( CV_StsOutOfRange, "Corner arc length must be 9, 10, 11 or 12." );
+	
+	
+	/* Make sure the input is unsigned char */
+	/* In principle, FAST can work on any type, but trees are only included for unsigned char */
+//    src = (CvMat*)input_image;
+//    CV_CALL( src = cvGetMat( input_image, &stub, NULL, 0 ));
+
+//    if( CV_MAT_TYPE(src->type) != CV_8UC1 )
+//        CV_ERROR( CV_StsUnsupportedFormat, "Input must be 8uC1." );
+
+	rows = src.rows;
+	cols = src.cols;
+	stride = src.step;
+	data = src.data;
+	
+	/*Detect corners*/
+	corners = icvFast9Detect(data, cols, rows, stride, threshold, &num_corners);
+
+	/*Compute scores*/
+	*scores = icvFast9Score(data, stride, corners, num_corners, threshold);
+
+	*ret_number_of_corners = num_corners;
+	*ret_corners = corners;
+	
+	//Do nonmax suppression if need be
+	if(nonmax_suppression)
+	{
+		nonmax_corners = icvFastNonmaxSuppression(corners, *scores, num_corners, & num_nonmax);
+
+		*ret_corners = nonmax_corners;
+		*ret_number_of_corners = num_nonmax; 
+
+		free(corners);
+	}
+
+    __CV_END__;
+}
+
+int icvFast9CornerScore(const unsigned char* p, const int pixel[], int bstart)
+{    
+    int bmin = bstart;
+    int bmax = 255;
+    int b = (bmax + bmin)/2;
+    
+    /*Compute the score using binary search*/
+	for(;;)
+    {
+		int cb = *p + b;
+		int c_b= *p - b;
+
+
+        if( p[pixel[0]] > cb)
+         if( p[pixel[1]] > cb)
+          if( p[pixel[2]] > cb)
+           if( p[pixel[3]] > cb)
+            if( p[pixel[4]] > cb)
+             if( p[pixel[5]] > cb)
+              if( p[pixel[6]] > cb)
+               if( p[pixel[7]] > cb)
+                if( p[pixel[8]] > cb)
+                 goto is_a_corner;
+                else
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else if( p[pixel[7]] < c_b)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else if( p[pixel[14]] < c_b)
+                 if( p[pixel[8]] < c_b)
+                  if( p[pixel[9]] < c_b)
+                   if( p[pixel[10]] < c_b)
+                    if( p[pixel[11]] < c_b)
+                     if( p[pixel[12]] < c_b)
+                      if( p[pixel[13]] < c_b)
+                       if( p[pixel[15]] < c_b)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else if( p[pixel[6]] < c_b)
+               if( p[pixel[15]] > cb)
+                if( p[pixel[13]] > cb)
+                 if( p[pixel[14]] > cb)
+                  goto is_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else if( p[pixel[13]] < c_b)
+                 if( p[pixel[7]] < c_b)
+                  if( p[pixel[8]] < c_b)
+                   if( p[pixel[9]] < c_b)
+                    if( p[pixel[10]] < c_b)
+                     if( p[pixel[11]] < c_b)
+                      if( p[pixel[12]] < c_b)
+                       if( p[pixel[14]] < c_b)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                if( p[pixel[7]] < c_b)
+                 if( p[pixel[8]] < c_b)
+                  if( p[pixel[9]] < c_b)
+                   if( p[pixel[10]] < c_b)
+                    if( p[pixel[11]] < c_b)
+                     if( p[pixel[12]] < c_b)
+                      if( p[pixel[13]] < c_b)
+                       if( p[pixel[14]] < c_b)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[13]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else if( p[pixel[13]] < c_b)
+                if( p[pixel[7]] < c_b)
+                 if( p[pixel[8]] < c_b)
+                  if( p[pixel[9]] < c_b)
+                   if( p[pixel[10]] < c_b)
+                    if( p[pixel[11]] < c_b)
+                     if( p[pixel[12]] < c_b)
+                      if( p[pixel[14]] < c_b)
+                       if( p[pixel[15]] < c_b)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else if( p[pixel[5]] < c_b)
+              if( p[pixel[14]] > cb)
+               if( p[pixel[12]] > cb)
+                if( p[pixel[13]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      if( p[pixel[10]] > cb)
+                       if( p[pixel[11]] > cb)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else if( p[pixel[12]] < c_b)
+                if( p[pixel[6]] < c_b)
+                 if( p[pixel[7]] < c_b)
+                  if( p[pixel[8]] < c_b)
+                   if( p[pixel[9]] < c_b)
+                    if( p[pixel[10]] < c_b)
+                     if( p[pixel[11]] < c_b)
+                      if( p[pixel[13]] < c_b)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else if( p[pixel[14]] < c_b)
+               if( p[pixel[7]] < c_b)
+                if( p[pixel[8]] < c_b)
+                 if( p[pixel[9]] < c_b)
+                  if( p[pixel[10]] < c_b)
+                   if( p[pixel[11]] < c_b)
+                    if( p[pixel[12]] < c_b)
+                     if( p[pixel[13]] < c_b)
+                      if( p[pixel[6]] < c_b)
+                       goto is_a_corner;
+                      else
+                       if( p[pixel[15]] < c_b)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               if( p[pixel[6]] < c_b)
+                if( p[pixel[7]] < c_b)
+                 if( p[pixel[8]] < c_b)
+                  if( p[pixel[9]] < c_b)
+                   if( p[pixel[10]] < c_b)
+                    if( p[pixel[11]] < c_b)
+                     if( p[pixel[12]] < c_b)
+                      if( p[pixel[13]] < c_b)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              if( p[pixel[12]] > cb)
+               if( p[pixel[13]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      if( p[pixel[10]] > cb)
+                       if( p[pixel[11]] > cb)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else if( p[pixel[12]] < c_b)
+               if( p[pixel[7]] < c_b)
+                if( p[pixel[8]] < c_b)
+                 if( p[pixel[9]] < c_b)
+                  if( p[pixel[10]] < c_b)
+                   if( p[pixel[11]] < c_b)
+                    if( p[pixel[13]] < c_b)
+                     if( p[pixel[14]] < c_b)
+                      if( p[pixel[6]] < c_b)
+                       goto is_a_corner;
+                      else
+                       if( p[pixel[15]] < c_b)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else if( p[pixel[4]] < c_b)
+             if( p[pixel[13]] > cb)
+              if( p[pixel[11]] > cb)
+               if( p[pixel[12]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      if( p[pixel[10]] > cb)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      if( p[pixel[10]] > cb)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else if( p[pixel[11]] < c_b)
+               if( p[pixel[5]] < c_b)
+                if( p[pixel[6]] < c_b)
+                 if( p[pixel[7]] < c_b)
+                  if( p[pixel[8]] < c_b)
+                   if( p[pixel[9]] < c_b)
+                    if( p[pixel[10]] < c_b)
+                     if( p[pixel[12]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else if( p[pixel[13]] < c_b)
+              if( p[pixel[7]] < c_b)
+               if( p[pixel[8]] < c_b)
+                if( p[pixel[9]] < c_b)
+                 if( p[pixel[10]] < c_b)
+                  if( p[pixel[11]] < c_b)
+                   if( p[pixel[12]] < c_b)
+                    if( p[pixel[6]] < c_b)
+                     if( p[pixel[5]] < c_b)
+                      goto is_a_corner;
+                     else
+                      if( p[pixel[14]] < c_b)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                    else
+                     if( p[pixel[14]] < c_b)
+                      if( p[pixel[15]] < c_b)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              if( p[pixel[5]] < c_b)
+               if( p[pixel[6]] < c_b)
+                if( p[pixel[7]] < c_b)
+                 if( p[pixel[8]] < c_b)
+                  if( p[pixel[9]] < c_b)
+                   if( p[pixel[10]] < c_b)
+                    if( p[pixel[11]] < c_b)
+                     if( p[pixel[12]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else
+             if( p[pixel[11]] > cb)
+              if( p[pixel[12]] > cb)
+               if( p[pixel[13]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      if( p[pixel[10]] > cb)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      if( p[pixel[10]] > cb)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else if( p[pixel[11]] < c_b)
+              if( p[pixel[7]] < c_b)
+               if( p[pixel[8]] < c_b)
+                if( p[pixel[9]] < c_b)
+                 if( p[pixel[10]] < c_b)
+                  if( p[pixel[12]] < c_b)
+                   if( p[pixel[13]] < c_b)
+                    if( p[pixel[6]] < c_b)
+                     if( p[pixel[5]] < c_b)
+                      goto is_a_corner;
+                     else
+                      if( p[pixel[14]] < c_b)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                    else
+                     if( p[pixel[14]] < c_b)
+                      if( p[pixel[15]] < c_b)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+           else if( p[pixel[3]] < c_b)
+            if( p[pixel[10]] > cb)
+             if( p[pixel[11]] > cb)
+              if( p[pixel[12]] > cb)
+               if( p[pixel[13]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else if( p[pixel[10]] < c_b)
+             if( p[pixel[7]] < c_b)
+              if( p[pixel[8]] < c_b)
+               if( p[pixel[9]] < c_b)
+                if( p[pixel[11]] < c_b)
+                 if( p[pixel[6]] < c_b)
+                  if( p[pixel[5]] < c_b)
+                   if( p[pixel[4]] < c_b)
+                    goto is_a_corner;
+                   else
+                    if( p[pixel[12]] < c_b)
+                     if( p[pixel[13]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                  else
+                   if( p[pixel[12]] < c_b)
+                    if( p[pixel[13]] < c_b)
+                     if( p[pixel[14]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                 else
+                  if( p[pixel[12]] < c_b)
+                   if( p[pixel[13]] < c_b)
+                    if( p[pixel[14]] < c_b)
+                     if( p[pixel[15]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            if( p[pixel[10]] > cb)
+             if( p[pixel[11]] > cb)
+              if( p[pixel[12]] > cb)
+               if( p[pixel[13]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     if( p[pixel[9]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else if( p[pixel[10]] < c_b)
+             if( p[pixel[7]] < c_b)
+              if( p[pixel[8]] < c_b)
+               if( p[pixel[9]] < c_b)
+                if( p[pixel[11]] < c_b)
+                 if( p[pixel[12]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[5]] < c_b)
+                    if( p[pixel[4]] < c_b)
+                     goto is_a_corner;
+                    else
+                     if( p[pixel[13]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                   else
+                    if( p[pixel[13]] < c_b)
+                     if( p[pixel[14]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                  else
+                   if( p[pixel[13]] < c_b)
+                    if( p[pixel[14]] < c_b)
+                     if( p[pixel[15]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+          else if( p[pixel[2]] < c_b)
+           if( p[pixel[9]] > cb)
+            if( p[pixel[10]] > cb)
+             if( p[pixel[11]] > cb)
+              if( p[pixel[12]] > cb)
+               if( p[pixel[13]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[3]] > cb)
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else if( p[pixel[9]] < c_b)
+            if( p[pixel[7]] < c_b)
+             if( p[pixel[8]] < c_b)
+              if( p[pixel[10]] < c_b)
+               if( p[pixel[6]] < c_b)
+                if( p[pixel[5]] < c_b)
+                 if( p[pixel[4]] < c_b)
+                  if( p[pixel[3]] < c_b)
+                   goto is_a_corner;
+                  else
+                   if( p[pixel[11]] < c_b)
+                    if( p[pixel[12]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                 else
+                  if( p[pixel[11]] < c_b)
+                   if( p[pixel[12]] < c_b)
+                    if( p[pixel[13]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[11]] < c_b)
+                  if( p[pixel[12]] < c_b)
+                   if( p[pixel[13]] < c_b)
+                    if( p[pixel[14]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[11]] < c_b)
+                 if( p[pixel[12]] < c_b)
+                  if( p[pixel[13]] < c_b)
+                   if( p[pixel[14]] < c_b)
+                    if( p[pixel[15]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else
+           if( p[pixel[9]] > cb)
+            if( p[pixel[10]] > cb)
+             if( p[pixel[11]] > cb)
+              if( p[pixel[12]] > cb)
+               if( p[pixel[13]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[3]] > cb)
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    if( p[pixel[8]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else if( p[pixel[9]] < c_b)
+            if( p[pixel[7]] < c_b)
+             if( p[pixel[8]] < c_b)
+              if( p[pixel[10]] < c_b)
+               if( p[pixel[11]] < c_b)
+                if( p[pixel[6]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[4]] < c_b)
+                   if( p[pixel[3]] < c_b)
+                    goto is_a_corner;
+                   else
+                    if( p[pixel[12]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                  else
+                   if( p[pixel[12]] < c_b)
+                    if( p[pixel[13]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                 else
+                  if( p[pixel[12]] < c_b)
+                   if( p[pixel[13]] < c_b)
+                    if( p[pixel[14]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[12]] < c_b)
+                  if( p[pixel[13]] < c_b)
+                   if( p[pixel[14]] < c_b)
+                    if( p[pixel[15]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+         else if( p[pixel[1]] < c_b)
+          if( p[pixel[8]] > cb)
+           if( p[pixel[9]] > cb)
+            if( p[pixel[10]] > cb)
+             if( p[pixel[11]] > cb)
+              if( p[pixel[12]] > cb)
+               if( p[pixel[13]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[3]] > cb)
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              if( p[pixel[2]] > cb)
+               if( p[pixel[3]] > cb)
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else if( p[pixel[8]] < c_b)
+           if( p[pixel[7]] < c_b)
+            if( p[pixel[9]] < c_b)
+             if( p[pixel[6]] < c_b)
+              if( p[pixel[5]] < c_b)
+               if( p[pixel[4]] < c_b)
+                if( p[pixel[3]] < c_b)
+                 if( p[pixel[2]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[10]] < c_b)
+                   if( p[pixel[11]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[10]] < c_b)
+                  if( p[pixel[11]] < c_b)
+                   if( p[pixel[12]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[10]] < c_b)
+                 if( p[pixel[11]] < c_b)
+                  if( p[pixel[12]] < c_b)
+                   if( p[pixel[13]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[10]] < c_b)
+                if( p[pixel[11]] < c_b)
+                 if( p[pixel[12]] < c_b)
+                  if( p[pixel[13]] < c_b)
+                   if( p[pixel[14]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              if( p[pixel[10]] < c_b)
+               if( p[pixel[11]] < c_b)
+                if( p[pixel[12]] < c_b)
+                 if( p[pixel[13]] < c_b)
+                  if( p[pixel[14]] < c_b)
+                   if( p[pixel[15]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else
+           goto is_not_a_corner;
+         else
+          if( p[pixel[8]] > cb)
+           if( p[pixel[9]] > cb)
+            if( p[pixel[10]] > cb)
+             if( p[pixel[11]] > cb)
+              if( p[pixel[12]] > cb)
+               if( p[pixel[13]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[15]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[3]] > cb)
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              if( p[pixel[2]] > cb)
+               if( p[pixel[3]] > cb)
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[7]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else if( p[pixel[8]] < c_b)
+           if( p[pixel[7]] < c_b)
+            if( p[pixel[9]] < c_b)
+             if( p[pixel[10]] < c_b)
+              if( p[pixel[6]] < c_b)
+               if( p[pixel[5]] < c_b)
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[3]] < c_b)
+                  if( p[pixel[2]] < c_b)
+                   goto is_a_corner;
+                  else
+                   if( p[pixel[11]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                 else
+                  if( p[pixel[11]] < c_b)
+                   if( p[pixel[12]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[11]] < c_b)
+                  if( p[pixel[12]] < c_b)
+                   if( p[pixel[13]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[11]] < c_b)
+                 if( p[pixel[12]] < c_b)
+                  if( p[pixel[13]] < c_b)
+                   if( p[pixel[14]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[11]] < c_b)
+                if( p[pixel[12]] < c_b)
+                 if( p[pixel[13]] < c_b)
+                  if( p[pixel[14]] < c_b)
+                   if( p[pixel[15]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else
+           goto is_not_a_corner;
+        else if( p[pixel[0]] < c_b)
+         if( p[pixel[1]] > cb)
+          if( p[pixel[8]] > cb)
+           if( p[pixel[7]] > cb)
+            if( p[pixel[9]] > cb)
+             if( p[pixel[6]] > cb)
+              if( p[pixel[5]] > cb)
+               if( p[pixel[4]] > cb)
+                if( p[pixel[3]] > cb)
+                 if( p[pixel[2]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[10]] > cb)
+                   if( p[pixel[11]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[10]] > cb)
+                  if( p[pixel[11]] > cb)
+                   if( p[pixel[12]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[10]] > cb)
+                 if( p[pixel[11]] > cb)
+                  if( p[pixel[12]] > cb)
+                   if( p[pixel[13]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[10]] > cb)
+                if( p[pixel[11]] > cb)
+                 if( p[pixel[12]] > cb)
+                  if( p[pixel[13]] > cb)
+                   if( p[pixel[14]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              if( p[pixel[10]] > cb)
+               if( p[pixel[11]] > cb)
+                if( p[pixel[12]] > cb)
+                 if( p[pixel[13]] > cb)
+                  if( p[pixel[14]] > cb)
+                   if( p[pixel[15]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else if( p[pixel[8]] < c_b)
+           if( p[pixel[9]] < c_b)
+            if( p[pixel[10]] < c_b)
+             if( p[pixel[11]] < c_b)
+              if( p[pixel[12]] < c_b)
+               if( p[pixel[13]] < c_b)
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[3]] < c_b)
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              if( p[pixel[2]] < c_b)
+               if( p[pixel[3]] < c_b)
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else
+           goto is_not_a_corner;
+         else if( p[pixel[1]] < c_b)
+          if( p[pixel[2]] > cb)
+           if( p[pixel[9]] > cb)
+            if( p[pixel[7]] > cb)
+             if( p[pixel[8]] > cb)
+              if( p[pixel[10]] > cb)
+               if( p[pixel[6]] > cb)
+                if( p[pixel[5]] > cb)
+                 if( p[pixel[4]] > cb)
+                  if( p[pixel[3]] > cb)
+                   goto is_a_corner;
+                  else
+                   if( p[pixel[11]] > cb)
+                    if( p[pixel[12]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                 else
+                  if( p[pixel[11]] > cb)
+                   if( p[pixel[12]] > cb)
+                    if( p[pixel[13]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[11]] > cb)
+                  if( p[pixel[12]] > cb)
+                   if( p[pixel[13]] > cb)
+                    if( p[pixel[14]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[11]] > cb)
+                 if( p[pixel[12]] > cb)
+                  if( p[pixel[13]] > cb)
+                   if( p[pixel[14]] > cb)
+                    if( p[pixel[15]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else if( p[pixel[9]] < c_b)
+            if( p[pixel[10]] < c_b)
+             if( p[pixel[11]] < c_b)
+              if( p[pixel[12]] < c_b)
+               if( p[pixel[13]] < c_b)
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[3]] < c_b)
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else if( p[pixel[2]] < c_b)
+           if( p[pixel[3]] > cb)
+            if( p[pixel[10]] > cb)
+             if( p[pixel[7]] > cb)
+              if( p[pixel[8]] > cb)
+               if( p[pixel[9]] > cb)
+                if( p[pixel[11]] > cb)
+                 if( p[pixel[6]] > cb)
+                  if( p[pixel[5]] > cb)
+                   if( p[pixel[4]] > cb)
+                    goto is_a_corner;
+                   else
+                    if( p[pixel[12]] > cb)
+                     if( p[pixel[13]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                  else
+                   if( p[pixel[12]] > cb)
+                    if( p[pixel[13]] > cb)
+                     if( p[pixel[14]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                 else
+                  if( p[pixel[12]] > cb)
+                   if( p[pixel[13]] > cb)
+                    if( p[pixel[14]] > cb)
+                     if( p[pixel[15]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else if( p[pixel[10]] < c_b)
+             if( p[pixel[11]] < c_b)
+              if( p[pixel[12]] < c_b)
+               if( p[pixel[13]] < c_b)
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else if( p[pixel[3]] < c_b)
+            if( p[pixel[4]] > cb)
+             if( p[pixel[13]] > cb)
+              if( p[pixel[7]] > cb)
+               if( p[pixel[8]] > cb)
+                if( p[pixel[9]] > cb)
+                 if( p[pixel[10]] > cb)
+                  if( p[pixel[11]] > cb)
+                   if( p[pixel[12]] > cb)
+                    if( p[pixel[6]] > cb)
+                     if( p[pixel[5]] > cb)
+                      goto is_a_corner;
+                     else
+                      if( p[pixel[14]] > cb)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                    else
+                     if( p[pixel[14]] > cb)
+                      if( p[pixel[15]] > cb)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else if( p[pixel[13]] < c_b)
+              if( p[pixel[11]] > cb)
+               if( p[pixel[5]] > cb)
+                if( p[pixel[6]] > cb)
+                 if( p[pixel[7]] > cb)
+                  if( p[pixel[8]] > cb)
+                   if( p[pixel[9]] > cb)
+                    if( p[pixel[10]] > cb)
+                     if( p[pixel[12]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else if( p[pixel[11]] < c_b)
+               if( p[pixel[12]] < c_b)
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      if( p[pixel[10]] < c_b)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      if( p[pixel[10]] < c_b)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              if( p[pixel[5]] > cb)
+               if( p[pixel[6]] > cb)
+                if( p[pixel[7]] > cb)
+                 if( p[pixel[8]] > cb)
+                  if( p[pixel[9]] > cb)
+                   if( p[pixel[10]] > cb)
+                    if( p[pixel[11]] > cb)
+                     if( p[pixel[12]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else if( p[pixel[4]] < c_b)
+             if( p[pixel[5]] > cb)
+              if( p[pixel[14]] > cb)
+               if( p[pixel[7]] > cb)
+                if( p[pixel[8]] > cb)
+                 if( p[pixel[9]] > cb)
+                  if( p[pixel[10]] > cb)
+                   if( p[pixel[11]] > cb)
+                    if( p[pixel[12]] > cb)
+                     if( p[pixel[13]] > cb)
+                      if( p[pixel[6]] > cb)
+                       goto is_a_corner;
+                      else
+                       if( p[pixel[15]] > cb)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else if( p[pixel[14]] < c_b)
+               if( p[pixel[12]] > cb)
+                if( p[pixel[6]] > cb)
+                 if( p[pixel[7]] > cb)
+                  if( p[pixel[8]] > cb)
+                   if( p[pixel[9]] > cb)
+                    if( p[pixel[10]] > cb)
+                     if( p[pixel[11]] > cb)
+                      if( p[pixel[13]] > cb)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else if( p[pixel[12]] < c_b)
+                if( p[pixel[13]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      if( p[pixel[10]] < c_b)
+                       if( p[pixel[11]] < c_b)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               if( p[pixel[6]] > cb)
+                if( p[pixel[7]] > cb)
+                 if( p[pixel[8]] > cb)
+                  if( p[pixel[9]] > cb)
+                   if( p[pixel[10]] > cb)
+                    if( p[pixel[11]] > cb)
+                     if( p[pixel[12]] > cb)
+                      if( p[pixel[13]] > cb)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else if( p[pixel[5]] < c_b)
+              if( p[pixel[6]] > cb)
+               if( p[pixel[15]] < c_b)
+                if( p[pixel[13]] > cb)
+                 if( p[pixel[7]] > cb)
+                  if( p[pixel[8]] > cb)
+                   if( p[pixel[9]] > cb)
+                    if( p[pixel[10]] > cb)
+                     if( p[pixel[11]] > cb)
+                      if( p[pixel[12]] > cb)
+                       if( p[pixel[14]] > cb)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else if( p[pixel[13]] < c_b)
+                 if( p[pixel[14]] < c_b)
+                  goto is_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                if( p[pixel[7]] > cb)
+                 if( p[pixel[8]] > cb)
+                  if( p[pixel[9]] > cb)
+                   if( p[pixel[10]] > cb)
+                    if( p[pixel[11]] > cb)
+                     if( p[pixel[12]] > cb)
+                      if( p[pixel[13]] > cb)
+                       if( p[pixel[14]] > cb)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else if( p[pixel[6]] < c_b)
+               if( p[pixel[7]] > cb)
+                if( p[pixel[14]] > cb)
+                 if( p[pixel[8]] > cb)
+                  if( p[pixel[9]] > cb)
+                   if( p[pixel[10]] > cb)
+                    if( p[pixel[11]] > cb)
+                     if( p[pixel[12]] > cb)
+                      if( p[pixel[13]] > cb)
+                       if( p[pixel[15]] > cb)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else if( p[pixel[7]] < c_b)
+                if( p[pixel[8]] < c_b)
+                 goto is_a_corner;
+                else
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[13]] > cb)
+                if( p[pixel[7]] > cb)
+                 if( p[pixel[8]] > cb)
+                  if( p[pixel[9]] > cb)
+                   if( p[pixel[10]] > cb)
+                    if( p[pixel[11]] > cb)
+                     if( p[pixel[12]] > cb)
+                      if( p[pixel[14]] > cb)
+                       if( p[pixel[15]] > cb)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else if( p[pixel[13]] < c_b)
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              if( p[pixel[12]] > cb)
+               if( p[pixel[7]] > cb)
+                if( p[pixel[8]] > cb)
+                 if( p[pixel[9]] > cb)
+                  if( p[pixel[10]] > cb)
+                   if( p[pixel[11]] > cb)
+                    if( p[pixel[13]] > cb)
+                     if( p[pixel[14]] > cb)
+                      if( p[pixel[6]] > cb)
+                       goto is_a_corner;
+                      else
+                       if( p[pixel[15]] > cb)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else if( p[pixel[12]] < c_b)
+               if( p[pixel[13]] < c_b)
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      if( p[pixel[10]] < c_b)
+                       if( p[pixel[11]] < c_b)
+                        goto is_a_corner;
+                       else
+                        goto is_not_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else
+             if( p[pixel[11]] > cb)
+              if( p[pixel[7]] > cb)
+               if( p[pixel[8]] > cb)
+                if( p[pixel[9]] > cb)
+                 if( p[pixel[10]] > cb)
+                  if( p[pixel[12]] > cb)
+                   if( p[pixel[13]] > cb)
+                    if( p[pixel[6]] > cb)
+                     if( p[pixel[5]] > cb)
+                      goto is_a_corner;
+                     else
+                      if( p[pixel[14]] > cb)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                    else
+                     if( p[pixel[14]] > cb)
+                      if( p[pixel[15]] > cb)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else if( p[pixel[11]] < c_b)
+              if( p[pixel[12]] < c_b)
+               if( p[pixel[13]] < c_b)
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      if( p[pixel[10]] < c_b)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      if( p[pixel[10]] < c_b)
+                       goto is_a_corner;
+                      else
+                       goto is_not_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+           else
+            if( p[pixel[10]] > cb)
+             if( p[pixel[7]] > cb)
+              if( p[pixel[8]] > cb)
+               if( p[pixel[9]] > cb)
+                if( p[pixel[11]] > cb)
+                 if( p[pixel[12]] > cb)
+                  if( p[pixel[6]] > cb)
+                   if( p[pixel[5]] > cb)
+                    if( p[pixel[4]] > cb)
+                     goto is_a_corner;
+                    else
+                     if( p[pixel[13]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                   else
+                    if( p[pixel[13]] > cb)
+                     if( p[pixel[14]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                  else
+                   if( p[pixel[13]] > cb)
+                    if( p[pixel[14]] > cb)
+                     if( p[pixel[15]] > cb)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else if( p[pixel[10]] < c_b)
+             if( p[pixel[11]] < c_b)
+              if( p[pixel[12]] < c_b)
+               if( p[pixel[13]] < c_b)
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     if( p[pixel[9]] < c_b)
+                      goto is_a_corner;
+                     else
+                      goto is_not_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+          else
+           if( p[pixel[9]] > cb)
+            if( p[pixel[7]] > cb)
+             if( p[pixel[8]] > cb)
+              if( p[pixel[10]] > cb)
+               if( p[pixel[11]] > cb)
+                if( p[pixel[6]] > cb)
+                 if( p[pixel[5]] > cb)
+                  if( p[pixel[4]] > cb)
+                   if( p[pixel[3]] > cb)
+                    goto is_a_corner;
+                   else
+                    if( p[pixel[12]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                  else
+                   if( p[pixel[12]] > cb)
+                    if( p[pixel[13]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                 else
+                  if( p[pixel[12]] > cb)
+                   if( p[pixel[13]] > cb)
+                    if( p[pixel[14]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[12]] > cb)
+                  if( p[pixel[13]] > cb)
+                   if( p[pixel[14]] > cb)
+                    if( p[pixel[15]] > cb)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else if( p[pixel[9]] < c_b)
+            if( p[pixel[10]] < c_b)
+             if( p[pixel[11]] < c_b)
+              if( p[pixel[12]] < c_b)
+               if( p[pixel[13]] < c_b)
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[3]] < c_b)
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    if( p[pixel[8]] < c_b)
+                     goto is_a_corner;
+                    else
+                     goto is_not_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+         else
+          if( p[pixel[8]] > cb)
+           if( p[pixel[7]] > cb)
+            if( p[pixel[9]] > cb)
+             if( p[pixel[10]] > cb)
+              if( p[pixel[6]] > cb)
+               if( p[pixel[5]] > cb)
+                if( p[pixel[4]] > cb)
+                 if( p[pixel[3]] > cb)
+                  if( p[pixel[2]] > cb)
+                   goto is_a_corner;
+                  else
+                   if( p[pixel[11]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                 else
+                  if( p[pixel[11]] > cb)
+                   if( p[pixel[12]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[11]] > cb)
+                  if( p[pixel[12]] > cb)
+                   if( p[pixel[13]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[11]] > cb)
+                 if( p[pixel[12]] > cb)
+                  if( p[pixel[13]] > cb)
+                   if( p[pixel[14]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[11]] > cb)
+                if( p[pixel[12]] > cb)
+                 if( p[pixel[13]] > cb)
+                  if( p[pixel[14]] > cb)
+                   if( p[pixel[15]] > cb)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else if( p[pixel[8]] < c_b)
+           if( p[pixel[9]] < c_b)
+            if( p[pixel[10]] < c_b)
+             if( p[pixel[11]] < c_b)
+              if( p[pixel[12]] < c_b)
+               if( p[pixel[13]] < c_b)
+                if( p[pixel[14]] < c_b)
+                 if( p[pixel[15]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[3]] < c_b)
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              if( p[pixel[2]] < c_b)
+               if( p[pixel[3]] < c_b)
+                if( p[pixel[4]] < c_b)
+                 if( p[pixel[5]] < c_b)
+                  if( p[pixel[6]] < c_b)
+                   if( p[pixel[7]] < c_b)
+                    goto is_a_corner;
+                   else
+                    goto is_not_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else
+             goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else
+           goto is_not_a_corner;
+        else
+         if( p[pixel[7]] > cb)
+          if( p[pixel[8]] > cb)
+           if( p[pixel[9]] > cb)
+            if( p[pixel[6]] > cb)
+             if( p[pixel[5]] > cb)
+              if( p[pixel[4]] > cb)
+               if( p[pixel[3]] > cb)
+                if( p[pixel[2]] > cb)
+                 if( p[pixel[1]] > cb)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[10]] > cb)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[10]] > cb)
+                  if( p[pixel[11]] > cb)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[10]] > cb)
+                 if( p[pixel[11]] > cb)
+                  if( p[pixel[12]] > cb)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[10]] > cb)
+                if( p[pixel[11]] > cb)
+                 if( p[pixel[12]] > cb)
+                  if( p[pixel[13]] > cb)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              if( p[pixel[10]] > cb)
+               if( p[pixel[11]] > cb)
+                if( p[pixel[12]] > cb)
+                 if( p[pixel[13]] > cb)
+                  if( p[pixel[14]] > cb)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else
+             if( p[pixel[10]] > cb)
+              if( p[pixel[11]] > cb)
+               if( p[pixel[12]] > cb)
+                if( p[pixel[13]] > cb)
+                 if( p[pixel[14]] > cb)
+                  if( p[pixel[15]] > cb)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else
+           goto is_not_a_corner;
+         else if( p[pixel[7]] < c_b)
+          if( p[pixel[8]] < c_b)
+           if( p[pixel[9]] < c_b)
+            if( p[pixel[6]] < c_b)
+             if( p[pixel[5]] < c_b)
+              if( p[pixel[4]] < c_b)
+               if( p[pixel[3]] < c_b)
+                if( p[pixel[2]] < c_b)
+                 if( p[pixel[1]] < c_b)
+                  goto is_a_corner;
+                 else
+                  if( p[pixel[10]] < c_b)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                else
+                 if( p[pixel[10]] < c_b)
+                  if( p[pixel[11]] < c_b)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+               else
+                if( p[pixel[10]] < c_b)
+                 if( p[pixel[11]] < c_b)
+                  if( p[pixel[12]] < c_b)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+              else
+               if( p[pixel[10]] < c_b)
+                if( p[pixel[11]] < c_b)
+                 if( p[pixel[12]] < c_b)
+                  if( p[pixel[13]] < c_b)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+             else
+              if( p[pixel[10]] < c_b)
+               if( p[pixel[11]] < c_b)
+                if( p[pixel[12]] < c_b)
+                 if( p[pixel[13]] < c_b)
+                  if( p[pixel[14]] < c_b)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+            else
+             if( p[pixel[10]] < c_b)
+              if( p[pixel[11]] < c_b)
+               if( p[pixel[12]] < c_b)
+                if( p[pixel[13]] < c_b)
+                 if( p[pixel[14]] < c_b)
+                  if( p[pixel[15]] < c_b)
+                   goto is_a_corner;
+                  else
+                   goto is_not_a_corner;
+                 else
+                  goto is_not_a_corner;
+                else
+                 goto is_not_a_corner;
+               else
+                goto is_not_a_corner;
+              else
+               goto is_not_a_corner;
+             else
+              goto is_not_a_corner;
+           else
+            goto is_not_a_corner;
+          else
+           goto is_not_a_corner;
+         else
+          goto is_not_a_corner;
+
+		is_a_corner:
+			bmin=b;
+			goto end_if;
+
+		is_not_a_corner:
+			bmax=b;
+			goto end_if;
+
+		end_if:
+
+		if(bmin == bmax - 1 || bmin == bmax)
+			return bmin;
+		b = (bmin + bmax) / 2;
+    }
+}
+
+static void icvMakeOffsets(int pixel[], int row_stride)
+{
+        pixel[0] = 0 + row_stride * 3;
+        pixel[1] = 1 + row_stride * 3;
+        pixel[2] = 2 + row_stride * 2;
+        pixel[3] = 3 + row_stride * 1;
+        pixel[4] = 3 + row_stride * 0;
+        pixel[5] = 3 + row_stride * -1;
+        pixel[6] = 2 + row_stride * -2;
+        pixel[7] = 1 + row_stride * -3;
+        pixel[8] = 0 + row_stride * -3;
+        pixel[9] = -1 + row_stride * -3;
+        pixel[10] = -2 + row_stride * -2;
+        pixel[11] = -3 + row_stride * -1;
+        pixel[12] = -3 + row_stride * 0;
+        pixel[13] = -3 + row_stride * 1;
+        pixel[14] = -2 + row_stride * 2;
+        pixel[15] = -1 + row_stride * 3;
+}
+
+
+
+int* icvFast9Score(const unsigned char* i, int stride, CvPoint* corners, int num_corners, int b)
+{	
+	int* scores = (int*)malloc(sizeof(int)* num_corners);
+	int n;
+
+	int pixel[16];
+	icvMakeOffsets(pixel, stride);
+
+    for(n=0; n < num_corners; n++)
+        scores[n] = icvFast9CornerScore(i + corners[n].y*stride + corners[n].x, pixel, b);
+
+	return scores;
+}
+
+
+CvPoint* icvFast9Detect(const unsigned char* im, int xsize, int ysize, int stride, int b, int* ret_num_corners)
+{
+	int num_corners=0;
+	CvPoint* ret_corners;
+	int rsize=512;
+	int pixel[16];
+	int x, y;
+
+	ret_corners = (CvPoint*)malloc(sizeof(CvPoint)*rsize);
+	icvMakeOffsets(pixel, stride);
+
+	for(y=3; y < ysize - 3; y++)
+		for(x=3; x < xsize - 3; x++)
+		{
+			const unsigned char* p = im + y*stride + x;
+		
+			int cb = *p + b;
+			int c_b= *p - b;
+        if(p[pixel[0]] > cb)
+         if(p[pixel[1]] > cb)
+          if(p[pixel[2]] > cb)
+           if(p[pixel[3]] > cb)
+            if(p[pixel[4]] > cb)
+             if(p[pixel[5]] > cb)
+              if(p[pixel[6]] > cb)
+               if(p[pixel[7]] > cb)
+                if(p[pixel[8]] > cb)
+                 {}
+                else
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  continue;
+               else if(p[pixel[7]] < c_b)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  continue;
+                else if(p[pixel[14]] < c_b)
+                 if(p[pixel[8]] < c_b)
+                  if(p[pixel[9]] < c_b)
+                   if(p[pixel[10]] < c_b)
+                    if(p[pixel[11]] < c_b)
+                     if(p[pixel[12]] < c_b)
+                      if(p[pixel[13]] < c_b)
+                       if(p[pixel[15]] < c_b)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  continue;
+                else
+                 continue;
+              else if(p[pixel[6]] < c_b)
+               if(p[pixel[15]] > cb)
+                if(p[pixel[13]] > cb)
+                 if(p[pixel[14]] > cb)
+                  {}
+                 else
+                  continue;
+                else if(p[pixel[13]] < c_b)
+                 if(p[pixel[7]] < c_b)
+                  if(p[pixel[8]] < c_b)
+                   if(p[pixel[9]] < c_b)
+                    if(p[pixel[10]] < c_b)
+                     if(p[pixel[11]] < c_b)
+                      if(p[pixel[12]] < c_b)
+                       if(p[pixel[14]] < c_b)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                if(p[pixel[7]] < c_b)
+                 if(p[pixel[8]] < c_b)
+                  if(p[pixel[9]] < c_b)
+                   if(p[pixel[10]] < c_b)
+                    if(p[pixel[11]] < c_b)
+                     if(p[pixel[12]] < c_b)
+                      if(p[pixel[13]] < c_b)
+                       if(p[pixel[14]] < c_b)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[13]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  continue;
+                else
+                 continue;
+               else if(p[pixel[13]] < c_b)
+                if(p[pixel[7]] < c_b)
+                 if(p[pixel[8]] < c_b)
+                  if(p[pixel[9]] < c_b)
+                   if(p[pixel[10]] < c_b)
+                    if(p[pixel[11]] < c_b)
+                     if(p[pixel[12]] < c_b)
+                      if(p[pixel[14]] < c_b)
+                       if(p[pixel[15]] < c_b)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else if(p[pixel[5]] < c_b)
+              if(p[pixel[14]] > cb)
+               if(p[pixel[12]] > cb)
+                if(p[pixel[13]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      if(p[pixel[10]] > cb)
+                       if(p[pixel[11]] > cb)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 continue;
+               else if(p[pixel[12]] < c_b)
+                if(p[pixel[6]] < c_b)
+                 if(p[pixel[7]] < c_b)
+                  if(p[pixel[8]] < c_b)
+                   if(p[pixel[9]] < c_b)
+                    if(p[pixel[10]] < c_b)
+                     if(p[pixel[11]] < c_b)
+                      if(p[pixel[13]] < c_b)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else if(p[pixel[14]] < c_b)
+               if(p[pixel[7]] < c_b)
+                if(p[pixel[8]] < c_b)
+                 if(p[pixel[9]] < c_b)
+                  if(p[pixel[10]] < c_b)
+                   if(p[pixel[11]] < c_b)
+                    if(p[pixel[12]] < c_b)
+                     if(p[pixel[13]] < c_b)
+                      if(p[pixel[6]] < c_b)
+                       {}
+                      else
+                       if(p[pixel[15]] < c_b)
+                        {}
+                       else
+                        continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               if(p[pixel[6]] < c_b)
+                if(p[pixel[7]] < c_b)
+                 if(p[pixel[8]] < c_b)
+                  if(p[pixel[9]] < c_b)
+                   if(p[pixel[10]] < c_b)
+                    if(p[pixel[11]] < c_b)
+                     if(p[pixel[12]] < c_b)
+                      if(p[pixel[13]] < c_b)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              if(p[pixel[12]] > cb)
+               if(p[pixel[13]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      if(p[pixel[10]] > cb)
+                       if(p[pixel[11]] > cb)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 continue;
+               else
+                continue;
+              else if(p[pixel[12]] < c_b)
+               if(p[pixel[7]] < c_b)
+                if(p[pixel[8]] < c_b)
+                 if(p[pixel[9]] < c_b)
+                  if(p[pixel[10]] < c_b)
+                   if(p[pixel[11]] < c_b)
+                    if(p[pixel[13]] < c_b)
+                     if(p[pixel[14]] < c_b)
+                      if(p[pixel[6]] < c_b)
+                       {}
+                      else
+                       if(p[pixel[15]] < c_b)
+                        {}
+                       else
+                        continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else if(p[pixel[4]] < c_b)
+             if(p[pixel[13]] > cb)
+              if(p[pixel[11]] > cb)
+               if(p[pixel[12]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      if(p[pixel[10]] > cb)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      if(p[pixel[10]] > cb)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                continue;
+              else if(p[pixel[11]] < c_b)
+               if(p[pixel[5]] < c_b)
+                if(p[pixel[6]] < c_b)
+                 if(p[pixel[7]] < c_b)
+                  if(p[pixel[8]] < c_b)
+                   if(p[pixel[9]] < c_b)
+                    if(p[pixel[10]] < c_b)
+                     if(p[pixel[12]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else if(p[pixel[13]] < c_b)
+              if(p[pixel[7]] < c_b)
+               if(p[pixel[8]] < c_b)
+                if(p[pixel[9]] < c_b)
+                 if(p[pixel[10]] < c_b)
+                  if(p[pixel[11]] < c_b)
+                   if(p[pixel[12]] < c_b)
+                    if(p[pixel[6]] < c_b)
+                     if(p[pixel[5]] < c_b)
+                      {}
+                     else
+                      if(p[pixel[14]] < c_b)
+                       {}
+                      else
+                       continue;
+                    else
+                     if(p[pixel[14]] < c_b)
+                      if(p[pixel[15]] < c_b)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              if(p[pixel[5]] < c_b)
+               if(p[pixel[6]] < c_b)
+                if(p[pixel[7]] < c_b)
+                 if(p[pixel[8]] < c_b)
+                  if(p[pixel[9]] < c_b)
+                   if(p[pixel[10]] < c_b)
+                    if(p[pixel[11]] < c_b)
+                     if(p[pixel[12]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else
+             if(p[pixel[11]] > cb)
+              if(p[pixel[12]] > cb)
+               if(p[pixel[13]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      if(p[pixel[10]] > cb)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      if(p[pixel[10]] > cb)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                continue;
+              else
+               continue;
+             else if(p[pixel[11]] < c_b)
+              if(p[pixel[7]] < c_b)
+               if(p[pixel[8]] < c_b)
+                if(p[pixel[9]] < c_b)
+                 if(p[pixel[10]] < c_b)
+                  if(p[pixel[12]] < c_b)
+                   if(p[pixel[13]] < c_b)
+                    if(p[pixel[6]] < c_b)
+                     if(p[pixel[5]] < c_b)
+                      {}
+                     else
+                      if(p[pixel[14]] < c_b)
+                       {}
+                      else
+                       continue;
+                    else
+                     if(p[pixel[14]] < c_b)
+                      if(p[pixel[15]] < c_b)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              continue;
+           else if(p[pixel[3]] < c_b)
+            if(p[pixel[10]] > cb)
+             if(p[pixel[11]] > cb)
+              if(p[pixel[12]] > cb)
+               if(p[pixel[13]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               continue;
+             else
+              continue;
+            else if(p[pixel[10]] < c_b)
+             if(p[pixel[7]] < c_b)
+              if(p[pixel[8]] < c_b)
+               if(p[pixel[9]] < c_b)
+                if(p[pixel[11]] < c_b)
+                 if(p[pixel[6]] < c_b)
+                  if(p[pixel[5]] < c_b)
+                   if(p[pixel[4]] < c_b)
+                    {}
+                   else
+                    if(p[pixel[12]] < c_b)
+                     if(p[pixel[13]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                  else
+                   if(p[pixel[12]] < c_b)
+                    if(p[pixel[13]] < c_b)
+                     if(p[pixel[14]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                 else
+                  if(p[pixel[12]] < c_b)
+                   if(p[pixel[13]] < c_b)
+                    if(p[pixel[14]] < c_b)
+                     if(p[pixel[15]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              continue;
+            else
+             continue;
+           else
+            if(p[pixel[10]] > cb)
+             if(p[pixel[11]] > cb)
+              if(p[pixel[12]] > cb)
+               if(p[pixel[13]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     if(p[pixel[9]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               continue;
+             else
+              continue;
+            else if(p[pixel[10]] < c_b)
+             if(p[pixel[7]] < c_b)
+              if(p[pixel[8]] < c_b)
+               if(p[pixel[9]] < c_b)
+                if(p[pixel[11]] < c_b)
+                 if(p[pixel[12]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[5]] < c_b)
+                    if(p[pixel[4]] < c_b)
+                     {}
+                    else
+                     if(p[pixel[13]] < c_b)
+                      {}
+                     else
+                      continue;
+                   else
+                    if(p[pixel[13]] < c_b)
+                     if(p[pixel[14]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                  else
+                   if(p[pixel[13]] < c_b)
+                    if(p[pixel[14]] < c_b)
+                     if(p[pixel[15]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              continue;
+            else
+             continue;
+          else if(p[pixel[2]] < c_b)
+           if(p[pixel[9]] > cb)
+            if(p[pixel[10]] > cb)
+             if(p[pixel[11]] > cb)
+              if(p[pixel[12]] > cb)
+               if(p[pixel[13]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[3]] > cb)
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              continue;
+            else
+             continue;
+           else if(p[pixel[9]] < c_b)
+            if(p[pixel[7]] < c_b)
+             if(p[pixel[8]] < c_b)
+              if(p[pixel[10]] < c_b)
+               if(p[pixel[6]] < c_b)
+                if(p[pixel[5]] < c_b)
+                 if(p[pixel[4]] < c_b)
+                  if(p[pixel[3]] < c_b)
+                   {}
+                  else
+                   if(p[pixel[11]] < c_b)
+                    if(p[pixel[12]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                 else
+                  if(p[pixel[11]] < c_b)
+                   if(p[pixel[12]] < c_b)
+                    if(p[pixel[13]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[11]] < c_b)
+                  if(p[pixel[12]] < c_b)
+                   if(p[pixel[13]] < c_b)
+                    if(p[pixel[14]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[11]] < c_b)
+                 if(p[pixel[12]] < c_b)
+                  if(p[pixel[13]] < c_b)
+                   if(p[pixel[14]] < c_b)
+                    if(p[pixel[15]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               continue;
+             else
+              continue;
+            else
+             continue;
+           else
+            continue;
+          else
+           if(p[pixel[9]] > cb)
+            if(p[pixel[10]] > cb)
+             if(p[pixel[11]] > cb)
+              if(p[pixel[12]] > cb)
+               if(p[pixel[13]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[3]] > cb)
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    if(p[pixel[8]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              continue;
+            else
+             continue;
+           else if(p[pixel[9]] < c_b)
+            if(p[pixel[7]] < c_b)
+             if(p[pixel[8]] < c_b)
+              if(p[pixel[10]] < c_b)
+               if(p[pixel[11]] < c_b)
+                if(p[pixel[6]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[4]] < c_b)
+                   if(p[pixel[3]] < c_b)
+                    {}
+                   else
+                    if(p[pixel[12]] < c_b)
+                     {}
+                    else
+                     continue;
+                  else
+                   if(p[pixel[12]] < c_b)
+                    if(p[pixel[13]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                 else
+                  if(p[pixel[12]] < c_b)
+                   if(p[pixel[13]] < c_b)
+                    if(p[pixel[14]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[12]] < c_b)
+                  if(p[pixel[13]] < c_b)
+                   if(p[pixel[14]] < c_b)
+                    if(p[pixel[15]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              continue;
+            else
+             continue;
+           else
+            continue;
+         else if(p[pixel[1]] < c_b)
+          if(p[pixel[8]] > cb)
+           if(p[pixel[9]] > cb)
+            if(p[pixel[10]] > cb)
+             if(p[pixel[11]] > cb)
+              if(p[pixel[12]] > cb)
+               if(p[pixel[13]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[3]] > cb)
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              if(p[pixel[2]] > cb)
+               if(p[pixel[3]] > cb)
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else
+             continue;
+           else
+            continue;
+          else if(p[pixel[8]] < c_b)
+           if(p[pixel[7]] < c_b)
+            if(p[pixel[9]] < c_b)
+             if(p[pixel[6]] < c_b)
+              if(p[pixel[5]] < c_b)
+               if(p[pixel[4]] < c_b)
+                if(p[pixel[3]] < c_b)
+                 if(p[pixel[2]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[10]] < c_b)
+                   if(p[pixel[11]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[10]] < c_b)
+                  if(p[pixel[11]] < c_b)
+                   if(p[pixel[12]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[10]] < c_b)
+                 if(p[pixel[11]] < c_b)
+                  if(p[pixel[12]] < c_b)
+                   if(p[pixel[13]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[10]] < c_b)
+                if(p[pixel[11]] < c_b)
+                 if(p[pixel[12]] < c_b)
+                  if(p[pixel[13]] < c_b)
+                   if(p[pixel[14]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              if(p[pixel[10]] < c_b)
+               if(p[pixel[11]] < c_b)
+                if(p[pixel[12]] < c_b)
+                 if(p[pixel[13]] < c_b)
+                  if(p[pixel[14]] < c_b)
+                   if(p[pixel[15]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else
+             continue;
+           else
+            continue;
+          else
+           continue;
+         else
+          if(p[pixel[8]] > cb)
+           if(p[pixel[9]] > cb)
+            if(p[pixel[10]] > cb)
+             if(p[pixel[11]] > cb)
+              if(p[pixel[12]] > cb)
+               if(p[pixel[13]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[15]] > cb)
+                  {}
+                 else
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[3]] > cb)
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              if(p[pixel[2]] > cb)
+               if(p[pixel[3]] > cb)
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[7]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else
+             continue;
+           else
+            continue;
+          else if(p[pixel[8]] < c_b)
+           if(p[pixel[7]] < c_b)
+            if(p[pixel[9]] < c_b)
+             if(p[pixel[10]] < c_b)
+              if(p[pixel[6]] < c_b)
+               if(p[pixel[5]] < c_b)
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[3]] < c_b)
+                  if(p[pixel[2]] < c_b)
+                   {}
+                  else
+                   if(p[pixel[11]] < c_b)
+                    {}
+                   else
+                    continue;
+                 else
+                  if(p[pixel[11]] < c_b)
+                   if(p[pixel[12]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[11]] < c_b)
+                  if(p[pixel[12]] < c_b)
+                   if(p[pixel[13]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[11]] < c_b)
+                 if(p[pixel[12]] < c_b)
+                  if(p[pixel[13]] < c_b)
+                   if(p[pixel[14]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[11]] < c_b)
+                if(p[pixel[12]] < c_b)
+                 if(p[pixel[13]] < c_b)
+                  if(p[pixel[14]] < c_b)
+                   if(p[pixel[15]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              continue;
+            else
+             continue;
+           else
+            continue;
+          else
+           continue;
+        else if(p[pixel[0]] < c_b)
+         if(p[pixel[1]] > cb)
+          if(p[pixel[8]] > cb)
+           if(p[pixel[7]] > cb)
+            if(p[pixel[9]] > cb)
+             if(p[pixel[6]] > cb)
+              if(p[pixel[5]] > cb)
+               if(p[pixel[4]] > cb)
+                if(p[pixel[3]] > cb)
+                 if(p[pixel[2]] > cb)
+                  {}
+                 else
+                  if(p[pixel[10]] > cb)
+                   if(p[pixel[11]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[10]] > cb)
+                  if(p[pixel[11]] > cb)
+                   if(p[pixel[12]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[10]] > cb)
+                 if(p[pixel[11]] > cb)
+                  if(p[pixel[12]] > cb)
+                   if(p[pixel[13]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[10]] > cb)
+                if(p[pixel[11]] > cb)
+                 if(p[pixel[12]] > cb)
+                  if(p[pixel[13]] > cb)
+                   if(p[pixel[14]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              if(p[pixel[10]] > cb)
+               if(p[pixel[11]] > cb)
+                if(p[pixel[12]] > cb)
+                 if(p[pixel[13]] > cb)
+                  if(p[pixel[14]] > cb)
+                   if(p[pixel[15]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else
+             continue;
+           else
+            continue;
+          else if(p[pixel[8]] < c_b)
+           if(p[pixel[9]] < c_b)
+            if(p[pixel[10]] < c_b)
+             if(p[pixel[11]] < c_b)
+              if(p[pixel[12]] < c_b)
+               if(p[pixel[13]] < c_b)
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[3]] < c_b)
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              if(p[pixel[2]] < c_b)
+               if(p[pixel[3]] < c_b)
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else
+             continue;
+           else
+            continue;
+          else
+           continue;
+         else if(p[pixel[1]] < c_b)
+          if(p[pixel[2]] > cb)
+           if(p[pixel[9]] > cb)
+            if(p[pixel[7]] > cb)
+             if(p[pixel[8]] > cb)
+              if(p[pixel[10]] > cb)
+               if(p[pixel[6]] > cb)
+                if(p[pixel[5]] > cb)
+                 if(p[pixel[4]] > cb)
+                  if(p[pixel[3]] > cb)
+                   {}
+                  else
+                   if(p[pixel[11]] > cb)
+                    if(p[pixel[12]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                 else
+                  if(p[pixel[11]] > cb)
+                   if(p[pixel[12]] > cb)
+                    if(p[pixel[13]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[11]] > cb)
+                  if(p[pixel[12]] > cb)
+                   if(p[pixel[13]] > cb)
+                    if(p[pixel[14]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[11]] > cb)
+                 if(p[pixel[12]] > cb)
+                  if(p[pixel[13]] > cb)
+                   if(p[pixel[14]] > cb)
+                    if(p[pixel[15]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               continue;
+             else
+              continue;
+            else
+             continue;
+           else if(p[pixel[9]] < c_b)
+            if(p[pixel[10]] < c_b)
+             if(p[pixel[11]] < c_b)
+              if(p[pixel[12]] < c_b)
+               if(p[pixel[13]] < c_b)
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[3]] < c_b)
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              continue;
+            else
+             continue;
+           else
+            continue;
+          else if(p[pixel[2]] < c_b)
+           if(p[pixel[3]] > cb)
+            if(p[pixel[10]] > cb)
+             if(p[pixel[7]] > cb)
+              if(p[pixel[8]] > cb)
+               if(p[pixel[9]] > cb)
+                if(p[pixel[11]] > cb)
+                 if(p[pixel[6]] > cb)
+                  if(p[pixel[5]] > cb)
+                   if(p[pixel[4]] > cb)
+                    {}
+                   else
+                    if(p[pixel[12]] > cb)
+                     if(p[pixel[13]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                  else
+                   if(p[pixel[12]] > cb)
+                    if(p[pixel[13]] > cb)
+                     if(p[pixel[14]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                 else
+                  if(p[pixel[12]] > cb)
+                   if(p[pixel[13]] > cb)
+                    if(p[pixel[14]] > cb)
+                     if(p[pixel[15]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              continue;
+            else if(p[pixel[10]] < c_b)
+             if(p[pixel[11]] < c_b)
+              if(p[pixel[12]] < c_b)
+               if(p[pixel[13]] < c_b)
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               continue;
+             else
+              continue;
+            else
+             continue;
+           else if(p[pixel[3]] < c_b)
+            if(p[pixel[4]] > cb)
+             if(p[pixel[13]] > cb)
+              if(p[pixel[7]] > cb)
+               if(p[pixel[8]] > cb)
+                if(p[pixel[9]] > cb)
+                 if(p[pixel[10]] > cb)
+                  if(p[pixel[11]] > cb)
+                   if(p[pixel[12]] > cb)
+                    if(p[pixel[6]] > cb)
+                     if(p[pixel[5]] > cb)
+                      {}
+                     else
+                      if(p[pixel[14]] > cb)
+                       {}
+                      else
+                       continue;
+                    else
+                     if(p[pixel[14]] > cb)
+                      if(p[pixel[15]] > cb)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else if(p[pixel[13]] < c_b)
+              if(p[pixel[11]] > cb)
+               if(p[pixel[5]] > cb)
+                if(p[pixel[6]] > cb)
+                 if(p[pixel[7]] > cb)
+                  if(p[pixel[8]] > cb)
+                   if(p[pixel[9]] > cb)
+                    if(p[pixel[10]] > cb)
+                     if(p[pixel[12]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else if(p[pixel[11]] < c_b)
+               if(p[pixel[12]] < c_b)
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      if(p[pixel[10]] < c_b)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      if(p[pixel[10]] < c_b)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              if(p[pixel[5]] > cb)
+               if(p[pixel[6]] > cb)
+                if(p[pixel[7]] > cb)
+                 if(p[pixel[8]] > cb)
+                  if(p[pixel[9]] > cb)
+                   if(p[pixel[10]] > cb)
+                    if(p[pixel[11]] > cb)
+                     if(p[pixel[12]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else if(p[pixel[4]] < c_b)
+             if(p[pixel[5]] > cb)
+              if(p[pixel[14]] > cb)
+               if(p[pixel[7]] > cb)
+                if(p[pixel[8]] > cb)
+                 if(p[pixel[9]] > cb)
+                  if(p[pixel[10]] > cb)
+                   if(p[pixel[11]] > cb)
+                    if(p[pixel[12]] > cb)
+                     if(p[pixel[13]] > cb)
+                      if(p[pixel[6]] > cb)
+                       {}
+                      else
+                       if(p[pixel[15]] > cb)
+                        {}
+                       else
+                        continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else if(p[pixel[14]] < c_b)
+               if(p[pixel[12]] > cb)
+                if(p[pixel[6]] > cb)
+                 if(p[pixel[7]] > cb)
+                  if(p[pixel[8]] > cb)
+                   if(p[pixel[9]] > cb)
+                    if(p[pixel[10]] > cb)
+                     if(p[pixel[11]] > cb)
+                      if(p[pixel[13]] > cb)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else if(p[pixel[12]] < c_b)
+                if(p[pixel[13]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      if(p[pixel[10]] < c_b)
+                       if(p[pixel[11]] < c_b)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               if(p[pixel[6]] > cb)
+                if(p[pixel[7]] > cb)
+                 if(p[pixel[8]] > cb)
+                  if(p[pixel[9]] > cb)
+                   if(p[pixel[10]] > cb)
+                    if(p[pixel[11]] > cb)
+                     if(p[pixel[12]] > cb)
+                      if(p[pixel[13]] > cb)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else if(p[pixel[5]] < c_b)
+              if(p[pixel[6]] > cb)
+               if(p[pixel[15]] < c_b)
+                if(p[pixel[13]] > cb)
+                 if(p[pixel[7]] > cb)
+                  if(p[pixel[8]] > cb)
+                   if(p[pixel[9]] > cb)
+                    if(p[pixel[10]] > cb)
+                     if(p[pixel[11]] > cb)
+                      if(p[pixel[12]] > cb)
+                       if(p[pixel[14]] > cb)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else if(p[pixel[13]] < c_b)
+                 if(p[pixel[14]] < c_b)
+                  {}
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                if(p[pixel[7]] > cb)
+                 if(p[pixel[8]] > cb)
+                  if(p[pixel[9]] > cb)
+                   if(p[pixel[10]] > cb)
+                    if(p[pixel[11]] > cb)
+                     if(p[pixel[12]] > cb)
+                      if(p[pixel[13]] > cb)
+                       if(p[pixel[14]] > cb)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else if(p[pixel[6]] < c_b)
+               if(p[pixel[7]] > cb)
+                if(p[pixel[14]] > cb)
+                 if(p[pixel[8]] > cb)
+                  if(p[pixel[9]] > cb)
+                   if(p[pixel[10]] > cb)
+                    if(p[pixel[11]] > cb)
+                     if(p[pixel[12]] > cb)
+                      if(p[pixel[13]] > cb)
+                       if(p[pixel[15]] > cb)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  continue;
+                else
+                 continue;
+               else if(p[pixel[7]] < c_b)
+                if(p[pixel[8]] < c_b)
+                 {}
+                else
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  continue;
+               else
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[13]] > cb)
+                if(p[pixel[7]] > cb)
+                 if(p[pixel[8]] > cb)
+                  if(p[pixel[9]] > cb)
+                   if(p[pixel[10]] > cb)
+                    if(p[pixel[11]] > cb)
+                     if(p[pixel[12]] > cb)
+                      if(p[pixel[14]] > cb)
+                       if(p[pixel[15]] > cb)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else if(p[pixel[13]] < c_b)
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              if(p[pixel[12]] > cb)
+               if(p[pixel[7]] > cb)
+                if(p[pixel[8]] > cb)
+                 if(p[pixel[9]] > cb)
+                  if(p[pixel[10]] > cb)
+                   if(p[pixel[11]] > cb)
+                    if(p[pixel[13]] > cb)
+                     if(p[pixel[14]] > cb)
+                      if(p[pixel[6]] > cb)
+                       {}
+                      else
+                       if(p[pixel[15]] > cb)
+                        {}
+                       else
+                        continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else if(p[pixel[12]] < c_b)
+               if(p[pixel[13]] < c_b)
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      if(p[pixel[10]] < c_b)
+                       if(p[pixel[11]] < c_b)
+                        {}
+                       else
+                        continue;
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else
+             if(p[pixel[11]] > cb)
+              if(p[pixel[7]] > cb)
+               if(p[pixel[8]] > cb)
+                if(p[pixel[9]] > cb)
+                 if(p[pixel[10]] > cb)
+                  if(p[pixel[12]] > cb)
+                   if(p[pixel[13]] > cb)
+                    if(p[pixel[6]] > cb)
+                     if(p[pixel[5]] > cb)
+                      {}
+                     else
+                      if(p[pixel[14]] > cb)
+                       {}
+                      else
+                       continue;
+                    else
+                     if(p[pixel[14]] > cb)
+                      if(p[pixel[15]] > cb)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else if(p[pixel[11]] < c_b)
+              if(p[pixel[12]] < c_b)
+               if(p[pixel[13]] < c_b)
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      if(p[pixel[10]] < c_b)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      if(p[pixel[10]] < c_b)
+                       {}
+                      else
+                       continue;
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              continue;
+           else
+            if(p[pixel[10]] > cb)
+             if(p[pixel[7]] > cb)
+              if(p[pixel[8]] > cb)
+               if(p[pixel[9]] > cb)
+                if(p[pixel[11]] > cb)
+                 if(p[pixel[12]] > cb)
+                  if(p[pixel[6]] > cb)
+                   if(p[pixel[5]] > cb)
+                    if(p[pixel[4]] > cb)
+                     {}
+                    else
+                     if(p[pixel[13]] > cb)
+                      {}
+                     else
+                      continue;
+                   else
+                    if(p[pixel[13]] > cb)
+                     if(p[pixel[14]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                  else
+                   if(p[pixel[13]] > cb)
+                    if(p[pixel[14]] > cb)
+                     if(p[pixel[15]] > cb)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              continue;
+            else if(p[pixel[10]] < c_b)
+             if(p[pixel[11]] < c_b)
+              if(p[pixel[12]] < c_b)
+               if(p[pixel[13]] < c_b)
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     if(p[pixel[9]] < c_b)
+                      {}
+                     else
+                      continue;
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               continue;
+             else
+              continue;
+            else
+             continue;
+          else
+           if(p[pixel[9]] > cb)
+            if(p[pixel[7]] > cb)
+             if(p[pixel[8]] > cb)
+              if(p[pixel[10]] > cb)
+               if(p[pixel[11]] > cb)
+                if(p[pixel[6]] > cb)
+                 if(p[pixel[5]] > cb)
+                  if(p[pixel[4]] > cb)
+                   if(p[pixel[3]] > cb)
+                    {}
+                   else
+                    if(p[pixel[12]] > cb)
+                     {}
+                    else
+                     continue;
+                  else
+                   if(p[pixel[12]] > cb)
+                    if(p[pixel[13]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                 else
+                  if(p[pixel[12]] > cb)
+                   if(p[pixel[13]] > cb)
+                    if(p[pixel[14]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[12]] > cb)
+                  if(p[pixel[13]] > cb)
+                   if(p[pixel[14]] > cb)
+                    if(p[pixel[15]] > cb)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              continue;
+            else
+             continue;
+           else if(p[pixel[9]] < c_b)
+            if(p[pixel[10]] < c_b)
+             if(p[pixel[11]] < c_b)
+              if(p[pixel[12]] < c_b)
+               if(p[pixel[13]] < c_b)
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[3]] < c_b)
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    if(p[pixel[8]] < c_b)
+                     {}
+                    else
+                     continue;
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              continue;
+            else
+             continue;
+           else
+            continue;
+         else
+          if(p[pixel[8]] > cb)
+           if(p[pixel[7]] > cb)
+            if(p[pixel[9]] > cb)
+             if(p[pixel[10]] > cb)
+              if(p[pixel[6]] > cb)
+               if(p[pixel[5]] > cb)
+                if(p[pixel[4]] > cb)
+                 if(p[pixel[3]] > cb)
+                  if(p[pixel[2]] > cb)
+                   {}
+                  else
+                   if(p[pixel[11]] > cb)
+                    {}
+                   else
+                    continue;
+                 else
+                  if(p[pixel[11]] > cb)
+                   if(p[pixel[12]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[11]] > cb)
+                  if(p[pixel[12]] > cb)
+                   if(p[pixel[13]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[11]] > cb)
+                 if(p[pixel[12]] > cb)
+                  if(p[pixel[13]] > cb)
+                   if(p[pixel[14]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[11]] > cb)
+                if(p[pixel[12]] > cb)
+                 if(p[pixel[13]] > cb)
+                  if(p[pixel[14]] > cb)
+                   if(p[pixel[15]] > cb)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              continue;
+            else
+             continue;
+           else
+            continue;
+          else if(p[pixel[8]] < c_b)
+           if(p[pixel[9]] < c_b)
+            if(p[pixel[10]] < c_b)
+             if(p[pixel[11]] < c_b)
+              if(p[pixel[12]] < c_b)
+               if(p[pixel[13]] < c_b)
+                if(p[pixel[14]] < c_b)
+                 if(p[pixel[15]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                else
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[3]] < c_b)
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              if(p[pixel[2]] < c_b)
+               if(p[pixel[3]] < c_b)
+                if(p[pixel[4]] < c_b)
+                 if(p[pixel[5]] < c_b)
+                  if(p[pixel[6]] < c_b)
+                   if(p[pixel[7]] < c_b)
+                    {}
+                   else
+                    continue;
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else
+             continue;
+           else
+            continue;
+          else
+           continue;
+        else
+         if(p[pixel[7]] > cb)
+          if(p[pixel[8]] > cb)
+           if(p[pixel[9]] > cb)
+            if(p[pixel[6]] > cb)
+             if(p[pixel[5]] > cb)
+              if(p[pixel[4]] > cb)
+               if(p[pixel[3]] > cb)
+                if(p[pixel[2]] > cb)
+                 if(p[pixel[1]] > cb)
+                  {}
+                 else
+                  if(p[pixel[10]] > cb)
+                   {}
+                  else
+                   continue;
+                else
+                 if(p[pixel[10]] > cb)
+                  if(p[pixel[11]] > cb)
+                   {}
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[10]] > cb)
+                 if(p[pixel[11]] > cb)
+                  if(p[pixel[12]] > cb)
+                   {}
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[10]] > cb)
+                if(p[pixel[11]] > cb)
+                 if(p[pixel[12]] > cb)
+                  if(p[pixel[13]] > cb)
+                   {}
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              if(p[pixel[10]] > cb)
+               if(p[pixel[11]] > cb)
+                if(p[pixel[12]] > cb)
+                 if(p[pixel[13]] > cb)
+                  if(p[pixel[14]] > cb)
+                   {}
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else
+             if(p[pixel[10]] > cb)
+              if(p[pixel[11]] > cb)
+               if(p[pixel[12]] > cb)
+                if(p[pixel[13]] > cb)
+                 if(p[pixel[14]] > cb)
+                  if(p[pixel[15]] > cb)
+                   {}
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              continue;
+           else
+            continue;
+          else
+           continue;
+         else if(p[pixel[7]] < c_b)
+          if(p[pixel[8]] < c_b)
+           if(p[pixel[9]] < c_b)
+            if(p[pixel[6]] < c_b)
+             if(p[pixel[5]] < c_b)
+              if(p[pixel[4]] < c_b)
+               if(p[pixel[3]] < c_b)
+                if(p[pixel[2]] < c_b)
+                 if(p[pixel[1]] < c_b)
+                  {}
+                 else
+                  if(p[pixel[10]] < c_b)
+                   {}
+                  else
+                   continue;
+                else
+                 if(p[pixel[10]] < c_b)
+                  if(p[pixel[11]] < c_b)
+                   {}
+                  else
+                   continue;
+                 else
+                  continue;
+               else
+                if(p[pixel[10]] < c_b)
+                 if(p[pixel[11]] < c_b)
+                  if(p[pixel[12]] < c_b)
+                   {}
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+              else
+               if(p[pixel[10]] < c_b)
+                if(p[pixel[11]] < c_b)
+                 if(p[pixel[12]] < c_b)
+                  if(p[pixel[13]] < c_b)
+                   {}
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+             else
+              if(p[pixel[10]] < c_b)
+               if(p[pixel[11]] < c_b)
+                if(p[pixel[12]] < c_b)
+                 if(p[pixel[13]] < c_b)
+                  if(p[pixel[14]] < c_b)
+                   {}
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+            else
+             if(p[pixel[10]] < c_b)
+              if(p[pixel[11]] < c_b)
+               if(p[pixel[12]] < c_b)
+                if(p[pixel[13]] < c_b)
+                 if(p[pixel[14]] < c_b)
+                  if(p[pixel[15]] < c_b)
+                   {}
+                  else
+                   continue;
+                 else
+                  continue;
+                else
+                 continue;
+               else
+                continue;
+              else
+               continue;
+             else
+              continue;
+           else
+            continue;
+          else
+           continue;
+         else
+          continue;
+			if(num_corners == rsize)
+			{
+				rsize*=2;
+				ret_corners = (CvPoint*)realloc(ret_corners, sizeof(CvPoint)*rsize);
+			}
+			ret_corners[num_corners].x = x;
+			ret_corners[num_corners].y = y;
+			num_corners++;
+		}
+	
+	*ret_num_corners = num_corners;
+	return ret_corners;
+
+}
+

Copied: trunk/src/stable/libs/visionlib/cvFast/cvfast.h (from rev 1023, trunk/src/stable/libs/visionlib/cvfast.h)
===================================================================
--- trunk/src/stable/libs/visionlib/cvFast/cvfast.h	                        (rev 0)
+++ trunk/src/stable/libs/visionlib/cvFast/cvfast.h	2013-10-09 14:41:27 UTC (rev 1026)
@@ -0,0 +1,12 @@
+#ifndef CVFAST_H
+#define CVFAST_H
+
+#include <opencv/cvaux.h>
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <stdlib.h>
+
+CVAPI(void)  cvCornerFast(cv::Mat &src, int threshold, int N,	int nonmax_suppression, int* ret_number_of_corners,	CvPoint** ret_corners, int ** scores);
+
+#endif

Deleted: trunk/src/stable/libs/visionlib/cvfast.cpp
===================================================================
--- trunk/src/stable/libs/visionlib/cvfast.cpp	2013-10-09 14:02:09 UTC (rev 1025)
+++ trunk/src/stable/libs/visionlib/cvfast.cpp	2013-10-09 14:41:27 UTC (rev 1026)
@@ -1,6104 +0,0 @@
-#include <opencv/cvaux.h>
-#include <opencv2/core/core.hpp>
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <stdio.h>
-
-//Definitions for corner detectors.
-//These are internal functions and should not be called directly.
-//Input checking is only done in cvCornerFast
-
-
-CvPoint* icvFast9Detect(const unsigned char* im, int xsize, int ysize, int stride, int b, int* ret_num_corners);
-int* icvFast9Score(const unsigned char* i, int stride, CvPoint* corners, int num_corners, int b);
-
-/*CvPoint* icvFast10Detect(const unsigned char* im, int xsize, int ysize, int stride, int b, int* ret_num_corners);
-int* icvFast10Score(const unsigned char* i, int stride, CvPoint* corners, int num_corners, int b);
-
-CvPoint* icvFast11Detect(const unsigned char* im, int xsize, int ysize, int stride, int b, int* ret_num_corners);
-int* icvFast11Score(const unsigned char* i, int stride, CvPoint* corners, int num_corners, int b);
-
-CvPoint* icvFast12Detect(const unsigned char* im, int xsize, int ysize, int stride, int b, int* ret_num_corners);
-int* icvFast12Score(const unsigned char* i, int stride, CvPoint* corners, int num_corners, int b);*/
-
-/* This defines non-strict maxima */
-#define Compare(X, Y) ((X)>=(Y))
-
-/* This is a fast, integer only, sparse nonmaximal suppression. */
-/* probably only useful for FAST corner detection */
-CvPoint* icvFastNonmaxSuppression(const CvPoint* corners, const int* scores, int num_corners, int* ret_num_nonmax)
-{
-	int num_nonmax=0;
-	int last_row;
-	int* row_start;
-	int i, j;
-	CvPoint* ret_nonmax;
-	const int sz = (int)num_corners; 
-
-	/*Point above points (roughly) to the pixel above the one of interest, if there
-    is a feature there.*/
-	int point_above = 0;
-	int point_below = 0;
-
-	
-	if(num_corners < 1)
-	{
-		*ret_num_nonmax = 0;
-		return 0;
-	}
-
-	ret_nonmax = (CvPoint*)malloc(num_corners * sizeof(CvPoint));
-
-	/* Find where each row begins
-	   (the corners are output in raster scan order). A beginning of -1 signifies
-	   that there are no corners on that row. */
-	last_row = corners[num_corners-1].y;
-	row_start = (int*)malloc((last_row+1)*sizeof(int));
-
-	for(i=0; i < last_row+1; i++)
-		row_start[i] = -1;
-	
-	{
-		int prev_row = -1;
-		for(i=0; i< num_corners; i++)
-			if(corners[i].y != prev_row)
-			{
-				row_start[corners[i].y] = i;
-				prev_row = corners[i].y;
-			}
-	}
-	
-	
-	
-	for(i=0; i < sz; i++)
-	{
-		int score = scores[i];
-		CvPoint pos = corners[i];
-			
-		/*Check left */
-		if(i > 0)
-			if(corners[i-1].x == pos.x-1 && corners[i-1].y == pos.y && Compare(scores[i-1], score))
-				continue;
-			
-		/*Check right*/
-		if(i < (sz - 1))
-			if(corners[i+1].x == pos.x+1 && corners[i+1].y == pos.y && Compare(scores[i+1], score))
-				continue;
-			
-		/*Check above (if there is a valid row above)*/
-		if(pos.y != 0 && row_start[pos.y - 1] != -1) 
-		{
-			/*Make sure that current point_above is one
-			  row above.*/
-			if(corners[point_above].y < pos.y - 1)
-				point_above = row_start[pos.y-1];
-			
-			/*Make point_above point to the first of the pixels above the current point,
-			  if it exists.*/
-			for(; corners[point_above].y < pos.y && corners[point_above].x < pos.x - 1; point_above++)
-			{}
-			
-			
-			for(j=point_above; corners[j].y < pos.y && corners[j].x <= pos.x + 1; j++)
-			{
-				int x = corners[j].x;
-				if( (x == pos.x - 1 || x ==pos.x || x == pos.x+1) && Compare(scores[j], score))
-					goto cont;
-			}
-			
-		}
-			
-		/*Check below (if there is anything below)*/
-		if(pos.y != last_row && row_start[pos.y + 1] != -1 && point_below < sz) /*Nothing below*/
-		{
-			if(corners[point_below].y < pos.y + 1)
-				point_below = row_start[pos.y+1];
-			
-			/* Make point below point to one of the pixels belowthe current point, if it
-			   exists.*/
-			for(; point_below < sz && corners[point_below].y == pos.y+1 && corners[point_below].x < pos.x - 1; point_below++)
-			{}
-
-			for(j=point_below; j < sz && corners[j].y == pos.y+1 && corners[j].x <= pos.x + 1; j++)
-			{
-				int x = corners[j].x;
-				if( (x == pos.x - 1 || x ==pos.x || x == pos.x+1) && Compare(scores[j],score))
-					goto cont;
-			}
-		}
-		
-		ret_nonmax[num_nonmax++] = corners[i];
-		cont:
-			;
-	}
-
-	free(row_start);
-	*ret_num_nonmax = num_nonmax;
-	return ret_nonmax;
-}
-
-
-CVAPI(void)
-cvCornerFast(cv::Mat &src, int threshold, int N, int nonmax_suppression, int* ret_number_of_corners, CvPoint** ret_corners, int ** scores)
-{
-	CV_FUNCNAME( "cvCornerFast" );
-
-	int rows, cols, stride;
-	uchar* data;
-	
-	CvPoint *corners=0, *nonmax_corners=0;
-	int num_corners=0, num_nonmax=0;
-	*scores=0;
-
-	CvMat stub;
-
-    __CV_BEGIN__;
-
-	//if(!input_image)
-  //      CV_ERROR( CV_StsNullPtr, "" );
-
-	if(!ret_number_of_corners)
-        CV_ERROR( CV_StsNullPtr, "" );
-
-	if( N < 9 || N > 12)
-        CV_ERROR( CV_StsOutOfRange, "Corner arc length must be 9, 10, 11 or 12." );
-	
-	
-	/* Make sure the input is unsigned char */
-	/* In principle, FAST can work on any type, but trees are only included for unsigned char */
-//    src = (CvMat*)input_image;
-//    CV_CALL( src = cvGetMat( input_image, &stub, NULL, 0 ));
-
-//    if( CV_MAT_TYPE(src->type) != CV_8UC1 )
-//        CV_ERROR( CV_StsUnsupportedFormat, "Input must be 8uC1." );
-
-	rows = src.rows;
-	cols = src.cols;
-	stride = src.step;
-	data = src.data;
-	
-	/*Detect corners*/
-	corners = icvFast9Detect(data, cols, rows, stride, threshold, &num_corners);
-
-	/*Compute scores*/
-	*scores = icvFast9Score(data, stride, corners, num_corners, threshold);
-
-	*ret_number_of_corners = num_corners;
-	*ret_corners = corners;
-	
-	//Do nonmax suppression if need be
-	if(nonmax_suppression)
-	{
-		nonmax_corners = icvFastNonmaxSuppression(corners, *scores, num_corners, & num_nonmax);
-
-		*ret_corners = nonmax_corners;
-		*ret_number_of_corners = num_nonmax; 
-
-		free(corners);
-	}
-
-    __CV_END__;
-}
-
-int icvFast9CornerScore(const unsigned char* p, const int pixel[], int bstart)
-{    
-    int bmin = bstart;
-    int bmax = 255;
-    int b = (bmax + bmin)/2;
-    
-    /*Compute the score using binary search*/
-	for(;;)
-    {
-		int cb = *p + b;
-		int c_b= *p - b;
-
-
-        if( p[pixel[0]] > cb)
-         if( p[pixel[1]] > cb)
-          if( p[pixel[2]] > cb)
-           if( p[pixel[3]] > cb)
-            if( p[pixel[4]] > cb)
-             if( p[pixel[5]] > cb)
-              if( p[pixel[6]] > cb)
-               if( p[pixel[7]] > cb)
-                if( p[pixel[8]] > cb)
-                 goto is_a_corner;
-                else
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else if( p[pixel[7]] < c_b)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else if( p[pixel[14]] < c_b)
-                 if( p[pixel[8]] < c_b)
-                  if( p[pixel[9]] < c_b)
-                   if( p[pixel[10]] < c_b)
-                    if( p[pixel[11]] < c_b)
-                     if( p[pixel[12]] < c_b)
-                      if( p[pixel[13]] < c_b)
-                       if( p[pixel[15]] < c_b)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else if( p[pixel[6]] < c_b)
-               if( p[pixel[15]] > cb)
-                if( p[pixel[13]] > cb)
-                 if( p[pixel[14]] > cb)
-                  goto is_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else if( p[pixel[13]] < c_b)
-                 if( p[pixel[7]] < c_b)
-                  if( p[pixel[8]] < c_b)
-                   if( p[pixel[9]] < c_b)
-                    if( p[pixel[10]] < c_b)
-                     if( p[pixel[11]] < c_b)
-                      if( p[pixel[12]] < c_b)
-                       if( p[pixel[14]] < c_b)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                if( p[pixel[7]] < c_b)
-                 if( p[pixel[8]] < c_b)
-                  if( p[pixel[9]] < c_b)
-                   if( p[pixel[10]] < c_b)
-                    if( p[pixel[11]] < c_b)
-                     if( p[pixel[12]] < c_b)
-                      if( p[pixel[13]] < c_b)
-                       if( p[pixel[14]] < c_b)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[13]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else if( p[pixel[13]] < c_b)
-                if( p[pixel[7]] < c_b)
-                 if( p[pixel[8]] < c_b)
-                  if( p[pixel[9]] < c_b)
-                   if( p[pixel[10]] < c_b)
-                    if( p[pixel[11]] < c_b)
-                     if( p[pixel[12]] < c_b)
-                      if( p[pixel[14]] < c_b)
-                       if( p[pixel[15]] < c_b)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else if( p[pixel[5]] < c_b)
-              if( p[pixel[14]] > cb)
-               if( p[pixel[12]] > cb)
-                if( p[pixel[13]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      if( p[pixel[10]] > cb)
-                       if( p[pixel[11]] > cb)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else if( p[pixel[12]] < c_b)
-                if( p[pixel[6]] < c_b)
-                 if( p[pixel[7]] < c_b)
-                  if( p[pixel[8]] < c_b)
-                   if( p[pixel[9]] < c_b)
-                    if( p[pixel[10]] < c_b)
-                     if( p[pixel[11]] < c_b)
-                      if( p[pixel[13]] < c_b)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else if( p[pixel[14]] < c_b)
-               if( p[pixel[7]] < c_b)
-                if( p[pixel[8]] < c_b)
-                 if( p[pixel[9]] < c_b)
-                  if( p[pixel[10]] < c_b)
-                   if( p[pixel[11]] < c_b)
-                    if( p[pixel[12]] < c_b)
-                     if( p[pixel[13]] < c_b)
-                      if( p[pixel[6]] < c_b)
-                       goto is_a_corner;
-                      else
-                       if( p[pixel[15]] < c_b)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               if( p[pixel[6]] < c_b)
-                if( p[pixel[7]] < c_b)
-                 if( p[pixel[8]] < c_b)
-                  if( p[pixel[9]] < c_b)
-                   if( p[pixel[10]] < c_b)
-                    if( p[pixel[11]] < c_b)
-                     if( p[pixel[12]] < c_b)
-                      if( p[pixel[13]] < c_b)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              if( p[pixel[12]] > cb)
-               if( p[pixel[13]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      if( p[pixel[10]] > cb)
-                       if( p[pixel[11]] > cb)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else if( p[pixel[12]] < c_b)
-               if( p[pixel[7]] < c_b)
-                if( p[pixel[8]] < c_b)
-                 if( p[pixel[9]] < c_b)
-                  if( p[pixel[10]] < c_b)
-                   if( p[pixel[11]] < c_b)
-                    if( p[pixel[13]] < c_b)
-                     if( p[pixel[14]] < c_b)
-                      if( p[pixel[6]] < c_b)
-                       goto is_a_corner;
-                      else
-                       if( p[pixel[15]] < c_b)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else if( p[pixel[4]] < c_b)
-             if( p[pixel[13]] > cb)
-              if( p[pixel[11]] > cb)
-               if( p[pixel[12]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      if( p[pixel[10]] > cb)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      if( p[pixel[10]] > cb)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else if( p[pixel[11]] < c_b)
-               if( p[pixel[5]] < c_b)
-                if( p[pixel[6]] < c_b)
-                 if( p[pixel[7]] < c_b)
-                  if( p[pixel[8]] < c_b)
-                   if( p[pixel[9]] < c_b)
-                    if( p[pixel[10]] < c_b)
-                     if( p[pixel[12]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else if( p[pixel[13]] < c_b)
-              if( p[pixel[7]] < c_b)
-               if( p[pixel[8]] < c_b)
-                if( p[pixel[9]] < c_b)
-                 if( p[pixel[10]] < c_b)
-                  if( p[pixel[11]] < c_b)
-                   if( p[pixel[12]] < c_b)
-                    if( p[pixel[6]] < c_b)
-                     if( p[pixel[5]] < c_b)
-                      goto is_a_corner;
-                     else
-                      if( p[pixel[14]] < c_b)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                    else
-                     if( p[pixel[14]] < c_b)
-                      if( p[pixel[15]] < c_b)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              if( p[pixel[5]] < c_b)
-               if( p[pixel[6]] < c_b)
-                if( p[pixel[7]] < c_b)
-                 if( p[pixel[8]] < c_b)
-                  if( p[pixel[9]] < c_b)
-                   if( p[pixel[10]] < c_b)
-                    if( p[pixel[11]] < c_b)
-                     if( p[pixel[12]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else
-             if( p[pixel[11]] > cb)
-              if( p[pixel[12]] > cb)
-               if( p[pixel[13]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      if( p[pixel[10]] > cb)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      if( p[pixel[10]] > cb)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else if( p[pixel[11]] < c_b)
-              if( p[pixel[7]] < c_b)
-               if( p[pixel[8]] < c_b)
-                if( p[pixel[9]] < c_b)
-                 if( p[pixel[10]] < c_b)
-                  if( p[pixel[12]] < c_b)
-                   if( p[pixel[13]] < c_b)
-                    if( p[pixel[6]] < c_b)
-                     if( p[pixel[5]] < c_b)
-                      goto is_a_corner;
-                     else
-                      if( p[pixel[14]] < c_b)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                    else
-                     if( p[pixel[14]] < c_b)
-                      if( p[pixel[15]] < c_b)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-           else if( p[pixel[3]] < c_b)
-            if( p[pixel[10]] > cb)
-             if( p[pixel[11]] > cb)
-              if( p[pixel[12]] > cb)
-               if( p[pixel[13]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else if( p[pixel[10]] < c_b)
-             if( p[pixel[7]] < c_b)
-              if( p[pixel[8]] < c_b)
-               if( p[pixel[9]] < c_b)
-                if( p[pixel[11]] < c_b)
-                 if( p[pixel[6]] < c_b)
-                  if( p[pixel[5]] < c_b)
-                   if( p[pixel[4]] < c_b)
-                    goto is_a_corner;
-                   else
-                    if( p[pixel[12]] < c_b)
-                     if( p[pixel[13]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                  else
-                   if( p[pixel[12]] < c_b)
-                    if( p[pixel[13]] < c_b)
-                     if( p[pixel[14]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                 else
-                  if( p[pixel[12]] < c_b)
-                   if( p[pixel[13]] < c_b)
-                    if( p[pixel[14]] < c_b)
-                     if( p[pixel[15]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            if( p[pixel[10]] > cb)
-             if( p[pixel[11]] > cb)
-              if( p[pixel[12]] > cb)
-               if( p[pixel[13]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     if( p[pixel[9]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else if( p[pixel[10]] < c_b)
-             if( p[pixel[7]] < c_b)
-              if( p[pixel[8]] < c_b)
-               if( p[pixel[9]] < c_b)
-                if( p[pixel[11]] < c_b)
-                 if( p[pixel[12]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[5]] < c_b)
-                    if( p[pixel[4]] < c_b)
-                     goto is_a_corner;
-                    else
-                     if( p[pixel[13]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                   else
-                    if( p[pixel[13]] < c_b)
-                     if( p[pixel[14]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                  else
-                   if( p[pixel[13]] < c_b)
-                    if( p[pixel[14]] < c_b)
-                     if( p[pixel[15]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-          else if( p[pixel[2]] < c_b)
-           if( p[pixel[9]] > cb)
-            if( p[pixel[10]] > cb)
-             if( p[pixel[11]] > cb)
-              if( p[pixel[12]] > cb)
-               if( p[pixel[13]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[3]] > cb)
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else if( p[pixel[9]] < c_b)
-            if( p[pixel[7]] < c_b)
-             if( p[pixel[8]] < c_b)
-              if( p[pixel[10]] < c_b)
-               if( p[pixel[6]] < c_b)
-                if( p[pixel[5]] < c_b)
-                 if( p[pixel[4]] < c_b)
-                  if( p[pixel[3]] < c_b)
-                   goto is_a_corner;
-                  else
-                   if( p[pixel[11]] < c_b)
-                    if( p[pixel[12]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                 else
-                  if( p[pixel[11]] < c_b)
-                   if( p[pixel[12]] < c_b)
-                    if( p[pixel[13]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[11]] < c_b)
-                  if( p[pixel[12]] < c_b)
-                   if( p[pixel[13]] < c_b)
-                    if( p[pixel[14]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[11]] < c_b)
-                 if( p[pixel[12]] < c_b)
-                  if( p[pixel[13]] < c_b)
-                   if( p[pixel[14]] < c_b)
-                    if( p[pixel[15]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else
-           if( p[pixel[9]] > cb)
-            if( p[pixel[10]] > cb)
-             if( p[pixel[11]] > cb)
-              if( p[pixel[12]] > cb)
-               if( p[pixel[13]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[3]] > cb)
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    if( p[pixel[8]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else if( p[pixel[9]] < c_b)
-            if( p[pixel[7]] < c_b)
-             if( p[pixel[8]] < c_b)
-              if( p[pixel[10]] < c_b)
-               if( p[pixel[11]] < c_b)
-                if( p[pixel[6]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[4]] < c_b)
-                   if( p[pixel[3]] < c_b)
-                    goto is_a_corner;
-                   else
-                    if( p[pixel[12]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                  else
-                   if( p[pixel[12]] < c_b)
-                    if( p[pixel[13]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                 else
-                  if( p[pixel[12]] < c_b)
-                   if( p[pixel[13]] < c_b)
-                    if( p[pixel[14]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[12]] < c_b)
-                  if( p[pixel[13]] < c_b)
-                   if( p[pixel[14]] < c_b)
-                    if( p[pixel[15]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-         else if( p[pixel[1]] < c_b)
-          if( p[pixel[8]] > cb)
-           if( p[pixel[9]] > cb)
-            if( p[pixel[10]] > cb)
-             if( p[pixel[11]] > cb)
-              if( p[pixel[12]] > cb)
-               if( p[pixel[13]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[3]] > cb)
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              if( p[pixel[2]] > cb)
-               if( p[pixel[3]] > cb)
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else if( p[pixel[8]] < c_b)
-           if( p[pixel[7]] < c_b)
-            if( p[pixel[9]] < c_b)
-             if( p[pixel[6]] < c_b)
-              if( p[pixel[5]] < c_b)
-               if( p[pixel[4]] < c_b)
-                if( p[pixel[3]] < c_b)
-                 if( p[pixel[2]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[10]] < c_b)
-                   if( p[pixel[11]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[10]] < c_b)
-                  if( p[pixel[11]] < c_b)
-                   if( p[pixel[12]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[10]] < c_b)
-                 if( p[pixel[11]] < c_b)
-                  if( p[pixel[12]] < c_b)
-                   if( p[pixel[13]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[10]] < c_b)
-                if( p[pixel[11]] < c_b)
-                 if( p[pixel[12]] < c_b)
-                  if( p[pixel[13]] < c_b)
-                   if( p[pixel[14]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              if( p[pixel[10]] < c_b)
-               if( p[pixel[11]] < c_b)
-                if( p[pixel[12]] < c_b)
-                 if( p[pixel[13]] < c_b)
-                  if( p[pixel[14]] < c_b)
-                   if( p[pixel[15]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else
-           goto is_not_a_corner;
-         else
-          if( p[pixel[8]] > cb)
-           if( p[pixel[9]] > cb)
-            if( p[pixel[10]] > cb)
-             if( p[pixel[11]] > cb)
-              if( p[pixel[12]] > cb)
-               if( p[pixel[13]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[15]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[3]] > cb)
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              if( p[pixel[2]] > cb)
-               if( p[pixel[3]] > cb)
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[7]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else if( p[pixel[8]] < c_b)
-           if( p[pixel[7]] < c_b)
-            if( p[pixel[9]] < c_b)
-             if( p[pixel[10]] < c_b)
-              if( p[pixel[6]] < c_b)
-               if( p[pixel[5]] < c_b)
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[3]] < c_b)
-                  if( p[pixel[2]] < c_b)
-                   goto is_a_corner;
-                  else
-                   if( p[pixel[11]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                 else
-                  if( p[pixel[11]] < c_b)
-                   if( p[pixel[12]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[11]] < c_b)
-                  if( p[pixel[12]] < c_b)
-                   if( p[pixel[13]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[11]] < c_b)
-                 if( p[pixel[12]] < c_b)
-                  if( p[pixel[13]] < c_b)
-                   if( p[pixel[14]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[11]] < c_b)
-                if( p[pixel[12]] < c_b)
-                 if( p[pixel[13]] < c_b)
-                  if( p[pixel[14]] < c_b)
-                   if( p[pixel[15]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else
-           goto is_not_a_corner;
-        else if( p[pixel[0]] < c_b)
-         if( p[pixel[1]] > cb)
-          if( p[pixel[8]] > cb)
-           if( p[pixel[7]] > cb)
-            if( p[pixel[9]] > cb)
-             if( p[pixel[6]] > cb)
-              if( p[pixel[5]] > cb)
-               if( p[pixel[4]] > cb)
-                if( p[pixel[3]] > cb)
-                 if( p[pixel[2]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[10]] > cb)
-                   if( p[pixel[11]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[10]] > cb)
-                  if( p[pixel[11]] > cb)
-                   if( p[pixel[12]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[10]] > cb)
-                 if( p[pixel[11]] > cb)
-                  if( p[pixel[12]] > cb)
-                   if( p[pixel[13]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[10]] > cb)
-                if( p[pixel[11]] > cb)
-                 if( p[pixel[12]] > cb)
-                  if( p[pixel[13]] > cb)
-                   if( p[pixel[14]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              if( p[pixel[10]] > cb)
-               if( p[pixel[11]] > cb)
-                if( p[pixel[12]] > cb)
-                 if( p[pixel[13]] > cb)
-                  if( p[pixel[14]] > cb)
-                   if( p[pixel[15]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else if( p[pixel[8]] < c_b)
-           if( p[pixel[9]] < c_b)
-            if( p[pixel[10]] < c_b)
-             if( p[pixel[11]] < c_b)
-              if( p[pixel[12]] < c_b)
-               if( p[pixel[13]] < c_b)
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[3]] < c_b)
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              if( p[pixel[2]] < c_b)
-               if( p[pixel[3]] < c_b)
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else
-           goto is_not_a_corner;
-         else if( p[pixel[1]] < c_b)
-          if( p[pixel[2]] > cb)
-           if( p[pixel[9]] > cb)
-            if( p[pixel[7]] > cb)
-             if( p[pixel[8]] > cb)
-              if( p[pixel[10]] > cb)
-               if( p[pixel[6]] > cb)
-                if( p[pixel[5]] > cb)
-                 if( p[pixel[4]] > cb)
-                  if( p[pixel[3]] > cb)
-                   goto is_a_corner;
-                  else
-                   if( p[pixel[11]] > cb)
-                    if( p[pixel[12]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                 else
-                  if( p[pixel[11]] > cb)
-                   if( p[pixel[12]] > cb)
-                    if( p[pixel[13]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[11]] > cb)
-                  if( p[pixel[12]] > cb)
-                   if( p[pixel[13]] > cb)
-                    if( p[pixel[14]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[11]] > cb)
-                 if( p[pixel[12]] > cb)
-                  if( p[pixel[13]] > cb)
-                   if( p[pixel[14]] > cb)
-                    if( p[pixel[15]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else if( p[pixel[9]] < c_b)
-            if( p[pixel[10]] < c_b)
-             if( p[pixel[11]] < c_b)
-              if( p[pixel[12]] < c_b)
-               if( p[pixel[13]] < c_b)
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[3]] < c_b)
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else if( p[pixel[2]] < c_b)
-           if( p[pixel[3]] > cb)
-            if( p[pixel[10]] > cb)
-             if( p[pixel[7]] > cb)
-              if( p[pixel[8]] > cb)
-               if( p[pixel[9]] > cb)
-                if( p[pixel[11]] > cb)
-                 if( p[pixel[6]] > cb)
-                  if( p[pixel[5]] > cb)
-                   if( p[pixel[4]] > cb)
-                    goto is_a_corner;
-                   else
-                    if( p[pixel[12]] > cb)
-                     if( p[pixel[13]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                  else
-                   if( p[pixel[12]] > cb)
-                    if( p[pixel[13]] > cb)
-                     if( p[pixel[14]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                 else
-                  if( p[pixel[12]] > cb)
-                   if( p[pixel[13]] > cb)
-                    if( p[pixel[14]] > cb)
-                     if( p[pixel[15]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else if( p[pixel[10]] < c_b)
-             if( p[pixel[11]] < c_b)
-              if( p[pixel[12]] < c_b)
-               if( p[pixel[13]] < c_b)
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else if( p[pixel[3]] < c_b)
-            if( p[pixel[4]] > cb)
-             if( p[pixel[13]] > cb)
-              if( p[pixel[7]] > cb)
-               if( p[pixel[8]] > cb)
-                if( p[pixel[9]] > cb)
-                 if( p[pixel[10]] > cb)
-                  if( p[pixel[11]] > cb)
-                   if( p[pixel[12]] > cb)
-                    if( p[pixel[6]] > cb)
-                     if( p[pixel[5]] > cb)
-                      goto is_a_corner;
-                     else
-                      if( p[pixel[14]] > cb)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                    else
-                     if( p[pixel[14]] > cb)
-                      if( p[pixel[15]] > cb)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else if( p[pixel[13]] < c_b)
-              if( p[pixel[11]] > cb)
-               if( p[pixel[5]] > cb)
-                if( p[pixel[6]] > cb)
-                 if( p[pixel[7]] > cb)
-                  if( p[pixel[8]] > cb)
-                   if( p[pixel[9]] > cb)
-                    if( p[pixel[10]] > cb)
-                     if( p[pixel[12]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else if( p[pixel[11]] < c_b)
-               if( p[pixel[12]] < c_b)
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      if( p[pixel[10]] < c_b)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      if( p[pixel[10]] < c_b)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              if( p[pixel[5]] > cb)
-               if( p[pixel[6]] > cb)
-                if( p[pixel[7]] > cb)
-                 if( p[pixel[8]] > cb)
-                  if( p[pixel[9]] > cb)
-                   if( p[pixel[10]] > cb)
-                    if( p[pixel[11]] > cb)
-                     if( p[pixel[12]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else if( p[pixel[4]] < c_b)
-             if( p[pixel[5]] > cb)
-              if( p[pixel[14]] > cb)
-               if( p[pixel[7]] > cb)
-                if( p[pixel[8]] > cb)
-                 if( p[pixel[9]] > cb)
-                  if( p[pixel[10]] > cb)
-                   if( p[pixel[11]] > cb)
-                    if( p[pixel[12]] > cb)
-                     if( p[pixel[13]] > cb)
-                      if( p[pixel[6]] > cb)
-                       goto is_a_corner;
-                      else
-                       if( p[pixel[15]] > cb)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else if( p[pixel[14]] < c_b)
-               if( p[pixel[12]] > cb)
-                if( p[pixel[6]] > cb)
-                 if( p[pixel[7]] > cb)
-                  if( p[pixel[8]] > cb)
-                   if( p[pixel[9]] > cb)
-                    if( p[pixel[10]] > cb)
-                     if( p[pixel[11]] > cb)
-                      if( p[pixel[13]] > cb)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else if( p[pixel[12]] < c_b)
-                if( p[pixel[13]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      if( p[pixel[10]] < c_b)
-                       if( p[pixel[11]] < c_b)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               if( p[pixel[6]] > cb)
-                if( p[pixel[7]] > cb)
-                 if( p[pixel[8]] > cb)
-                  if( p[pixel[9]] > cb)
-                   if( p[pixel[10]] > cb)
-                    if( p[pixel[11]] > cb)
-                     if( p[pixel[12]] > cb)
-                      if( p[pixel[13]] > cb)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else if( p[pixel[5]] < c_b)
-              if( p[pixel[6]] > cb)
-               if( p[pixel[15]] < c_b)
-                if( p[pixel[13]] > cb)
-                 if( p[pixel[7]] > cb)
-                  if( p[pixel[8]] > cb)
-                   if( p[pixel[9]] > cb)
-                    if( p[pixel[10]] > cb)
-                     if( p[pixel[11]] > cb)
-                      if( p[pixel[12]] > cb)
-                       if( p[pixel[14]] > cb)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else if( p[pixel[13]] < c_b)
-                 if( p[pixel[14]] < c_b)
-                  goto is_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                if( p[pixel[7]] > cb)
-                 if( p[pixel[8]] > cb)
-                  if( p[pixel[9]] > cb)
-                   if( p[pixel[10]] > cb)
-                    if( p[pixel[11]] > cb)
-                     if( p[pixel[12]] > cb)
-                      if( p[pixel[13]] > cb)
-                       if( p[pixel[14]] > cb)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else if( p[pixel[6]] < c_b)
-               if( p[pixel[7]] > cb)
-                if( p[pixel[14]] > cb)
-                 if( p[pixel[8]] > cb)
-                  if( p[pixel[9]] > cb)
-                   if( p[pixel[10]] > cb)
-                    if( p[pixel[11]] > cb)
-                     if( p[pixel[12]] > cb)
-                      if( p[pixel[13]] > cb)
-                       if( p[pixel[15]] > cb)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else if( p[pixel[7]] < c_b)
-                if( p[pixel[8]] < c_b)
-                 goto is_a_corner;
-                else
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[13]] > cb)
-                if( p[pixel[7]] > cb)
-                 if( p[pixel[8]] > cb)
-                  if( p[pixel[9]] > cb)
-                   if( p[pixel[10]] > cb)
-                    if( p[pixel[11]] > cb)
-                     if( p[pixel[12]] > cb)
-                      if( p[pixel[14]] > cb)
-                       if( p[pixel[15]] > cb)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else if( p[pixel[13]] < c_b)
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              if( p[pixel[12]] > cb)
-               if( p[pixel[7]] > cb)
-                if( p[pixel[8]] > cb)
-                 if( p[pixel[9]] > cb)
-                  if( p[pixel[10]] > cb)
-                   if( p[pixel[11]] > cb)
-                    if( p[pixel[13]] > cb)
-                     if( p[pixel[14]] > cb)
-                      if( p[pixel[6]] > cb)
-                       goto is_a_corner;
-                      else
-                       if( p[pixel[15]] > cb)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else if( p[pixel[12]] < c_b)
-               if( p[pixel[13]] < c_b)
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      if( p[pixel[10]] < c_b)
-                       if( p[pixel[11]] < c_b)
-                        goto is_a_corner;
-                       else
-                        goto is_not_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else
-             if( p[pixel[11]] > cb)
-              if( p[pixel[7]] > cb)
-               if( p[pixel[8]] > cb)
-                if( p[pixel[9]] > cb)
-                 if( p[pixel[10]] > cb)
-                  if( p[pixel[12]] > cb)
-                   if( p[pixel[13]] > cb)
-                    if( p[pixel[6]] > cb)
-                     if( p[pixel[5]] > cb)
-                      goto is_a_corner;
-                     else
-                      if( p[pixel[14]] > cb)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                    else
-                     if( p[pixel[14]] > cb)
-                      if( p[pixel[15]] > cb)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else if( p[pixel[11]] < c_b)
-              if( p[pixel[12]] < c_b)
-               if( p[pixel[13]] < c_b)
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      if( p[pixel[10]] < c_b)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      if( p[pixel[10]] < c_b)
-                       goto is_a_corner;
-                      else
-                       goto is_not_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-           else
-            if( p[pixel[10]] > cb)
-             if( p[pixel[7]] > cb)
-              if( p[pixel[8]] > cb)
-               if( p[pixel[9]] > cb)
-                if( p[pixel[11]] > cb)
-                 if( p[pixel[12]] > cb)
-                  if( p[pixel[6]] > cb)
-                   if( p[pixel[5]] > cb)
-                    if( p[pixel[4]] > cb)
-                     goto is_a_corner;
-                    else
-                     if( p[pixel[13]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                   else
-                    if( p[pixel[13]] > cb)
-                     if( p[pixel[14]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                  else
-                   if( p[pixel[13]] > cb)
-                    if( p[pixel[14]] > cb)
-                     if( p[pixel[15]] > cb)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else if( p[pixel[10]] < c_b)
-             if( p[pixel[11]] < c_b)
-              if( p[pixel[12]] < c_b)
-               if( p[pixel[13]] < c_b)
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     if( p[pixel[9]] < c_b)
-                      goto is_a_corner;
-                     else
-                      goto is_not_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-          else
-           if( p[pixel[9]] > cb)
-            if( p[pixel[7]] > cb)
-             if( p[pixel[8]] > cb)
-              if( p[pixel[10]] > cb)
-               if( p[pixel[11]] > cb)
-                if( p[pixel[6]] > cb)
-                 if( p[pixel[5]] > cb)
-                  if( p[pixel[4]] > cb)
-                   if( p[pixel[3]] > cb)
-                    goto is_a_corner;
-                   else
-                    if( p[pixel[12]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                  else
-                   if( p[pixel[12]] > cb)
-                    if( p[pixel[13]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                 else
-                  if( p[pixel[12]] > cb)
-                   if( p[pixel[13]] > cb)
-                    if( p[pixel[14]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[12]] > cb)
-                  if( p[pixel[13]] > cb)
-                   if( p[pixel[14]] > cb)
-                    if( p[pixel[15]] > cb)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else if( p[pixel[9]] < c_b)
-            if( p[pixel[10]] < c_b)
-             if( p[pixel[11]] < c_b)
-              if( p[pixel[12]] < c_b)
-               if( p[pixel[13]] < c_b)
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[3]] < c_b)
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    if( p[pixel[8]] < c_b)
-                     goto is_a_corner;
-                    else
-                     goto is_not_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-         else
-          if( p[pixel[8]] > cb)
-           if( p[pixel[7]] > cb)
-            if( p[pixel[9]] > cb)
-             if( p[pixel[10]] > cb)
-              if( p[pixel[6]] > cb)
-               if( p[pixel[5]] > cb)
-                if( p[pixel[4]] > cb)
-                 if( p[pixel[3]] > cb)
-                  if( p[pixel[2]] > cb)
-                   goto is_a_corner;
-                  else
-                   if( p[pixel[11]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                 else
-                  if( p[pixel[11]] > cb)
-                   if( p[pixel[12]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[11]] > cb)
-                  if( p[pixel[12]] > cb)
-                   if( p[pixel[13]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[11]] > cb)
-                 if( p[pixel[12]] > cb)
-                  if( p[pixel[13]] > cb)
-                   if( p[pixel[14]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[11]] > cb)
-                if( p[pixel[12]] > cb)
-                 if( p[pixel[13]] > cb)
-                  if( p[pixel[14]] > cb)
-                   if( p[pixel[15]] > cb)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else if( p[pixel[8]] < c_b)
-           if( p[pixel[9]] < c_b)
-            if( p[pixel[10]] < c_b)
-             if( p[pixel[11]] < c_b)
-              if( p[pixel[12]] < c_b)
-               if( p[pixel[13]] < c_b)
-                if( p[pixel[14]] < c_b)
-                 if( p[pixel[15]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[3]] < c_b)
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              if( p[pixel[2]] < c_b)
-               if( p[pixel[3]] < c_b)
-                if( p[pixel[4]] < c_b)
-                 if( p[pixel[5]] < c_b)
-                  if( p[pixel[6]] < c_b)
-                   if( p[pixel[7]] < c_b)
-                    goto is_a_corner;
-                   else
-                    goto is_not_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else
-             goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else
-           goto is_not_a_corner;
-        else
-         if( p[pixel[7]] > cb)
-          if( p[pixel[8]] > cb)
-           if( p[pixel[9]] > cb)
-            if( p[pixel[6]] > cb)
-             if( p[pixel[5]] > cb)
-              if( p[pixel[4]] > cb)
-               if( p[pixel[3]] > cb)
-                if( p[pixel[2]] > cb)
-                 if( p[pixel[1]] > cb)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[10]] > cb)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[10]] > cb)
-                  if( p[pixel[11]] > cb)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[10]] > cb)
-                 if( p[pixel[11]] > cb)
-                  if( p[pixel[12]] > cb)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[10]] > cb)
-                if( p[pixel[11]] > cb)
-                 if( p[pixel[12]] > cb)
-                  if( p[pixel[13]] > cb)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              if( p[pixel[10]] > cb)
-               if( p[pixel[11]] > cb)
-                if( p[pixel[12]] > cb)
-                 if( p[pixel[13]] > cb)
-                  if( p[pixel[14]] > cb)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else
-             if( p[pixel[10]] > cb)
-              if( p[pixel[11]] > cb)
-               if( p[pixel[12]] > cb)
-                if( p[pixel[13]] > cb)
-                 if( p[pixel[14]] > cb)
-                  if( p[pixel[15]] > cb)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else
-           goto is_not_a_corner;
-         else if( p[pixel[7]] < c_b)
-          if( p[pixel[8]] < c_b)
-           if( p[pixel[9]] < c_b)
-            if( p[pixel[6]] < c_b)
-             if( p[pixel[5]] < c_b)
-              if( p[pixel[4]] < c_b)
-               if( p[pixel[3]] < c_b)
-                if( p[pixel[2]] < c_b)
-                 if( p[pixel[1]] < c_b)
-                  goto is_a_corner;
-                 else
-                  if( p[pixel[10]] < c_b)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                else
-                 if( p[pixel[10]] < c_b)
-                  if( p[pixel[11]] < c_b)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-               else
-                if( p[pixel[10]] < c_b)
-                 if( p[pixel[11]] < c_b)
-                  if( p[pixel[12]] < c_b)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-              else
-               if( p[pixel[10]] < c_b)
-                if( p[pixel[11]] < c_b)
-                 if( p[pixel[12]] < c_b)
-                  if( p[pixel[13]] < c_b)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-             else
-              if( p[pixel[10]] < c_b)
-               if( p[pixel[11]] < c_b)
-                if( p[pixel[12]] < c_b)
-                 if( p[pixel[13]] < c_b)
-                  if( p[pixel[14]] < c_b)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-            else
-             if( p[pixel[10]] < c_b)
-              if( p[pixel[11]] < c_b)
-               if( p[pixel[12]] < c_b)
-                if( p[pixel[13]] < c_b)
-                 if( p[pixel[14]] < c_b)
-                  if( p[pixel[15]] < c_b)
-                   goto is_a_corner;
-                  else
-                   goto is_not_a_corner;
-                 else
-                  goto is_not_a_corner;
-                else
-                 goto is_not_a_corner;
-               else
-                goto is_not_a_corner;
-              else
-               goto is_not_a_corner;
-             else
-              goto is_not_a_corner;
-           else
-            goto is_not_a_corner;
-          else
-           goto is_not_a_corner;
-         else
-          goto is_not_a_corner;
-
-		is_a_corner:
-			bmin=b;
-			goto end_if;
-
-		is_not_a_corner:
-			bmax=b;
-			goto end_if;
-
-		end_if:
-
-		if(bmin == bmax - 1 || bmin == bmax)
-			return bmin;
-		b = (bmin + bmax) / 2;
-    }
-}
-
-static void icvMakeOffsets(int pixel[], int row_stride)
-{
-        pixel[0] = 0 + row_stride * 3;
-        pixel[1] = 1 + row_stride * 3;
-        pixel[2] = 2 + row_stride * 2;
-        pixel[3] = 3 + row_stride * 1;
-        pixel[4] = 3 + row_stride * 0;
-        pixel[5] = 3 + row_stride * -1;
-        pixel[6] = 2 + row_stride * -2;
-        pixel[7] = 1 + row_stride * -3;
-        pixel[8] = 0 + row_stride * -3;
-        pixel[9] = -1 + row_stride * -3;
-        pixel[10] = -2 + row_stride * -2;
-        pixel[11] = -3 + row_stride * -1;
-        pixel[12] = -3 + row_stride * 0;
-        pixel[13] = -3 + row_stride * 1;
-        pixel[14] = -2 + row_stride * 2;
-        pixel[15] = -1 + row_stride * 3;
-}
-
-
-
-int* icvFast9Score(const unsigned char* i, int stride, CvPoint* corners, int num_corners, int b)
-{	
-	int* scores = (int*)malloc(sizeof(int)* num_corners);
-	int n;
-
-	int pixel[16];
-	icvMakeOffsets(pixel, stride);
-
-    for(n=0; n < num_corners; n++)
-        scores[n] = icvFast9CornerScore(i + corners[n].y*stride + corners[n].x, pixel, b);
-
-	return scores;
-}
-
-
-CvPoint* icvFast9Detect(const unsigned char* im, int xsize, int ysize, int stride, int b, int* ret_num_corners)
-{
-	int num_corners=0;
-	CvPoint* ret_corners;
-	int rsize=512;
-	int pixel[16];
-	int x, y;
-
-	ret_corners = (CvPoint*)malloc(sizeof(CvPoint)*rsize);
-	icvMakeOffsets(pixel, stride);
-
-	for(y=3; y < ysize - 3; y++)
-		for(x=3; x < xsize - 3; x++)
-		{
-			const unsigned char* p = im + y*stride + x;
-		
-			int cb = *p + b;
-			int c_b= *p - b;
-        if(p[pixel[0]] > cb)
-         if(p[pixel[1]] > cb)
-          if(p[pixel[2]] > cb)
-           if(p[pixel[3]] > cb)
-            if(p[pixel[4]] > cb)
-             if(p[pixel[5]] > cb)
-              if(p[pixel[6]] > cb)
-               if(p[pixel[7]] > cb)
-                if(p[pixel[8]] > cb)
-                 {}
-                else
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  continue;
-               else if(p[pixel[7]] < c_b)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  continue;
-                else if(p[pixel[14]] < c_b)
-                 if(p[pixel[8]] < c_b)
-                  if(p[pixel[9]] < c_b)
-                   if(p[pixel[10]] < c_b)
-                    if(p[pixel[11]] < c_b)
-                     if(p[pixel[12]] < c_b)
-                      if(p[pixel[13]] < c_b)
-                       if(p[pixel[15]] < c_b)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  continue;
-                else
-                 continue;
-              else if(p[pixel[6]] < c_b)
-               if(p[pixel[15]] > cb)
-                if(p[pixel[13]] > cb)
-                 if(p[pixel[14]] > cb)
-                  {}
-                 else
-                  continue;
-                else if(p[pixel[13]] < c_b)
-                 if(p[pixel[7]] < c_b)
-                  if(p[pixel[8]] < c_b)
-                   if(p[pixel[9]] < c_b)
-                    if(p[pixel[10]] < c_b)
-                     if(p[pixel[11]] < c_b)
-                      if(p[pixel[12]] < c_b)
-                       if(p[pixel[14]] < c_b)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                if(p[pixel[7]] < c_b)
-                 if(p[pixel[8]] < c_b)
-                  if(p[pixel[9]] < c_b)
-                   if(p[pixel[10]] < c_b)
-                    if(p[pixel[11]] < c_b)
-                     if(p[pixel[12]] < c_b)
-                      if(p[pixel[13]] < c_b)
-                       if(p[pixel[14]] < c_b)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[13]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  continue;
-                else
-                 continue;
-               else if(p[pixel[13]] < c_b)
-                if(p[pixel[7]] < c_b)
-                 if(p[pixel[8]] < c_b)
-                  if(p[pixel[9]] < c_b)
-                   if(p[pixel[10]] < c_b)
-                    if(p[pixel[11]] < c_b)
-                     if(p[pixel[12]] < c_b)
-                      if(p[pixel[14]] < c_b)
-                       if(p[pixel[15]] < c_b)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else if(p[pixel[5]] < c_b)
-              if(p[pixel[14]] > cb)
-               if(p[pixel[12]] > cb)
-                if(p[pixel[13]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      if(p[pixel[10]] > cb)
-                       if(p[pixel[11]] > cb)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 continue;
-               else if(p[pixel[12]] < c_b)
-                if(p[pixel[6]] < c_b)
-                 if(p[pixel[7]] < c_b)
-                  if(p[pixel[8]] < c_b)
-                   if(p[pixel[9]] < c_b)
-                    if(p[pixel[10]] < c_b)
-                     if(p[pixel[11]] < c_b)
-                      if(p[pixel[13]] < c_b)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else if(p[pixel[14]] < c_b)
-               if(p[pixel[7]] < c_b)
-                if(p[pixel[8]] < c_b)
-                 if(p[pixel[9]] < c_b)
-                  if(p[pixel[10]] < c_b)
-                   if(p[pixel[11]] < c_b)
-                    if(p[pixel[12]] < c_b)
-                     if(p[pixel[13]] < c_b)
-                      if(p[pixel[6]] < c_b)
-                       {}
-                      else
-                       if(p[pixel[15]] < c_b)
-                        {}
-                       else
-                        continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               if(p[pixel[6]] < c_b)
-                if(p[pixel[7]] < c_b)
-                 if(p[pixel[8]] < c_b)
-                  if(p[pixel[9]] < c_b)
-                   if(p[pixel[10]] < c_b)
-                    if(p[pixel[11]] < c_b)
-                     if(p[pixel[12]] < c_b)
-                      if(p[pixel[13]] < c_b)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              if(p[pixel[12]] > cb)
-               if(p[pixel[13]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      if(p[pixel[10]] > cb)
-                       if(p[pixel[11]] > cb)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 continue;
-               else
-                continue;
-              else if(p[pixel[12]] < c_b)
-               if(p[pixel[7]] < c_b)
-                if(p[pixel[8]] < c_b)
-                 if(p[pixel[9]] < c_b)
-                  if(p[pixel[10]] < c_b)
-                   if(p[pixel[11]] < c_b)
-                    if(p[pixel[13]] < c_b)
-                     if(p[pixel[14]] < c_b)
-                      if(p[pixel[6]] < c_b)
-                       {}
-                      else
-                       if(p[pixel[15]] < c_b)
-                        {}
-                       else
-                        continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else if(p[pixel[4]] < c_b)
-             if(p[pixel[13]] > cb)
-              if(p[pixel[11]] > cb)
-               if(p[pixel[12]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      if(p[pixel[10]] > cb)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      if(p[pixel[10]] > cb)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                continue;
-              else if(p[pixel[11]] < c_b)
-               if(p[pixel[5]] < c_b)
-                if(p[pixel[6]] < c_b)
-                 if(p[pixel[7]] < c_b)
-                  if(p[pixel[8]] < c_b)
-                   if(p[pixel[9]] < c_b)
-                    if(p[pixel[10]] < c_b)
-                     if(p[pixel[12]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else if(p[pixel[13]] < c_b)
-              if(p[pixel[7]] < c_b)
-               if(p[pixel[8]] < c_b)
-                if(p[pixel[9]] < c_b)
-                 if(p[pixel[10]] < c_b)
-                  if(p[pixel[11]] < c_b)
-                   if(p[pixel[12]] < c_b)
-                    if(p[pixel[6]] < c_b)
-                     if(p[pixel[5]] < c_b)
-                      {}
-                     else
-                      if(p[pixel[14]] < c_b)
-                       {}
-                      else
-                       continue;
-                    else
-                     if(p[pixel[14]] < c_b)
-                      if(p[pixel[15]] < c_b)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              if(p[pixel[5]] < c_b)
-               if(p[pixel[6]] < c_b)
-                if(p[pixel[7]] < c_b)
-                 if(p[pixel[8]] < c_b)
-                  if(p[pixel[9]] < c_b)
-                   if(p[pixel[10]] < c_b)
-                    if(p[pixel[11]] < c_b)
-                     if(p[pixel[12]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else
-             if(p[pixel[11]] > cb)
-              if(p[pixel[12]] > cb)
-               if(p[pixel[13]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      if(p[pixel[10]] > cb)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      if(p[pixel[10]] > cb)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                continue;
-              else
-               continue;
-             else if(p[pixel[11]] < c_b)
-              if(p[pixel[7]] < c_b)
-               if(p[pixel[8]] < c_b)
-                if(p[pixel[9]] < c_b)
-                 if(p[pixel[10]] < c_b)
-                  if(p[pixel[12]] < c_b)
-                   if(p[pixel[13]] < c_b)
-                    if(p[pixel[6]] < c_b)
-                     if(p[pixel[5]] < c_b)
-                      {}
-                     else
-                      if(p[pixel[14]] < c_b)
-                       {}
-                      else
-                       continue;
-                    else
-                     if(p[pixel[14]] < c_b)
-                      if(p[pixel[15]] < c_b)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              continue;
-           else if(p[pixel[3]] < c_b)
-            if(p[pixel[10]] > cb)
-             if(p[pixel[11]] > cb)
-              if(p[pixel[12]] > cb)
-               if(p[pixel[13]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               continue;
-             else
-              continue;
-            else if(p[pixel[10]] < c_b)
-             if(p[pixel[7]] < c_b)
-              if(p[pixel[8]] < c_b)
-               if(p[pixel[9]] < c_b)
-                if(p[pixel[11]] < c_b)
-                 if(p[pixel[6]] < c_b)
-                  if(p[pixel[5]] < c_b)
-                   if(p[pixel[4]] < c_b)
-                    {}
-                   else
-                    if(p[pixel[12]] < c_b)
-                     if(p[pixel[13]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                  else
-                   if(p[pixel[12]] < c_b)
-                    if(p[pixel[13]] < c_b)
-                     if(p[pixel[14]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                 else
-                  if(p[pixel[12]] < c_b)
-                   if(p[pixel[13]] < c_b)
-                    if(p[pixel[14]] < c_b)
-                     if(p[pixel[15]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              continue;
-            else
-             continue;
-           else
-            if(p[pixel[10]] > cb)
-             if(p[pixel[11]] > cb)
-              if(p[pixel[12]] > cb)
-               if(p[pixel[13]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     if(p[pixel[9]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               continue;
-             else
-              continue;
-            else if(p[pixel[10]] < c_b)
-             if(p[pixel[7]] < c_b)
-              if(p[pixel[8]] < c_b)
-               if(p[pixel[9]] < c_b)
-                if(p[pixel[11]] < c_b)
-                 if(p[pixel[12]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[5]] < c_b)
-                    if(p[pixel[4]] < c_b)
-                     {}
-                    else
-                     if(p[pixel[13]] < c_b)
-                      {}
-                     else
-                      continue;
-                   else
-                    if(p[pixel[13]] < c_b)
-                     if(p[pixel[14]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                  else
-                   if(p[pixel[13]] < c_b)
-                    if(p[pixel[14]] < c_b)
-                     if(p[pixel[15]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              continue;
-            else
-             continue;
-          else if(p[pixel[2]] < c_b)
-           if(p[pixel[9]] > cb)
-            if(p[pixel[10]] > cb)
-             if(p[pixel[11]] > cb)
-              if(p[pixel[12]] > cb)
-               if(p[pixel[13]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[3]] > cb)
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              continue;
-            else
-             continue;
-           else if(p[pixel[9]] < c_b)
-            if(p[pixel[7]] < c_b)
-             if(p[pixel[8]] < c_b)
-              if(p[pixel[10]] < c_b)
-               if(p[pixel[6]] < c_b)
-                if(p[pixel[5]] < c_b)
-                 if(p[pixel[4]] < c_b)
-                  if(p[pixel[3]] < c_b)
-                   {}
-                  else
-                   if(p[pixel[11]] < c_b)
-                    if(p[pixel[12]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                 else
-                  if(p[pixel[11]] < c_b)
-                   if(p[pixel[12]] < c_b)
-                    if(p[pixel[13]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[11]] < c_b)
-                  if(p[pixel[12]] < c_b)
-                   if(p[pixel[13]] < c_b)
-                    if(p[pixel[14]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[11]] < c_b)
-                 if(p[pixel[12]] < c_b)
-                  if(p[pixel[13]] < c_b)
-                   if(p[pixel[14]] < c_b)
-                    if(p[pixel[15]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               continue;
-             else
-              continue;
-            else
-             continue;
-           else
-            continue;
-          else
-           if(p[pixel[9]] > cb)
-            if(p[pixel[10]] > cb)
-             if(p[pixel[11]] > cb)
-              if(p[pixel[12]] > cb)
-               if(p[pixel[13]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[3]] > cb)
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    if(p[pixel[8]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              continue;
-            else
-             continue;
-           else if(p[pixel[9]] < c_b)
-            if(p[pixel[7]] < c_b)
-             if(p[pixel[8]] < c_b)
-              if(p[pixel[10]] < c_b)
-               if(p[pixel[11]] < c_b)
-                if(p[pixel[6]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[4]] < c_b)
-                   if(p[pixel[3]] < c_b)
-                    {}
-                   else
-                    if(p[pixel[12]] < c_b)
-                     {}
-                    else
-                     continue;
-                  else
-                   if(p[pixel[12]] < c_b)
-                    if(p[pixel[13]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                 else
-                  if(p[pixel[12]] < c_b)
-                   if(p[pixel[13]] < c_b)
-                    if(p[pixel[14]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[12]] < c_b)
-                  if(p[pixel[13]] < c_b)
-                   if(p[pixel[14]] < c_b)
-                    if(p[pixel[15]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              continue;
-            else
-             continue;
-           else
-            continue;
-         else if(p[pixel[1]] < c_b)
-          if(p[pixel[8]] > cb)
-           if(p[pixel[9]] > cb)
-            if(p[pixel[10]] > cb)
-             if(p[pixel[11]] > cb)
-              if(p[pixel[12]] > cb)
-               if(p[pixel[13]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[3]] > cb)
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              if(p[pixel[2]] > cb)
-               if(p[pixel[3]] > cb)
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else
-             continue;
-           else
-            continue;
-          else if(p[pixel[8]] < c_b)
-           if(p[pixel[7]] < c_b)
-            if(p[pixel[9]] < c_b)
-             if(p[pixel[6]] < c_b)
-              if(p[pixel[5]] < c_b)
-               if(p[pixel[4]] < c_b)
-                if(p[pixel[3]] < c_b)
-                 if(p[pixel[2]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[10]] < c_b)
-                   if(p[pixel[11]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[10]] < c_b)
-                  if(p[pixel[11]] < c_b)
-                   if(p[pixel[12]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[10]] < c_b)
-                 if(p[pixel[11]] < c_b)
-                  if(p[pixel[12]] < c_b)
-                   if(p[pixel[13]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[10]] < c_b)
-                if(p[pixel[11]] < c_b)
-                 if(p[pixel[12]] < c_b)
-                  if(p[pixel[13]] < c_b)
-                   if(p[pixel[14]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              if(p[pixel[10]] < c_b)
-               if(p[pixel[11]] < c_b)
-                if(p[pixel[12]] < c_b)
-                 if(p[pixel[13]] < c_b)
-                  if(p[pixel[14]] < c_b)
-                   if(p[pixel[15]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else
-             continue;
-           else
-            continue;
-          else
-           continue;
-         else
-          if(p[pixel[8]] > cb)
-           if(p[pixel[9]] > cb)
-            if(p[pixel[10]] > cb)
-             if(p[pixel[11]] > cb)
-              if(p[pixel[12]] > cb)
-               if(p[pixel[13]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[15]] > cb)
-                  {}
-                 else
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[3]] > cb)
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              if(p[pixel[2]] > cb)
-               if(p[pixel[3]] > cb)
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[7]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else
-             continue;
-           else
-            continue;
-          else if(p[pixel[8]] < c_b)
-           if(p[pixel[7]] < c_b)
-            if(p[pixel[9]] < c_b)
-             if(p[pixel[10]] < c_b)
-              if(p[pixel[6]] < c_b)
-               if(p[pixel[5]] < c_b)
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[3]] < c_b)
-                  if(p[pixel[2]] < c_b)
-                   {}
-                  else
-                   if(p[pixel[11]] < c_b)
-                    {}
-                   else
-                    continue;
-                 else
-                  if(p[pixel[11]] < c_b)
-                   if(p[pixel[12]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[11]] < c_b)
-                  if(p[pixel[12]] < c_b)
-                   if(p[pixel[13]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[11]] < c_b)
-                 if(p[pixel[12]] < c_b)
-                  if(p[pixel[13]] < c_b)
-                   if(p[pixel[14]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[11]] < c_b)
-                if(p[pixel[12]] < c_b)
-                 if(p[pixel[13]] < c_b)
-                  if(p[pixel[14]] < c_b)
-                   if(p[pixel[15]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              continue;
-            else
-             continue;
-           else
-            continue;
-          else
-           continue;
-        else if(p[pixel[0]] < c_b)
-         if(p[pixel[1]] > cb)
-          if(p[pixel[8]] > cb)
-           if(p[pixel[7]] > cb)
-            if(p[pixel[9]] > cb)
-             if(p[pixel[6]] > cb)
-              if(p[pixel[5]] > cb)
-               if(p[pixel[4]] > cb)
-                if(p[pixel[3]] > cb)
-                 if(p[pixel[2]] > cb)
-                  {}
-                 else
-                  if(p[pixel[10]] > cb)
-                   if(p[pixel[11]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[10]] > cb)
-                  if(p[pixel[11]] > cb)
-                   if(p[pixel[12]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[10]] > cb)
-                 if(p[pixel[11]] > cb)
-                  if(p[pixel[12]] > cb)
-                   if(p[pixel[13]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[10]] > cb)
-                if(p[pixel[11]] > cb)
-                 if(p[pixel[12]] > cb)
-                  if(p[pixel[13]] > cb)
-                   if(p[pixel[14]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              if(p[pixel[10]] > cb)
-               if(p[pixel[11]] > cb)
-                if(p[pixel[12]] > cb)
-                 if(p[pixel[13]] > cb)
-                  if(p[pixel[14]] > cb)
-                   if(p[pixel[15]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else
-             continue;
-           else
-            continue;
-          else if(p[pixel[8]] < c_b)
-           if(p[pixel[9]] < c_b)
-            if(p[pixel[10]] < c_b)
-             if(p[pixel[11]] < c_b)
-              if(p[pixel[12]] < c_b)
-               if(p[pixel[13]] < c_b)
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[3]] < c_b)
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              if(p[pixel[2]] < c_b)
-               if(p[pixel[3]] < c_b)
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else
-             continue;
-           else
-            continue;
-          else
-           continue;
-         else if(p[pixel[1]] < c_b)
-          if(p[pixel[2]] > cb)
-           if(p[pixel[9]] > cb)
-            if(p[pixel[7]] > cb)
-             if(p[pixel[8]] > cb)
-              if(p[pixel[10]] > cb)
-               if(p[pixel[6]] > cb)
-                if(p[pixel[5]] > cb)
-                 if(p[pixel[4]] > cb)
-                  if(p[pixel[3]] > cb)
-                   {}
-                  else
-                   if(p[pixel[11]] > cb)
-                    if(p[pixel[12]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                 else
-                  if(p[pixel[11]] > cb)
-                   if(p[pixel[12]] > cb)
-                    if(p[pixel[13]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[11]] > cb)
-                  if(p[pixel[12]] > cb)
-                   if(p[pixel[13]] > cb)
-                    if(p[pixel[14]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[11]] > cb)
-                 if(p[pixel[12]] > cb)
-                  if(p[pixel[13]] > cb)
-                   if(p[pixel[14]] > cb)
-                    if(p[pixel[15]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               continue;
-             else
-              continue;
-            else
-             continue;
-           else if(p[pixel[9]] < c_b)
-            if(p[pixel[10]] < c_b)
-             if(p[pixel[11]] < c_b)
-              if(p[pixel[12]] < c_b)
-               if(p[pixel[13]] < c_b)
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[3]] < c_b)
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              continue;
-            else
-             continue;
-           else
-            continue;
-          else if(p[pixel[2]] < c_b)
-           if(p[pixel[3]] > cb)
-            if(p[pixel[10]] > cb)
-             if(p[pixel[7]] > cb)
-              if(p[pixel[8]] > cb)
-               if(p[pixel[9]] > cb)
-                if(p[pixel[11]] > cb)
-                 if(p[pixel[6]] > cb)
-                  if(p[pixel[5]] > cb)
-                   if(p[pixel[4]] > cb)
-                    {}
-                   else
-                    if(p[pixel[12]] > cb)
-                     if(p[pixel[13]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                  else
-                   if(p[pixel[12]] > cb)
-                    if(p[pixel[13]] > cb)
-                     if(p[pixel[14]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                 else
-                  if(p[pixel[12]] > cb)
-                   if(p[pixel[13]] > cb)
-                    if(p[pixel[14]] > cb)
-                     if(p[pixel[15]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              continue;
-            else if(p[pixel[10]] < c_b)
-             if(p[pixel[11]] < c_b)
-              if(p[pixel[12]] < c_b)
-               if(p[pixel[13]] < c_b)
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               continue;
-             else
-              continue;
-            else
-             continue;
-           else if(p[pixel[3]] < c_b)
-            if(p[pixel[4]] > cb)
-             if(p[pixel[13]] > cb)
-              if(p[pixel[7]] > cb)
-               if(p[pixel[8]] > cb)
-                if(p[pixel[9]] > cb)
-                 if(p[pixel[10]] > cb)
-                  if(p[pixel[11]] > cb)
-                   if(p[pixel[12]] > cb)
-                    if(p[pixel[6]] > cb)
-                     if(p[pixel[5]] > cb)
-                      {}
-                     else
-                      if(p[pixel[14]] > cb)
-                       {}
-                      else
-                       continue;
-                    else
-                     if(p[pixel[14]] > cb)
-                      if(p[pixel[15]] > cb)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else if(p[pixel[13]] < c_b)
-              if(p[pixel[11]] > cb)
-               if(p[pixel[5]] > cb)
-                if(p[pixel[6]] > cb)
-                 if(p[pixel[7]] > cb)
-                  if(p[pixel[8]] > cb)
-                   if(p[pixel[9]] > cb)
-                    if(p[pixel[10]] > cb)
-                     if(p[pixel[12]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else if(p[pixel[11]] < c_b)
-               if(p[pixel[12]] < c_b)
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      if(p[pixel[10]] < c_b)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      if(p[pixel[10]] < c_b)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              if(p[pixel[5]] > cb)
-               if(p[pixel[6]] > cb)
-                if(p[pixel[7]] > cb)
-                 if(p[pixel[8]] > cb)
-                  if(p[pixel[9]] > cb)
-                   if(p[pixel[10]] > cb)
-                    if(p[pixel[11]] > cb)
-                     if(p[pixel[12]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else if(p[pixel[4]] < c_b)
-             if(p[pixel[5]] > cb)
-              if(p[pixel[14]] > cb)
-               if(p[pixel[7]] > cb)
-                if(p[pixel[8]] > cb)
-                 if(p[pixel[9]] > cb)
-                  if(p[pixel[10]] > cb)
-                   if(p[pixel[11]] > cb)
-                    if(p[pixel[12]] > cb)
-                     if(p[pixel[13]] > cb)
-                      if(p[pixel[6]] > cb)
-                       {}
-                      else
-                       if(p[pixel[15]] > cb)
-                        {}
-                       else
-                        continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else if(p[pixel[14]] < c_b)
-               if(p[pixel[12]] > cb)
-                if(p[pixel[6]] > cb)
-                 if(p[pixel[7]] > cb)
-                  if(p[pixel[8]] > cb)
-                   if(p[pixel[9]] > cb)
-                    if(p[pixel[10]] > cb)
-                     if(p[pixel[11]] > cb)
-                      if(p[pixel[13]] > cb)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else if(p[pixel[12]] < c_b)
-                if(p[pixel[13]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      if(p[pixel[10]] < c_b)
-                       if(p[pixel[11]] < c_b)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               if(p[pixel[6]] > cb)
-                if(p[pixel[7]] > cb)
-                 if(p[pixel[8]] > cb)
-                  if(p[pixel[9]] > cb)
-                   if(p[pixel[10]] > cb)
-                    if(p[pixel[11]] > cb)
-                     if(p[pixel[12]] > cb)
-                      if(p[pixel[13]] > cb)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else if(p[pixel[5]] < c_b)
-              if(p[pixel[6]] > cb)
-               if(p[pixel[15]] < c_b)
-                if(p[pixel[13]] > cb)
-                 if(p[pixel[7]] > cb)
-                  if(p[pixel[8]] > cb)
-                   if(p[pixel[9]] > cb)
-                    if(p[pixel[10]] > cb)
-                     if(p[pixel[11]] > cb)
-                      if(p[pixel[12]] > cb)
-                       if(p[pixel[14]] > cb)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else if(p[pixel[13]] < c_b)
-                 if(p[pixel[14]] < c_b)
-                  {}
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                if(p[pixel[7]] > cb)
-                 if(p[pixel[8]] > cb)
-                  if(p[pixel[9]] > cb)
-                   if(p[pixel[10]] > cb)
-                    if(p[pixel[11]] > cb)
-                     if(p[pixel[12]] > cb)
-                      if(p[pixel[13]] > cb)
-                       if(p[pixel[14]] > cb)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else if(p[pixel[6]] < c_b)
-               if(p[pixel[7]] > cb)
-                if(p[pixel[14]] > cb)
-                 if(p[pixel[8]] > cb)
-                  if(p[pixel[9]] > cb)
-                   if(p[pixel[10]] > cb)
-                    if(p[pixel[11]] > cb)
-                     if(p[pixel[12]] > cb)
-                      if(p[pixel[13]] > cb)
-                       if(p[pixel[15]] > cb)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  continue;
-                else
-                 continue;
-               else if(p[pixel[7]] < c_b)
-                if(p[pixel[8]] < c_b)
-                 {}
-                else
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  continue;
-               else
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[13]] > cb)
-                if(p[pixel[7]] > cb)
-                 if(p[pixel[8]] > cb)
-                  if(p[pixel[9]] > cb)
-                   if(p[pixel[10]] > cb)
-                    if(p[pixel[11]] > cb)
-                     if(p[pixel[12]] > cb)
-                      if(p[pixel[14]] > cb)
-                       if(p[pixel[15]] > cb)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else if(p[pixel[13]] < c_b)
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              if(p[pixel[12]] > cb)
-               if(p[pixel[7]] > cb)
-                if(p[pixel[8]] > cb)
-                 if(p[pixel[9]] > cb)
-                  if(p[pixel[10]] > cb)
-                   if(p[pixel[11]] > cb)
-                    if(p[pixel[13]] > cb)
-                     if(p[pixel[14]] > cb)
-                      if(p[pixel[6]] > cb)
-                       {}
-                      else
-                       if(p[pixel[15]] > cb)
-                        {}
-                       else
-                        continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else if(p[pixel[12]] < c_b)
-               if(p[pixel[13]] < c_b)
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      if(p[pixel[10]] < c_b)
-                       if(p[pixel[11]] < c_b)
-                        {}
-                       else
-                        continue;
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else
-             if(p[pixel[11]] > cb)
-              if(p[pixel[7]] > cb)
-               if(p[pixel[8]] > cb)
-                if(p[pixel[9]] > cb)
-                 if(p[pixel[10]] > cb)
-                  if(p[pixel[12]] > cb)
-                   if(p[pixel[13]] > cb)
-                    if(p[pixel[6]] > cb)
-                     if(p[pixel[5]] > cb)
-                      {}
-                     else
-                      if(p[pixel[14]] > cb)
-                       {}
-                      else
-                       continue;
-                    else
-                     if(p[pixel[14]] > cb)
-                      if(p[pixel[15]] > cb)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else if(p[pixel[11]] < c_b)
-              if(p[pixel[12]] < c_b)
-               if(p[pixel[13]] < c_b)
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      if(p[pixel[10]] < c_b)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      if(p[pixel[10]] < c_b)
-                       {}
-                      else
-                       continue;
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              continue;
-           else
-            if(p[pixel[10]] > cb)
-             if(p[pixel[7]] > cb)
-              if(p[pixel[8]] > cb)
-               if(p[pixel[9]] > cb)
-                if(p[pixel[11]] > cb)
-                 if(p[pixel[12]] > cb)
-                  if(p[pixel[6]] > cb)
-                   if(p[pixel[5]] > cb)
-                    if(p[pixel[4]] > cb)
-                     {}
-                    else
-                     if(p[pixel[13]] > cb)
-                      {}
-                     else
-                      continue;
-                   else
-                    if(p[pixel[13]] > cb)
-                     if(p[pixel[14]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                  else
-                   if(p[pixel[13]] > cb)
-                    if(p[pixel[14]] > cb)
-                     if(p[pixel[15]] > cb)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              continue;
-            else if(p[pixel[10]] < c_b)
-             if(p[pixel[11]] < c_b)
-              if(p[pixel[12]] < c_b)
-               if(p[pixel[13]] < c_b)
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     if(p[pixel[9]] < c_b)
-                      {}
-                     else
-                      continue;
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               continue;
-             else
-              continue;
-            else
-             continue;
-          else
-           if(p[pixel[9]] > cb)
-            if(p[pixel[7]] > cb)
-             if(p[pixel[8]] > cb)
-              if(p[pixel[10]] > cb)
-               if(p[pixel[11]] > cb)
-                if(p[pixel[6]] > cb)
-                 if(p[pixel[5]] > cb)
-                  if(p[pixel[4]] > cb)
-                   if(p[pixel[3]] > cb)
-                    {}
-                   else
-                    if(p[pixel[12]] > cb)
-                     {}
-                    else
-                     continue;
-                  else
-                   if(p[pixel[12]] > cb)
-                    if(p[pixel[13]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                 else
-                  if(p[pixel[12]] > cb)
-                   if(p[pixel[13]] > cb)
-                    if(p[pixel[14]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[12]] > cb)
-                  if(p[pixel[13]] > cb)
-                   if(p[pixel[14]] > cb)
-                    if(p[pixel[15]] > cb)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              continue;
-            else
-             continue;
-           else if(p[pixel[9]] < c_b)
-            if(p[pixel[10]] < c_b)
-             if(p[pixel[11]] < c_b)
-              if(p[pixel[12]] < c_b)
-               if(p[pixel[13]] < c_b)
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[3]] < c_b)
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    if(p[pixel[8]] < c_b)
-                     {}
-                    else
-                     continue;
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              continue;
-            else
-             continue;
-           else
-            continue;
-         else
-          if(p[pixel[8]] > cb)
-           if(p[pixel[7]] > cb)
-            if(p[pixel[9]] > cb)
-             if(p[pixel[10]] > cb)
-              if(p[pixel[6]] > cb)
-               if(p[pixel[5]] > cb)
-                if(p[pixel[4]] > cb)
-                 if(p[pixel[3]] > cb)
-                  if(p[pixel[2]] > cb)
-                   {}
-                  else
-                   if(p[pixel[11]] > cb)
-                    {}
-                   else
-                    continue;
-                 else
-                  if(p[pixel[11]] > cb)
-                   if(p[pixel[12]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[11]] > cb)
-                  if(p[pixel[12]] > cb)
-                   if(p[pixel[13]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[11]] > cb)
-                 if(p[pixel[12]] > cb)
-                  if(p[pixel[13]] > cb)
-                   if(p[pixel[14]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[11]] > cb)
-                if(p[pixel[12]] > cb)
-                 if(p[pixel[13]] > cb)
-                  if(p[pixel[14]] > cb)
-                   if(p[pixel[15]] > cb)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              continue;
-            else
-             continue;
-           else
-            continue;
-          else if(p[pixel[8]] < c_b)
-           if(p[pixel[9]] < c_b)
-            if(p[pixel[10]] < c_b)
-             if(p[pixel[11]] < c_b)
-              if(p[pixel[12]] < c_b)
-               if(p[pixel[13]] < c_b)
-                if(p[pixel[14]] < c_b)
-                 if(p[pixel[15]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                else
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[3]] < c_b)
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              if(p[pixel[2]] < c_b)
-               if(p[pixel[3]] < c_b)
-                if(p[pixel[4]] < c_b)
-                 if(p[pixel[5]] < c_b)
-                  if(p[pixel[6]] < c_b)
-                   if(p[pixel[7]] < c_b)
-                    {}
-                   else
-                    continue;
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else
-             continue;
-           else
-            continue;
-          else
-           continue;
-        else
-         if(p[pixel[7]] > cb)
-          if(p[pixel[8]] > cb)
-           if(p[pixel[9]] > cb)
-            if(p[pixel[6]] > cb)
-             if(p[pixel[5]] > cb)
-              if(p[pixel[4]] > cb)
-               if(p[pixel[3]] > cb)
-                if(p[pixel[2]] > cb)
-                 if(p[pixel[1]] > cb)
-                  {}
-                 else
-                  if(p[pixel[10]] > cb)
-                   {}
-                  else
-                   continue;
-                else
-                 if(p[pixel[10]] > cb)
-                  if(p[pixel[11]] > cb)
-                   {}
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[10]] > cb)
-                 if(p[pixel[11]] > cb)
-                  if(p[pixel[12]] > cb)
-                   {}
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[10]] > cb)
-                if(p[pixel[11]] > cb)
-                 if(p[pixel[12]] > cb)
-                  if(p[pixel[13]] > cb)
-                   {}
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              if(p[pixel[10]] > cb)
-               if(p[pixel[11]] > cb)
-                if(p[pixel[12]] > cb)
-                 if(p[pixel[13]] > cb)
-                  if(p[pixel[14]] > cb)
-                   {}
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else
-             if(p[pixel[10]] > cb)
-              if(p[pixel[11]] > cb)
-               if(p[pixel[12]] > cb)
-                if(p[pixel[13]] > cb)
-                 if(p[pixel[14]] > cb)
-                  if(p[pixel[15]] > cb)
-                   {}
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              continue;
-           else
-            continue;
-          else
-           continue;
-         else if(p[pixel[7]] < c_b)
-          if(p[pixel[8]] < c_b)
-           if(p[pixel[9]] < c_b)
-            if(p[pixel[6]] < c_b)
-             if(p[pixel[5]] < c_b)
-              if(p[pixel[4]] < c_b)
-               if(p[pixel[3]] < c_b)
-                if(p[pixel[2]] < c_b)
-                 if(p[pixel[1]] < c_b)
-                  {}
-                 else
-                  if(p[pixel[10]] < c_b)
-                   {}
-                  else
-                   continue;
-                else
-                 if(p[pixel[10]] < c_b)
-                  if(p[pixel[11]] < c_b)
-                   {}
-                  else
-                   continue;
-                 else
-                  continue;
-               else
-                if(p[pixel[10]] < c_b)
-                 if(p[pixel[11]] < c_b)
-                  if(p[pixel[12]] < c_b)
-                   {}
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-              else
-               if(p[pixel[10]] < c_b)
-                if(p[pixel[11]] < c_b)
-                 if(p[pixel[12]] < c_b)
-                  if(p[pixel[13]] < c_b)
-                   {}
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-             else
-              if(p[pixel[10]] < c_b)
-               if(p[pixel[11]] < c_b)
-                if(p[pixel[12]] < c_b)
-                 if(p[pixel[13]] < c_b)
-                  if(p[pixel[14]] < c_b)
-                   {}
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-            else
-             if(p[pixel[10]] < c_b)
-              if(p[pixel[11]] < c_b)
-               if(p[pixel[12]] < c_b)
-                if(p[pixel[13]] < c_b)
-                 if(p[pixel[14]] < c_b)
-                  if(p[pixel[15]] < c_b)
-                   {}
-                  else
-                   continue;
-                 else
-                  continue;
-                else
-                 continue;
-               else
-                continue;
-              else
-               continue;
-             else
-              continue;
-           else
-            continue;
-          else
-           continue;
-         else
-          continue;
-			if(num_corners == rsize)
-			{
-				rsize*=2;
-				ret_corners = (CvPoint*)realloc(ret_corners, sizeof(CvPoint)*rsize);
-			}
-			ret_corners[num_corners].x = x;
-			ret_corners[num_corners].y = y;
-			num_corners++;
-		}
-	
-	*ret_num_corners = num_corners;
-	return ret_corners;
-
-}
-

Deleted: trunk/src/stable/libs/visionlib/cvfast.h
===================================================================
--- trunk/src/stable/libs/visionlib/cvfast.h	2013-10-09 14:02:09 UTC (rev 1025)
+++ trunk/src/stable/libs/visionlib/cvfast.h	2013-10-09 14:41:27 UTC (rev 1026)
@@ -1,12 +0,0 @@
-#ifndef CVFAST_H
-#define CVFAST_H
-
-#include <opencv/cvaux.h>
-#include <opencv2/core/core.hpp>
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <stdlib.h>
-
-CVAPI(void)  cvCornerFast(cv::Mat &src, int threshold, int N,	int nonmax_suppression, int* ret_number_of_corners,	CvPoint** ret_corners, int ** scores);
-
-#endif

Modified: trunk/src/stable/libs/visionlib/image.h
===================================================================
--- trunk/src/stable/libs/visionlib/image.h	2013-10-09 14:02:09 UTC (rev 1025)
+++ trunk/src/stable/libs/visionlib/image.h	2013-10-09 14:41:27 UTC (rev 1026)
@@ -29,7 +29,7 @@
 #include <opencv/cv.h>
 #include <opencv/highgui.h>
 #include "structs.h"
-#include "cvfast.h"
+#include <visionlib/cvFast/cvfast.h>
 #include "geometry.h"
 
 #ifndef I_SQUARE

Modified: trunk/src/stable/libs/visionlib/linesDetection.h
===================================================================
--- trunk/src/stable/libs/visionlib/linesDetection.h	2013-10-09 14:02:09 UTC (rev 1025)
+++ trunk/src/stable/libs/visionlib/linesDetection.h	2013-10-09 14:41:27 UTC (rev 1026)
@@ -28,11 +28,8 @@
 #include <opencv/highgui.h>
 #include <stdio.h>
 #include <visionlib/colorspaces/colorspacesmm.h>
-#include "geometry.h"
-#include "cvfast.h"
-#include "structs.h"
-#include "image.h"
 #include <sys/time.h>
+#include "image.h"
 
 using namespace visionLibrary;
 using namespace std;

Modified: trunk/src/stable/libs/visionlib/visionlib.h
===================================================================
--- trunk/src/stable/libs/visionlib/visionlib.h	2013-10-09 14:02:09 UTC (rev 1025)
+++ trunk/src/stable/libs/visionlib/visionlib.h	2013-10-09 14:41:27 UTC (rev 1026)
@@ -6,5 +6,6 @@
 #include <image.h>
 #include <structs.h>
 #include <progeo/progeo.h>
+#include <visionlib/cvFast/cvfast.h>
 
 #endif



More information about the Jderobot-admin mailing list