anchor.diff:      let assignmentExpressionPRef = ParserWithPositionalErrors.createRefParser ()
       let functionCallHeaderWithParametersPRef = ParserWithPositionalErrors.createRefParser ()
       let unaryExpressionPRef = ParserWithPositionalErrors.createRefParser ()
  -        
  -    let rec structDeclaratorP =
  -        (identifierP |>> ignore) <|> (identifierP .>>. arraySpecifierP |>> ignore)
  -
  -    and structDeclaratorListP =
  +    let arraySpecifierPRef = ParserWithPositionalErrors.createRefParser ()
  +    let typeQualifierPRef = ParserWithPositionalErrors.createRefParser ()
  +    let statementPRef = ParserWithPositionalErrors.createRefParser ()
  +        
  +    let structDeclaratorP =
  +        (identifierP |>> ignore) <|> (identifierP .>>. arraySpecifierPRef.Parser |>> ignore)
  +
  +    let structDeclaratorListP =
           (structDeclaratorP .>>. (many (commaP .>>. structDeclaratorP)) |>> ignore)
           
  -    and structDeclarationP =
  +    let structDeclarationP =
           (typeSpecifierPRef.Parser .>>. structDeclaratorListP .>>. semicolonP |>> ignore)
  -        <|> (typeQualifierP .>>. typeSpecifierPRef.Parser .>>. structDeclaratorListP .>>. semicolonP |>> ignore)
  -    
  -    and structDeclarationListP = (many1 structDeclarationP) |>> ignore
  -
  -    and structSpecifierP =
  +        <|> (typeQualifierPRef.Parser .>>. typeSpecifierPRef.Parser .>>. structDeclaratorListP .>>. semicolonP |>> ignore)
  +    
  +    let structDeclarationListP = (many1 structDeclarationP) |>> ignore
  +
  +    let structSpecifierP =
           (tokenP Token.STRUCT .>>. identifierP .>>. leftBraceP .>>. structDeclarationListP .>>. rightBraceP |>> ignore)
           <|> (tokenP Token.STRUCT .>>. leftBraceP .>>. structDeclarationListP .>>. rightBraceP |>> ignore)
       
  -    and typeSpecifierNonArrayP =
  +    let typeSpecifierNonArrayP =
           let tokens = [
                   Token.VOID
                   Token.FLOAT
  
positive.code:         <|> (postfixExpressionPRef.Parser .>>. tokenP Token.INCOP |>> ignore)
          <|> (postfixExpressionPRef.Parser .>>. tokenP Token.DECOP |>> ignore)
      
      and unaryOperatorP =
          tokenP Token.PLUS
          <|> tokenP Token.DASH
          <|> tokenP Token.BANG
          <|> tokenP Token.TILDE |>> ignore
      
      and unaryExpressionP =
          (postfixExpressionP |>> ignore)
          <|> (tokenP Token.INCOP .>>. unaryExpressionPRef.Parser |>> ignore)
          <|> (tokenP Token.DECOP .>>. unaryExpressionPRef.Parser |>> ignore)
          <|> (unaryOperatorP .>>. unaryExpressionPRef.Parser |>> ignore)
          
      and multiplicativeExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and multiplicativeExpressionP =
          unaryExpressionP
          <|> (multiplicativeExpressionPRef.Parser .>>. tokenP Token.STAR .>>. unaryExpressionP |>> ignore)
          <|> (multiplicativeExpressionPRef.Parser .>>. tokenP Token.SLASH .>>. unaryExpressionP |>> ignore)
          <|> (multiplicativeExpressionPRef.Parser .>>. tokenP Token.PERCENT .>>. unaryExpressionP |>> ignore)
          
      and additiveExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and additiveExpressionP =
          multiplicativeExpressionP
          <|> (additiveExpressionPRef.Parser .>>. tokenP Token.PLUS .>>. multiplicativeExpressionP |>> ignore)
          <|> (additiveExpressionPRef.Parser .>>. tokenP Token.DASH .>>. multiplicativeExpressionP |>> ignore)
  
      and shiftExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and shiftExpressionP =
          additiveExpressionP
          <|> (shiftExpressionPRef.Parser .>>. tokenP Token.LEFTOP .>>. additiveExpressionP |>> ignore)
          <|> (shiftExpressionPRef.Parser .>>. tokenP Token.RIGHTOP .>>. additiveExpressionP |>> ignore)
      
      and relationalExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and relationalExpressionP =
          shiftExpressionP
          <|> (relationalExpressionPRef.Parser .>>. tokenP Token.LEFTANGLE .>>. shiftExpressionP |>> ignore)
          <|> (relationalExpressionPRef.Parser .>>. tokenP Token.RIGHTANGLE .>>. shiftExpressionP |>> ignore)
          <|> (relationalExpressionPRef.Parser .>>. tokenP Token.LEOP .>>. shiftExpressionP |>> ignore)
          <|> (relationalExpressionPRef.Parser .>>. tokenP Token.GEOP .>>. shiftExpressionP |>> ignore)
  
      and equalityExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and equalityExpressionP =
          relationalExpressionP
          <|> (equalityExpressionPRef.Parser .>>. tokenP Token.EQOP .>>. relationalExpressionP |>> ignore)
          <|> (equalityExpressionPRef.Parser .>>. tokenP Token.NEOP .>>. relationalExpressionP |>> ignore)
      
      and andExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and andExpressionP =
          equalityExpressionP
          <|> (andExpressionPRef.Parser .>>. tokenP Token.AMPERSAND .>>. equalityExpressionP |>> ignore) 
  
      and exclusiveOrExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and exclusiveOrExpressionP =    
          andExpressionP
          <|> (exclusiveOrExpressionPRef.Parser .>>. tokenP Token.CARET .>>. andExpressionP |>> ignore)
          
      and inclusiveOrExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and inclusiveOrExpressionP =
          exclusiveOrExpressionP
          <|> (inclusiveOrExpressionPRef.Parser .>>. tokenP Token.VERTICALBAR .>>. exclusiveOrExpressionP |>> ignore)
  
      and logicalAndExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and logicalAndExpressionP =
          inclusiveOrExpressionP
          <|> (logicalAndExpressionPRef.Parser .>>. tokenP Token.ANDOP .>>. inclusiveOrExpressionP |>> ignore) 
  
      and logicalXorExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and logicalXorExpressionP =
          logicalAndExpressionP
          <|> (logicalXorExpressionPRef.Parser .>>. tokenP Token.XOROP .>>. logicalAndExpressionP |>> ignore)
  
      and logicalOrExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      and logicalOrExpressionP =
          logicalXorExpressionP
          <|> (logicalOrExpressionPRef.Parser .>>. tokenP Token.OROP .>>. logicalXorExpressionP |>> ignore)
          
      and conditionalExpressionP =
          logicalOrExpressionP
          <|> (logicalOrExpressionP .>>. tokenP Token.QUESTION .>>. expressionPRef.Parser .>>. tokenP Token.COLON .>>. assignmentExpressionPRef.Parser |>> ignore)
  
      and assignmentExpressionP =
          conditionalExpressionP
          <|> (unaryExpressionP .>>. assignmentOpP .>>. assignmentExpressionP |>> ignore)
      
      and expressionP =
          assignmentExpressionP .>>. (many (commaP .>>. assignmentExpressionP)) |>> ignore
          
      and expressionStatementP =
          (semicolonP |>> ignore)
          <|> (expressionP .>>. semicolonP |>> ignore)
  
      and selectionRestStatementP =
          (statementP .>>. tokenP Token.ELSE .>>. statementP |>> ignore)
          <|> statementP
              
      and selectionStatementP =
          tokenP Token.IF .>>. leftParenP .>>. expressionP .>>. rightParenP .>>. selectionRestStatementP |>> ignore
      
      and switchStatementListP = statementListP
  
      and switchStatementP =
          tokenP Token.SWITCH .>>. leftParenP .>>. expressionP .>>. rightParenP .>>. leftBraceP .>>. switchStatementListP .>>. rightBraceP |>> ignore
          
      and caseLabelP =
          (tokenP Token.CASE .>>. expressionP .>>. tokenP Token.COLON) |>> ignore
          <|> (tokenP Token.DEFAULT .>>. tokenP Token.COLON |>> ignore)
      
      and iterationStatementP =
          tokenP Token.WHILE .>>. leftParenP .>>. conditionP .>>. rightParenP .>>. statementNoNewScopeP
          DO statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON
          FOR LEFT_PAREN for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope
          
      
      and jumpStatementP = failwith "todo"
      
      and simpleStatementP =    
          declarationStatementP
          <|> expressionStatementP
          <|> selectionStatementP
  
negative.code:         satisfy pred "FLOATCONSTANT"
          
          
      let doubleConstant =
          let pred token =
              match token with
              | Token.DOUBLECONSTANT _ -> true
  