anchor.diff:          satisfy pred "FLOATCONSTANT"
           
           
  -    and doubleConstant =
  +    let doubleConstant =
           let pred token =
               match token with
               | Token.DOUBLECONSTANT _ -> true
  
positive.code:         
          tokensP <|> (identifierP |>> ignore) (*TYPE_NAME*) <|> structSpecifierP
  
      and arraySpecifierP =
          let singular =
              (leftBracketP .>>. rightBracketP |>> ignore) 
              <|> (leftBracketP .>>. constantExpressionP .>>. rightBracketP |>> ignore) 
          
          many1 singular |>> ignore
      
      and typeSpecifierP =
          (typeSpecifierNonArrayP |>> ignore)
          <|> (typeSpecifierNonArrayP .>>. arraySpecifierP |>> ignore)
      
      and typeNameListP =
          (identifierP |>> ignore) .>>. many (commaP .>>. identifierP |>> ignore) 
      
      and storageQualifierP =
          let tokens = [
              Token.CONST
              Token.IN
  
negative.code:         <|> (postfixExpressionPRef.Parser .>>. tokenP Token.INCOP |>> ignore)
          <|> (postfixExpressionPRef.Parser .>>. tokenP Token.DECOP |>> ignore)
      
      let unaryOperatorP =
          (tokenP Token.PLUS
          <|> tokenP Token.DASH
          <|> tokenP Token.BANG
          <|> tokenP Token.TILDE) |>> ignore
      
      let unaryExpressionP =
          (postfixExpressionP |>> ignore)
          <|> (tokenP Token.INCOP .>>. unaryExpressionPRef.Parser |>> ignore)
          <|> (tokenP Token.DECOP .>>. unaryExpressionPRef.Parser |>> ignore)
          <|> (unaryOperatorP .>>. unaryExpressionPRef.Parser |>> ignore)
          
      let multiplicativeExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let multiplicativeExpressionP =
          unaryExpressionP
          <|> (multiplicativeExpressionPRef.Parser .>>. tokenP Token.STAR .>>. unaryExpressionP |>> ignore)
          <|> (multiplicativeExpressionPRef.Parser .>>. tokenP Token.SLASH .>>. unaryExpressionP |>> ignore)
          <|> (multiplicativeExpressionPRef.Parser .>>. tokenP Token.PERCENT .>>. unaryExpressionP |>> ignore)
          
      let additiveExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let additiveExpressionP =
          multiplicativeExpressionP
          <|> (additiveExpressionPRef.Parser .>>. tokenP Token.PLUS .>>. multiplicativeExpressionP |>> ignore)
          <|> (additiveExpressionPRef.Parser .>>. tokenP Token.DASH .>>. multiplicativeExpressionP |>> ignore)
  
      let shiftExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let shiftExpressionP =
          additiveExpressionP
          <|> (shiftExpressionPRef.Parser .>>. tokenP Token.LEFTOP .>>. additiveExpressionP |>> ignore)
          <|> (shiftExpressionPRef.Parser .>>. tokenP Token.RIGHTOP .>>. additiveExpressionP |>> ignore)
      
      let relationalExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let 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)
  
      let equalityExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let equalityExpressionP =
          relationalExpressionP
          <|> (equalityExpressionPRef.Parser .>>. tokenP Token.EQOP .>>. relationalExpressionP |>> ignore)
          <|> (equalityExpressionPRef.Parser .>>. tokenP Token.NEOP .>>. relationalExpressionP |>> ignore)
      
      let andExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let andExpressionP =
          equalityExpressionP
          <|> (andExpressionPRef.Parser .>>. tokenP Token.AMPERSAND .>>. equalityExpressionP |>> ignore) 
  
      let exclusiveOrExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let exclusiveOrExpressionP =    
          andExpressionP
          <|> (exclusiveOrExpressionPRef.Parser .>>. tokenP Token.CARET .>>. andExpressionP |>> ignore)
          
      let inclusiveOrExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let inclusiveOrExpressionP =
          exclusiveOrExpressionP
          <|> (inclusiveOrExpressionPRef.Parser .>>. tokenP Token.VERTICALBAR .>>. exclusiveOrExpressionP |>> ignore)
  
      let logicalAndExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let logicalAndExpressionP =
          inclusiveOrExpressionP
          <|> (logicalAndExpressionPRef.Parser .>>. tokenP Token.ANDOP .>>. inclusiveOrExpressionP |>> ignore) 
  
      let logicalXorExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let logicalXorExpressionP =
          logicalAndExpressionP
          <|> (logicalXorExpressionPRef.Parser .>>. tokenP Token.XOROP .>>. logicalAndExpressionP |>> ignore)
  
      let logicalOrExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let logicalOrExpressionP =
          logicalXorExpressionP
          <|> (logicalOrExpressionPRef.Parser .>>. tokenP Token.OROP .>>. logicalXorExpressionP |>> ignore)
          
      let conditionalExpressionP =
          logicalOrExpressionP
          <|> (logicalOrExpressionP .>>. tokenP Token.QUESTION .>>. expressionPRef.Parser .>>. tokenP Token.COLON .>>. assignmentExpressionPRef.Parser |>> ignore)
  
      let assignmentExpressionPRef = ParserWithPositionalErrors.createRefParser ()
      let assignmentExpressionP =
          conditionalExpressionP
          <|> (unaryExpressionP .>>. assignmentOpP .>>. assignmentExpressionPRef.Parser |>> ignore)
      
      let expressionP =
          assignmentExpressionP .>>. (many (commaP .>>. assignmentExpressionP)) |>> ignore
          
      let expressionStatementP =
          (semicolonP |>> ignore)
          <|> (expressionP .>>. semicolonP |>> ignore)
  
      let selectionRestStatementP =
          (statementPRef.Parser .>>. tokenP Token.ELSE .>>. statementPRef.Parser |>> ignore)
          <|> statementPRef.Parser
              
      let selectionStatementP =
          tokenP Token.IF .>>. leftParenP .>>. expressionP .>>. rightParenP .>>. selectionRestStatementP |>> ignore
      
      let switchStatementListP = statementListP
  
      let switchStatementP =
          tokenP Token.SWITCH .>>. leftParenP .>>. expressionP .>>. rightParenP .>>. leftBraceP .>>. switchStatementListP .>>. rightBraceP |>> ignore
          
      let caseLabelP =
          (tokenP Token.CASE .>>. expressionP .>>. tokenP Token.COLON) |>> ignore
          <|> (tokenP Token.DEFAULT .>>. tokenP Token.COLON |>> ignore)
      
      let iterationStatementP = failwith "todo"
      //    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
          
      
      let jumpStatementP = failwith "todo"
      
      let simpleStatementP =    
          declarationStatementP
          <|> expressionStatementP
          <|> selectionStatementP
  