Yes, this looks like something is hard coded. We want this.
423802
public function add(INotification $note){
		switch( $note->position ){
			case Blueprint::TOP:
				$this->top($note);
				return;

			case Blueprint::MIDDLE:
				$this->middle($note);
				return;

			case Blueprint::BOTTOM:
				$this->bottom($note);
				return;
			
			default:
				$this->middle($note);
				return;
		}
	}
311948
@Override
    public void sawOpcode(int seen) {

        FinallyBlockInfo fbi = fbInfo.get(0);

        if (getPC() < fbi.startPC) {
            return;
        }

        if (getPC() == fbi.startPC) {
            if (OpcodeUtils.isAStore(seen)) {
                fbi.exReg = RegisterUtils.getAStoreReg(this, seen);
            } else {
                removeEarliestFinallyBlock();
                sawOpcode(seen);
                return;
            }
            return;
        }

        if (seen == Const.MONITORENTER) {
            fbi.monitorCount++;
        } else if (seen == Const.MONITOREXIT) {
            fbi.monitorCount--;
            if (fbi.monitorCount < 0) {
                removeEarliestFinallyBlock();
                sawOpcode(seen);
                return;
            }
        }

        if ((seen == Const.ATHROW) && (loadedReg == fbi.exReg)) {
            removeEarliestFinallyBlock();
            sawOpcode(seen);
            return;
        } else if (OpcodeUtils.isALoad(seen)) {
            loadedReg = RegisterUtils.getALoadReg(this, seen);
        } else {
            loadedReg = -1;
        }

        if (OpcodeUtils.isReturn(seen) || (seen == Const.ATHROW)) {
            bugReporter.reportBug(new BugInstance(this, BugType.AFBR_ABNORMAL_FINALLY_BLOCK_RETURN.name(), NORMAL_PRIORITY).addClass(this).addMethod(this)
                    .addSourceLine(this));
            removeEarliestFinallyBlock();
        } else if (OpcodeUtils.isStandardInvoke(seen)) {
            try {
                JavaClass cls = Repository.lookupClass(getClassConstantOperand());
                Method m = findMethod(cls, getNameConstantOperand(), getSigConstantOperand());
                if (m != null) {
                    ExceptionTable et = m.getExceptionTable();
                    if ((et != null) && (et.getLength() > 0) && !catchBlockInFinally(fbi)) {
                        bugReporter.reportBug(new BugInstance(this, BugType.AFBR_ABNORMAL_FINALLY_BLOCK_RETURN.name(), LOW_PRIORITY).addClass(this)
                                .addMethod(this).addSourceLine(this));
                        removeEarliestFinallyBlock();
                    }
                }
            } catch (ClassNotFoundException cnfe) {
                bugReporter.reportMissingClass(cnfe);
            }
        }
    }
720014
static boolean bodyMayHaveConditionalCode(Node n) {
    if (!n.isReturn() && !n.isExprResult()) {
      return true;
    }
    return mayHaveConditionalCode(n);
  }
206541
private void sawInitOpcode(int seen) {
        boolean isSyncCollection = false;
        try {
            stack.mergeJumps(this);
            isSyncCollection = isSyncCollectionCreation(seen);
            if (seen == Const.PUTFIELD) {
                processCollectionStore();
            }
        } finally {
            stack.sawOpcode(this, seen);
            if (isSyncCollection && (stack.getStackDepth() > 0)) {
                OpcodeStack.Item item = stack.getStackItem(0);
                item.setUserValue(Boolean.TRUE);
            }
        }
    }
332576
void maybePrepareCall(Reference ref) {
    CallSiteType callSiteType = classifyCallSite(ref);
    callSiteType.prepare(this, ref);
  }
484857
def is_code(self):
        """"""
        if self.cell_type == 'code':
            return True
        if self.cell_type == 'raw' and 'active' in self.metadata:
            return True
        return False
1004364
@Override
    public void sawOpcode(int seen) {
        try {
            stack.precomputation(this);

            if ((seen == Const.ARETURN) && (stack.getStackDepth() > 0)) {
                OpcodeStack.Item itm = stack.getStackItem(0);
                if (!itm.isNull()) {
                    returnTypes.put(itm.getJavaClass(), Integer.valueOf(getPC()));
                }
            }
        } catch (ClassNotFoundException cnfe) {
            bugReporter.reportMissingClass(cnfe);
        } finally {
            stack.sawOpcode(this, seen);
        }
    }
1029337
void xor(LongBitSet other) {
		assert other.numWords <= numWords : "numWords=" + numWords + ", other.numWords=" + other.numWords;
		int pos = Math.min(numWords, other.numWords);
		while (--pos >= 0) {
			bits[pos] ^= other.bits[pos];
		}
	}
754522
@Override
    public void sawOpcode(int seen) {
        try {
            stack.precomputation(this);

            if (seen == Const.INVOKEINTERFACE) {
                KeyType type = isKeyAccessMethod(seen);
                if (type != null) {
                    int numParms = SignatureUtils.getNumParameters(getSigConstantOperand());
                    if (stack.getStackDepth() >= numParms) {
                        OpcodeStack.Item item = stack.getStackItem(numParms - 1);
                        String parmName = (String) item.getConstant();
                        if (parmName != null) {
                            String upperParmName = parmName.toUpperCase(Locale.getDefault());
                            Map<String, Map<String, List<SourceInfo>>> typeMap = parmInfo.get(KeyType.PARAMETER);
                            Map<String, List<SourceInfo>> parmCaseInfo = typeMap.get(upperParmName);
                            if (parmCaseInfo == null) {
                                parmCaseInfo = new HashMap<>();
                                typeMap.put(upperParmName, parmCaseInfo);
                            }

                            List<SourceInfo> annotations = parmCaseInfo.get(parmName);
                            if (annotations == null) {
                                annotations = new ArrayList<>();
                                parmCaseInfo.put(parmName, annotations);
                            }

                            annotations.add(new SourceInfo(getClassName(), getMethodName(), getMethodSig(), getMethod().isStatic(),
                                    SourceLineAnnotation.fromVisitedInstruction(getClassContext(), this, getPC())));
                        }
                    }
                }
            }
        } finally {
            stack.sawOpcode(this, seen);
        }
    }
146430
@Override
    public void sawOpcode(int seen) {
        int pc = 0;
        try {
            stack.precomputation(this);

            switch (state) {
                case SAW_NOTHING:
                    pc = sawOpcodeAfterNothing(seen);
                break;

                case SAW_CTOR:
                    if ((seen == Const.POP) || (seen == Const.RETURN)) {
                        bugReporter.reportBug(new BugInstance(this, BugType.SEC_SIDE_EFFECT_CONSTRUCTOR.name(), NORMAL_PRIORITY).addClass(this).addMethod(this)
                                .addSourceLine(this));
                    }
                    state = State.SAW_NOTHING;
                break;
            }
        } finally {
            TernaryPatcher.pre(stack, seen);
            stack.sawOpcode(this, seen);
            TernaryPatcher.post(stack, seen);
            if ((pc != 0) && (stack.getStackDepth() > 0)) {
                OpcodeStack.Item item = stack.getStackItem(0);
                item.setUserValue(Integer.valueOf(pc));
            }
        }
    }
661188
def gencode(self):
        
        ledict = requests.get(self.api_url).json()
        ledict = self.dotopdict(ledict)
        out = self.dodict(ledict)
        self._code = out
268364
@Override
    public void sawOpcode(final int seen) {
        if (stage == Stage.FIND_LOOP_STAGE) {
            sawOpcodeLoop(seen);
        } else {
            sawOpcodeBug(seen);
        }
    }
169146
function maybe_type() {
  skip_horiz_white();
  if (look(/\{/)) {
    var tdf = typedef();
    current_tag["type"] = tdf["type"];
    current_tag["optional"] = tdf["optional"] ? true : false;
  }
}
816608
public function onBeforeWrite()
    {
        if (!$this->owner->MFAEnabled && SiteConfig::current_site_config()->ForceMFA) {
            $this->owner->MFAEnabled = true;
            $this->owner->updateMFA = true;
        }
        if (!$this->owner->BackupCodeSalt || $this->owner->updateMFA) {
            $algorithm = Security::config()->get('password_encryption_algorithm');

            $encryptor = PasswordEncryptor::create_for_algorithm($algorithm);

            // No password. It's not even used in the salt generation
            $this->owner->BackupCodeSalt = $encryptor->salt('');
        }
    }
26855
def apply_code!(letter = 'm', *pars)
			raise AnsiSysError, "Invalid code for SGR: #{letter.inspect}" unless 'm' == letter
			pars = [0] unless pars
			pars.each do |code|
				case code
				when 0
					@intensity = :normal
					@italic = :off
					@underline = :none
					@blink = :off
					@image = :positive
					@conceal = :off
					@foreground = :white
					@background = :black
				when 1..28
					apply_code_table!(code)
				when 30..37
					@foreground = COLOR[code - 30]
					@intensity = :normal
				when 39
					reset!
				when 40..47
					@background = COLOR[code - 40]
					@intensity = :normal
				when 49
					reset!
				when 90..97
					@foreground = COLOR[code - 90]
					@intensity = :bold
				when 99
					reset!
				when 100..107
					@background = COLOR[code - 100]
					@intensity = :bold
				when 109
					reset!
				else
					raise AnsiSysError, "Invalid SGR code #{code.inspect}" unless CODE.has_key?(code)
				end
			end
			return self
		end
805895
static boolean mayHaveConditionalCode(Node n) {
    for (Node c = n.getFirstChild(); c != null; c = c.getNext()) {
      switch (c.getToken()) {
        case FUNCTION:
        case AND:
        case OR:
        case HOOK:
          return true;
        default:
          break;
      }
      if (mayHaveConditionalCode(c)) {
        return true;
      }
    }
    return false;
  }
958838
@Override
    public void sawOpcode(int seen) {
        try {
            if ((seen == Const.ATHROW) && (stack.getStackDepth() > 0)) {
                OpcodeStack.Item item = stack.getStackItem(0);
                if ("Ljava/lang/CloneNotSupportedException;".equals(item.getSignature())) {
                    throwsCNFE = true;
                }
            }
        } finally {
            stack.sawOpcode(this, seen);
        }
    }