The nodeFlags store the encoders to check for accessibility in edgeFlags. E.g. if nodeFlags==3, then the
accessibility of the first two encoders will be check in edgeFlags
491498
private static boolean isOnePassable(List<BooleanEncodedValue> checkEncoders, IntsRef edgeFlags) {
        for (BooleanEncodedValue accessEnc : checkEncoders) {
            if (accessEnc.getBool(false, edgeFlags) || accessEnc.getBool(true, edgeFlags))
                return true;
        }
        return false;
    }
605934
function checkSpacingForProperty(node) {
            if (node.static) {
                checkSpacingAroundFirstToken(node);
            }
            if (node.kind === "get" ||
                node.kind === "set" ||
                (
                    (node.method || node.type === "MethodDefinition") &&
                    node.value.async
                )
            ) {
                const token = sourceCode.getTokenBefore(
                    node.key,
                    tok => {
                        switch (tok.value) {
                            case "get":
                            case "set":
                            case "async":
                                return true;
                            default:
                                return false;
                        }
                    }
                );

                if (!token) {
                    throw new Error("Failed to find token get, set, or async beside method name");
                }


                checkSpacingAround(token);
            }
        }
816112
public long handleNodeTags(ReaderNode node) {
        long flags = 0;
        for (AbstractFlagEncoder encoder : edgeEncoders) {
            flags |= encoder.handleNodeTags(node);
        }

        return flags;
    }
946358
private byte directionFromFlags() {
        /* if the text contains AN and neutrals, then some neutrals may become RTL */
        if (!((flags & MASK_RTL) != 0 ||
              ((flags & DirPropFlag(AN)) != 0 &&
               (flags & MASK_POSSIBLE_N) != 0))) {
            return LTR;
        } else if ((flags & MASK_LTR) == 0) {
            return RTL;
        } else {
            return MIXED;
        }
    }
1223607
private void lookForVariableAccess(OptFunctionNode fn, Node n)
    {
        switch (n.getType()) {
            case Token.TYPEOFNAME:
            {
                // TYPEOFNAME may be used with undefined names, which is why
                // this is handled separately from GETVAR above.
                int varIndex = fn.fnode.getIndexForNameNode(n);
                if (varIndex > -1 && !itsNotDefSet.get(varIndex))
                    itsUseBeforeDefSet.set(varIndex);
            }
            break;
            case Token.DEC :
            case Token.INC :
            {
                Node child = n.getFirstChild();
                if (child.getType() == Token.GETVAR) {
                    int varIndex = fn.getVarIndex(child);
                    if (!itsNotDefSet.get(varIndex))
                        itsUseBeforeDefSet.set(varIndex);
                    itsNotDefSet.set(varIndex);
                } else {
                    lookForVariableAccess(fn, child);
                }
            }
            break;
            case Token.SETVAR :
            case Token.SETCONSTVAR :
            {
                Node lhs = n.getFirstChild();
                Node rhs = lhs.getNext();
                lookForVariableAccess(fn, rhs);
                itsNotDefSet.set(fn.getVarIndex(n));
            }
            break;
            case Token.GETVAR :
            {
                int varIndex = fn.getVarIndex(n);
                if (!itsNotDefSet.get(varIndex))
                    itsUseBeforeDefSet.set(varIndex);
            }
            break;
            default :
                Node child = n.getFirstChild();
                while (child != null) {
                    lookForVariableAccess(fn, child);
                    child = child.getNext();
                }
                break;
        }
    }
719862
private static boolean isValidCarrierNode(final boolean sslEnabled, final NodeInfo nodeInfo) {
        if (sslEnabled && nodeInfo.sslServices().containsKey(ServiceType.BINARY)) {
            return true;
        } else if (nodeInfo.services().containsKey(ServiceType.BINARY)) {
            return true;
        }
        return false;
    }
145668
private void parseFlags(byte[] flags) throws ID3v2FormatException
	{
		int bytesRead = 1;

		update = (flags[0]&0x80)!=0;
		if (update) bytesRead++;
		
		crced = (flags[0]&0x40)!=0;
		if (crced)
		{
			bytesRead++;
			for (int i = 0; i < crc.length; i++) crc[i] = flags[bytesRead++];
		}
		
		if ((flags[0]&0x80)!=0)
		{
			bytesRead++;
			byte b = flags[bytesRead];
			maxTagSize = (b&0xC0)>>6;
			textEncode = (b&0x20)!=0;
			maxTextSize = (b&0x18)>>3;
			imageEncode = (b&0x04)!=0;
			imageRestrict = (b&0x03);
			bytesRead++;
		}
		if (bytesRead != numFlagBytes)
		{
			throw new ID3v2FormatException("The number of found flag bytes in the extended header is not equal to the number specified in the extended header.");
		}
	}
536790
function findFlag(key, flags) {
	debug('findFlag: ' + key);
	for (var i = 0; i < flags.length; i++) {
		var flag = flags[i];
		if (flag.shortFlag == key || flag.longFlag == key) {
			debug('Flag found!', flag);
			return flag;
		}
	}
	debug('returning null');
	return null;
}
125814
function compactFlags(flags) {
  var result = [];
  var prevFlag = -1;
  var firstRepeat = false;

  _.forEach(flags, function (flag) {
    if (prevFlag === flag) {
      if (firstRepeat) {
        result[result.length - 1] += 8; //current flag repeats previous one, need to set 3rd bit of previous flag and set 1 to the current one
        result.push(1);
        firstRepeat = false;
      } else {
        result[result.length - 1]++; //when flag is repeating second or more times, we need to increase the last flag value
      }
    } else {
      firstRepeat = true;
      prevFlag = flag;
      result.push(flag);
    }
  });
  return result;
}
431262
synchronized void insureNodesParsed()
    {
        if ( paramsNode != null ) // there is always a paramsNode
            return;

        Object firstNode = jjtGetChild(0);
        firstThrowsClause = 1;
        if ( firstNode instanceof BSHReturnType )
        {
            returnTypeNode = (BSHReturnType)firstNode;
            paramsNode = (BSHFormalParameters)jjtGetChild(1);
            if ( jjtGetNumChildren() > 2+numThrows )
                blockNode = (BSHBlock)jjtGetChild(2+numThrows); // skip throws
            ++firstThrowsClause;
        }
        else
        {
            paramsNode = (BSHFormalParameters)jjtGetChild(0);
            blockNode = (BSHBlock)jjtGetChild(1+numThrows); // skip throws
        }
        paramsNode.insureParsed();
        isVarArgs = paramsNode.isVarArgs;
    }
353661
function setFlags() {
		flagN = !!( P & 0x80 );
		flagV = !!( P & 0x40 );
		flagB = !!( P & 0x10 );
		flagD = !!( P & 0x08 );
		flagI = !!( P & 0x04 );
		flagZ = !!( P & 0x02 );
		flagC = !!( P & 0x01 );
	}
1072511
private static boolean hasText(AccessibilityNodeInfoCompat node) {
        if (node == null) {
            return false;
        }

        return (!TextUtils.isEmpty(node.getText())
                || !TextUtils.isEmpty(node.getContentDescription()));
    }
973005
Collection<EdgeIteratorState> addBarrierEdge(long fromId, long toId, IntsRef inEdgeFlags, long nodeFlags, long wayOsmId) {
        IntsRef edgeFlags = IntsRef.deepCopyOf(inEdgeFlags);
        // clear blocked directions from flags
        for (BooleanEncodedValue accessEnc : encodingManager.getAccessEncFromNodeFlags(nodeFlags)) {
            accessEnc.setBool(false, edgeFlags, false);
            accessEnc.setBool(true, edgeFlags, false);
        }
        // add edge
        barrierNodeIds.clear();
        barrierNodeIds.add(fromId);
        barrierNodeIds.add(toId);
        return addOSMWay(barrierNodeIds, edgeFlags, wayOsmId);
    }
153203
private final void setFlags() {
    if (gotFlags) {
      jmo.setField(ControlAccess.FLAGS, Byte.valueOf(flags));
      gotFlags = false;
    }
  }
165829
private void parseFlags(byte[] flags) throws ID3v2FormatException
	{
		if (flags.length != FRAME_FLAGS_SIZE)
		{
			throw new ID3v2FormatException("Error parsing flags of frame: " + id + ".  Expected 2 bytes.");
		}
		else
		{
			tagAlterDiscard = (flags[0]&0x40)!=0;
			fileAlterDiscard = (flags[0]&0x20)!=0;
			readOnly = (flags[0]&0x10)!=0;
			grouped = (flags[1]&0x40)!=0;
			compressed = (flags[1]&0x08)!=0;
			encrypted = (flags[1]&0x04)!=0;
			unsynchronised = (flags[1]&0x02)!=0;
			lengthIndicator = (flags[1]&0x01)!=0;

			if (compressed && !lengthIndicator)
			{
				throw new ID3v2FormatException("Error parsing flags of frame: " + id + ".  Compressed bit set without data length bit set.");
			}
		}
	}
213572
def has_flags(self, *flags):
        

        mask = sum(flags)
        return (self.bits & mask) == mask
1000842
def ifdef(parser, token):
    
    block_tokens = ('elifdef', 'else', 'endifdef')
    # {% ifdef ... %}
    bits = token.split_contents()[1:]
    if len(bits) > 1:
        raise TemplateSyntaxError('%r is not an identifier.' % token)
    condition = IfDefParser(bits).parse()
    nodelist = parser.parse(block_tokens)
    conditions_nodelists = [(condition, nodelist)]
    token = parser.next_token()

    # {% elifdef ... %} (repeatable)
    while token.contents.startswith('elifdef'):
        bits = token.split_contents()[1:]
        if len(bits) > 1:
            raise TemplateSyntaxError('%r is not an identifier.' % token)
        condition = IfDefParser(bits).parse()
        nodelist = parser.parse(block_tokens)
        conditions_nodelists.append((condition, nodelist))
        token = parser.next_token()

    # {% else %} (optional)
    if token.contents == 'else':
        nodelist = parser.parse(block_tokens[-1:])
        conditions_nodelists.append((None, nodelist))
        token = parser.next_token()

    # {% endifdef %}
    assert token.contents == 'endifdef'

    return IfNode(conditions_nodelists)