Go to the documentation of this file.00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 
00025 
00026 
00027 
00028 #include <stdint.h>                                                                                                                                                     
00029 #include <stdlib.h>
00030 #include "cvWrapper.h"
00031 #include "agast7_12d.h"
00032 
00033 using namespace std;
00034 using namespace agast;
00035 
00036 void AgastDetector7_12d::detect(const unsigned char* im, vector<CvPoint>& corners_all)
00037 {
00038         int total=0;
00039         int nExpectedCorners=corners_all.capacity();
00040         CvPoint h;
00041         register int x, y;
00042         register int xsizeB=xsize - 4;
00043         register int ysizeB=ysize - 3;
00044         register int_fast16_t offset0, offset1, offset2, offset3, offset4, offset5, offset6, offset7, offset8, offset9, offset10, offset11;
00045         register int width;
00046 
00047         corners_all.resize(0);
00048 
00049         offset0=s_offset0;
00050         offset1=s_offset1;
00051         offset2=s_offset2;
00052         offset3=s_offset3;
00053         offset4=s_offset4;
00054         offset5=s_offset5;
00055         offset6=s_offset6;
00056         offset7=s_offset7;
00057         offset8=s_offset8;
00058         offset9=s_offset9;
00059         offset10=s_offset10;
00060         offset11=s_offset11;
00061         width=xsize;
00062 
00063         for(y=3; y < ysizeB; y++)
00064         {                                                                               
00065                 x=2;
00066                 while(1)                                                        
00067                 {                                                                       
00068 homogeneous:
00069 {
00070                         x++;                    
00071                         if(x>xsizeB)    
00072                                 break;          
00073                         else
00074                         {
00075                                 register const unsigned char* const p = im + y*width + x;
00076                                 register const int cb = *p + b;
00077                                 register const int c_b = *p - b;
00078                                 if(p[offset0] > cb)
00079                                   if(p[offset5] > cb)
00080                                         if(p[offset2] > cb)
00081                                           if(p[offset9] > cb)
00082                                                 if(p[offset1] > cb)
00083                                                   if(p[offset6] > cb)
00084                                                         if(p[offset3] > cb)
00085                                                           if(p[offset4] > cb)
00086                                                                 goto success_homogeneous;
00087                                                           else
00088                                                                 if(p[offset10] > cb)
00089                                                                   if(p[offset11] > cb)
00090                                                                         goto success_structured;
00091                                                                   else
00092                                                                         goto homogeneous;
00093                                                                 else
00094                                                                   goto homogeneous;
00095                                                         else
00096                                                           if(p[offset8] > cb)
00097                                                                 if(p[offset10] > cb)
00098                                                                   if(p[offset11] > cb)
00099                                                                         goto success_structured;
00100                                                                   else
00101                                                                         if(p[offset4] > cb)
00102                                                                           if(p[offset7] > cb)
00103                                                                                 goto success_structured;
00104                                                                           else
00105                                                                                 goto structured;
00106                                                                         else
00107                                                                           goto homogeneous;
00108                                                                 else
00109                                                                   goto homogeneous;
00110                                                           else
00111                                                                 goto homogeneous;
00112                                                   else
00113                                                         if(p[offset11] > cb)
00114                                                           if(p[offset3] > cb)
00115                                                                 if(p[offset4] > cb)
00116                                                                   goto success_homogeneous;
00117                                                                 else
00118                                                                   if(p[offset10] > cb)
00119                                                                         goto success_homogeneous;
00120                                                                   else
00121                                                                         goto homogeneous;
00122                                                           else
00123                                                                 if(p[offset8] > cb)
00124                                                                   if(p[offset10] > cb)
00125                                                                         goto success_homogeneous;
00126                                                                   else
00127                                                                         goto homogeneous;
00128                                                                 else
00129                                                                   goto homogeneous;
00130                                                         else
00131                                                           goto homogeneous;
00132                                                 else
00133                                                   if(p[offset6] > cb)
00134                                                         if(p[offset7] > cb)
00135                                                           if(p[offset8] > cb)
00136                                                                 if(p[offset4] > cb)
00137                                                                   if(p[offset3] > cb)
00138                                                                         goto success_structured;
00139                                                                   else
00140                                                                         if(p[offset10] > cb)
00141                                                                           goto success_structured;
00142                                                                         else
00143                                                                           goto homogeneous;
00144                                                                 else
00145                                                                   if(p[offset10] > cb)
00146                                                                         if(p[offset11] > cb)
00147                                                                           goto success_structured;
00148                                                                         else
00149                                                                           goto homogeneous;
00150                                                                   else
00151                                                                         goto homogeneous;
00152                                                           else
00153                                                                 goto homogeneous;
00154                                                         else
00155                                                           goto homogeneous;
00156                                                   else
00157                                                         goto homogeneous;
00158                                           else
00159                                                 if(p[offset3] > cb)
00160                                                   if(p[offset4] > cb)
00161                                                         if(p[offset1] > cb)
00162                                                           if(p[offset6] > cb)
00163                                                                 goto success_homogeneous;
00164                                                           else
00165                                                                 if(p[offset11] > cb)
00166                                                                   goto success_homogeneous;
00167                                                                 else
00168                                                                   goto homogeneous;
00169                                                         else
00170                                                           if(p[offset6] > cb)
00171                                                                 if(p[offset7] > cb)
00172                                                                   if(p[offset8] > cb)
00173                                                                         goto success_homogeneous;
00174                                                                   else
00175                                                                         goto homogeneous;
00176                                                                 else
00177                                                                   goto homogeneous;
00178                                                           else
00179                                                                 goto homogeneous;
00180                                                   else
00181                                                         goto homogeneous;
00182                                                 else
00183                                                   goto homogeneous;
00184                                         else
00185                                           if(p[offset9] > cb)
00186                                                 if(p[offset7] > cb)
00187                                                   if(p[offset8] > cb)
00188                                                         if(p[offset1] > cb)
00189                                                           if(p[offset10] > cb)
00190                                                                 if(p[offset11] > cb)
00191                                                                   goto success_homogeneous;
00192                                                                 else
00193                                                                   if(p[offset6] > cb)
00194                                                                         if(p[offset4] > cb)
00195                                                                           goto success_structured;
00196                                                                         else
00197                                                                           goto homogeneous;
00198                                                                   else
00199                                                                         goto homogeneous;
00200                                                           else
00201                                                                 if(p[offset6] > cb)
00202                                                                   if(p[offset3] > cb)
00203                                                                         if(p[offset4] > cb)
00204                                                                           goto success_structured;
00205                                                                         else
00206                                                                           goto homogeneous;
00207                                                                   else
00208                                                                         goto homogeneous;
00209                                                                 else
00210                                                                   goto homogeneous;
00211                                                         else
00212                                                           if(p[offset6] > cb)
00213                                                                 if(p[offset4] > cb)
00214                                                                   if(p[offset3] > cb)
00215                                                                         goto success_homogeneous;
00216                                                                   else
00217                                                                         if(p[offset10] > cb)
00218                                                                           goto success_homogeneous;
00219                                                                         else
00220                                                                           goto homogeneous;
00221                                                                 else
00222                                                                   if(p[offset10] > cb)
00223                                                                         if(p[offset11] > cb)
00224                                                                           goto success_homogeneous;
00225                                                                         else
00226                                                                           goto homogeneous;
00227                                                                   else
00228                                                                         goto homogeneous;
00229                                                           else
00230                                                                 goto homogeneous;
00231                                                   else
00232                                                         goto homogeneous;
00233                                                 else
00234                                                   goto homogeneous;
00235                                           else
00236                                                 goto homogeneous;
00237                                   else
00238                                         if(p[offset5] < c_b)
00239                                           if(p[offset9] > cb)
00240                                                 if(p[offset3] < c_b)
00241                                                   if(p[offset4] < c_b)
00242                                                         if(p[offset11] > cb)
00243                                                           if(p[offset1] > cb)
00244                                                                 if(p[offset8] > cb)
00245                                                                   if(p[offset10] > cb)
00246                                                                         if(p[offset2] > cb)
00247                                                                           goto success_structured;
00248                                                                         else
00249                                                                           if(p[offset7] > cb)
00250                                                                                 goto success_structured;
00251                                                                           else
00252                                                                                 goto structured;
00253                                                                   else
00254                                                                         goto homogeneous;
00255                                                                 else
00256                                                                   if(p[offset6] < c_b)
00257                                                                         if(p[offset2] < c_b)
00258                                                                           if(p[offset7] < c_b)
00259                                                                                 if(p[offset8] < c_b)
00260                                                                                   goto success_structured;
00261                                                                                 else
00262                                                                                   goto structured;
00263                                                                           else
00264                                                                                 goto structured;
00265                                                                         else
00266                                                                           goto homogeneous;
00267                                                                   else
00268                                                                         goto homogeneous;
00269                                                           else
00270                                                                 if(p[offset6] > cb)
00271                                                                   if(p[offset7] > cb)
00272                                                                         if(p[offset8] > cb)
00273                                                                           if(p[offset10] > cb)
00274                                                                                 goto success_structured;
00275                                                                           else
00276                                                                                 goto structured;
00277                                                                         else
00278                                                                           goto homogeneous;
00279                                                                   else
00280                                                                         goto homogeneous;
00281                                                                 else
00282                                                                   if(p[offset6] < c_b)
00283                                                                         if(p[offset2] < c_b)
00284                                                                           if(p[offset7] < c_b)
00285                                                                                 if(p[offset1] < c_b)
00286                                                                                   goto success_structured;
00287                                                                                 else
00288                                                                                   if(p[offset8] < c_b)
00289                                                                                         goto success_structured;
00290                                                                                   else
00291                                                                                         goto structured;
00292                                                                           else
00293                                                                                 goto homogeneous;
00294                                                                         else
00295                                                                           goto homogeneous;
00296                                                                   else
00297                                                                         goto homogeneous;
00298                                                         else
00299                                                           if(p[offset2] < c_b)
00300                                                                 if(p[offset7] < c_b)
00301                                                                   if(p[offset1] < c_b)
00302                                                                         if(p[offset6] < c_b)
00303                                                                           goto success_structured;
00304                                                                         else
00305                                                                           goto homogeneous;
00306                                                                   else
00307                                                                         if(p[offset6] < c_b)
00308                                                                           if(p[offset8] < c_b)
00309                                                                                 goto success_structured;
00310                                                                           else
00311                                                                                 goto homogeneous;
00312                                                                         else
00313                                                                           goto homogeneous;
00314                                                                 else
00315                                                                   goto homogeneous;
00316                                                           else
00317                                                                 goto homogeneous;
00318                                                   else
00319                                                         if(p[offset11] > cb)
00320                                                           if(p[offset8] > cb)
00321                                                                 if(p[offset10] > cb)
00322                                                                   if(p[offset1] > cb)
00323                                                                         if(p[offset2] > cb)
00324                                                                           goto success_structured;
00325                                                                         else
00326                                                                           if(p[offset7] > cb)
00327                                                                                 goto success_structured;
00328                                                                           else
00329                                                                                 goto homogeneous;
00330                                                                   else
00331                                                                         if(p[offset6] > cb)
00332                                                                           if(p[offset7] > cb)
00333                                                                                 goto success_structured;
00334                                                                           else
00335                                                                                 goto homogeneous;
00336                                                                         else
00337                                                                           goto homogeneous;
00338                                                                 else
00339                                                                   goto homogeneous;
00340                                                           else
00341                                                                 goto homogeneous;
00342                                                         else
00343                                                           goto homogeneous;
00344                                                 else
00345                                                   if(p[offset11] > cb)
00346                                                         if(p[offset10] > cb)
00347                                                           if(p[offset3] > cb)
00348                                                                 if(p[offset1] > cb)
00349                                                                   if(p[offset2] > cb)
00350                                                                         goto success_homogeneous;
00351                                                                   else
00352                                                                         if(p[offset7] > cb)
00353                                                                           if(p[offset8] > cb)
00354                                                                                 goto success_structured;
00355                                                                           else
00356                                                                                 goto homogeneous;
00357                                                                         else
00358                                                                           goto homogeneous;
00359                                                                 else
00360                                                                   if(p[offset6] > cb)
00361                                                                         if(p[offset7] > cb)
00362                                                                           if(p[offset8] > cb)
00363                                                                                 goto success_structured;
00364                                                                           else
00365                                                                                 goto homogeneous;
00366                                                                         else
00367                                                                           goto homogeneous;
00368                                                                   else
00369                                                                         goto homogeneous;
00370                                                           else
00371                                                                 if(p[offset8] > cb)
00372                                                                   if(p[offset1] > cb)
00373                                                                         if(p[offset2] > cb)
00374                                                                           goto success_homogeneous;
00375                                                                         else
00376                                                                           if(p[offset7] > cb)
00377                                                                                 goto success_homogeneous;
00378                                                                           else
00379                                                                                 goto homogeneous;
00380                                                                   else
00381                                                                         if(p[offset6] > cb)
00382                                                                           if(p[offset7] > cb)
00383                                                                                 goto success_homogeneous;
00384                                                                           else
00385                                                                                 goto homogeneous;
00386                                                                         else
00387                                                                           goto homogeneous;
00388                                                                 else
00389                                                                   goto homogeneous;
00390                                                         else
00391                                                           goto homogeneous;
00392                                                   else
00393                                                         goto homogeneous;
00394                                           else
00395                                                 if(p[offset9] < c_b)
00396                                                   if(p[offset2] > cb)
00397                                                         if(p[offset1] > cb)
00398                                                           if(p[offset4] > cb)
00399                                                                 if(p[offset10] > cb)
00400                                                                   if(p[offset3] > cb)
00401                                                                         if(p[offset11] > cb)
00402                                                                           goto success_structured;
00403                                                                         else
00404                                                                           goto homogeneous;
00405                                                                   else
00406                                                                         goto homogeneous;
00407                                                                 else
00408                                                                   if(p[offset6] < c_b)
00409                                                                         if(p[offset7] < c_b)
00410                                                                           if(p[offset8] < c_b)
00411                                                                                 if(p[offset11] < c_b)
00412                                                                                   if(p[offset10] < c_b)
00413                                                                                         goto success_structured;
00414                                                                                   else
00415                                                                                         goto structured;
00416                                                                                 else
00417                                                                                   goto structured;
00418                                                                           else
00419                                                                                 goto homogeneous;
00420                                                                         else
00421                                                                           goto homogeneous;
00422                                                                   else
00423                                                                         goto homogeneous;
00424                                                           else
00425                                                                 if(p[offset6] < c_b)
00426                                                                   if(p[offset7] < c_b)
00427                                                                         if(p[offset8] < c_b)
00428                                                                           if(p[offset10] < c_b)
00429                                                                                 if(p[offset4] < c_b)
00430                                                                                   goto success_structured;
00431                                                                                 else
00432                                                                                   if(p[offset11] < c_b)
00433                                                                                         goto success_structured;
00434                                                                                   else
00435                                                                                         goto structured;
00436                                                                           else
00437                                                                                 if(p[offset3] < c_b)
00438                                                                                   if(p[offset4] < c_b)
00439                                                                                         goto success_structured;
00440                                                                                   else
00441                                                                                         goto structured;
00442                                                                                 else
00443                                                                                   goto homogeneous;
00444                                                                         else
00445                                                                           goto homogeneous;
00446                                                                   else
00447                                                                         goto homogeneous;
00448                                                                 else
00449                                                                   goto homogeneous;
00450                                                         else
00451                                                           if(p[offset6] < c_b)
00452                                                                 if(p[offset7] < c_b)
00453                                                                   if(p[offset8] < c_b)
00454                                                                         if(p[offset4] < c_b)
00455                                                                           if(p[offset3] < c_b)
00456                                                                                 goto success_structured;
00457                                                                           else
00458                                                                                 if(p[offset10] < c_b)
00459                                                                                   goto success_structured;
00460                                                                                 else
00461                                                                                   goto homogeneous;
00462                                                                         else
00463                                                                           if(p[offset10] < c_b)
00464                                                                                 if(p[offset11] < c_b)
00465                                                                                   goto success_structured;
00466                                                                                 else
00467                                                                                   goto homogeneous;
00468                                                                           else
00469                                                                                 goto homogeneous;
00470                                                                   else
00471                                                                         goto homogeneous;
00472                                                                 else
00473                                                                   goto homogeneous;
00474                                                           else
00475                                                                 goto homogeneous;
00476                                                   else
00477                                                         if(p[offset6] < c_b)
00478                                                           if(p[offset7] < c_b)
00479                                                                 if(p[offset8] < c_b)
00480                                                                   if(p[offset4] < c_b)
00481                                                                         if(p[offset3] < c_b)
00482                                                                           goto success_homogeneous;
00483                                                                         else
00484                                                                           if(p[offset10] < c_b)
00485                                                                                 goto success_homogeneous;
00486                                                                           else
00487                                                                                 goto homogeneous;
00488                                                                   else
00489                                                                         if(p[offset10] < c_b)
00490                                                                           if(p[offset11] < c_b)
00491                                                                                 goto success_homogeneous;
00492                                                                           else
00493                                                                                 goto homogeneous;
00494                                                                         else
00495                                                                           goto homogeneous;
00496                                                                 else
00497                                                                   if(p[offset2] < c_b)
00498                                                                         if(p[offset1] < c_b)
00499                                                                           if(p[offset3] < c_b)
00500                                                                                 if(p[offset4] < c_b)
00501                                                                                   goto success_structured;
00502                                                                                 else
00503                                                                                   goto homogeneous;
00504                                                                           else
00505                                                                                 goto homogeneous;
00506                                                                         else
00507                                                                           goto homogeneous;
00508                                                                   else
00509                                                                         goto homogeneous;
00510                                                           else
00511                                                                 goto homogeneous;
00512                                                         else
00513                                                           goto homogeneous;
00514                                                 else
00515                                                   if(p[offset2] > cb)
00516                                                         if(p[offset1] > cb)
00517                                                           if(p[offset3] > cb)
00518                                                                 if(p[offset4] > cb)
00519                                                                   if(p[offset10] > cb)
00520                                                                         if(p[offset11] > cb)
00521                                                                           goto success_homogeneous;
00522                                                                         else
00523                                                                           goto homogeneous;
00524                                                                   else
00525                                                                         goto homogeneous;
00526                                                                 else
00527                                                                   goto homogeneous;
00528                                                           else
00529                                                                 goto homogeneous;
00530                                                         else
00531                                                           goto homogeneous;
00532                                                   else
00533                                                         if(p[offset2] < c_b)
00534                                                           if(p[offset3] < c_b)
00535                                                                 if(p[offset4] < c_b)
00536                                                                   if(p[offset7] < c_b)
00537                                                                         if(p[offset1] < c_b)
00538                                                                           if(p[offset6] < c_b)
00539                                                                                 goto success_homogeneous;
00540                                                                           else
00541                                                                                 goto homogeneous;
00542                                                                         else
00543                                                                           if(p[offset6] < c_b)
00544                                                                                 if(p[offset8] < c_b)
00545                                                                                   goto success_homogeneous;
00546                                                                                 else
00547                                                                                   goto homogeneous;
00548                                                                           else
00549                                                                                 goto homogeneous;
00550                                                                   else
00551                                                                         goto homogeneous;
00552                                                                 else
00553                                                                   goto homogeneous;
00554                                                           else
00555                                                                 goto homogeneous;
00556                                                         else
00557                                                           goto homogeneous;
00558                                         else
00559                                           if(p[offset2] > cb)
00560                                                 if(p[offset10] > cb)
00561                                                   if(p[offset11] > cb)
00562                                                         if(p[offset9] > cb)
00563                                                           if(p[offset1] > cb)
00564                                                                 if(p[offset3] > cb)
00565                                                                   goto success_homogeneous;
00566                                                                 else
00567                                                                   if(p[offset8] > cb)
00568                                                                         goto success_homogeneous;
00569                                                                   else
00570                                                                         goto homogeneous;
00571                                                           else
00572                                                                 if(p[offset6] > cb)
00573                                                                   if(p[offset7] > cb)
00574                                                                         if(p[offset8] > cb)
00575                                                                           goto success_homogeneous;
00576                                                                         else
00577                                                                           goto homogeneous;
00578                                                                   else
00579                                                                         goto homogeneous;
00580                                                                 else
00581                                                                   goto homogeneous;
00582                                                         else
00583                                                           if(p[offset1] > cb)
00584                                                                 if(p[offset3] > cb)
00585                                                                   if(p[offset4] > cb)
00586                                                                         goto success_homogeneous;
00587                                                                   else
00588                                                                         goto homogeneous;
00589                                                                 else
00590                                                                   goto homogeneous;
00591                                                           else
00592                                                                 goto homogeneous;
00593                                                   else
00594                                                         goto homogeneous;
00595                                                 else
00596                                                   goto homogeneous;
00597                                           else
00598                                                 if(p[offset9] > cb)
00599                                                   if(p[offset7] > cb)
00600                                                         if(p[offset8] > cb)
00601                                                           if(p[offset10] > cb)
00602                                                                 if(p[offset11] > cb)
00603                                                                   if(p[offset1] > cb)
00604                                                                         goto success_homogeneous;
00605                                                                   else
00606                                                                         if(p[offset6] > cb)
00607                                                                           goto success_homogeneous;
00608                                                                         else
00609                                                                           goto homogeneous;
00610                                                                 else
00611                                                                   goto homogeneous;
00612                                                           else
00613                                                                 goto homogeneous;
00614                                                         else
00615                                                           goto homogeneous;
00616                                                   else
00617                                                         goto homogeneous;
00618                                                 else
00619                                                   goto homogeneous;
00620                                 else if(p[offset0] < c_b)
00621                                   if(p[offset2] > cb)
00622                                         if(p[offset5] > cb)
00623                                           if(p[offset7] > cb)
00624                                                 if(p[offset6] > cb)
00625                                                   if(p[offset4] > cb)
00626                                                         if(p[offset3] > cb)
00627                                                           if(p[offset1] > cb)
00628                                                                 goto success_homogeneous;
00629                                                           else
00630                                                                 if(p[offset8] > cb)
00631                                                                   goto success_homogeneous;
00632                                                                 else
00633                                                                   goto homogeneous;
00634                                                         else
00635                                                           if(p[offset9] > cb)
00636                                                                 if(p[offset8] > cb)
00637                                                                   if(p[offset10] > cb)
00638                                                                         goto success_structured;
00639                                                                   else
00640                                                                         goto homogeneous;
00641                                                                 else
00642                                                                   goto homogeneous;
00643                                                           else
00644                                                                 goto homogeneous;
00645                                                   else
00646                                                         if(p[offset9] > cb)
00647                                                           if(p[offset8] > cb)
00648                                                                 if(p[offset10] > cb)
00649                                                                   if(p[offset11] > cb)
00650                                                                         goto success_structured;
00651                                                                   else
00652                                                                         goto homogeneous;
00653                                                                 else
00654                                                                   goto homogeneous;
00655                                                           else
00656                                                                 goto homogeneous;
00657                                                         else
00658                                                           goto homogeneous;
00659                                                 else
00660                                                   goto homogeneous;
00661                                           else
00662                                                 if(p[offset9] < c_b)
00663                                                   if(p[offset8] < c_b)
00664                                                         if(p[offset10] < c_b)
00665                                                           if(p[offset11] < c_b)
00666                                                                 if(p[offset7] < c_b)
00667                                                                   if(p[offset1] < c_b)
00668                                                                         goto success_structured;
00669                                                                   else
00670                                                                         if(p[offset6] < c_b)
00671                                                                           goto success_structured;
00672                                                                         else
00673                                                                           goto homogeneous;
00674                                                                 else
00675                                                                   goto homogeneous;
00676                                                           else
00677                                                                 goto homogeneous;
00678                                                         else
00679                                                           goto homogeneous;
00680                                                   else
00681                                                         goto homogeneous;
00682                                                 else
00683                                                   goto homogeneous;
00684                                         else
00685                                           if(p[offset9] < c_b)
00686                                                 if(p[offset7] < c_b)
00687                                                   if(p[offset8] < c_b)
00688                                                         if(p[offset5] < c_b)
00689                                                           if(p[offset1] < c_b)
00690                                                                 if(p[offset10] < c_b)
00691                                                                   if(p[offset11] < c_b)
00692                                                                         goto success_structured;
00693                                                                   else
00694                                                                         if(p[offset6] < c_b)
00695                                                                           if(p[offset4] < c_b)
00696                                                                                 goto success_structured;
00697                                                                           else
00698                                                                                 goto structured;
00699                                                                         else
00700                                                                           goto homogeneous;
00701                                                                 else
00702                                                                   if(p[offset6] < c_b)
00703                                                                         if(p[offset3] < c_b)
00704                                                                           if(p[offset4] < c_b)
00705                                                                                 goto success_structured;
00706                                                                           else
00707                                                                                 goto structured;
00708                                                                         else
00709                                                                           goto homogeneous;
00710                                                                   else
00711                                                                         goto homogeneous;
00712                                                           else
00713                                                                 if(p[offset6] < c_b)
00714                                                                   if(p[offset4] < c_b)
00715                                                                         if(p[offset3] < c_b)
00716                                                                           goto success_structured;
00717                                                                         else
00718                                                                           if(p[offset10] < c_b)
00719                                                                                 goto success_structured;
00720                                                                           else
00721                                                                                 goto homogeneous;
00722                                                                   else
00723                                                                         if(p[offset10] < c_b)
00724                                                                           if(p[offset11] < c_b)
00725                                                                                 goto success_structured;
00726                                                                           else
00727                                                                                 goto homogeneous;
00728                                                                         else
00729                                                                           goto homogeneous;
00730                                                                 else
00731                                                                   goto homogeneous;
00732                                                         else
00733                                                           if(p[offset10] < c_b)
00734                                                                 if(p[offset11] < c_b)
00735                                                                   if(p[offset1] < c_b)
00736                                                                         goto success_homogeneous;
00737                                                                   else
00738                                                                         if(p[offset6] < c_b)
00739                                                                           goto success_homogeneous;
00740                                                                         else
00741                                                                           goto homogeneous;
00742                                                                 else
00743                                                                   goto homogeneous;
00744                                                           else
00745                                                                 goto homogeneous;
00746                                                   else
00747                                                         goto homogeneous;
00748                                                 else
00749                                                   goto homogeneous;
00750                                           else
00751                                                 goto homogeneous;
00752                                   else
00753                                         if(p[offset2] < c_b)
00754                                           if(p[offset9] > cb)
00755                                                 if(p[offset5] > cb)
00756                                                   if(p[offset1] < c_b)
00757                                                         if(p[offset4] < c_b)
00758                                                           if(p[offset10] < c_b)
00759                                                                 if(p[offset3] < c_b)
00760                                                                   if(p[offset11] < c_b)
00761                                                                         goto success_structured;
00762                                                                   else
00763                                                                         goto homogeneous;
00764                                                                 else
00765                                                                   goto homogeneous;
00766                                                           else
00767                                                                 if(p[offset6] > cb)
00768                                                                   if(p[offset7] > cb)
00769                                                                         if(p[offset8] > cb)
00770                                                                           if(p[offset11] > cb)
00771                                                                                 if(p[offset10] > cb)
00772                                                                                   goto success_structured;
00773                                                                                 else
00774                                                                                   goto structured;
00775                                                                           else
00776                                                                                 goto structured;
00777                                                                         else
00778                                                                           goto homogeneous;
00779                                                                   else
00780                                                                         goto homogeneous;
00781                                                                 else
00782                                                                   goto homogeneous;
00783                                                         else
00784                                                           if(p[offset6] > cb)
00785                                                                 if(p[offset7] > cb)
00786                                                                   if(p[offset8] > cb)
00787                                                                         if(p[offset10] > cb)
00788                                                                           if(p[offset4] > cb)
00789                                                                                 goto success_structured;
00790                                                                           else
00791                                                                                 if(p[offset11] > cb)
00792                                                                                   goto success_structured;
00793                                                                                 else
00794                                                                                   goto structured;
00795                                                                         else
00796                                                                           if(p[offset3] > cb)
00797                                                                                 if(p[offset4] > cb)
00798                                                                                   goto success_structured;
00799                                                                                 else
00800                                                                                   goto structured;
00801                                                                           else
00802                                                                                 goto homogeneous;
00803                                                                   else
00804                                                                         goto homogeneous;
00805                                                                 else
00806                                                                   goto homogeneous;
00807                                                           else
00808                                                                 goto homogeneous;
00809                                                   else
00810                                                         if(p[offset6] > cb)
00811                                                           if(p[offset7] > cb)
00812                                                                 if(p[offset8] > cb)
00813                                                                   if(p[offset4] > cb)
00814                                                                         if(p[offset3] > cb)
00815                                                                           goto success_structured;
00816                                                                         else
00817                                                                           if(p[offset10] > cb)
00818                                                                                 goto success_structured;
00819                                                                           else
00820                                                                                 goto homogeneous;
00821                                                                   else
00822                                                                         if(p[offset10] > cb)
00823                                                                           if(p[offset11] > cb)
00824                                                                                 goto success_structured;
00825                                                                           else
00826                                                                                 goto homogeneous;
00827                                                                         else
00828                                                                           goto homogeneous;
00829                                                                 else
00830                                                                   goto homogeneous;
00831                                                           else
00832                                                                 goto homogeneous;
00833                                                         else
00834                                                           goto homogeneous;
00835                                                 else
00836                                                   if(p[offset3] < c_b)
00837                                                         if(p[offset4] < c_b)
00838                                                           if(p[offset5] < c_b)
00839                                                                 if(p[offset1] < c_b)
00840                                                                   if(p[offset6] < c_b)
00841                                                                         goto success_homogeneous;
00842                                                                   else
00843                                                                         if(p[offset11] < c_b)
00844                                                                           goto success_homogeneous;
00845                                                                         else
00846                                                                           goto homogeneous;
00847                                                                 else
00848                                                                   if(p[offset6] < c_b)
00849                                                                         if(p[offset7] < c_b)
00850                                                                           if(p[offset8] < c_b)
00851                                                                                 goto success_structured;
00852                                                                           else
00853                                                                                 goto homogeneous;
00854                                                                         else
00855                                                                           goto homogeneous;
00856                                                                   else
00857                                                                         goto homogeneous;
00858                                                           else
00859                                                                 if(p[offset1] < c_b)
00860                                                                   if(p[offset10] < c_b)
00861                                                                         if(p[offset11] < c_b)
00862                                                                           goto success_homogeneous;
00863                                                                         else
00864                                                                           goto homogeneous;
00865                                                                   else
00866                                                                         goto homogeneous;
00867                                                                 else
00868                                                                   goto homogeneous;
00869                                                         else
00870                                                           goto homogeneous;
00871                                                   else
00872                                                         goto homogeneous;
00873                                           else
00874                                                 if(p[offset9] < c_b)
00875                                                   if(p[offset5] < c_b)
00876                                                         if(p[offset1] < c_b)
00877                                                           if(p[offset6] < c_b)
00878                                                                 if(p[offset3] < c_b)
00879                                                                   if(p[offset4] < c_b)
00880                                                                         goto success_homogeneous;
00881                                                                   else
00882                                                                         if(p[offset10] < c_b)
00883                                                                           if(p[offset11] < c_b)
00884                                                                                 goto success_structured;
00885                                                                           else
00886                                                                                 goto homogeneous;
00887                                                                         else
00888                                                                           goto homogeneous;
00889                                                                 else
00890                                                                   if(p[offset8] < c_b)
00891                                                                         if(p[offset10] < c_b)
00892                                                                           if(p[offset11] < c_b)
00893                                                                                 goto success_structured;
00894                                                                           else
00895                                                                                 if(p[offset4] < c_b)
00896                                                                                   if(p[offset7] < c_b)
00897                                                                                         goto success_structured;
00898                                                                                   else
00899                                                                                         goto structured;
00900                                                                                 else
00901                                                                                   goto homogeneous;
00902                                                                         else
00903                                                                           goto homogeneous;
00904                                                                   else
00905                                                                         goto homogeneous;
00906                                                           else
00907                                                                 if(p[offset11] < c_b)
00908                                                                   if(p[offset3] < c_b)
00909                                                                         if(p[offset4] < c_b)
00910                                                                           goto success_homogeneous;
00911                                                                         else
00912                                                                           if(p[offset10] < c_b)
00913                                                                                 goto success_homogeneous;
00914                                                                           else
00915                                                                                 goto homogeneous;
00916                                                                   else
00917                                                                         if(p[offset8] < c_b)
00918                                                                           if(p[offset10] < c_b)
00919                                                                                 goto success_homogeneous;
00920                                                                           else
00921                                                                                 goto homogeneous;
00922                                                                         else
00923                                                                           goto homogeneous;
00924                                                                 else
00925                                                                   goto homogeneous;
00926                                                         else
00927                                                           if(p[offset6] < c_b)
00928                                                                 if(p[offset7] < c_b)
00929                                                                   if(p[offset8] < c_b)
00930                                                                         if(p[offset4] < c_b)
00931                                                                           if(p[offset3] < c_b)
00932                                                                                 goto success_structured;
00933                                                                           else
00934                                                                                 if(p[offset10] < c_b)
00935                                                                                   goto success_structured;
00936                                                                                 else
00937                                                                                   goto homogeneous;
00938                                                                         else
00939                                                                           if(p[offset10] < c_b)
00940                                                                                 if(p[offset11] < c_b)
00941                                                                                   goto success_structured;
00942                                                                                 else
00943                                                                                   goto homogeneous;
00944                                                                           else
00945                                                                                 goto homogeneous;
00946                                                                   else
00947                                                                         goto homogeneous;
00948                                                                 else
00949                                                                   goto homogeneous;
00950                                                           else
00951                                                                 goto homogeneous;
00952                                                   else
00953                                                         if(p[offset10] < c_b)
00954                                                           if(p[offset11] < c_b)
00955                                                                 if(p[offset1] < c_b)
00956                                                                   if(p[offset3] < c_b)
00957                                                                         goto success_homogeneous;
00958                                                                   else
00959                                                                         if(p[offset8] < c_b)
00960                                                                           goto success_homogeneous;
00961                                                                         else
00962                                                                           goto homogeneous;
00963                                                                 else
00964                                                                   if(p[offset6] < c_b)
00965                                                                         if(p[offset7] < c_b)
00966                                                                           if(p[offset8] < c_b)
00967                                                                                 goto success_homogeneous;
00968                                                                           else
00969                                                                                 goto homogeneous;
00970                                                                         else
00971                                                                           goto homogeneous;
00972                                                                   else
00973                                                                         goto homogeneous;
00974                                                           else
00975                                                                 goto homogeneous;
00976                                                         else
00977                                                           goto homogeneous;
00978                                                 else
00979                                                   if(p[offset3] < c_b)
00980                                                         if(p[offset4] < c_b)
00981                                                           if(p[offset5] < c_b)
00982                                                                 if(p[offset1] < c_b)
00983                                                                   if(p[offset6] < c_b)
00984                                                                         goto success_homogeneous;
00985                                                                   else
00986                                                                         if(p[offset11] < c_b)
00987                                                                           goto success_homogeneous;
00988                                                                         else
00989                                                                           goto homogeneous;
00990                                                                 else
00991                                                                   if(p[offset6] < c_b)
00992                                                                         if(p[offset7] < c_b)
00993                                                                           if(p[offset8] < c_b)
00994                                                                                 goto success_homogeneous;
00995                                                                           else
00996                                                                                 goto homogeneous;
00997                                                                         else
00998                                                                           goto homogeneous;
00999                                                                   else
01000                                                                         goto homogeneous;
01001                                                           else
01002                                                                 if(p[offset1] < c_b)
01003                                                                   if(p[offset10] < c_b)
01004                                                                         if(p[offset11] < c_b)
01005                                                                           goto success_homogeneous;
01006                                                                         else
01007                                                                           goto homogeneous;
01008                                                                   else
01009                                                                         goto homogeneous;
01010                                                                 else
01011                                                                   goto homogeneous;
01012                                                         else
01013                                                           goto homogeneous;
01014                                                   else
01015                                                         goto homogeneous;
01016                                         else
01017                                           if(p[offset9] < c_b)
01018                                                 if(p[offset7] < c_b)
01019                                                   if(p[offset8] < c_b)
01020                                                         if(p[offset5] < c_b)
01021                                                           if(p[offset1] < c_b)
01022                                                                 if(p[offset10] < c_b)
01023                                                                   if(p[offset11] < c_b)
01024                                                                         goto success_homogeneous;
01025                                                                   else
01026                                                                         if(p[offset6] < c_b)
01027                                                                           if(p[offset4] < c_b)
01028                                                                                 goto success_structured;
01029                                                                           else
01030                                                                                 goto homogeneous;
01031                                                                         else
01032                                                                           goto homogeneous;
01033                                                                 else
01034                                                                   if(p[offset6] < c_b)
01035                                                                         if(p[offset3] < c_b)
01036                                                                           if(p[offset4] < c_b)
01037                                                                                 goto success_structured;
01038                                                                           else
01039                                                                                 goto homogeneous;
01040                                                                         else
01041                                                                           goto homogeneous;
01042                                                                   else
01043                                                                         goto homogeneous;
01044                                                           else
01045                                                                 if(p[offset6] < c_b)
01046                                                                   if(p[offset4] < c_b)
01047                                                                         if(p[offset3] < c_b)
01048                                                                           goto success_homogeneous;
01049                                                                         else
01050                                                                           if(p[offset10] < c_b)
01051                                                                                 goto success_homogeneous;
01052                                                                           else
01053                                                                                 goto homogeneous;
01054                                                                   else
01055                                                                         if(p[offset10] < c_b)
01056                                                                           if(p[offset11] < c_b)
01057                                                                                 goto success_homogeneous;
01058                                                                           else
01059                                                                                 goto homogeneous;
01060                                                                         else
01061                                                                           goto homogeneous;
01062                                                                 else
01063                                                                   goto homogeneous;
01064                                                         else
01065                                                           if(p[offset10] < c_b)
01066                                                                 if(p[offset11] < c_b)
01067                                                                   if(p[offset1] < c_b)
01068                                                                         goto success_homogeneous;
01069                                                                   else
01070                                                                         if(p[offset6] < c_b)
01071                                                                           goto success_homogeneous;
01072                                                                         else
01073                                                                           goto homogeneous;
01074                                                                 else
01075                                                                   goto homogeneous;
01076                                                           else
01077                                                                 goto homogeneous;
01078                                                   else
01079                                                         goto homogeneous;
01080                                                 else
01081                                                   goto homogeneous;
01082                                           else
01083                                                 if(p[offset5] > cb)
01084                                                   if(p[offset9] > cb)
01085                                                         if(p[offset6] > cb)
01086                                                           if(p[offset7] > cb)
01087                                                                 if(p[offset8] > cb)
01088                                                                   if(p[offset4] > cb)
01089                                                                         if(p[offset3] > cb)
01090                                                                           goto success_homogeneous;
01091                                                                         else
01092                                                                           if(p[offset10] > cb)
01093                                                                                 goto success_homogeneous;
01094                                                                           else
01095                                                                                 goto homogeneous;
01096                                                                   else
01097                                                                         if(p[offset10] > cb)
01098                                                                           if(p[offset11] > cb)
01099                                                                                 goto success_homogeneous;
01100                                                                           else
01101                                                                                 goto homogeneous;
01102                                                                         else
01103                                                                           goto homogeneous;
01104                                                                 else
01105                                                                   goto homogeneous;
01106                                                           else
01107                                                                 goto homogeneous;
01108                                                         else
01109                                                           goto homogeneous;
01110                                                   else
01111                                                         goto homogeneous;
01112                                                 else
01113                                                   goto homogeneous;
01114                                 else
01115                                   if(p[offset5] > cb)
01116                                         if(p[offset9] > cb)
01117                                           if(p[offset6] > cb)
01118                                                 if(p[offset7] > cb)
01119                                                   if(p[offset4] > cb)
01120                                                         if(p[offset3] > cb)
01121                                                           if(p[offset8] > cb)
01122                                                                 goto success_homogeneous;
01123                                                           else
01124                                                                 if(p[offset1] > cb)
01125                                                                   if(p[offset2] > cb)
01126                                                                         goto success_homogeneous;
01127                                                                   else
01128                                                                         goto homogeneous;
01129                                                                 else
01130                                                                   goto homogeneous;
01131                                                         else
01132                                                           if(p[offset8] > cb)
01133                                                                 if(p[offset10] > cb)
01134                                                                   goto success_homogeneous;
01135                                                                 else
01136                                                                   goto homogeneous;
01137                                                           else
01138                                                                 goto homogeneous;
01139                                                   else
01140                                                         if(p[offset11] > cb)
01141                                                           if(p[offset8] > cb)
01142                                                                 if(p[offset10] > cb)
01143                                                                   goto success_homogeneous;
01144                                                                 else
01145                                                                   goto homogeneous;
01146                                                           else
01147                                                                 goto homogeneous;
01148                                                         else
01149                                                           goto homogeneous;
01150                                                 else
01151                                                   goto homogeneous;
01152                                           else
01153                                                 goto homogeneous;
01154                                         else
01155                                           if(p[offset2] > cb)
01156                                                 if(p[offset3] > cb)
01157                                                   if(p[offset4] > cb)
01158                                                         if(p[offset7] > cb)
01159                                                           if(p[offset1] > cb)
01160                                                                 if(p[offset6] > cb)
01161                                                                   goto success_homogeneous;
01162                                                                 else
01163                                                                   goto homogeneous;
01164                                                           else
01165                                                                 if(p[offset6] > cb)
01166                                                                   if(p[offset8] > cb)
01167                                                                         goto success_homogeneous;
01168                                                                   else
01169                                                                         goto homogeneous;
01170                                                                 else
01171                                                                   goto homogeneous;
01172                                                         else
01173                                                           goto homogeneous;
01174                                                   else
01175                                                         goto homogeneous;
01176                                                 else
01177                                                   goto homogeneous;
01178                                           else
01179                                                 goto homogeneous;
01180                                   else
01181                                         if(p[offset5] < c_b)
01182                                           if(p[offset9] < c_b)
01183                                                 if(p[offset6] < c_b)
01184                                                   if(p[offset7] < c_b)
01185                                                         if(p[offset4] < c_b)
01186                                                           if(p[offset3] < c_b)
01187                                                                 if(p[offset8] < c_b)
01188                                                                   goto success_homogeneous;
01189                                                                 else
01190                                                                   if(p[offset1] < c_b)
01191                                                                         if(p[offset2] < c_b)
01192                                                                           goto success_homogeneous;
01193                                                                         else
01194                                                                           goto homogeneous;
01195                                                                   else
01196                                                                         goto homogeneous;
01197                                                           else
01198                                                                 if(p[offset8] < c_b)
01199                                                                   if(p[offset10] < c_b)
01200                                                                         goto success_homogeneous;
01201                                                                   else
01202                                                                         goto homogeneous;
01203                                                                 else
01204                                                                   goto homogeneous;
01205                                                         else
01206                                                           if(p[offset11] < c_b)
01207                                                                 if(p[offset8] < c_b)
01208                                                                   if(p[offset10] < c_b)
01209                                                                         goto success_homogeneous;
01210                                                                   else
01211                                                                         goto homogeneous;
01212                                                                 else
01213                                                                   goto homogeneous;
01214                                                           else
01215                                                                 goto homogeneous;
01216                                                   else
01217                                                         goto homogeneous;
01218                                                 else
01219                                                   goto homogeneous;
01220                                           else
01221                                                 if(p[offset2] < c_b)
01222                                                   if(p[offset3] < c_b)
01223                                                         if(p[offset4] < c_b)
01224                                                           if(p[offset7] < c_b)
01225                                                                 if(p[offset1] < c_b)
01226                                                                   if(p[offset6] < c_b)
01227                                                                         goto success_homogeneous;
01228                                                                   else
01229                                                                         goto homogeneous;
01230                                                                 else
01231                                                                   if(p[offset6] < c_b)
01232                                                                         if(p[offset8] < c_b)
01233                                                                           goto success_homogeneous;
01234                                                                         else
01235                                                                           goto homogeneous;
01236                                                                   else
01237                                                                         goto homogeneous;
01238                                                           else
01239                                                                 goto homogeneous;
01240                                                         else
01241                                                           goto homogeneous;
01242                                                   else
01243                                                         goto homogeneous;
01244                                                 else
01245                                                   goto homogeneous;
01246                                         else
01247                                           goto homogeneous;
01248                         }
01249 }
01250 structured:
01251 {
01252                         x++;                    
01253                         if(x>xsizeB)    
01254                                 break;
01255                         else
01256                         {
01257                                 register const unsigned char* const p = im + y*width + x;
01258                                 register const int cb = *p + b;
01259                                 register const int c_b = *p - b;
01260                                 if(p[offset0] > cb)
01261                                   if(p[offset5] > cb)
01262                                         if(p[offset2] > cb)
01263                                           if(p[offset9] > cb)
01264                                                 if(p[offset1] > cb)
01265                                                   if(p[offset6] > cb)
01266                                                         if(p[offset3] > cb)
01267                                                           if(p[offset4] > cb)
01268                                                                 goto success_structured;
01269                                                           else
01270                                                                 if(p[offset10] > cb)
01271                                                                   if(p[offset11] > cb)
01272                                                                         goto success_structured;
01273                                                                   else
01274                                                                         goto structured;
01275                                                                 else
01276                                                                   goto structured;
01277                                                         else
01278                                                           if(p[offset8] > cb)
01279                                                                 if(p[offset10] > cb)
01280                                                                   if(p[offset11] > cb)
01281                                                                         goto success_structured;
01282                                                                   else
01283                                                                         if(p[offset4] > cb)
01284                                                                           if(p[offset7] > cb)
01285                                                                                 goto success_structured;
01286                                                                           else
01287                                                                                 goto structured;
01288                                                                         else
01289                                                                           goto structured;
01290                                                                 else
01291                                                                   goto structured;
01292                                                           else
01293                                                                 goto structured;
01294                                                   else
01295                                                         if(p[offset11] > cb)
01296                                                           if(p[offset3] > cb)
01297                                                                 if(p[offset4] > cb)
01298                                                                   goto success_structured;
01299                                                                 else
01300                                                                   if(p[offset10] > cb)
01301                                                                         goto success_structured;
01302                                                                   else
01303                                                                         goto structured;
01304                                                           else
01305                                                                 if(p[offset8] > cb)
01306                                                                   if(p[offset10] > cb)
01307                                                                         goto success_structured;
01308                                                                   else
01309                                                                         goto structured;
01310                                                                 else
01311                                                                   goto structured;
01312                                                         else
01313                                                           goto structured;
01314                                                 else
01315                                                   if(p[offset6] > cb)
01316                                                         if(p[offset7] > cb)
01317                                                           if(p[offset8] > cb)
01318                                                                 if(p[offset4] > cb)
01319                                                                   if(p[offset3] > cb)
01320                                                                         goto success_structured;
01321                                                                   else
01322                                                                         if(p[offset10] > cb)
01323                                                                           goto success_structured;
01324                                                                         else
01325                                                                           goto structured;
01326                                                                 else
01327                                                                   if(p[offset10] > cb)
01328                                                                         if(p[offset11] > cb)
01329                                                                           goto success_structured;
01330                                                                         else
01331                                                                           goto structured;
01332                                                                   else
01333                                                                         goto structured;
01334                                                           else
01335                                                                 goto structured;
01336                                                         else
01337                                                           goto structured;
01338                                                   else
01339                                                         goto structured;
01340                                           else
01341                                                 if(p[offset3] > cb)
01342                                                   if(p[offset4] > cb)
01343                                                         if(p[offset1] > cb)
01344                                                           if(p[offset6] > cb)
01345                                                                 goto success_structured;
01346                                                           else
01347                                                                 if(p[offset11] > cb)
01348                                                                   goto success_structured;
01349                                                                 else
01350                                                                   goto structured;
01351                                                         else
01352                                                           if(p[offset6] > cb)
01353                                                                 if(p[offset7] > cb)
01354                                                                   if(p[offset8] > cb)
01355                                                                         goto success_structured;
01356                                                                   else
01357                                                                         goto structured;
01358                                                                 else
01359                                                                   goto structured;
01360                                                           else
01361                                                                 goto structured;
01362                                                   else
01363                                                         goto structured;
01364                                                 else
01365                                                   goto structured;
01366                                         else
01367                                           if(p[offset9] > cb)
01368                                                 if(p[offset7] > cb)
01369                                                   if(p[offset8] > cb)
01370                                                         if(p[offset1] > cb)
01371                                                           if(p[offset10] > cb)
01372                                                                 if(p[offset11] > cb)
01373                                                                   goto success_structured;
01374                                                                 else
01375                                                                   if(p[offset6] > cb)
01376                                                                         if(p[offset4] > cb)
01377                                                                           goto success_structured;
01378                                                                         else
01379                                                                           goto structured;
01380                                                                   else
01381                                                                         goto structured;
01382                                                           else
01383                                                                 if(p[offset6] > cb)
01384                                                                   if(p[offset3] > cb)
01385                                                                         if(p[offset4] > cb)
01386                                                                           goto success_structured;
01387                                                                         else
01388                                                                           goto structured;
01389                                                                   else
01390                                                                         goto structured;
01391                                                                 else
01392                                                                   goto structured;
01393                                                         else
01394                                                           if(p[offset6] > cb)
01395                                                                 if(p[offset4] > cb)
01396                                                                   if(p[offset3] > cb)
01397                                                                         goto success_structured;
01398                                                                   else
01399                                                                         if(p[offset10] > cb)
01400                                                                           goto success_structured;
01401                                                                         else
01402                                                                           goto structured;
01403                                                                 else
01404                                                                   if(p[offset10] > cb)
01405                                                                         if(p[offset11] > cb)
01406                                                                           goto success_structured;
01407                                                                         else
01408                                                                           goto structured;
01409                                                                   else
01410                                                                         goto structured;
01411                                                           else
01412                                                                 goto structured;
01413                                                   else
01414                                                         goto structured;
01415                                                 else
01416                                                   goto structured;
01417                                           else
01418                                                 goto structured;
01419                                   else
01420                                         if(p[offset5] < c_b)
01421                                           if(p[offset9] > cb)
01422                                                 if(p[offset3] < c_b)
01423                                                   if(p[offset4] < c_b)
01424                                                         if(p[offset11] > cb)
01425                                                           if(p[offset1] > cb)
01426                                                                 if(p[offset8] > cb)
01427                                                                   if(p[offset10] > cb)
01428                                                                         if(p[offset2] > cb)
01429                                                                           goto success_structured;
01430                                                                         else
01431                                                                           if(p[offset7] > cb)
01432                                                                                 goto success_structured;
01433                                                                           else
01434                                                                                 goto structured;
01435                                                                   else
01436                                                                         goto structured;
01437                                                                 else
01438                                                                   if(p[offset6] < c_b)
01439                                                                         if(p[offset2] < c_b)
01440                                                                           if(p[offset7] < c_b)
01441                                                                                 if(p[offset8] < c_b)
01442                                                                                   goto success_structured;
01443                                                                                 else
01444                                                                                   goto structured;
01445                                                                           else
01446                                                                                 goto structured;
01447                                                                         else
01448                                                                           goto structured;
01449                                                                   else
01450                                                                         goto structured;
01451                                                           else
01452                                                                 if(p[offset6] > cb)
01453                                                                   if(p[offset7] > cb)
01454                                                                         if(p[offset8] > cb)
01455                                                                           if(p[offset10] > cb)
01456                                                                                 goto success_structured;
01457                                                                           else
01458                                                                                 goto structured;
01459                                                                         else
01460                                                                           goto structured;
01461                                                                   else
01462                                                                         goto structured;
01463                                                                 else
01464                                                                   if(p[offset6] < c_b)
01465                                                                         if(p[offset2] < c_b)
01466                                                                           if(p[offset7] < c_b)
01467                                                                                 if(p[offset1] < c_b)
01468                                                                                   goto success_structured;
01469                                                                                 else
01470                                                                                   if(p[offset8] < c_b)
01471                                                                                         goto success_structured;
01472                                                                                   else
01473                                                                                         goto structured;
01474                                                                           else
01475                                                                                 goto structured;
01476                                                                         else
01477                                                                           goto structured;
01478                                                                   else
01479                                                                         goto structured;
01480                                                         else
01481                                                           if(p[offset2] < c_b)
01482                                                                 if(p[offset7] < c_b)
01483                                                                   if(p[offset1] < c_b)
01484                                                                         if(p[offset6] < c_b)
01485                                                                           goto success_structured;
01486                                                                         else
01487                                                                           goto structured;
01488                                                                   else
01489                                                                         if(p[offset6] < c_b)
01490                                                                           if(p[offset8] < c_b)
01491                                                                                 goto success_structured;
01492                                                                           else
01493                                                                                 goto structured;
01494                                                                         else
01495                                                                           goto structured;
01496                                                                 else
01497                                                                   goto structured;
01498                                                           else
01499                                                                 goto structured;
01500                                                   else
01501                                                         if(p[offset11] > cb)
01502                                                           if(p[offset8] > cb)
01503                                                                 if(p[offset10] > cb)
01504                                                                   if(p[offset1] > cb)
01505                                                                         if(p[offset2] > cb)
01506                                                                           goto success_structured;
01507                                                                         else
01508                                                                           if(p[offset7] > cb)
01509                                                                                 goto success_structured;
01510                                                                           else
01511                                                                                 goto structured;
01512                                                                   else
01513                                                                         if(p[offset6] > cb)
01514                                                                           if(p[offset7] > cb)
01515                                                                                 goto success_structured;
01516                                                                           else
01517                                                                                 goto structured;
01518                                                                         else
01519                                                                           goto structured;
01520                                                                 else
01521                                                                   goto structured;
01522                                                           else
01523                                                                 goto structured;
01524                                                         else
01525                                                           goto structured;
01526                                                 else
01527                                                   if(p[offset11] > cb)
01528                                                         if(p[offset10] > cb)
01529                                                           if(p[offset3] > cb)
01530                                                                 if(p[offset1] > cb)
01531                                                                   if(p[offset2] > cb)
01532                                                                         goto success_structured;
01533                                                                   else
01534                                                                         if(p[offset7] > cb)
01535                                                                           if(p[offset8] > cb)
01536                                                                                 goto success_structured;
01537                                                                           else
01538                                                                                 goto structured;
01539                                                                         else
01540                                                                           goto structured;
01541                                                                 else
01542                                                                   if(p[offset6] > cb)
01543                                                                         if(p[offset7] > cb)
01544                                                                           if(p[offset8] > cb)
01545                                                                                 goto success_structured;
01546                                                                           else
01547                                                                                 goto structured;
01548                                                                         else
01549                                                                           goto structured;
01550                                                                   else
01551                                                                         goto structured;
01552                                                           else
01553                                                                 if(p[offset8] > cb)
01554                                                                   if(p[offset1] > cb)
01555                                                                         if(p[offset2] > cb)
01556                                                                           goto success_structured;
01557                                                                         else
01558                                                                           if(p[offset7] > cb)
01559                                                                                 goto success_structured;
01560                                                                           else
01561                                                                                 goto structured;
01562                                                                   else
01563                                                                         if(p[offset6] > cb)
01564                                                                           if(p[offset7] > cb)
01565                                                                                 goto success_structured;
01566                                                                           else
01567                                                                                 goto structured;
01568                                                                         else
01569                                                                           goto structured;
01570                                                                 else
01571                                                                   goto structured;
01572                                                         else
01573                                                           goto structured;
01574                                                   else
01575                                                         goto structured;
01576                                           else
01577                                                 if(p[offset9] < c_b)
01578                                                   if(p[offset2] > cb)
01579                                                         if(p[offset1] > cb)
01580                                                           if(p[offset4] > cb)
01581                                                                 if(p[offset10] > cb)
01582                                                                   if(p[offset3] > cb)
01583                                                                         if(p[offset11] > cb)
01584                                                                           goto success_structured;
01585                                                                         else
01586                                                                           goto structured;
01587                                                                   else
01588                                                                         goto structured;
01589                                                                 else
01590                                                                   if(p[offset6] < c_b)
01591                                                                         if(p[offset7] < c_b)
01592                                                                           if(p[offset8] < c_b)
01593                                                                                 if(p[offset11] < c_b)
01594                                                                                   if(p[offset10] < c_b)
01595                                                                                         goto success_structured;
01596                                                                                   else
01597                                                                                         goto structured;
01598                                                                                 else
01599                                                                                   goto structured;
01600                                                                           else
01601                                                                                 goto structured;
01602                                                                         else
01603                                                                           goto structured;
01604                                                                   else
01605                                                                         goto structured;
01606                                                           else
01607                                                                 if(p[offset6] < c_b)
01608                                                                   if(p[offset7] < c_b)
01609                                                                         if(p[offset8] < c_b)
01610                                                                           if(p[offset10] < c_b)
01611                                                                                 if(p[offset4] < c_b)
01612                                                                                   goto success_structured;
01613                                                                                 else
01614                                                                                   if(p[offset11] < c_b)
01615                                                                                         goto success_structured;
01616                                                                                   else
01617                                                                                         goto structured;
01618                                                                           else
01619                                                                                 if(p[offset3] < c_b)
01620                                                                                   if(p[offset4] < c_b)
01621                                                                                         goto success_structured;
01622                                                                                   else
01623                                                                                         goto structured;
01624                                                                                 else
01625                                                                                   goto structured;
01626                                                                         else
01627                                                                           goto structured;
01628                                                                   else
01629                                                                         goto structured;
01630                                                                 else
01631                                                                   goto structured;
01632                                                         else
01633                                                           if(p[offset6] < c_b)
01634                                                                 if(p[offset7] < c_b)
01635                                                                   if(p[offset8] < c_b)
01636                                                                         if(p[offset4] < c_b)
01637                                                                           if(p[offset3] < c_b)
01638                                                                                 goto success_structured;
01639                                                                           else
01640                                                                                 if(p[offset10] < c_b)
01641                                                                                   goto success_structured;
01642                                                                                 else
01643                                                                                   goto structured;
01644                                                                         else
01645                                                                           if(p[offset10] < c_b)
01646                                                                                 if(p[offset11] < c_b)
01647                                                                                   goto success_structured;
01648                                                                                 else
01649                                                                                   goto structured;
01650                                                                           else
01651                                                                                 goto structured;
01652                                                                   else
01653                                                                         goto structured;
01654                                                                 else
01655                                                                   goto structured;
01656                                                           else
01657                                                                 goto structured;
01658                                                   else
01659                                                         if(p[offset6] < c_b)
01660                                                           if(p[offset7] < c_b)
01661                                                                 if(p[offset8] < c_b)
01662                                                                   if(p[offset4] < c_b)
01663                                                                         if(p[offset3] < c_b)
01664                                                                           goto success_structured;
01665                                                                         else
01666                                                                           if(p[offset10] < c_b)
01667                                                                                 goto success_structured;
01668                                                                           else
01669                                                                                 goto structured;
01670                                                                   else
01671                                                                         if(p[offset10] < c_b)
01672                                                                           if(p[offset11] < c_b)
01673                                                                                 goto success_structured;
01674                                                                           else
01675                                                                                 goto structured;
01676                                                                         else
01677                                                                           goto structured;
01678                                                                 else
01679                                                                   if(p[offset2] < c_b)
01680                                                                         if(p[offset1] < c_b)
01681                                                                           if(p[offset3] < c_b)
01682                                                                                 if(p[offset4] < c_b)
01683                                                                                   goto success_structured;
01684                                                                                 else
01685                                                                                   goto structured;
01686                                                                           else
01687                                                                                 goto structured;
01688                                                                         else
01689                                                                           goto structured;
01690                                                                   else
01691                                                                         goto structured;
01692                                                           else
01693                                                                 goto structured;
01694                                                         else
01695                                                           goto structured;
01696                                                 else
01697                                                   if(p[offset2] > cb)
01698                                                         if(p[offset1] > cb)
01699                                                           if(p[offset3] > cb)
01700                                                                 if(p[offset4] > cb)
01701                                                                   if(p[offset10] > cb)
01702                                                                         if(p[offset11] > cb)
01703                                                                           goto success_structured;
01704                                                                         else
01705                                                                           goto structured;
01706                                                                   else
01707                                                                         goto structured;
01708                                                                 else
01709                                                                   goto structured;
01710                                                           else
01711                                                                 goto structured;
01712                                                         else
01713                                                           goto structured;
01714                                                   else
01715                                                         if(p[offset2] < c_b)
01716                                                           if(p[offset3] < c_b)
01717                                                                 if(p[offset4] < c_b)
01718                                                                   if(p[offset7] < c_b)
01719                                                                         if(p[offset1] < c_b)
01720                                                                           if(p[offset6] < c_b)
01721                                                                                 goto success_structured;
01722                                                                           else
01723                                                                                 goto structured;
01724                                                                         else
01725                                                                           if(p[offset6] < c_b)
01726                                                                                 if(p[offset8] < c_b)
01727                                                                                   goto success_structured;
01728                                                                                 else
01729                                                                                   goto structured;
01730                                                                           else
01731                                                                                 goto structured;
01732                                                                   else
01733                                                                         goto structured;
01734                                                                 else
01735                                                                   goto structured;
01736                                                           else
01737                                                                 goto structured;
01738                                                         else
01739                                                           goto homogeneous;
01740                                         else
01741                                           if(p[offset2] > cb)
01742                                                 if(p[offset10] > cb)
01743                                                   if(p[offset11] > cb)
01744                                                         if(p[offset9] > cb)
01745                                                           if(p[offset1] > cb)
01746                                                                 if(p[offset3] > cb)
01747                                                                   goto success_structured;
01748                                                                 else
01749                                                                   if(p[offset8] > cb)
01750                                                                         goto success_structured;
01751                                                                   else
01752                                                                         goto structured;
01753                                                           else
01754                                                                 if(p[offset6] > cb)
01755                                                                   if(p[offset7] > cb)
01756                                                                         if(p[offset8] > cb)
01757                                                                           goto success_structured;
01758                                                                         else
01759                                                                           goto structured;
01760                                                                   else
01761                                                                         goto structured;
01762                                                                 else
01763                                                                   goto structured;
01764                                                         else
01765                                                           if(p[offset1] > cb)
01766                                                                 if(p[offset3] > cb)
01767                                                                   if(p[offset4] > cb)
01768                                                                         goto success_structured;
01769                                                                   else
01770                                                                         goto structured;
01771                                                                 else
01772                                                                   goto structured;
01773                                                           else
01774                                                                 goto structured;
01775                                                   else
01776                                                         goto structured;
01777                                                 else
01778                                                   goto structured;
01779                                           else
01780                                                 if(p[offset9] > cb)
01781                                                   if(p[offset7] > cb)
01782                                                         if(p[offset8] > cb)
01783                                                           if(p[offset10] > cb)
01784                                                                 if(p[offset11] > cb)
01785                                                                   if(p[offset1] > cb)
01786                                                                         goto success_structured;
01787                                                                   else
01788                                                                         if(p[offset6] > cb)
01789                                                                           goto success_structured;
01790                                                                         else
01791                                                                           goto structured;
01792                                                                 else
01793                                                                   goto structured;
01794                                                           else
01795                                                                 goto structured;
01796                                                         else
01797                                                           goto structured;
01798                                                   else
01799                                                         goto structured;
01800                                                 else
01801                                                   goto structured;
01802                                 else if(p[offset0] < c_b)
01803                                   if(p[offset2] > cb)
01804                                         if(p[offset5] > cb)
01805                                           if(p[offset7] > cb)
01806                                                 if(p[offset6] > cb)
01807                                                   if(p[offset4] > cb)
01808                                                         if(p[offset3] > cb)
01809                                                           if(p[offset1] > cb)
01810                                                                 goto success_structured;
01811                                                           else
01812                                                                 if(p[offset8] > cb)
01813                                                                   goto success_structured;
01814                                                                 else
01815                                                                   goto structured;
01816                                                         else
01817                                                           if(p[offset9] > cb)
01818                                                                 if(p[offset8] > cb)
01819                                                                   if(p[offset10] > cb)
01820                                                                         goto success_structured;
01821                                                                   else
01822                                                                         goto structured;
01823                                                                 else
01824                                                                   goto structured;
01825                                                           else
01826                                                                 goto structured;
01827                                                   else
01828                                                         if(p[offset9] > cb)
01829                                                           if(p[offset8] > cb)
01830                                                                 if(p[offset10] > cb)
01831                                                                   if(p[offset11] > cb)
01832                                                                         goto success_structured;
01833                                                                   else
01834                                                                         goto structured;
01835                                                                 else
01836                                                                   goto structured;
01837                                                           else
01838                                                                 goto structured;
01839                                                         else
01840                                                           goto structured;
01841                                                 else
01842                                                   goto structured;
01843                                           else
01844                                                 if(p[offset9] < c_b)
01845                                                   if(p[offset8] < c_b)
01846                                                         if(p[offset10] < c_b)
01847                                                           if(p[offset11] < c_b)
01848                                                                 if(p[offset7] < c_b)
01849                                                                   if(p[offset1] < c_b)
01850                                                                         goto success_structured;
01851                                                                   else
01852                                                                         if(p[offset6] < c_b)
01853                                                                           goto success_structured;
01854                                                                         else
01855                                                                           goto structured;
01856                                                                 else
01857                                                                   goto structured;
01858                                                           else
01859                                                                 goto structured;
01860                                                         else
01861                                                           goto structured;
01862                                                   else
01863                                                         goto structured;
01864                                                 else
01865                                                   goto structured;
01866                                         else
01867                                           if(p[offset9] < c_b)
01868                                                 if(p[offset7] < c_b)
01869                                                   if(p[offset8] < c_b)
01870                                                         if(p[offset5] < c_b)
01871                                                           if(p[offset1] < c_b)
01872                                                                 if(p[offset10] < c_b)
01873                                                                   if(p[offset11] < c_b)
01874                                                                         goto success_structured;
01875                                                                   else
01876                                                                         if(p[offset6] < c_b)
01877                                                                           if(p[offset4] < c_b)
01878                                                                                 goto success_structured;
01879                                                                           else
01880                                                                                 goto structured;
01881                                                                         else
01882                                                                           goto structured;
01883                                                                 else
01884                                                                   if(p[offset6] < c_b)
01885                                                                         if(p[offset3] < c_b)
01886                                                                           if(p[offset4] < c_b)
01887                                                                                 goto success_structured;
01888                                                                           else
01889                                                                                 goto structured;
01890                                                                         else
01891                                                                           goto structured;
01892                                                                   else
01893                                                                         goto structured;
01894                                                           else
01895                                                                 if(p[offset6] < c_b)
01896                                                                   if(p[offset4] < c_b)
01897                                                                         if(p[offset3] < c_b)
01898                                                                           goto success_structured;
01899                                                                         else
01900                                                                           if(p[offset10] < c_b)
01901                                                                                 goto success_structured;
01902                                                                           else
01903                                                                                 goto structured;
01904                                                                   else
01905                                                                         if(p[offset10] < c_b)
01906                                                                           if(p[offset11] < c_b)
01907                                                                                 goto success_structured;
01908                                                                           else
01909                                                                                 goto structured;
01910                                                                         else
01911                                                                           goto structured;
01912                                                                 else
01913                                                                   goto structured;
01914                                                         else
01915                                                           if(p[offset10] < c_b)
01916                                                                 if(p[offset11] < c_b)
01917                                                                   if(p[offset1] < c_b)
01918                                                                         goto success_structured;
01919                                                                   else
01920                                                                         if(p[offset6] < c_b)
01921                                                                           goto success_structured;
01922                                                                         else
01923                                                                           goto structured;
01924                                                                 else
01925                                                                   goto structured;
01926                                                           else
01927                                                                 goto structured;
01928                                                   else
01929                                                         goto structured;
01930                                                 else
01931                                                   goto structured;
01932                                           else
01933                                                 goto structured;
01934                                   else
01935                                         if(p[offset2] < c_b)
01936                                           if(p[offset9] > cb)
01937                                                 if(p[offset5] > cb)
01938                                                   if(p[offset1] < c_b)
01939                                                         if(p[offset4] < c_b)
01940                                                           if(p[offset10] < c_b)
01941                                                                 if(p[offset3] < c_b)
01942                                                                   if(p[offset11] < c_b)
01943                                                                         goto success_structured;
01944                                                                   else
01945                                                                         goto structured;
01946                                                                 else
01947                                                                   goto structured;
01948                                                           else
01949                                                                 if(p[offset6] > cb)
01950                                                                   if(p[offset7] > cb)
01951                                                                         if(p[offset8] > cb)
01952                                                                           if(p[offset11] > cb)
01953                                                                                 if(p[offset10] > cb)
01954                                                                                   goto success_structured;
01955                                                                                 else
01956                                                                                   goto structured;
01957                                                                           else
01958                                                                                 goto structured;
01959                                                                         else
01960                                                                           goto structured;
01961                                                                   else
01962                                                                         goto structured;
01963                                                                 else
01964                                                                   goto structured;
01965                                                         else
01966                                                           if(p[offset6] > cb)
01967                                                                 if(p[offset7] > cb)
01968                                                                   if(p[offset8] > cb)
01969                                                                         if(p[offset10] > cb)
01970                                                                           if(p[offset4] > cb)
01971                                                                                 goto success_structured;
01972                                                                           else
01973                                                                                 if(p[offset11] > cb)
01974                                                                                   goto success_structured;
01975                                                                                 else
01976                                                                                   goto structured;
01977                                                                         else
01978                                                                           if(p[offset3] > cb)
01979                                                                                 if(p[offset4] > cb)
01980                                                                                   goto success_structured;
01981                                                                                 else
01982                                                                                   goto structured;
01983                                                                           else
01984                                                                                 goto structured;
01985                                                                   else
01986                                                                         goto structured;
01987                                                                 else
01988                                                                   goto structured;
01989                                                           else
01990                                                                 goto structured;
01991                                                   else
01992                                                         if(p[offset6] > cb)
01993                                                           if(p[offset7] > cb)
01994                                                                 if(p[offset8] > cb)
01995                                                                   if(p[offset4] > cb)
01996                                                                         if(p[offset3] > cb)
01997                                                                           goto success_structured;
01998                                                                         else
01999                                                                           if(p[offset10] > cb)
02000                                                                                 goto success_structured;
02001                                                                           else
02002                                                                                 goto structured;
02003                                                                   else
02004                                                                         if(p[offset10] > cb)
02005                                                                           if(p[offset11] > cb)
02006                                                                                 goto success_structured;
02007                                                                           else
02008                                                                                 goto structured;
02009                                                                         else
02010                                                                           goto structured;
02011                                                                 else
02012                                                                   goto structured;
02013                                                           else
02014                                                                 goto structured;
02015                                                         else
02016                                                           goto structured;
02017                                                 else
02018                                                   if(p[offset3] < c_b)
02019                                                         if(p[offset4] < c_b)
02020                                                           if(p[offset5] < c_b)
02021                                                                 if(p[offset1] < c_b)
02022                                                                   if(p[offset6] < c_b)
02023                                                                         goto success_structured;
02024                                                                   else
02025                                                                         if(p[offset11] < c_b)
02026                                                                           goto success_structured;
02027                                                                         else
02028                                                                           goto structured;
02029                                                                 else
02030                                                                   if(p[offset6] < c_b)
02031                                                                         if(p[offset7] < c_b)
02032                                                                           if(p[offset8] < c_b)
02033                                                                                 goto success_structured;
02034                                                                           else
02035                                                                                 goto structured;
02036                                                                         else
02037                                                                           goto structured;
02038                                                                   else
02039                                                                         goto structured;
02040                                                           else
02041                                                                 if(p[offset1] < c_b)
02042                                                                   if(p[offset10] < c_b)
02043                                                                         if(p[offset11] < c_b)
02044                                                                           goto success_structured;
02045                                                                         else
02046                                                                           goto structured;
02047                                                                   else
02048                                                                         goto structured;
02049                                                                 else
02050                                                                   goto structured;
02051                                                         else
02052                                                           goto structured;
02053                                                   else
02054                                                         goto structured;
02055                                           else
02056                                                 if(p[offset9] < c_b)
02057                                                   if(p[offset5] < c_b)
02058                                                         if(p[offset1] < c_b)
02059                                                           if(p[offset6] < c_b)
02060                                                                 if(p[offset3] < c_b)
02061                                                                   if(p[offset4] < c_b)
02062                                                                         goto success_structured;
02063                                                                   else
02064                                                                         if(p[offset10] < c_b)
02065                                                                           if(p[offset11] < c_b)
02066                                                                                 goto success_structured;
02067                                                                           else
02068                                                                                 goto structured;
02069                                                                         else
02070                                                                           goto structured;
02071                                                                 else
02072                                                                   if(p[offset8] < c_b)
02073                                                                         if(p[offset10] < c_b)
02074                                                                           if(p[offset11] < c_b)
02075                                                                                 goto success_structured;
02076                                                                           else
02077                                                                                 if(p[offset4] < c_b)
02078                                                                                   if(p[offset7] < c_b)
02079                                                                                         goto success_structured;
02080                                                                                   else
02081                                                                                         goto structured;
02082                                                                                 else
02083                                                                                   goto structured;
02084                                                                         else
02085                                                                           goto structured;
02086                                                                   else
02087                                                                         goto structured;
02088                                                           else
02089                                                                 if(p[offset11] < c_b)
02090                                                                   if(p[offset3] < c_b)
02091                                                                         if(p[offset4] < c_b)
02092                                                                           goto success_structured;
02093                                                                         else
02094                                                                           if(p[offset10] < c_b)
02095                                                                                 goto success_structured;
02096                                                                           else
02097                                                                                 goto structured;
02098                                                                   else
02099                                                                         if(p[offset8] < c_b)
02100                                                                           if(p[offset10] < c_b)
02101                                                                                 goto success_structured;
02102                                                                           else
02103                                                                                 goto structured;
02104                                                                         else
02105                                                                           goto structured;
02106                                                                 else
02107                                                                   goto structured;
02108                                                         else
02109                                                           if(p[offset6] < c_b)
02110                                                                 if(p[offset7] < c_b)
02111                                                                   if(p[offset8] < c_b)
02112                                                                         if(p[offset4] < c_b)
02113                                                                           if(p[offset3] < c_b)
02114                                                                                 goto success_structured;
02115                                                                           else
02116                                                                                 if(p[offset10] < c_b)
02117                                                                                   goto success_structured;
02118                                                                                 else
02119                                                                                   goto structured;
02120                                                                         else
02121                                                                           if(p[offset10] < c_b)
02122                                                                                 if(p[offset11] < c_b)
02123                                                                                   goto success_structured;
02124                                                                                 else
02125                                                                                   goto structured;
02126                                                                           else
02127                                                                                 goto structured;
02128                                                                   else
02129                                                                         goto structured;
02130                                                                 else
02131                                                                   goto structured;
02132                                                           else
02133                                                                 goto structured;
02134                                                   else
02135                                                         if(p[offset10] < c_b)
02136                                                           if(p[offset11] < c_b)
02137                                                                 if(p[offset1] < c_b)
02138                                                                   if(p[offset3] < c_b)
02139                                                                         goto success_structured;
02140                                                                   else
02141                                                                         if(p[offset8] < c_b)
02142                                                                           goto success_structured;
02143                                                                         else
02144                                                                           goto structured;
02145                                                                 else
02146                                                                   if(p[offset6] < c_b)
02147                                                                         if(p[offset7] < c_b)
02148                                                                           if(p[offset8] < c_b)
02149                                                                                 goto success_structured;
02150                                                                           else
02151                                                                                 goto structured;
02152                                                                         else
02153                                                                           goto structured;
02154                                                                   else
02155                                                                         goto structured;
02156                                                           else
02157                                                                 goto structured;
02158                                                         else
02159                                                           goto structured;
02160                                                 else
02161                                                   if(p[offset3] < c_b)
02162                                                         if(p[offset4] < c_b)
02163                                                           if(p[offset5] < c_b)
02164                                                                 if(p[offset1] < c_b)
02165                                                                   if(p[offset6] < c_b)
02166                                                                         goto success_structured;
02167                                                                   else
02168                                                                         if(p[offset11] < c_b)
02169                                                                           goto success_structured;
02170                                                                         else
02171                                                                           goto structured;
02172                                                                 else
02173                                                                   if(p[offset6] < c_b)
02174                                                                         if(p[offset7] < c_b)
02175                                                                           if(p[offset8] < c_b)
02176                                                                                 goto success_structured;
02177                                                                           else
02178                                                                                 goto structured;
02179                                                                         else
02180                                                                           goto structured;
02181                                                                   else
02182                                                                         goto structured;
02183                                                           else
02184                                                                 if(p[offset1] < c_b)
02185                                                                   if(p[offset10] < c_b)
02186                                                                         if(p[offset11] < c_b)
02187                                                                           goto success_structured;
02188                                                                         else
02189                                                                           goto structured;
02190                                                                   else
02191                                                                         goto structured;
02192                                                                 else
02193                                                                   goto structured;
02194                                                         else
02195                                                           goto structured;
02196                                                   else
02197                                                         goto structured;
02198                                         else
02199                                           if(p[offset9] < c_b)
02200                                                 if(p[offset7] < c_b)
02201                                                   if(p[offset8] < c_b)
02202                                                         if(p[offset5] < c_b)
02203                                                           if(p[offset1] < c_b)
02204                                                                 if(p[offset10] < c_b)
02205                                                                   if(p[offset11] < c_b)
02206                                                                         goto success_structured;
02207                                                                   else
02208                                                                         if(p[offset6] < c_b)
02209                                                                           if(p[offset4] < c_b)
02210                                                                                 goto success_structured;
02211                                                                           else
02212                                                                                 goto structured;
02213                                                                         else
02214                                                                           goto structured;
02215                                                                 else
02216                                                                   if(p[offset6] < c_b)
02217                                                                         if(p[offset3] < c_b)
02218                                                                           if(p[offset4] < c_b)
02219                                                                                 goto success_structured;
02220                                                                           else
02221                                                                                 goto structured;
02222                                                                         else
02223                                                                           goto structured;
02224                                                                   else
02225                                                                         goto structured;
02226                                                           else
02227                                                                 if(p[offset6] < c_b)
02228                                                                   if(p[offset4] < c_b)
02229                                                                         if(p[offset3] < c_b)
02230                                                                           goto success_structured;
02231                                                                         else
02232                                                                           if(p[offset10] < c_b)
02233                                                                                 goto success_structured;
02234                                                                           else
02235                                                                                 goto structured;
02236                                                                   else
02237                                                                         if(p[offset10] < c_b)
02238                                                                           if(p[offset11] < c_b)
02239                                                                                 goto success_structured;
02240                                                                           else
02241                                                                                 goto structured;
02242                                                                         else
02243                                                                           goto structured;
02244                                                                 else
02245                                                                   goto structured;
02246                                                         else
02247                                                           if(p[offset10] < c_b)
02248                                                                 if(p[offset11] < c_b)
02249                                                                   if(p[offset1] < c_b)
02250                                                                         goto success_structured;
02251                                                                   else
02252                                                                         if(p[offset6] < c_b)
02253                                                                           goto success_structured;
02254                                                                         else
02255                                                                           goto structured;
02256                                                                 else
02257                                                                   goto structured;
02258                                                           else
02259                                                                 goto structured;
02260                                                   else
02261                                                         goto structured;
02262                                                 else
02263                                                   goto structured;
02264                                           else
02265                                                 if(p[offset5] > cb)
02266                                                   if(p[offset9] > cb)
02267                                                         if(p[offset6] > cb)
02268                                                           if(p[offset7] > cb)
02269                                                                 if(p[offset8] > cb)
02270                                                                   if(p[offset4] > cb)
02271                                                                         if(p[offset3] > cb)
02272                                                                           goto success_structured;
02273                                                                         else
02274                                                                           if(p[offset10] > cb)
02275                                                                                 goto success_structured;
02276                                                                           else
02277                                                                                 goto structured;
02278                                                                   else
02279                                                                         if(p[offset10] > cb)
02280                                                                           if(p[offset11] > cb)
02281                                                                                 goto success_structured;
02282                                                                           else
02283                                                                                 goto structured;
02284                                                                         else
02285                                                                           goto structured;
02286                                                                 else
02287                                                                   goto structured;
02288                                                           else
02289                                                                 goto structured;
02290                                                         else
02291                                                           goto structured;
02292                                                   else
02293                                                         goto homogeneous;
02294                                                 else
02295                                                   goto structured;
02296                                 else
02297                                   if(p[offset5] > cb)
02298                                         if(p[offset9] > cb)
02299                                           if(p[offset6] > cb)
02300                                                 if(p[offset7] > cb)
02301                                                   if(p[offset4] > cb)
02302                                                         if(p[offset3] > cb)
02303                                                           if(p[offset8] > cb)
02304                                                                 goto success_structured;
02305                                                           else
02306                                                                 if(p[offset1] > cb)
02307                                                                   if(p[offset2] > cb)
02308                                                                         goto success_structured;
02309                                                                   else
02310                                                                         goto structured;
02311                                                                 else
02312                                                                   goto structured;
02313                                                         else
02314                                                           if(p[offset8] > cb)
02315                                                                 if(p[offset10] > cb)
02316                                                                   goto success_structured;
02317                                                                 else
02318                                                                   goto structured;
02319                                                           else
02320                                                                 goto structured;
02321                                                   else
02322                                                         if(p[offset11] > cb)
02323                                                           if(p[offset8] > cb)
02324                                                                 if(p[offset10] > cb)
02325                                                                   goto success_structured;
02326                                                                 else
02327                                                                   goto structured;
02328                                                           else
02329                                                                 goto structured;
02330                                                         else
02331                                                           goto structured;
02332                                                 else
02333                                                   goto structured;
02334                                           else
02335                                                 goto structured;
02336                                         else
02337                                           if(p[offset2] > cb)
02338                                                 if(p[offset3] > cb)
02339                                                   if(p[offset4] > cb)
02340                                                         if(p[offset7] > cb)
02341                                                           if(p[offset1] > cb)
02342                                                                 if(p[offset6] > cb)
02343                                                                   goto success_structured;
02344                                                                 else
02345                                                                   goto structured;
02346                                                           else
02347                                                                 if(p[offset6] > cb)
02348                                                                   if(p[offset8] > cb)
02349                                                                         goto success_structured;
02350                                                                   else
02351                                                                         goto structured;
02352                                                                 else
02353                                                                   goto structured;
02354                                                         else
02355                                                           goto structured;
02356                                                   else
02357                                                         goto structured;
02358                                                 else
02359                                                   goto structured;
02360                                           else
02361                                                 goto structured;
02362                                   else
02363                                         if(p[offset5] < c_b)
02364                                           if(p[offset9] < c_b)
02365                                                 if(p[offset6] < c_b)
02366                                                   if(p[offset7] < c_b)
02367                                                         if(p[offset4] < c_b)
02368                                                           if(p[offset3] < c_b)
02369                                                                 if(p[offset8] < c_b)
02370                                                                   goto success_structured;
02371                                                                 else
02372                                                                   if(p[offset1] < c_b)
02373                                                                         if(p[offset2] < c_b)
02374                                                                           goto success_structured;
02375                                                                         else
02376                                                                           goto structured;
02377                                                                   else
02378                                                                         goto structured;
02379                                                           else
02380                                                                 if(p[offset8] < c_b)
02381                                                                   if(p[offset10] < c_b)
02382                                                                         goto success_structured;
02383                                                                   else
02384                                                                         goto structured;
02385                                                                 else
02386                                                                   goto structured;
02387                                                         else
02388                                                           if(p[offset11] < c_b)
02389                                                                 if(p[offset8] < c_b)
02390                                                                   if(p[offset10] < c_b)
02391                                                                         goto success_structured;
02392                                                                   else
02393                                                                         goto structured;
02394                                                                 else
02395                                                                   goto structured;
02396                                                           else
02397                                                                 goto structured;
02398                                                   else
02399                                                         goto structured;
02400                                                 else
02401                                                   goto structured;
02402                                           else
02403                                                 if(p[offset2] < c_b)
02404                                                   if(p[offset3] < c_b)
02405                                                         if(p[offset4] < c_b)
02406                                                           if(p[offset7] < c_b)
02407                                                                 if(p[offset1] < c_b)
02408                                                                   if(p[offset6] < c_b)
02409                                                                         goto success_structured;
02410                                                                   else
02411                                                                         goto structured;
02412                                                                 else
02413                                                                   if(p[offset6] < c_b)
02414                                                                         if(p[offset8] < c_b)
02415                                                                           goto success_structured;
02416                                                                         else
02417                                                                           goto structured;
02418                                                                   else
02419                                                                         goto structured;
02420                                                           else
02421                                                                 goto structured;
02422                                                         else
02423                                                           goto structured;
02424                                                   else
02425                                                         goto structured;
02426                                                 else
02427                                                   goto structured;
02428                                         else
02429                                           goto homogeneous;
02430                         }
02431 }
02432 success_homogeneous:
02433                         if(total == nExpectedCorners)
02434                         {
02435                                 if(nExpectedCorners==0)
02436                                 {
02437                                         nExpectedCorners=512;
02438                                         corners_all.reserve(nExpectedCorners);
02439                                 }
02440                                 else
02441                                 {
02442                                         nExpectedCorners *=2;
02443                                         corners_all.reserve(nExpectedCorners);
02444                                 }
02445                         }
02446                         h.x=x;
02447                         h.y=y;
02448                         corners_all.push_back(h);
02449                         total++;
02450                         goto homogeneous;                               
02451 success_structured:
02452                         if(total == nExpectedCorners)
02453                         {
02454                                 if(nExpectedCorners==0)
02455                                 {
02456                                         nExpectedCorners=512;
02457                                         corners_all.reserve(nExpectedCorners);
02458                                 }
02459                                 else
02460                                 {
02461                                         nExpectedCorners *=2;
02462                                         corners_all.reserve(nExpectedCorners);
02463                                 }
02464                         }
02465                         h.x=x;
02466                         h.y=y;
02467                         corners_all.push_back(h);
02468                         total++;                                                
02469                         goto structured;                                
02470                 }                                                                       
02471         }                                                                               
02472 }
02473 
02474