RelationalBinding
p EQ 2001
p GE 2001
967933
private void _buildRelationalBinding(
                    final RelationalBinding binding,
                    final StringBuilder stmt,
                    final List<Object> params
                    )
    {
        String  property = binding.getProperty();
        Object  value = binding.getValue();
        Relation  rel = binding.getRelation();

        if (value == null) {
            NullBinding  nullBinding = new NullBinding();
            nullBinding.setProperty( property );
            if (Relation.EQUAL == rel) {
                nullBinding.setNotNull( false );
            } else if (Relation.NOT_EQUAL == rel) {
                nullBinding.setNotNull( true );
            } else {
                throw new IllegalArgumentException(
                                "invalid null-valued RelationalBinding: "
                                + String.valueOf( binding ) );
            }
            _buildNullBinding( nullBinding, stmt );
            //throws SearchException

        } else {
            _buildProperty( property, stmt );
            //throws SearchException
            stmt.append( _SPACE_ );
            stmt.append( rel.operator() );
            stmt.append( _SPACE_ );
            _buildParameter( value, stmt, params );
        }
    }
679803
def bind(self, **bindings):
    """"""
    found_vars = set()
    result = []
    for layer in self.flatten():
      if isinstance(layer, _DeferredLayer):
        var_keys = {var.key for var in six.itervalues(layer.unbound_vars)}
        layers_bindings = {
            k: v
            for k, v in six.iteritems(bindings) if k in var_keys
        }
        result.append(layer.bind(**layers_bindings))
        found_vars.update(six.iterkeys(layers_bindings))
      else:
        result.append(layer)
    missing_vars = set(six.iterkeys(bindings)) - found_vars
    if missing_vars:
      raise ValueError('Unused bindings: %s' % missing_vars)
    return self.__class__(*result)
1000152
function() {
      var properties = {
        normal: [],
        relational: [],
        derived: []
      };
      var privateProps = this._private || {};
      var relations = _.result(this, 'relations') || {};
      var derived = _.result(this, 'derived') || {};

      var isEditable = function(value) {
        if (!_.isObject(value)) {
          return true;
        } else if (_.isArray(value)) {
          var result = true;
          _.each(value, function(i) {
            result = result && isEditable(i);
          });
          return result;
        } else {
          try {
            JSON.stringify(value);
            return true;
          } catch (ex) {
            return false;
          }
        }
      };

      _.each(this.attributes, function(value, key) {
        if (privateProps[key]) {
          return;
        }
        var prop;
        if (relations && relations[key]) {
          properties.relational.push({
            key: key,
            data: {
              isRelation: true,
              name: value.getDebugName()
            }
          });
        } else if (derived && derived[key]) {
          properties.derived.push({
            key: key,
            data: {
              isDerived: derived[key],
              value: value,
              displayValue: isEditable(value) ? JSON.stringify(value) : Object.prototype.toString.call(value)
            }
          });
        } else {
          prop = {
            key: key,
            data: {
              isEditable: isEditable(value),
              isEditing: false,
              isRemovable: true,
              value: value
            }
          };

          prop.data.displayValue = prop.data.isEditable ? JSON.stringify(value) : Object.prototype.toString.call(value);
          properties.normal.push(prop);
        }
      });

      properties.normal = _.sortBy(properties.normal, 'key');
      properties.relational = _.sortBy(properties.relational, 'key');
      properties.derived = _.sortBy(properties.derived, 'key');

      return properties;
    }
662221
public final hqlParser.relationalExpression_return relationalExpression() throws RecognitionException {
		hqlParser.relationalExpression_return retval = new hqlParser.relationalExpression_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token n=null;
		Token i=null;
		Token b=null;
		Token l=null;
		Token LT167=null;
		Token GT168=null;
		Token LE169=null;
		Token GE170=null;
		Token MEMBER176=null;
		Token OF177=null;
		ParserRuleReturnScope p =null;
		ParserRuleReturnScope concatenation166 =null;
		ParserRuleReturnScope bitwiseNotExpression171 =null;
		ParserRuleReturnScope inList172 =null;
		ParserRuleReturnScope betweenList173 =null;
		ParserRuleReturnScope concatenation174 =null;
		ParserRuleReturnScope likeEscape175 =null;

		CommonTree n_tree=null;
		CommonTree i_tree=null;
		CommonTree b_tree=null;
		CommonTree l_tree=null;
		CommonTree LT167_tree=null;
		CommonTree GT168_tree=null;
		CommonTree LE169_tree=null;
		CommonTree GE170_tree=null;
		CommonTree MEMBER176_tree=null;
		CommonTree OF177_tree=null;

		try {
			// hql.g:454:2: ( concatenation ( ( ( ( LT ^| GT ^| LE ^| GE ^) bitwiseNotExpression )* ) | (n= NOT !)? ( (i= IN ^ inList ) | (b= BETWEEN ^ betweenList ) | (l= LIKE ^ concatenation likeEscape ) | ( MEMBER ! ( OF !)? p= path !) ) ) )
			// hql.g:454:4: concatenation ( ( ( ( LT ^| GT ^| LE ^| GE ^) bitwiseNotExpression )* ) | (n= NOT !)? ( (i= IN ^ inList ) | (b= BETWEEN ^ betweenList ) | (l= LIKE ^ concatenation likeEscape ) | ( MEMBER ! ( OF !)? p= path !) ) )
			{
			root_0 = (CommonTree)adaptor.nil();


			pushFollow(FOLLOW_concatenation_in_relationalExpression2059);
			concatenation166=concatenation();
			state._fsp--;

			adaptor.addChild(root_0, concatenation166.getTree());

			// hql.g:454:18: ( ( ( ( LT ^| GT ^| LE ^| GE ^) bitwiseNotExpression )* ) | (n= NOT !)? ( (i= IN ^ inList ) | (b= BETWEEN ^ betweenList ) | (l= LIKE ^ concatenation likeEscape ) | ( MEMBER ! ( OF !)? p= path !) ) )
			int alt62=2;
			int LA62_0 = input.LA(1);
			if ( (LA62_0==EOF||LA62_0==AND||(LA62_0 >= AS && LA62_0 <= ASCENDING)||(LA62_0 >= CLOSE && LA62_0 <= CLOSE_BRACKET)||LA62_0==COMMA||LA62_0==DESCENDING||LA62_0==ELSE||(LA62_0 >= END && LA62_0 <= EQ)||(LA62_0 >= FROM && LA62_0 <= HAVING)||LA62_0==INNER||LA62_0==IS||(LA62_0 >= JOIN && LA62_0 <= LE)||LA62_0==LEFT||LA62_0==LT||LA62_0==NE||(LA62_0 >= OR && LA62_0 <= ORDER)||LA62_0==RIGHT||LA62_0==SKIP||LA62_0==SQL_NE||(LA62_0 >= TAKE && LA62_0 <= THEN)||LA62_0==UNION||(LA62_0 >= WHEN && LA62_0 <= WHERE)||(LA62_0 >= 133 && LA62_0 <= 134)) ) {
				alt62=1;
			}
			else if ( (LA62_0==BETWEEN||LA62_0==IN||LA62_0==LIKE||LA62_0==MEMBER||LA62_0==NOT) ) {
				alt62=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 62, 0, input);
				throw nvae;
			}

			switch (alt62) {
				case 1 :
					// hql.g:455:3: ( ( ( LT ^| GT ^| LE ^| GE ^) bitwiseNotExpression )* )
					{
					// hql.g:455:3: ( ( ( LT ^| GT ^| LE ^| GE ^) bitwiseNotExpression )* )
					// hql.g:455:5: ( ( LT ^| GT ^| LE ^| GE ^) bitwiseNotExpression )*
					{
					// hql.g:455:5: ( ( LT ^| GT ^| LE ^| GE ^) bitwiseNotExpression )*
					loop58:
					while (true) {
						int alt58=2;
						int LA58_0 = input.LA(1);
						if ( (LA58_0==GE||LA58_0==GT||LA58_0==LE||LA58_0==LT) ) {
							alt58=1;
						}

						switch (alt58) {
						case 1 :
							// hql.g:455:7: ( LT ^| GT ^| LE ^| GE ^) bitwiseNotExpression
							{
							// hql.g:455:7: ( LT ^| GT ^| LE ^| GE ^)
							int alt57=4;
							switch ( input.LA(1) ) {
							case LT:
								{
								alt57=1;
								}
								break;
							case GT:
								{
								alt57=2;
								}
								break;
							case LE:
								{
								alt57=3;
								}
								break;
							case GE:
								{
								alt57=4;
								}
								break;
							default:
								NoViableAltException nvae =
									new NoViableAltException("", 57, 0, input);
								throw nvae;
							}
							switch (alt57) {
								case 1 :
									// hql.g:455:9: LT ^
									{
									LT167=(Token)match(input,LT,FOLLOW_LT_in_relationalExpression2071);
									LT167_tree = (CommonTree)adaptor.create(LT167);
									root_0 = (CommonTree)adaptor.becomeRoot(LT167_tree, root_0);

									}
									break;
								case 2 :
									// hql.g:455:15: GT ^
									{
									GT168=(Token)match(input,GT,FOLLOW_GT_in_relationalExpression2076);
									GT168_tree = (CommonTree)adaptor.create(GT168);
									root_0 = (CommonTree)adaptor.becomeRoot(GT168_tree, root_0);

									}
									break;
								case 3 :
									// hql.g:455:21: LE ^
									{
									LE169=(Token)match(input,LE,FOLLOW_LE_in_relationalExpression2081);
									LE169_tree = (CommonTree)adaptor.create(LE169);
									root_0 = (CommonTree)adaptor.becomeRoot(LE169_tree, root_0);

									}
									break;
								case 4 :
									// hql.g:455:27: GE ^
									{
									GE170=(Token)match(input,GE,FOLLOW_GE_in_relationalExpression2086);
									GE170_tree = (CommonTree)adaptor.create(GE170);
									root_0 = (CommonTree)adaptor.becomeRoot(GE170_tree, root_0);

									}
									break;

							}

							pushFollow(FOLLOW_bitwiseNotExpression_in_relationalExpression2091);
							bitwiseNotExpression171=bitwiseNotExpression();
							state._fsp--;

							adaptor.addChild(root_0, bitwiseNotExpression171.getTree());

							}
							break;

						default :
							break loop58;
						}
					}

					}

					}
					break;
				case 2 :
					// hql.g:457:5: (n= NOT !)? ( (i= IN ^ inList ) | (b= BETWEEN ^ betweenList ) | (l= LIKE ^ concatenation likeEscape ) | ( MEMBER ! ( OF !)? p= path !) )
					{
					// hql.g:457:5: (n= NOT !)?
					int alt59=2;
					int LA59_0 = input.LA(1);
					if ( (LA59_0==NOT) ) {
						alt59=1;
					}
					switch (alt59) {
						case 1 :
							// hql.g:457:6: n= NOT !
							{
							n=(Token)match(input,NOT,FOLLOW_NOT_in_relationalExpression2108);
							}
							break;

					}

					// hql.g:457:15: ( (i= IN ^ inList ) | (b= BETWEEN ^ betweenList ) | (l= LIKE ^ concatenation likeEscape ) | ( MEMBER ! ( OF !)? p= path !) )
					int alt61=4;
					switch ( input.LA(1) ) {
					case IN:
						{
						alt61=1;
						}
						break;
					case BETWEEN:
						{
						alt61=2;
						}
						break;
					case LIKE:
						{
						alt61=3;
						}
						break;
					case MEMBER:
						{
						alt61=4;
						}
						break;
					default:
						NoViableAltException nvae =
							new NoViableAltException("", 61, 0, input);
						throw nvae;
					}
					switch (alt61) {
						case 1 :
							// hql.g:460:4: (i= IN ^ inList )
							{
							// hql.g:460:4: (i= IN ^ inList )
							// hql.g:460:5: i= IN ^ inList
							{
							i=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression2129);
							i_tree = (CommonTree)adaptor.create(i);
							root_0 = (CommonTree)adaptor.becomeRoot(i_tree, root_0);


												i.setType( (n == null) ? IN : NOT_IN );
												i.setText( (n == null) ? "in" : "not in" );

							pushFollow(FOLLOW_inList_in_relationalExpression2138);
							inList172=inList();
							state._fsp--;

							adaptor.addChild(root_0, inList172.getTree());

							}

							}
							break;
						case 2 :
							// hql.g:465:6: (b= BETWEEN ^ betweenList )
							{
							// hql.g:465:6: (b= BETWEEN ^ betweenList )
							// hql.g:465:7: b= BETWEEN ^ betweenList
							{
							b=(Token)match(input,BETWEEN,FOLLOW_BETWEEN_in_relationalExpression2149);
							b_tree = (CommonTree)adaptor.create(b);
							root_0 = (CommonTree)adaptor.becomeRoot(b_tree, root_0);


												b.setType( (n == null) ? BETWEEN : NOT_BETWEEN );
												b.setText( (n == null) ? "between" : "not between" );

							pushFollow(FOLLOW_betweenList_in_relationalExpression2158);
							betweenList173=betweenList();
							state._fsp--;

							adaptor.addChild(root_0, betweenList173.getTree());

							}

							}
							break;
						case 3 :
							// hql.g:470:6: (l= LIKE ^ concatenation likeEscape )
							{
							// hql.g:470:6: (l= LIKE ^ concatenation likeEscape )
							// hql.g:470:7: l= LIKE ^ concatenation likeEscape
							{
							l=(Token)match(input,LIKE,FOLLOW_LIKE_in_relationalExpression2170);
							l_tree = (CommonTree)adaptor.create(l);
							root_0 = (CommonTree)adaptor.becomeRoot(l_tree, root_0);


												l.setType( (n == null) ? LIKE : NOT_LIKE );
												l.setText( (n == null) ? "like" : "not like" );

							pushFollow(FOLLOW_concatenation_in_relationalExpression2179);
							concatenation174=concatenation();
							state._fsp--;

							adaptor.addChild(root_0, concatenation174.getTree());

							pushFollow(FOLLOW_likeEscape_in_relationalExpression2181);
							likeEscape175=likeEscape();
							state._fsp--;

							adaptor.addChild(root_0, likeEscape175.getTree());

							}

							}
							break;
						case 4 :
							// hql.g:475:6: ( MEMBER ! ( OF !)? p= path !)
							{
							// hql.g:475:6: ( MEMBER ! ( OF !)? p= path !)
							// hql.g:475:7: MEMBER ! ( OF !)? p= path !
							{
							MEMBER176=(Token)match(input,MEMBER,FOLLOW_MEMBER_in_relationalExpression2190);
							// hql.g:475:15: ( OF !)?
							int alt60=2;
							int LA60_0 = input.LA(1);
							if ( (LA60_0==OF) ) {
								alt60=1;
							}
							switch (alt60) {
								case 1 :
									// hql.g:475:16: OF !
									{
									OF177=(Token)match(input,OF,FOLLOW_OF_in_relationalExpression2194);
									}
									break;

							}

							pushFollow(FOLLOW_path_in_relationalExpression2201);
							p=path();
							state._fsp--;


											root_0 = ProcessMemberOf(n,(p!=null?((CommonTree)p.getTree()):null), root_0);

							}

							}
							break;

					}

					}
					break;

			}

			}

			retval.stop = input.LT(-1);

			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
235774
RelationImpl buildRelation(EdgeElement edge, RelationType type, Role owner, Role value) {
        return getOrBuildConcept(edge, (e) -> RelationImpl.create(RelationEdge.create(type, owner, value, edge)));
    }
64187
def get_implicit_constraints(self,relations):
        ''' '''

        constraints = []
        for relation in [r for r in relations if not r.is_negated()]  :
            const_dict = relation.get_constants()
            for constant in const_dict:
                for position in const_dict[constant]:
                    constraints.append( \
                        relation.get_name() + '.' + self.mapPositionToColumnName(relation,position) + ' = ' + str(constant) \
                    )
        return constraints
400415
private void resolve(LinkRelation rel) {
    Iterator<LinkRelationRef> refs = rel.getLinkRelationRefs().iterator();
    while (refs.hasNext()) {
      LinkRelationRef ref = refs.next();
      LinkRelation referencedRel = linkRelations.stream()
          .filter(item -> StringUtils.equals(item.getRel(), ref.getRel()))
          .findFirst().orElse(null);
      if (referencedRel == null) {
        refs.remove();
      }
      else {
        if (StringUtils.isBlank(ref.getShortDescription())) {
          ref.setShortDescription(referencedRel.getShortDescription());
        }
      }
    }
  }
216246
public Object recursivelyFindEntities(Object entity, Map<String, Object> relationsMap, EntityMetadata m,
            PersistenceDelegator pd, boolean lazilyLoaded, Map<Object, Object> relationStack)
    {
        return handleAssociation(entity, relationsMap, m, pd, lazilyLoaded, relationStack);

    }
1178258
def _add_constraints(self, relation):
        
        expression = relation.expression
        pairs = []
        for value_set in expression.value_sets():
            ind, val = zip(*((self._variables[variable], float(value))
                             for variable, value in value_set))
            pairs.append(cp.SparsePair(ind=ind, val=val))

        names = [next(self._constr_names) for _ in pairs]

        sense = self.CONSTR_SENSE_MAP[relation.sense]
        self._cp.linear_constraints.add(
            names=names, lin_expr=pairs,
            senses=tuple(repeat(sense, len(pairs))),
            rhs=tuple(repeat(float(-expression.offset), len(pairs))))

        return names
535978
protected void bindBlobLiteral(int index, byte[] value) {
        if (blobLiterals == null) {
            blobLiterals = new LinkedHashMap<>();
        }
        blobLiterals.put(index, value);
    }
1343524
private char getRelationFromRels(char builtForRel, char glossRel) {
        if (builtForRel == IMappingElement.EQUIVALENCE) {
            return glossRel;
        }
        if (builtForRel == IMappingElement.LESS_GENERAL) {
            if ((glossRel == IMappingElement.LESS_GENERAL) || (glossRel == IMappingElement.EQUIVALENCE)) {
                return IMappingElement.LESS_GENERAL;
            }
        }
        if (builtForRel == IMappingElement.MORE_GENERAL) {
            if ((glossRel == IMappingElement.MORE_GENERAL) || (glossRel == IMappingElement.EQUIVALENCE)) {
                return IMappingElement.MORE_GENERAL;
            }
        }
        return IMappingElement.IDK;
    }
615514
def transform_relations(rdf, relationmap):
    """"""

    affected_types = (SKOS.Concept, SKOS.Collection,
                      SKOSEXT.DeprecatedConcept)

    props = set()
    for t in affected_types:
        for conc in rdf.subjects(RDF.type, t):
            for p, o in rdf.predicate_objects(conc):
                if isinstance(o, (URIRef, BNode)) \
                   and (p in relationmap or not in_general_ns(p)):
                    props.add(p)

    for p in props:
        if mapping_match(p, relationmap):
            newval = mapping_get(p, relationmap)
            logging.debug("transform relation %s -> %s", p, str(newval))
            replace_predicate(
                rdf, p, newval, subjecttypes=affected_types)
        else:
            logging.info("Don't know what to do with relation %s", p)
598073
private ConstraintSet solveEquality() {
    List<Constraint> current = eqConstraints;
    List<Constraint> next = Lists.newArrayList();
    boolean done = false;
    boolean solvable = this.solvable;

    TypeReplacement nextBindings = new TypeReplacement(bindings);
    while (!done) {
      done = true;
      // Iterative constraint solving algorithm with four cases
      for (Constraint c : current) {
        Type subtype = c.subtype.substitute(nextBindings.getBindings());
        Type supertype = c.supertype.substitute(nextBindings.getBindings());
        
        if (subtype.isFunctional() && supertype.isFunctional()) {
          // Case 1: <a,b> = <c,d> => a = c && b = d
          
          // Replace this constraint with the entailed subtype
          // constraints on argument/return types.
          next.add(new Constraint(supertype.getArgumentType(), subtype.getArgumentType()));
          next.add(new Constraint(subtype.getReturnType(), supertype.getReturnType()));
          done = false;
        } else if (!subtype.isFunctional() && supertype.isFunctional()) {
          // Case 2: A = <c,d> => A = <c,d> (if A is a type var, else fail)
          if (subtype.hasTypeVariables()) {
            nextBindings.add(subtype.getAtomicTypeVar(), supertype);
            done = false;
          } else {
            solvable = false;
          }
        } else if (subtype.isFunctional() && !supertype.isFunctional()) {
          // Case 3: <c,d> = A => A = <c,d> (if A is a type var, else fail)
          if (supertype.hasTypeVariables()) {
            nextBindings.add(supertype.getAtomicTypeVar(), subtype);
            done = false;
          } else {
            solvable = false;
          }
        } else {
          // Case 4: A = B => A = B
          if (subtype.hasTypeVariables() && supertype.hasTypeVariables()) {
            if (subtype.getAtomicTypeVar() != supertype.getAtomicTypeVar()) {
              nextBindings.add(subtype.getAtomicTypeVar(), supertype);
            }
          } else if (subtype.hasTypeVariables()) {
            nextBindings.add(subtype.getAtomicTypeVar(), supertype);
            done = false;
          } else if (supertype.hasTypeVariables()) {
            nextBindings.add(supertype.getAtomicTypeVar(), subtype);
            done = false;
          } else {
            if (!subtype.equals(supertype)) {
              solvable = false;
            }
          }
        }
      }

      current = next;
      next = Lists.newArrayList();
    }
    
    List<Constraint> newSubConstraints = Lists.newArrayList();
    for (Constraint c : subConstraints) {
      newSubConstraints.add(c.substitute(nextBindings.getBindings()));
    }
    return new ConstraintSet(Lists.newArrayList(), newSubConstraints, nextBindings,
        solvable, typeVarCounter);
  }
559168
private Statement relationPattern(Variable varName, Collection<RelationProperty.RolePlayer> relationPlayers) {
        Statement var = new Statement(varName);
        for (RelationProperty.RolePlayer rp : relationPlayers) {
            Statement rolePattern = rp.getRole().orElse(null);
            var = rolePattern != null? var.rel(rolePattern, rp.getPlayer()) : var.rel(rp.getPlayer());
        }
        return var;
    }
162271
function globalizeDeclaration(node, bindings) {
  return node.declarations.map(declaration =>
    t.expressionStatement(
      t.assignmentExpression(
        "=",
        getAssignmentTarget(declaration.id, bindings),
        declaration.init || t.unaryExpression("void", t.numericLiteral(0))
      )
    )
  );
}
158875
public final void relationalOp() throws RecognitionException {
		int relationalOp_StartIndex = input.index();

		try {
			if ( state.backtracking>0 && alreadyParsedRule(input, 119) ) { return; }

			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1174:5: ( ( '<' '=' | '>' '=' | '<' | '>' ) )
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1174:7: ( '<' '=' | '>' '=' | '<' | '>' )
			{
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1174:7: ( '<' '=' | '>' '=' | '<' | '>' )
			int alt151=4;
			int LA151_0 = input.LA(1);
			if ( (LA151_0==53) ) {
				int LA151_1 = input.LA(2);
				if ( (LA151_1==54) ) {
					alt151=1;
				}
				else if ( ((LA151_1 >= CharacterLiteral && LA151_1 <= DecimalLiteral)||LA151_1==FloatingPointLiteral||(LA151_1 >= HexLiteral && LA151_1 <= Identifier)||(LA151_1 >= OctalLiteral && LA151_1 <= StringLiteral)||LA151_1==29||LA151_1==36||(LA151_1 >= 40 && LA151_1 <= 41)||(LA151_1 >= 44 && LA151_1 <= 45)||LA151_1==53||LA151_1==65||LA151_1==67||(LA151_1 >= 70 && LA151_1 <= 71)||LA151_1==77||(LA151_1 >= 79 && LA151_1 <= 80)||LA151_1==82||LA151_1==85||LA151_1==92||LA151_1==94||(LA151_1 >= 97 && LA151_1 <= 98)||LA151_1==105||LA151_1==108||LA151_1==111||LA151_1==115||LA151_1==118||LA151_1==126) ) {
					alt151=3;
				}

				else {
					if (state.backtracking>0) {state.failed=true; return;}
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 151, 1, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}
			else if ( (LA151_0==56) ) {
				int LA151_2 = input.LA(2);
				if ( (LA151_2==54) ) {
					alt151=2;
				}
				else if ( ((LA151_2 >= CharacterLiteral && LA151_2 <= DecimalLiteral)||LA151_2==FloatingPointLiteral||(LA151_2 >= HexLiteral && LA151_2 <= Identifier)||(LA151_2 >= OctalLiteral && LA151_2 <= StringLiteral)||LA151_2==29||LA151_2==36||(LA151_2 >= 40 && LA151_2 <= 41)||(LA151_2 >= 44 && LA151_2 <= 45)||LA151_2==53||LA151_2==65||LA151_2==67||(LA151_2 >= 70 && LA151_2 <= 71)||LA151_2==77||(LA151_2 >= 79 && LA151_2 <= 80)||LA151_2==82||LA151_2==85||LA151_2==92||LA151_2==94||(LA151_2 >= 97 && LA151_2 <= 98)||LA151_2==105||LA151_2==108||LA151_2==111||LA151_2==115||LA151_2==118||LA151_2==126) ) {
					alt151=4;
				}

				else {
					if (state.backtracking>0) {state.failed=true; return;}
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 151, 2, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}

			else {
				if (state.backtracking>0) {state.failed=true; return;}
				NoViableAltException nvae =
					new NoViableAltException("", 151, 0, input);
				throw nvae;
			}

			switch (alt151) {
				case 1 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1174:8: '<' '='
					{
					match(input,53,FOLLOW_53_in_relationalOp5301); if (state.failed) return;
					match(input,54,FOLLOW_54_in_relationalOp5303); if (state.failed) return;
					}
					break;
				case 2 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1174:18: '>' '='
					{
					match(input,56,FOLLOW_56_in_relationalOp5307); if (state.failed) return;
					match(input,54,FOLLOW_54_in_relationalOp5309); if (state.failed) return;
					}
					break;
				case 3 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1174:28: '<'
					{
					match(input,53,FOLLOW_53_in_relationalOp5313); if (state.failed) return;
					}
					break;
				case 4 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1174:34: '>'
					{
					match(input,56,FOLLOW_56_in_relationalOp5317); if (state.failed) return;
					}
					break;

			}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			if ( state.backtracking>0 ) { memoize(input, 119, relationalOp_StartIndex); }

		}
	}
546011
public final void relationalExpression() throws RecognitionException {
		int relationalExpression_StartIndex = input.index();

		try {
			if ( state.backtracking>0 && alreadyParsedRule(input, 118) ) { return; }

			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1170:5: ( shiftExpression ( relationalOp shiftExpression )* )
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1170:9: shiftExpression ( relationalOp shiftExpression )*
			{
			pushFollow(FOLLOW_shiftExpression_in_relationalExpression5274);
			shiftExpression();
			state._fsp--;
			if (state.failed) return;
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1170:25: ( relationalOp shiftExpression )*
			loop150:
			while (true) {
				int alt150=2;
				alt150 = dfa150.predict(input);
				switch (alt150) {
				case 1 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:1170:27: relationalOp shiftExpression
					{
					pushFollow(FOLLOW_relationalOp_in_relationalExpression5278);
					relationalOp();
					state._fsp--;
					if (state.failed) return;
					pushFollow(FOLLOW_shiftExpression_in_relationalExpression5280);
					shiftExpression();
					state._fsp--;
					if (state.failed) return;
					}
					break;

				default :
					break loop150;
				}
			}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			if ( state.backtracking>0 ) { memoize(input, 118, relationalExpression_StartIndex); }

		}
	}