agast7_12d.cc
Go to the documentation of this file.
00001 //
00002 //    agast7d - AGAST, an adaptive and generic corner detector based on the
00003 //              accelerated segment test for a 12 pixel mask in diamond format
00004 //
00005 //    Copyright (C) 2010  Elmar Mair
00006 //
00007 //    This program is free software: you can redistribute it and/or modify
00008 //    it under the terms of the GNU General Public License as published by
00009 //    the Free Software Foundation, either version 3 of the License, or
00010 //    (at your option) any later version.
00011 //
00012 //    This program is distributed in the hope that it will be useful,
00013 //    but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 //    GNU General Public License for more details.
00016 //
00017 //    You should have received a copy of the GNU General Public License
00018 //    along with this program.  If not, see <http://www.gnu.org/licenses/>.
00019 
00020 //machine generated code
00021 //probability of an equal pixel on the Bresenham's circle: 0.33 and 0.1
00022 //number of equal pixels to switch: 2
00023 //number of unequal pixels to switch: 9
00024 //memory costs: cache=0.2
00025 //              same line=1
00026 //              memory=4
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 //end of file


ptam
Author(s): Markus Achtelik , Stephan Weiss , Simon Lynen
autogenerated on Sun Oct 5 2014 23:52:33