#   elseyystrlen (yystr)     const char *yystr;#   endif{  register const char *yys = yystr;  while (*yys++ != '\0')    continue;  return yys - yystr - 1;}#  endif# endif# ifndef yystpcpy#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)#   define yystpcpy stpcpy#  else/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in   YYDEST.  */static char *#   if defined (__STDC__) || defined (__cplusplus)yystpcpy (char *yydest, const char *yysrc)#   elseyystpcpy (yydest, yysrc)     char *yydest;     const char *yysrc;#   endif{  register char *yyd = yydest;  register const char *yys = yysrc;  while ((*yyd++ = *yys++) != '\0')    continue;  return yyd - 1;}#  endif# endif#endif /* !YYERROR_VERBOSE */#if YYDEBUG/*--------------------------------.| Print this symbol on YYOUTPUT.  |`--------------------------------*/#if defined (__STDC__) || defined (__cplusplus)static voidyysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)#elsestatic voidyysymprint (yyoutput, yytype, yyvaluep)    FILE *yyoutput;    int yytype;    YYSTYPE *yyvaluep;#endif{  /* Pacify ``unused variable'' warnings.  */  (void) yyvaluep;  if (yytype < YYNTOKENS)    {      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);# ifdef YYPRINT      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);# endif    }  else    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);  switch (yytype)    {      default:        break;    }  YYFPRINTF (yyoutput, ")");}#endif /* ! YYDEBUG *//*-----------------------------------------------.| Release the memory associated to this symbol.  |`-----------------------------------------------*/#if defined (__STDC__) || defined (__cplusplus)static voidyydestruct (int yytype, YYSTYPE *yyvaluep)#elsestatic voidyydestruct (yytype, yyvaluep)    int yytype;    YYSTYPE *yyvaluep;#endif{  /* Pacify ``unused variable'' warnings.  */  (void) yyvaluep;  switch (yytype)    {      default:        break;    }}/* Prevent warnings from -Wmissing-prototypes.  */#ifdef YYPARSE_PARAM# if defined (__STDC__) || defined (__cplusplus)int yyparse (void *YYPARSE_PARAM);# elseint yyparse ();# endif#else /* ! YYPARSE_PARAM */#if defined (__STDC__) || defined (__cplusplus)int yyparse (void);#elseint yyparse ();#endif#endif /* ! YYPARSE_PARAM *//* The lookahead symbol.  */int yychar;/* The semantic value of the lookahead symbol.  */YYSTYPE yylval;/* Number of syntax errors so far.  */int yynerrs;/*----------.| yyparse.  |`----------*/#ifdef YYPARSE_PARAM# if defined (__STDC__) || defined (__cplusplus)int yyparse (void *YYPARSE_PARAM)# elseint yyparse (YYPARSE_PARAM)  void *YYPARSE_PARAM;# endif#else /* ! YYPARSE_PARAM */#if defined (__STDC__) || defined (__cplusplus)intyyparse (void)#elseintyyparse ()#endif#endif{    register int yystate;  register int yyn;  int yyresult;  /* Number of tokens to shift before error messages enabled.  */  int yyerrstatus;  /* Lookahead token as an internal (translated) token number.  */  int yytoken = 0;  /* Three stacks and their tools:     `yyss': related to states,     `yyvs': related to semantic values,     `yyls': related to locations.     Refer to the stacks thru separate pointers, to allow yyoverflow     to reallocate them elsewhere.  */  /* The state stack.  */  short	yyssa[YYINITDEPTH];  short *yyss = yyssa;  register short *yyssp;  /* The semantic value stack.  */  YYSTYPE yyvsa[YYINITDEPTH];  YYSTYPE *yyvs = yyvsa;  register YYSTYPE *yyvsp;#define YYPOPSTACK   (yyvsp--, yyssp--)  YYSIZE_T yystacksize = YYINITDEPTH;  /* The variables used to return semantic value and location from the     action routines.  */  YYSTYPE yyval;  /* When reducing, the number of symbols on the RHS of the reduced     rule.  */  int yylen;  YYDPRINTF ((stderr, "Starting parse\n"));  yystate = 0;  yyerrstatus = 0;  yynerrs = 0;  yychar = YYEMPTY;		/* Cause a token to be read.  */  /* Initialize stack pointers.     Waste one element of value and location stack     so that they stay on the same level as the state stack.     The wasted elements are never initialized.  */  yyssp = yyss;  yyvsp = yyvs;  goto yysetstate;/*------------------------------------------------------------.| yynewstate -- Push a new state, which is found in yystate.  |`------------------------------------------------------------*/ yynewstate:  /* In all cases, when you get here, the value and location stacks     have just been pushed. so pushing a state here evens the stacks.     */  yyssp++; yysetstate:  *yyssp = yystate;  if (yyss + yystacksize - 1 <= yyssp)    {      /* Get the current used size of the three stacks, in elements.  */      YYSIZE_T yysize = yyssp - yyss + 1;#ifdef yyoverflow      {	/* Give user a chance to reallocate the stack. Use copies of	   these so that the &'s don't force the real ones into	   memory.  */	YYSTYPE *yyvs1 = yyvs;	short *yyss1 = yyss;	/* Each stack pointer address is followed by the size of the	   data in use in that stack, in bytes.  This used to be a	   conditional around just the two extra args, but that might	   be undefined if yyoverflow is a macro.  */	yyoverflow ("parser stack overflow",		    &yyss1, yysize * sizeof (*yyssp),		    &yyvs1, yysize * sizeof (*yyvsp),		    &yystacksize);	yyss = yyss1;	yyvs = yyvs1;      }#else /* no yyoverflow */# ifndef YYSTACK_RELOCATE      goto yyoverflowlab;# else      /* Extend the stack our own way.  */      if (YYMAXDEPTH <= yystacksize)	goto yyoverflowlab;      yystacksize *= 2;      if (YYMAXDEPTH < yystacksize)	yystacksize = YYMAXDEPTH;      {	short *yyss1 = yyss;	union yyalloc *yyptr =	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));	if (! yyptr)	  goto yyoverflowlab;	YYSTACK_RELOCATE (yyss);	YYSTACK_RELOCATE (yyvs);#  undef YYSTACK_RELOCATE	if (yyss1 != yyssa)	  YYSTACK_FREE (yyss1);      }# endif#endif /* no yyoverflow */      yyssp = yyss + yysize - 1;      yyvsp = yyvs + yysize - 1;      YYDPRINTF ((stderr, "Stack size increased to %lu\n",		  (unsigned long int) yystacksize));      if (yyss + yystacksize - 1 <= yyssp)	YYABORT;    }  YYDPRINTF ((stderr, "Entering state %d\n", yystate));  goto yybackup;/*-----------.| yybackup.  |`-----------*/yybackup:/* Do appropriate processing given the current state.  *//* Read a lookahead token if we need one and don't already have one.  *//* yyresume: */  /* First try to decide what to do without reference to lookahead token.  */  yyn = yypact[yystate];  if (yyn == YYPACT_NINF)    goto yydefault;  /* Not known => get a lookahead token if don't already have one.  */  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */  if (yychar == YYEMPTY)    {      YYDPRINTF ((stderr, "Reading a token: "));      yychar = YYLEX;    }  if (yychar <= YYEOF)    {      yychar = yytoken = YYEOF;      YYDPRINTF ((stderr, "Now at end of input.\n"));    }  else    {      yytoken = YYTRANSLATE (yychar);      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);    }  /* If the proper action on seeing token YYTOKEN is to reduce or to     detect an error, take that action.  */  yyn += yytoken;  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)    goto yydefault;  yyn = yytable[yyn];  if (yyn <= 0)    {      if (yyn == 0 || yyn == YYTABLE_NINF)	goto yyerrlab;      yyn = -yyn;      goto yyreduce;    }  if (yyn == YYFINAL)    YYACCEPT;  /* Shift the lookahead token.  */  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));  /* Discard the token being shifted unless it is eof.  */  if (yychar != YYEOF)    yychar = YYEMPTY;  *++yyvsp = yylval;  /* Count tokens shifted since error; after three, turn off error     status.  */  if (yyerrstatus)    yyerrstatus--;  yystate = yyn;  goto yynewstate;/*-----------------------------------------------------------.| yydefault -- do the default action for the current state.  |`-----------------------------------------------------------*/yydefault:  yyn = yydefact[yystate];  if (yyn == 0)    goto yyerrlab;  goto yyreduce;/*-----------------------------.| yyreduce -- Do a reduction.  |`-----------------------------*/yyreduce:  /* yyn is the number of a rule to reduce with.  */  yylen = yyr2[yyn];  /* If YYLEN is nonzero, implement the default value of the action:     `$$ = $1'.     Otherwise, the following line sets YYVAL to garbage.     This behavior is undocumented and Bison     users should not rely upon it.  Assigning to YYVAL     unconditionally makes the parser a bit smaller, and it avoids a     GCC warning that YYVAL may be used uninitialized.  */  yyval = yyvsp[1-yylen];  YY_REDUCE_PRINT (yyn);  switch (yyn)    {        case 2:#line 209 "CascadeFileParser.yy"    {}    break;  case 3:#line 210 "CascadeFileParser.yy"    {}    break;  case 4:#line 217 "CascadeFileParser.yy"    {  }    break;  case 5:#line 222 "CascadeFileParser.yy"    {  }    break;  case 6:#line 226 "CascadeFileParser.yy"    {  }    break;  case 7:#line 232 "CascadeFileParser.yy"    {    if (!parse_entire_cascade) {      throw ITException("wrong parsing mode set");    }    pCascade = new CClassifierCascade();    pCascade->m_name = yyIDstring;//    pCascade->m_name = $3;    curr_branch = -1;  }    break;  case 8:#line 247 "CascadeFileParser.yy"    {    image_width = yyvsp[-16].ival;    image_height = yyvsp[-14].ival;    pCascade->m_template_width = yyvsp[-16].ival;    pCascade->m_template_height = yyvsp[-14].ival;    pCascade->m_image_area_ratio = yyvsp[-11].fval;    pCascade->m_structure_type = CClassifierCascade::CASCADE_TYPE_SEQUENTIAL;    pCascade->m_total_false_positive_rate = yyvsp[-7].fval;    pCascade->m_last_detection_rate = yyvsp[-3].fval;    pCascade->m_trainset_exhausted = yyvsp[-1].bval;  }    break;  case 9:#line 265 "CascadeFileParser.yy"    {    image_width = yyvsp[-19].ival;    image_height = yyvsp[-17].ival;    pCascade->m_template_width = yyvsp[-19].ival;    pCascade->m_template_height = yyvsp[-17].ival;    pCascade->m_image_area_ratio = yyvsp[-14].fval;    pCascade->m_structure_type = CClassifierCascade::CASCADE_TYPE_FAN;    pCascade->m_total_false_positive_rate = yyvsp[-10].fval;    pCascade->m_last_detection_rate = yyvsp[-6].fval;    pCascade->m_trainset_exhausted = yyvsp[-4].bval;    int num_branches = yyvsp[-2].ival;    pCascade->m_branch_classifiers.resize(num_branches);    pCascade->m_branch_names.resize(num_branches);    pCascade->m_branch_false_positive_rates.resize(num_branches);    pCascade->m_branch_detection_rates.resize(num_branches);    pCascade->m_branch_lyr_false_positive_rates.resize(num_branches);    pCascade->m_branch_lyr_detection_rates.resize(num_branches);  }    break;  case 10:#line 287 "CascadeFileParser.yy"    {    pCascade->m_structure_type = CClassifierCascade::CASCADE_TYPE_TREE;