text: # Tenko parser test case
  
  - Path: tests/testcases/operator_precedent/sanity_canaries/div_and_lhs_xor_gte_min_lor_land_seq_or_pow.one.rev.md
  
  > :: operator precedent : sanity canaries
  >
  > ::> div and lhs xor gte min lor land seq or pow.one.rev
  >
  > Random ops to test for precedence
  
  ## Input
  
  `````js
  x0 / x1 & x2 << x3 ^ x4 >= x5 - x6 || x7 && x8 === x9 | x10 ** x
  `````
  
  ## Output
  
  _Note: the whole output block is auto-generated. Manual changes will be overwritten!_
  
  Below follow outputs in five parsing modes: sloppy, sloppy+annexb, strict script, module, module+annexb.
  
  Note that the output parts are auto-generated by the test runner to reflect actual result.
  
  ### Sloppy mode
  
  Parsed with script goal and as if the code did not start with strict mode header.
  
  `````
  ast: {
    type: 'Program',
    loc:{start:{line:1,column:0},end:{line:1,column:64},source:''},
    body: [
      {
        type: 'ExpressionStatement',
        loc:{start:{line:1,column:0},end:{line:1,column:64},source:''},
        expression: {
          type: 'LogicalExpression',
          loc:{start:{line:1,column:0},end:{line:1,column:64},source:''},
          left: {
            type: 'BinaryExpression',
            loc:{start:{line:1,column:0},end:{line:1,column:34},source:''},
            left: {
              type: 'BinaryExpression',
              loc:{start:{line:1,column:0},end:{line:1,column:18},source:''},
              left: {
                type: 'BinaryExpression',
                loc:{start:{line:1,column:0},end:{line:1,column:7},source:''},
                left: {
                  type: 'Identifier',
                  loc:{start:{line:1,column:0},end:{line:1,column:2},source:''},
                  name: 'x0'
                },
                operator: '/',
                right: {
                  type: 'Identifier',
                  loc:{start:{line:1,column:5},end:{line:1,column:7},source:''},
                  name: 'x1'
                }
              },
              operator: '&',
              right: {
                type: 'BinaryExpression',
                loc:{start:{line:1,column:10},end:{line:1,column:18},source:''},
                left: {
                  type: 'Identifier',
                  loc:{start:{line:1,column:10},end:{line:1,column:12},source:''},
                  name: 'x2'
                },
                operator: '<<',
                right: {
                  type: 'Identifier',
                  loc:{start:{line:1,column:16},end:{line:1,column:18},source:''},
                  name: 'x3'
                }
              }
            },
            operator: '^',
            right: {
              type: 'BinaryExpression',
              loc:{start:{line:1,column:21},end:{line:1,column:34},source:''},
              left: {
                type: 'Identifier',
                loc:{start:{line:1,column:21},end:{line:1,column:23},source:''},
                name: 'x4'
              },
              operator: '>=',
              right: {
                type: 'BinaryExpression',
                loc:{start:{line:1,column:27},end:{line:1,column:34},source:''},
                left: {
                  type: 'Identifier',
                  loc:{start:{line:1,column:27},end:{line:1,column:29},source:''},
                  name: 'x5'
                },
                operator: '-',
                right: {
                  type: 'Identifier',
                  loc:{start:{line:1,column:32},end:{line:1,column:34},source:''},
                  name: 'x6'
                }
              }
            }
          },
          operator: '||',
          right: {
            type: 'LogicalExpression',
            loc:{start:{line:1,column:38},end:{line:1,column:64},source:''},
            left: {
              type: 'Identifier',
              loc:{start:{line:1,column:38},end:{line:1,column:40},source:''},
              name: 'x7'
            },
            operator: '&&',
            right: {
              type: 'BinaryExpression',
              loc:{start:{line:1,column:44},end:{line:1,column:64},source:''},
              left: {
                type: 'BinaryExpression',
                loc:{start:{line:1,column:44},end:{line:1,column:53},source:''},
                left: {
                  type: 'Identifier',
                  loc:{start:{line:1,column:44},end:{line:1,column:46},source:''},
                  name: 'x8'
                },
                operator: '===',
                right: {
                  type: 'Identifier',
                  loc:{start:{line:1,column:51},end:{line:1,column:53},source:''},
                  name: 'x9'
                }
              },
              operator: '|',
              right: {
                type: 'BinaryExpression',
                loc:{start:{line:1,column:56},end:{line:1,column:64},source:''},
                left: {
                  type: 'Identifier',
                  loc:{start:{line:1,column:56},end:{line:1,column:59},source:''},
                  name: 'x10'
                },
                operator: '**',
                right: {
                  type: 'Identifier',
                  loc:{start:{line:1,column:63},end:{line:1,column:64},source:''},
                  name: 'x'
                }
              }
            }
          }
        }
      }
    ]
  }
  
  tokens (25x):
         IDENT PUNC_DIV IDENT PUNC_AND IDENT PUNC_LT_LT IDENT PUNC_CARET
         IDENT PUNC_GT_EQ IDENT PUNC_MIN IDENT PUNC_OR_OR IDENT
         PUNC_AND_AND IDENT PUNC_EQ_EQ_EQ IDENT PUNC_OR IDENT
         PUNC_STAR_STAR IDENT ASI
  `````
  
  ### Strict mode
  
  Parsed with script goal but as if it was starting with `"use strict"` at the top.
  
  _Output same as sloppy mode._
  
  ### Module goal
  
  Parsed with the module goal.
  
  _Output same as sloppy mode._
  
  ### Sloppy mode with AnnexB
  
  Parsed with script goal with AnnexB rules enabled and as if the code did not start with strict mode header.
  
  _Output same as sloppy mode._
  
  ### Module goal with AnnexB
  
  Parsed with the module goal with AnnexB rules enabled.
  
  _Output same as sloppy mode._
  
  ## AST Printer
  
  Printer output different from input [sloppy][annexb:no]:
  
  ````js
  ((((x0 / x1) & (x2 << x3)) ^ (x4 >= (x5 - x6))) || ((x7 && ((x8 === x9) | (x10 ** x)))));
  ````
  
  Produces same AST
  