/* (non-Javadoc)
@see org.joml.Vector4fc#fma(org.joml.Vector4fc, org.joml.Vector4fc, org.joml.Vector4f)
490723
public Vector4f fma(Vector4fc a, Vector4fc b, Vector4f dest) {
        dest.x = x + a.x() * b.x();
        dest.y = y + a.y() * b.y();
        dest.z = z + a.z() * b.z();
        dest.w = w + a.w() * b.w();
        return dest;
    }
229210
public Vector4d fma(Vector4dc a, Vector4dc b, Vector4d dest) {
        dest.x = x + a.x() * b.x();
        dest.y = y + a.y() * b.y();
        dest.z = z + a.z() * b.z();
        dest.w = w + a.w() * b.w();
        return dest;
    }
1206354
public Matrix4f transformAab(Vector3fc min, Vector3fc max, Vector3f outMin, Vector3f outMax) {
        return transformAab(min.x(), min.y(), min.z(), max.x(), max.y(), max.z(), outMin, outMax);
    }
753442
private void processModifiersAndVariablesOfFieldDeclaration( FieldDeclaration fieldDeclaration,
                                                                 FieldMetadata arrayTypeFieldMetadata ) {
        processModifiersOfFieldDeclaration(fieldDeclaration, arrayTypeFieldMetadata);
        processVariablesOfVariableDeclarationFragment(fieldDeclaration, arrayTypeFieldMetadata);
    }
1243667
public Matrix4x3f set(Matrix4fc m) {
        if (m instanceof Matrix4f) {
            MemUtil.INSTANCE.copy((Matrix4f) m, this);
        } else {
            setMatrix4fc(m);
        }
        properties = m.properties() & (PROPERTY_IDENTITY | PROPERTY_TRANSLATION | PROPERTY_ORTHONORMAL);
        return this;
    }
1292379
private void addFmtAttribute(Text attribute) throws IllegalArgumentException {
    	if (!attribute.startsWith(SessionDescription.FMTP)) {
    		throw new IllegalArgumentException("Not a valid FMT attribute"+attribute);
    	}
    	
    	Iterator<Text> it = attribute.split(':').iterator();
    	Text token = it.next();
        
    	token = it.next();
        token.trim();

        //payload and format descriptor
        it = token.split(' ').iterator();

        //payload
        token = it.next();
        token.trim();

        int payload = token.toInteger();

        //format descriptor
        token = it.next();
        token.trim();

        RTPFormat fmt = getFormat(payload);
        if (fmt != null) {
            //TODO : replace string with text
            fmt.getFormat().setOptions(token);
        }
    }
668485
@Override
  protected SoyValue visitFunctionNode(FunctionNode node) {
    Object soyFunction = node.getSoyFunction();
    // Handle nonplugin functions.
    if (soyFunction instanceof BuiltinFunction) {
      BuiltinFunction nonpluginFn = (BuiltinFunction) soyFunction;
      switch (nonpluginFn) {
        case IS_FIRST:
          return visitIsFirstFunction(node);
        case IS_LAST:
          return visitIsLastFunction(node);
        case INDEX:
          return visitIndexFunction(node);
        case CHECK_NOT_NULL:
          return visitCheckNotNullFunction(node.getChild(0));
        case CSS:
          return visitCssFunction(node);
        case XID:
          return visitXidFunction(node);
        case IS_PRIMARY_MSG_IN_USE:
          return visitIsPrimaryMsgInUseFunction(node);
        case V1_EXPRESSION:
          throw new UnsupportedOperationException(
              "the v1Expression function can't be used in templates compiled to Java");
        case TO_FLOAT:
          return visitToFloatFunction(node);
        case DEBUG_SOY_TEMPLATE_INFO:
          return BooleanData.forValue(debugSoyTemplateInfo);
        case VE_DATA:
          return NullData.INSTANCE;
        case MSG_WITH_ID:
        case REMAINDER:
          // should have been removed earlier in the compiler
          throw new AssertionError();
      }
      throw new AssertionError();
    } else if (soyFunction instanceof SoyJavaFunction) {
      List<SoyValue> args = this.visitChildren(node);
      SoyJavaFunction fn = (SoyJavaFunction) soyFunction;
      // Note: Arity has already been checked by CheckFunctionCallsVisitor.
      return computeFunctionHelper(fn, args, node);
    } else if (soyFunction instanceof SoyJavaSourceFunction) {
      List<SoyValue> args = this.visitChildren(node);
      SoyJavaSourceFunction fn = (SoyJavaSourceFunction) soyFunction;
      // Note: Arity has already been checked by CheckFunctionCallsVisitor.
      return computeFunctionHelper(fn, args, node);
    } else if (soyFunction instanceof LoggingFunction) {
      return StringData.forValue(((LoggingFunction) soyFunction).getPlaceholder());
    } else {
      throw RenderException.create(
          "Failed to find Soy function with name '"
              + node.getFunctionName()
              + "'"
              + " (function call \""
              + node.toSourceString()
              + "\").");
    }
  }
350366
public FacilityAcceptedMessage createFAA() {
        FacilityAcceptedMessage msg = new FacilityAcceptedMessageImpl(_FAA_HOLDER.mandatoryCodes,
                _FAA_HOLDER.mandatoryVariableCodes, _FAA_HOLDER.optionalCodes, _FAA_HOLDER.mandatoryCodeToIndex,
                _FAA_HOLDER.mandatoryVariableCodeToIndex, _FAA_HOLDER.optionalCodeToIndex);

        return msg;
    }
1029333
public Vector3f fma(Vector3fc a, Vector3fc b) {
        return fma(a, b, thisOrNew());
    }
278455
public Vector3f transform(Vector3fc v, Vector3f dest) {
        v.mul(this, dest);
        return dest;
    }
1014633
protected void augmentMultifactorProviderFlowRegistry(final FlowDefinitionRegistry mfaProviderFlowRegistry) {
        val flowIds = mfaProviderFlowRegistry.getFlowDefinitionIds();
        Arrays.stream(flowIds).forEach(id -> {
            val flow = (Flow) mfaProviderFlowRegistry.getFlowDefinition(id);
            if (flow != null && containsFlowState(flow, CasWebflowConstants.STATE_ID_REAL_SUBMIT)) {
                val states = getCandidateStatesForMultifactorAuthentication();
                states.forEach(s -> {
                    val state = getState(flow, s);
                    ensureEndStateTransitionExists(state, flow, CasWebflowConstants.TRANSITION_ID_SUCCESS, CasWebflowConstants.STATE_ID_SUCCESS);
                    ensureEndStateTransitionExists(state, flow, CasWebflowConstants.TRANSITION_ID_SUCCESS_WITH_WARNINGS, CasWebflowConstants.TRANSITION_ID_SUCCESS_WITH_WARNINGS);
                    ensureEndStateTransitionExists(state, flow, CasWebflowConstants.TRANSITION_ID_UNAVAILABLE, CasWebflowConstants.STATE_ID_MFA_UNAVAILABLE);
                    ensureEndStateTransitionExists(state, flow, CasWebflowConstants.TRANSITION_ID_DENY, CasWebflowConstants.STATE_ID_MFA_DENIED);
                });
            }
        });

    }
405528
protected void setMemberFactories(FaceletCache.MemberFactory<V> faceletFactory,
                                      FaceletCache.MemberFactory<V> viewMetadataFaceletFactory,
                                      FaceletCache.MemberFactory<V> compositeComponentMetadataFaceletFactory)
    {
        if  (compositeComponentMetadataFaceletFactory == null)
        {
            throw new NullPointerException("viewMetadataFaceletFactory is null");
        }
        _compositeComponentMetadataFaceletFactory = compositeComponentMetadataFaceletFactory;
        setMemberFactories(faceletFactory, viewMetadataFaceletFactory);
    }
298341
@Override
    public boolean applyAction(Model m) {
        Mapping map = m.getMapping();

        if (!map.contains(id)) {
            map.addReadyVM(id);
            return true;
        }
        return false;
    }
830542
public Matrix4f fma4x3(Matrix4fc other, float otherFactor, Matrix4f dest) {
        dest._m00(m00 + other.m00() * otherFactor);
        dest._m01(m01 + other.m01() * otherFactor);
        dest._m02(m02 + other.m02() * otherFactor);
        dest._m03(m03);
        dest._m10(m10 + other.m10() * otherFactor);
        dest._m11(m11 + other.m11() * otherFactor);
        dest._m12(m12 + other.m12() * otherFactor);
        dest._m13(m13);
        dest._m20(m20 + other.m20() * otherFactor);
        dest._m21(m21 + other.m21() * otherFactor);
        dest._m22(m22 + other.m22() * otherFactor);
        dest._m23(m23);
        dest._m30(m30 + other.m30() * otherFactor);
        dest._m31(m31 + other.m31() * otherFactor);
        dest._m32(m32 + other.m32() * otherFactor);
        dest._m33(m33);
        dest._properties(0);
        return dest;
    }
446068
@Override
    public Object visitMultiplicationOrDivisionExpression(ExcellentParser.MultiplicationOrDivisionExpressionContext ctx) {
        boolean multiplication = ctx.TIMES() != null;

        BigDecimal arg1 = Conversions.toDecimal(visit(ctx.expression(0)), m_evalContext);
        BigDecimal arg2 = Conversions.toDecimal(visit(ctx.expression(1)), m_evalContext);

        if (!multiplication && arg2.equals(BigDecimal.ZERO)) {
            throw new EvaluationError("Division by zero");
        }

        return multiplication ? arg1.multiply(arg2, ExpressionUtils.MATH) : arg1.divide(arg2, ExpressionUtils.MATH);
    }
793851
public Vector4f transformAffine(Vector4fc v, Vector4f dest) {
        return transformAffine(v.x(), v.y(), v.z(), v.w(), dest);
    }
1056823
public DFAState<T> constructDFA(Scope<DFAState<T>> dfaScope)
    {
        Map<Set<NFAState<T>>,DFAState<T>> all = new HashMap<>();
        Deque<DFAState<T>> unmarked = new ArrayDeque<>();
        Set<NFAState<T>> startSet = epsilonClosure(dfaScope);
        DFAState<T> startDfa = new DFAState<>(dfaScope, startSet);
        all.put(startSet, startDfa);
        unmarked.add(startDfa);
        while (!unmarked.isEmpty())
        {
            DFAState<T> dfa = unmarked.pop();
            for (CharRange c : dfa.possibleMoves())
            {
                Set<NFAState<T>> moveSet = dfa.nfaTransitsFor(c);
                if (!moveSet.isEmpty())
                {
                    Set<NFAState<T>> newSet = epsilonClosure(dfaScope, moveSet);
                    DFAState<T> ndfa = all.get(newSet);
                    if (ndfa == null)
                    {
                        ndfa = new DFAState<>(dfaScope, newSet);
                        all.put(newSet, ndfa);
                        unmarked.add(ndfa);
                    }
                    dfa.addTransition(c, ndfa);
                }
            }
        }
        // optimize
        for (DFAState<T> dfa : all.values())
        {
            dfa.removeTransitionsFromAcceptImmediatelyStates();
        }
        for (DFAState<T> dfa : all.values())
        {
            dfa.removeDeadEndTransitions();
        }
        for (DFAState<T> dfa : startDfa)
        {
            dfa.optimizeTransitions();
        }
        return startDfa;
    }