jdk.graal.compiler.hotspot.replacements.PluginFactory_HotSpotReplacementsUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of compiler Show documentation
The GraalVM compiler and the Graal-truffle optimizer.
The newest version!
// CheckStyle: stop header check
// CheckStyle: stop line length check
// GENERATED CONTENT - DO NOT EDIT
// GENERATORS: jdk.graal.compiler.replacements.processor.ReplacementsAnnotationProcessor, jdk.graal.compiler.replacements.processor.PluginGenerator
package jdk.graal.compiler.hotspot.replacements;


import java.lang.annotation.Annotation;
import jdk.graal.compiler.core.common.type.Stamp;
import jdk.graal.compiler.debug.GraalError;
import jdk.graal.compiler.graph.NodeInputList;
import jdk.graal.compiler.nodes.ConstantNode;
import jdk.graal.compiler.nodes.PluginReplacementNode;
import jdk.graal.compiler.nodes.ValueNode;
import jdk.graal.compiler.nodes.graphbuilderconf.GeneratedFoldInvocationPlugin;
import jdk.graal.compiler.nodes.graphbuilderconf.GeneratedNodeIntrinsicInvocationPlugin;
import jdk.graal.compiler.nodes.graphbuilderconf.GeneratedPluginFactory;
import jdk.graal.compiler.nodes.graphbuilderconf.GeneratedPluginInjectionProvider;
import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext;
import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugin;
import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugins;
import jdk.graal.compiler.nodes.spi.Replacements;
import jdk.graal.compiler.options.ExcludeFromJacocoGeneratedReport;
import jdk.vm.ci.meta.JavaConstant;
import jdk.vm.ci.meta.JavaKind;
import jdk.vm.ci.meta.ResolvedJavaMethod;

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: allocateInstancePrefetchLines(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_allocateInstancePrefetchLines extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_allocateInstancePrefetchLines.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.allocateInstancePrefetchLines(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_allocateInstancePrefetchLines(GeneratedPluginInjectionProvider injection) {
        super("allocateInstancePrefetchLines", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: allocateInstancePrefetchLines(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_allocateInstancePrefetchLines implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_allocateInstancePrefetchLines();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.allocateInstancePrefetchLines(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: allocatePrefetchDistance(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_allocatePrefetchDistance extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchDistance.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.allocatePrefetchDistance(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_allocatePrefetchDistance(GeneratedPluginInjectionProvider injection) {
        super("allocatePrefetchDistance", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: allocatePrefetchDistance(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchDistance implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchDistance();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.allocatePrefetchDistance(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: allocatePrefetchLines(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_allocatePrefetchLines extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchLines.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.allocatePrefetchLines(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_allocatePrefetchLines(GeneratedPluginInjectionProvider injection) {
        super("allocatePrefetchLines", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: allocatePrefetchLines(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchLines implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchLines();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.allocatePrefetchLines(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: allocatePrefetchStepSize(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_allocatePrefetchStepSize extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchStepSize.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.allocatePrefetchStepSize(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_allocatePrefetchStepSize(GeneratedPluginInjectionProvider injection) {
        super("allocatePrefetchStepSize", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: allocatePrefetchStepSize(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchStepSize implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchStepSize();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.allocatePrefetchStepSize(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: allocatePrefetchStyle(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_allocatePrefetchStyle extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchStyle.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.allocatePrefetchStyle(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_allocatePrefetchStyle(GeneratedPluginInjectionProvider injection) {
        super("allocatePrefetchStyle", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: allocatePrefetchStyle(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchStyle implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_allocatePrefetchStyle();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.allocatePrefetchStyle(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: arrayClassElementOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_arrayClassElementOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_arrayClassElementOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.arrayClassElementOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_arrayClassElementOffset(GeneratedPluginInjectionProvider injection) {
        super("arrayClassElementOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: arrayClassElementOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_arrayClassElementOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_arrayClassElementOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.arrayClassElementOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: arrayKlassOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_arrayKlassOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_arrayKlassOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.arrayKlassOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_arrayKlassOffset(GeneratedPluginInjectionProvider injection) {
        super("arrayKlassOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: arrayKlassOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_arrayKlassOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_arrayKlassOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.arrayKlassOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: arrayLengthOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_arrayLengthOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_arrayLengthOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.arrayLengthOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_arrayLengthOffset(GeneratedPluginInjectionProvider injection) {
        super("arrayLengthOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: arrayLengthOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_arrayLengthOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_arrayLengthOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.arrayLengthOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: cardTableShift(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_cardTableShift extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_cardTableShift.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.cardTableShift(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_cardTableShift(GeneratedPluginInjectionProvider injection) {
        super("cardTableShift", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: cardTableShift(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_cardTableShift implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_cardTableShift();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.cardTableShift(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: cardTableStart(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_cardTableStart extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_cardTableStart.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.cardTableStart(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_cardTableStart(GeneratedPluginInjectionProvider injection) {
        super("cardTableStart", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: cardTableStart(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_cardTableStart implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_cardTableStart();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.cardTableStart(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: compress(jdk.graal.compiler.nodes.CompressionNode.CompressionOp,jdk.graal.compiler.hotspot.word.KlassPointer,jdk.graal.compiler.core.common.CompressEncoding)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$ConstructorPlugin
final class Plugin_HotSpotReplacementsUtil_compress extends GeneratedNodeIntrinsicInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        jdk.graal.compiler.nodes.CompressionNode.CompressionOp arg0;
        if (args[0].isConstant()) {
            arg0 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(jdk.graal.compiler.nodes.CompressionNode.CompressionOp.class, args[0].asJavaConstant());
            assert arg0 != null;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_compress.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[0];
            return false;
        }
        ValueNode arg1 = args[1];
        jdk.graal.compiler.core.common.CompressEncoding arg2;
        if (args[2].isConstant()) {
            arg2 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(jdk.graal.compiler.core.common.CompressEncoding.class, args[2].asJavaConstant());
            assert arg2 != null;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_compress.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[2];
            return false;
        }
        jdk.graal.compiler.hotspot.nodes.HotSpotCompressionNode node = new jdk.graal.compiler.hotspot.nodes.HotSpotCompressionNode(arg0, arg1, arg2);
        b.addPush(JavaKind.Object, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.graph.Node.NodeIntrinsic.class;
    }

    private final jdk.graal.compiler.api.replacements.SnippetReflectionProvider snippetReflection;

    Plugin_HotSpotReplacementsUtil_compress(GeneratedPluginInjectionProvider injection) {
        super("compress", jdk.graal.compiler.nodes.CompressionNode.CompressionOp.class, jdk.graal.compiler.hotspot.word.KlassPointer.class, jdk.graal.compiler.core.common.CompressEncoding.class);
        this.snippetReflection = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: compress(jdk.graal.compiler.nodes.CompressionNode.CompressionOp,jdk.graal.compiler.hotspot.word.KlassPointer,jdk.graal.compiler.core.common.CompressEncoding)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$ConstructorPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_compress implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_compress();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        jdk.graal.compiler.nodes.CompressionNode.CompressionOp arg0;
        if (args.get(0).isConstant()) {
            arg0 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(jdk.graal.compiler.nodes.CompressionNode.CompressionOp.class, args.get(0).asJavaConstant());
            assert arg0 != null;
        } else {
            return false;
        }
        ValueNode arg1 = args.get(1);
        jdk.graal.compiler.core.common.CompressEncoding arg2;
        if (args.get(2).isConstant()) {
            arg2 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(jdk.graal.compiler.core.common.CompressEncoding.class, args.get(2).asJavaConstant());
            assert arg2 != null;
        } else {
            return false;
        }
        jdk.graal.compiler.hotspot.nodes.HotSpotCompressionNode node = new jdk.graal.compiler.hotspot.nodes.HotSpotCompressionNode(arg0, arg1, arg2);
        b.addPush(JavaKind.Object, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: defaultPrototypeMarkWord(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_defaultPrototypeMarkWord extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_defaultPrototypeMarkWord.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.defaultPrototypeMarkWord(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_defaultPrototypeMarkWord(GeneratedPluginInjectionProvider injection) {
        super("defaultPrototypeMarkWord", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: defaultPrototypeMarkWord(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_defaultPrototypeMarkWord implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_defaultPrototypeMarkWord();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.defaultPrototypeMarkWord(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: diagnoseSyncOnValueBasedClasses(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_diagnoseSyncOnValueBasedClasses extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_diagnoseSyncOnValueBasedClasses.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.diagnoseSyncOnValueBasedClasses(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_diagnoseSyncOnValueBasedClasses(GeneratedPluginInjectionProvider injection) {
        super("diagnoseSyncOnValueBasedClasses", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: diagnoseSyncOnValueBasedClasses(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_diagnoseSyncOnValueBasedClasses implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_diagnoseSyncOnValueBasedClasses();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.diagnoseSyncOnValueBasedClasses(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: dirtyCardValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_dirtyCardValue extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_dirtyCardValue.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        byte result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.dirtyCardValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_dirtyCardValue(GeneratedPluginInjectionProvider injection) {
        super("dirtyCardValue", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: dirtyCardValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_dirtyCardValue implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_dirtyCardValue();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        byte result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.dirtyCardValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: doingUnsafeAccessOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_doingUnsafeAccessOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_doingUnsafeAccessOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.doingUnsafeAccessOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_doingUnsafeAccessOffset(GeneratedPluginInjectionProvider injection) {
        super("doingUnsafeAccessOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: doingUnsafeAccessOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_doingUnsafeAccessOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_doingUnsafeAccessOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.doingUnsafeAccessOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1CardQueueBufferOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_g1CardQueueBufferOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_g1CardQueueBufferOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1CardQueueBufferOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_g1CardQueueBufferOffset(GeneratedPluginInjectionProvider injection) {
        super("g1CardQueueBufferOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1CardQueueBufferOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_g1CardQueueBufferOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_g1CardQueueBufferOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1CardQueueBufferOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1CardQueueIndexOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_g1CardQueueIndexOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_g1CardQueueIndexOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1CardQueueIndexOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_g1CardQueueIndexOffset(GeneratedPluginInjectionProvider injection) {
        super("g1CardQueueIndexOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1CardQueueIndexOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_g1CardQueueIndexOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_g1CardQueueIndexOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1CardQueueIndexOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1SATBQueueBufferOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_g1SATBQueueBufferOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_g1SATBQueueBufferOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1SATBQueueBufferOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_g1SATBQueueBufferOffset(GeneratedPluginInjectionProvider injection) {
        super("g1SATBQueueBufferOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1SATBQueueBufferOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_g1SATBQueueBufferOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_g1SATBQueueBufferOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1SATBQueueBufferOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1SATBQueueIndexOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_g1SATBQueueIndexOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_g1SATBQueueIndexOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1SATBQueueIndexOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_g1SATBQueueIndexOffset(GeneratedPluginInjectionProvider injection) {
        super("g1SATBQueueIndexOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1SATBQueueIndexOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_g1SATBQueueIndexOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_g1SATBQueueIndexOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1SATBQueueIndexOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1SATBQueueMarkingActiveOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_g1SATBQueueMarkingActiveOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_g1SATBQueueMarkingActiveOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1SATBQueueMarkingActiveOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_g1SATBQueueMarkingActiveOffset(GeneratedPluginInjectionProvider injection) {
        super("g1SATBQueueMarkingActiveOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1SATBQueueMarkingActiveOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_g1SATBQueueMarkingActiveOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_g1SATBQueueMarkingActiveOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1SATBQueueMarkingActiveOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1YoungCardValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_g1YoungCardValue extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_g1YoungCardValue.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        byte result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1YoungCardValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_g1YoungCardValue(GeneratedPluginInjectionProvider injection) {
        super("g1YoungCardValue", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: g1YoungCardValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_g1YoungCardValue implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_g1YoungCardValue();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        byte result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.g1YoungCardValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: gcTotalCollectionsAddress(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_gcTotalCollectionsAddress extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_gcTotalCollectionsAddress.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.gcTotalCollectionsAddress(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_gcTotalCollectionsAddress(GeneratedPluginInjectionProvider injection) {
        super("gcTotalCollectionsAddress", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: gcTotalCollectionsAddress(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_gcTotalCollectionsAddress implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_gcTotalCollectionsAddress();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.gcTotalCollectionsAddress(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: getFieldOffset(jdk.vm.ci.meta.ResolvedJavaType,java.lang.String)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_getFieldOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_getFieldOffset.FUNCTION);
            return true;
        }
        jdk.vm.ci.meta.ResolvedJavaType arg0;
        if (args[0].isConstant()) {
            jdk.vm.ci.meta.JavaConstant cst = args[0].asJavaConstant();
            arg0 = b.getConstantReflection()/* A CONSTANT_REFLECTION */.asJavaType(cst);
            if (arg0 == null) {
                arg0 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(jdk.vm.ci.meta.ResolvedJavaType.class, cst);
            }
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_getFieldOffset.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[0];
            return false;
        }
        java.lang.String arg1;
        if (args[1].isConstant()) {
            arg1 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(java.lang.String.class, args[1].asJavaConstant());
            assert arg1 != null;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_getFieldOffset.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[1];
            return false;
        }
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.getFieldOffset(arg0, arg1);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.api.replacements.SnippetReflectionProvider snippetReflection;

    Plugin_HotSpotReplacementsUtil_getFieldOffset(GeneratedPluginInjectionProvider injection) {
        super("getFieldOffset", jdk.vm.ci.meta.ResolvedJavaType.class, java.lang.String.class);
        this.snippetReflection = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: getFieldOffset(jdk.vm.ci.meta.ResolvedJavaType,java.lang.String)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_getFieldOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_getFieldOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        jdk.vm.ci.meta.ResolvedJavaType arg0;
        if (args.get(0).isConstant()) {
            jdk.vm.ci.meta.JavaConstant cst = args.get(0).asJavaConstant();
            arg0 = b.getConstantReflection()/* B CONSTANT_REFLECTION */.asJavaType(cst);
            if (arg0 == null) {
                arg0 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(jdk.vm.ci.meta.ResolvedJavaType.class, cst);
            }
        } else {
            return false;
        }
        java.lang.String arg1;
        if (args.get(1).isConstant()) {
            arg1 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(java.lang.String.class, args.get(1).asJavaConstant());
            assert arg1 != null;
        } else {
            return false;
        }
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.getFieldOffset(arg0, arg1);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: getHeapWordSize(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_getHeapWordSize extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_getHeapWordSize.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.getHeapWordSize(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_getHeapWordSize(GeneratedPluginInjectionProvider injection) {
        super("getHeapWordSize", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: getHeapWordSize(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_getHeapWordSize implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_getHeapWordSize();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.getHeapWordSize(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: getWordKind()
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_getWordKind extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_getWordKind.FUNCTION);
            return true;
        }
        jdk.vm.ci.meta.JavaKind result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.getWordKind();
        JavaConstant constant = snippetReflection/* A SNIPPET_REFLECTION */.forObject(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Object, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.api.replacements.SnippetReflectionProvider snippetReflection;

    Plugin_HotSpotReplacementsUtil_getWordKind(GeneratedPluginInjectionProvider injection) {
        super("getWordKind");
        this.snippetReflection = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: getWordKind()
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_getWordKind implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_getWordKind();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        jdk.vm.ci.meta.JavaKind result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.getWordKind();
        JavaConstant constant = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.forObject(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Object, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: heldMonitorCountOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_heldMonitorCountOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_heldMonitorCountOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.heldMonitorCountOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_heldMonitorCountOffset(GeneratedPluginInjectionProvider injection) {
        super("heldMonitorCountOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: heldMonitorCountOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_heldMonitorCountOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_heldMonitorCountOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.heldMonitorCountOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: hubOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_hubOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_hubOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.hubOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_hubOffset(GeneratedPluginInjectionProvider injection) {
        super("hubOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: hubOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_hubOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_hubOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.hubOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: identityHashCode(jdk.graal.compiler.core.common.spi.ForeignCallDescriptor,java.lang.Object)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$CustomFactoryPlugin
final class Plugin_HotSpotReplacementsUtil_identityHashCode extends GeneratedNodeIntrinsicInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        jdk.graal.compiler.core.common.type.Stamp arg0 = stamp;
        jdk.graal.compiler.core.common.spi.ForeignCallDescriptor arg1;
        if (args[0].isConstant()) {
            arg1 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(jdk.graal.compiler.core.common.spi.ForeignCallDescriptor.class, args[0].asJavaConstant());
            assert arg1 != null;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_identityHashCode.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[0];
            return false;
        }
        assert verifyForeignCallDescriptor(b, targetMethod, arg1) : arg1;
        ValueNode arg2 = args[1];
        if (jdk.graal.compiler.nodes.extended.ForeignCallNode.intrinsify(b, arg0, arg1, arg2)) {
            return true;
        }
        if (b.canDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_identityHashCode.FUNCTION);
            return true;
        }
        throw GraalError.shouldNotReachHere("Can't inline plugin " + b.getClass().toString());
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.graph.Node.NodeIntrinsic.class;
    }

    private final jdk.graal.compiler.core.common.type.Stamp stamp;
    private final jdk.graal.compiler.api.replacements.SnippetReflectionProvider snippetReflection;

    Plugin_HotSpotReplacementsUtil_identityHashCode(GeneratedPluginInjectionProvider injection) {
        super("identityHashCode", jdk.graal.compiler.core.common.spi.ForeignCallDescriptor.class, java.lang.Object.class);
        this.stamp = injection.getInjectedStamp(int.class);
        this.snippetReflection = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: identityHashCode(jdk.graal.compiler.core.common.spi.ForeignCallDescriptor,java.lang.Object)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$CustomFactoryPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_identityHashCode implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_identityHashCode();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        jdk.graal.compiler.core.common.type.Stamp arg0 = injection.getInjectedStamp(int.class);
        jdk.graal.compiler.core.common.spi.ForeignCallDescriptor arg1;
        if (args.get(0).isConstant()) {
            arg1 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(jdk.graal.compiler.core.common.spi.ForeignCallDescriptor.class, args.get(0).asJavaConstant());
            assert arg1 != null;
        } else {
            return false;
        }
        ValueNode arg2 = args.get(1);
        if (jdk.graal.compiler.nodes.extended.ForeignCallNode.intrinsify(b, arg0, arg1, arg2)) {
            return true;
        }
        return false;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: instanceHeaderSize(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_instanceHeaderSize extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_instanceHeaderSize.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.instanceHeaderSize(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_instanceHeaderSize(GeneratedPluginInjectionProvider injection) {
        super("instanceHeaderSize", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: instanceHeaderSize(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_instanceHeaderSize implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_instanceHeaderSize();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.instanceHeaderSize(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: instanceKlassInitStateOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_instanceKlassInitStateOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassInitStateOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.instanceKlassInitStateOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_instanceKlassInitStateOffset(GeneratedPluginInjectionProvider injection) {
        super("instanceKlassInitStateOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: instanceKlassInitStateOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassInitStateOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassInitStateOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.instanceKlassInitStateOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: instanceKlassInitThreadOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_instanceKlassInitThreadOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassInitThreadOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.instanceKlassInitThreadOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_instanceKlassInitThreadOffset(GeneratedPluginInjectionProvider injection) {
        super("instanceKlassInitThreadOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: instanceKlassInitThreadOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassInitThreadOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassInitThreadOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.instanceKlassInitThreadOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: instanceKlassStateBeingInitialized(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_instanceKlassStateBeingInitialized extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassStateBeingInitialized.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.instanceKlassStateBeingInitialized(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_instanceKlassStateBeingInitialized(GeneratedPluginInjectionProvider injection) {
        super("instanceKlassStateBeingInitialized", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: instanceKlassStateBeingInitialized(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassStateBeingInitialized implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassStateBeingInitialized();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.instanceKlassStateBeingInitialized(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: instanceKlassStateFullyInitialized(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_instanceKlassStateFullyInitialized extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassStateFullyInitialized.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.instanceKlassStateFullyInitialized(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_instanceKlassStateFullyInitialized(GeneratedPluginInjectionProvider injection) {
        super("instanceKlassStateFullyInitialized", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: instanceKlassStateFullyInitialized(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassStateFullyInitialized implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_instanceKlassStateFullyInitialized();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.instanceKlassStateFullyInitialized(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: isCAssertEnabled(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_isCAssertEnabled extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_isCAssertEnabled.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.isCAssertEnabled(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_isCAssertEnabled(GeneratedPluginInjectionProvider injection) {
        super("isCAssertEnabled", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: isCAssertEnabled(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_isCAssertEnabled implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_isCAssertEnabled();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.isCAssertEnabled(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaLangThreadJFREpochOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_javaLangThreadJFREpochOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_javaLangThreadJFREpochOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaLangThreadJFREpochOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_javaLangThreadJFREpochOffset(GeneratedPluginInjectionProvider injection) {
        super("javaLangThreadJFREpochOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaLangThreadJFREpochOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_javaLangThreadJFREpochOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_javaLangThreadJFREpochOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaLangThreadJFREpochOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaLangThreadTIDOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_javaLangThreadTIDOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_javaLangThreadTIDOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaLangThreadTIDOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_javaLangThreadTIDOffset(GeneratedPluginInjectionProvider injection) {
        super("javaLangThreadTIDOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaLangThreadTIDOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_javaLangThreadTIDOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_javaLangThreadTIDOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaLangThreadTIDOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaThreadLockStackEndOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_javaThreadLockStackEndOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_javaThreadLockStackEndOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaThreadLockStackEndOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_javaThreadLockStackEndOffset(GeneratedPluginInjectionProvider injection) {
        super("javaThreadLockStackEndOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaThreadLockStackEndOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_javaThreadLockStackEndOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_javaThreadLockStackEndOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaThreadLockStackEndOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaThreadLockStackTopOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_javaThreadLockStackTopOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_javaThreadLockStackTopOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaThreadLockStackTopOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_javaThreadLockStackTopOffset(GeneratedPluginInjectionProvider injection) {
        super("javaThreadLockStackTopOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaThreadLockStackTopOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_javaThreadLockStackTopOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_javaThreadLockStackTopOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaThreadLockStackTopOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaThreadMonitorOwnerIDOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_javaThreadMonitorOwnerIDOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_javaThreadMonitorOwnerIDOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaThreadMonitorOwnerIDOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_javaThreadMonitorOwnerIDOffset(GeneratedPluginInjectionProvider injection) {
        super("javaThreadMonitorOwnerIDOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaThreadMonitorOwnerIDOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_javaThreadMonitorOwnerIDOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_javaThreadMonitorOwnerIDOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaThreadMonitorOwnerIDOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaThreadOomCacheOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_javaThreadOomCacheOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_javaThreadOomCacheOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaThreadOomCacheOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_javaThreadOomCacheOffset(GeneratedPluginInjectionProvider injection) {
        super("javaThreadOomCacheOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaThreadOomCacheOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_javaThreadOomCacheOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_javaThreadOomCacheOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaThreadOomCacheOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaThreadUnlockedInflatedMonitorOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_javaThreadUnlockedInflatedMonitorOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_javaThreadUnlockedInflatedMonitorOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaThreadUnlockedInflatedMonitorOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_javaThreadUnlockedInflatedMonitorOffset(GeneratedPluginInjectionProvider injection) {
        super("javaThreadUnlockedInflatedMonitorOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: javaThreadUnlockedInflatedMonitorOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_javaThreadUnlockedInflatedMonitorOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_javaThreadUnlockedInflatedMonitorOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.javaThreadUnlockedInflatedMonitorOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jfrThreadLocalVthreadEpochOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadEpochOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadEpochOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jfrThreadLocalVthreadEpochOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadEpochOffset(GeneratedPluginInjectionProvider injection) {
        super("jfrThreadLocalVthreadEpochOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jfrThreadLocalVthreadEpochOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadEpochOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadEpochOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jfrThreadLocalVthreadEpochOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jfrThreadLocalVthreadExcludedOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadExcludedOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadExcludedOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jfrThreadLocalVthreadExcludedOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadExcludedOffset(GeneratedPluginInjectionProvider injection) {
        super("jfrThreadLocalVthreadExcludedOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jfrThreadLocalVthreadExcludedOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadExcludedOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadExcludedOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jfrThreadLocalVthreadExcludedOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jfrThreadLocalVthreadIDOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadIDOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadIDOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jfrThreadLocalVthreadIDOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadIDOffset(GeneratedPluginInjectionProvider injection) {
        super("jfrThreadLocalVthreadIDOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jfrThreadLocalVthreadIDOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadIDOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadIDOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jfrThreadLocalVthreadIDOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jfrThreadLocalVthreadOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jfrThreadLocalVthreadOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadOffset(GeneratedPluginInjectionProvider injection) {
        super("jfrThreadLocalVthreadOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jfrThreadLocalVthreadOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_jfrThreadLocalVthreadOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jfrThreadLocalVthreadOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jvmAccHasFinalizer(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_jvmAccHasFinalizer extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_jvmAccHasFinalizer.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jvmAccHasFinalizer(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_jvmAccHasFinalizer(GeneratedPluginInjectionProvider injection) {
        super("jvmAccHasFinalizer", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jvmAccHasFinalizer(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_jvmAccHasFinalizer implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_jvmAccHasFinalizer();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jvmAccHasFinalizer(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jvmAccIsValueBasedClass(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_jvmAccIsValueBasedClass extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_jvmAccIsValueBasedClass.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jvmAccIsValueBasedClass(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_jvmAccIsValueBasedClass(GeneratedPluginInjectionProvider injection) {
        super("jvmAccIsValueBasedClass", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: jvmAccIsValueBasedClass(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_jvmAccIsValueBasedClass implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_jvmAccIsValueBasedClass();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.jvmAccIsValueBasedClass(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassAccessFlagsOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_klassAccessFlagsOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_klassAccessFlagsOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassAccessFlagsOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_klassAccessFlagsOffset(GeneratedPluginInjectionProvider injection) {
        super("klassAccessFlagsOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassAccessFlagsOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_klassAccessFlagsOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_klassAccessFlagsOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassAccessFlagsOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassBitmapOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_klassBitmapOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_klassBitmapOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassBitmapOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_klassBitmapOffset(GeneratedPluginInjectionProvider injection) {
        super("klassBitmapOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassBitmapOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_klassBitmapOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_klassBitmapOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassBitmapOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassEncoding(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_klassEncoding extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_klassEncoding.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        jdk.graal.compiler.core.common.CompressEncoding result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassEncoding(arg0);
        JavaConstant constant = snippetReflection/* A SNIPPET_REFLECTION */.forObject(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Object, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;
    private final jdk.graal.compiler.api.replacements.SnippetReflectionProvider snippetReflection;

    Plugin_HotSpotReplacementsUtil_klassEncoding(GeneratedPluginInjectionProvider injection) {
        super("klassEncoding", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.snippetReflection = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassEncoding(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_klassEncoding implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_klassEncoding();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        jdk.graal.compiler.core.common.CompressEncoding result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassEncoding(arg0);
        JavaConstant constant = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.forObject(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Object, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassHashSlotOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_klassHashSlotOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_klassHashSlotOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassHashSlotOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_klassHashSlotOffset(GeneratedPluginInjectionProvider injection) {
        super("klassHashSlotOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassHashSlotOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_klassHashSlotOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_klassHashSlotOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassHashSlotOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassLayoutHelperNeutralValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_klassLayoutHelperNeutralValue extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_klassLayoutHelperNeutralValue.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassLayoutHelperNeutralValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_klassLayoutHelperNeutralValue(GeneratedPluginInjectionProvider injection) {
        super("klassLayoutHelperNeutralValue", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassLayoutHelperNeutralValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_klassLayoutHelperNeutralValue implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_klassLayoutHelperNeutralValue();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassLayoutHelperNeutralValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassMiscFlagsOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_klassMiscFlagsOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_klassMiscFlagsOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassMiscFlagsOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_klassMiscFlagsOffset(GeneratedPluginInjectionProvider injection) {
        super("klassMiscFlagsOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: klassMiscFlagsOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_klassMiscFlagsOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_klassMiscFlagsOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.klassMiscFlagsOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: layoutHelperHeaderSizeMask(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_layoutHelperHeaderSizeMask extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperHeaderSizeMask.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.layoutHelperHeaderSizeMask(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_layoutHelperHeaderSizeMask(GeneratedPluginInjectionProvider injection) {
        super("layoutHelperHeaderSizeMask", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: layoutHelperHeaderSizeMask(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperHeaderSizeMask implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperHeaderSizeMask();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.layoutHelperHeaderSizeMask(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: layoutHelperHeaderSizeShift(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_layoutHelperHeaderSizeShift extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperHeaderSizeShift.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.layoutHelperHeaderSizeShift(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_layoutHelperHeaderSizeShift(GeneratedPluginInjectionProvider injection) {
        super("layoutHelperHeaderSizeShift", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: layoutHelperHeaderSizeShift(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperHeaderSizeShift implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperHeaderSizeShift();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.layoutHelperHeaderSizeShift(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: layoutHelperLog2ElementSizeMask(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeMask extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeMask.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.layoutHelperLog2ElementSizeMask(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeMask(GeneratedPluginInjectionProvider injection) {
        super("layoutHelperLog2ElementSizeMask", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: layoutHelperLog2ElementSizeMask(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeMask implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeMask();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.layoutHelperLog2ElementSizeMask(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: layoutHelperLog2ElementSizeShift(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeShift extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeShift.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.layoutHelperLog2ElementSizeShift(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeShift(GeneratedPluginInjectionProvider injection) {
        super("layoutHelperLog2ElementSizeShift", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: layoutHelperLog2ElementSizeShift(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeShift implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeShift();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.layoutHelperLog2ElementSizeShift(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: loadHubIntrinsic(java.lang.Object)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$ConstructorPlugin
final class Plugin_HotSpotReplacementsUtil_loadHubIntrinsic extends GeneratedNodeIntrinsicInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        jdk.graal.compiler.nodes.spi.StampProvider arg0 = b.getStampProvider();
        ValueNode arg1 = args[0];
        jdk.graal.compiler.nodes.extended.LoadHubNode node = new jdk.graal.compiler.nodes.extended.LoadHubNode(arg0, arg1);
        b.addPush(JavaKind.Object, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.graph.Node.NodeIntrinsic.class;
    }

    Plugin_HotSpotReplacementsUtil_loadHubIntrinsic() {
        super("loadHubIntrinsic", java.lang.Object.class);
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: loadHubOrNullIntrinsic(java.lang.Object)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$ConstructorPlugin
final class Plugin_HotSpotReplacementsUtil_loadHubOrNullIntrinsic extends GeneratedNodeIntrinsicInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        jdk.graal.compiler.nodes.spi.StampProvider arg0 = b.getStampProvider();
        ValueNode arg1 = args[0];
        jdk.graal.compiler.nodes.extended.LoadHubOrNullNode node = new jdk.graal.compiler.nodes.extended.LoadHubOrNullNode(arg0, arg1);
        b.addPush(JavaKind.Object, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.graph.Node.NodeIntrinsic.class;
    }

    Plugin_HotSpotReplacementsUtil_loadHubOrNullIntrinsic() {
        super("loadHubOrNullIntrinsic", java.lang.Object.class);
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: loadKlassFromObjectIntrinsic(java.lang.Object,long,org.graalvm.word.LocationIdentity,jdk.vm.ci.meta.JavaKind)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$ConstructorPlugin
final class Plugin_HotSpotReplacementsUtil_loadKlassFromObjectIntrinsic extends GeneratedNodeIntrinsicInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        jdk.graal.compiler.core.common.type.Stamp arg0 = stamp;
        ValueNode arg1 = args[0];
        ValueNode arg2 = args[1];
        org.graalvm.word.LocationIdentity arg3;
        if (args[2].isConstant()) {
            arg3 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(org.graalvm.word.LocationIdentity.class, args[2].asJavaConstant());
            assert arg3 != null;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_loadKlassFromObjectIntrinsic.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[2];
            return false;
        }
        jdk.vm.ci.meta.JavaKind arg4;
        if (args[3].isConstant()) {
            arg4 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(jdk.vm.ci.meta.JavaKind.class, args[3].asJavaConstant());
            assert arg4 != null;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_loadKlassFromObjectIntrinsic.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[3];
            return false;
        }
        jdk.graal.compiler.nodes.extended.RawLoadNode node = new jdk.graal.compiler.nodes.extended.RawLoadNode(arg0, arg1, arg2, arg3, arg4);
        b.addPush(JavaKind.Object, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.graph.Node.NodeIntrinsic.class;
    }

    private final jdk.graal.compiler.core.common.type.Stamp stamp;
    private final jdk.graal.compiler.api.replacements.SnippetReflectionProvider snippetReflection;

    Plugin_HotSpotReplacementsUtil_loadKlassFromObjectIntrinsic(GeneratedPluginInjectionProvider injection) {
        super("loadKlassFromObjectIntrinsic", java.lang.Object.class, long.class, org.graalvm.word.LocationIdentity.class, jdk.vm.ci.meta.JavaKind.class);
        this.stamp = injection.getInjectedStamp(jdk.graal.compiler.hotspot.word.KlassPointer.class);
        this.snippetReflection = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: loadKlassFromObjectIntrinsic(java.lang.Object,long,org.graalvm.word.LocationIdentity,jdk.vm.ci.meta.JavaKind)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$ConstructorPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_loadKlassFromObjectIntrinsic implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_loadKlassFromObjectIntrinsic();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        jdk.graal.compiler.core.common.type.Stamp arg0 = injection.getInjectedStamp(jdk.graal.compiler.hotspot.word.KlassPointer.class);
        ValueNode arg1 = args.get(0);
        ValueNode arg2 = args.get(1);
        org.graalvm.word.LocationIdentity arg3;
        if (args.get(2).isConstant()) {
            arg3 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(org.graalvm.word.LocationIdentity.class, args.get(2).asJavaConstant());
            assert arg3 != null;
        } else {
            return false;
        }
        jdk.vm.ci.meta.JavaKind arg4;
        if (args.get(3).isConstant()) {
            arg4 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(jdk.vm.ci.meta.JavaKind.class, args.get(3).asJavaConstant());
            assert arg4 != null;
        } else {
            return false;
        }
        jdk.graal.compiler.nodes.extended.RawLoadNode node = new jdk.graal.compiler.nodes.extended.RawLoadNode(arg0, arg1, arg2, arg3, arg4);
        b.addPush(JavaKind.Object, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: loadWordFromObjectIntrinsic(java.lang.Object,long,org.graalvm.word.LocationIdentity,jdk.vm.ci.meta.JavaKind)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$ConstructorPlugin
final class Plugin_HotSpotReplacementsUtil_loadWordFromObjectIntrinsic extends GeneratedNodeIntrinsicInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        jdk.graal.compiler.core.common.type.Stamp arg0 = stamp;
        ValueNode arg1 = args[0];
        ValueNode arg2 = args[1];
        org.graalvm.word.LocationIdentity arg3;
        if (args[2].isConstant()) {
            arg3 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(org.graalvm.word.LocationIdentity.class, args[2].asJavaConstant());
            assert arg3 != null;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_loadWordFromObjectIntrinsic.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[2];
            return false;
        }
        jdk.vm.ci.meta.JavaKind arg4;
        if (args[3].isConstant()) {
            arg4 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(jdk.vm.ci.meta.JavaKind.class, args[3].asJavaConstant());
            assert arg4 != null;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_loadWordFromObjectIntrinsic.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[3];
            return false;
        }
        jdk.graal.compiler.nodes.extended.RawLoadNode node = new jdk.graal.compiler.nodes.extended.RawLoadNode(arg0, arg1, arg2, arg3, arg4);
        b.addPush(JavaKind.Object, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.graph.Node.NodeIntrinsic.class;
    }

    private final jdk.graal.compiler.core.common.type.Stamp stamp;
    private final jdk.graal.compiler.api.replacements.SnippetReflectionProvider snippetReflection;

    Plugin_HotSpotReplacementsUtil_loadWordFromObjectIntrinsic(GeneratedPluginInjectionProvider injection) {
        super("loadWordFromObjectIntrinsic", java.lang.Object.class, long.class, org.graalvm.word.LocationIdentity.class, jdk.vm.ci.meta.JavaKind.class);
        this.stamp = injection.getInjectedStamp(jdk.graal.compiler.word.Word.class);
        this.snippetReflection = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: loadWordFromObjectIntrinsic(java.lang.Object,long,org.graalvm.word.LocationIdentity,jdk.vm.ci.meta.JavaKind)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$ConstructorPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_loadWordFromObjectIntrinsic implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_loadWordFromObjectIntrinsic();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        jdk.graal.compiler.core.common.type.Stamp arg0 = injection.getInjectedStamp(jdk.graal.compiler.word.Word.class);
        ValueNode arg1 = args.get(0);
        ValueNode arg2 = args.get(1);
        org.graalvm.word.LocationIdentity arg3;
        if (args.get(2).isConstant()) {
            arg3 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(org.graalvm.word.LocationIdentity.class, args.get(2).asJavaConstant());
            assert arg3 != null;
        } else {
            return false;
        }
        jdk.vm.ci.meta.JavaKind arg4;
        if (args.get(3).isConstant()) {
            arg4 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(jdk.vm.ci.meta.JavaKind.class, args.get(3).asJavaConstant());
            assert arg4 != null;
        } else {
            return false;
        }
        jdk.graal.compiler.nodes.extended.RawLoadNode node = new jdk.graal.compiler.nodes.extended.RawLoadNode(arg0, arg1, arg2, arg3, arg4);
        b.addPush(JavaKind.Object, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: lockMetadataOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_lockMetadataOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_lockMetadataOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.lockMetadataOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_lockMetadataOffset(GeneratedPluginInjectionProvider injection) {
        super("lockMetadataOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: lockMetadataOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_lockMetadataOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_lockMetadataOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.lockMetadataOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: logOfHeapRegionGrainBytes(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_logOfHeapRegionGrainBytes extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_logOfHeapRegionGrainBytes.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.logOfHeapRegionGrainBytes(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_logOfHeapRegionGrainBytes(GeneratedPluginInjectionProvider injection) {
        super("logOfHeapRegionGrainBytes", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: logOfHeapRegionGrainBytes(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_logOfHeapRegionGrainBytes implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_logOfHeapRegionGrainBytes();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.logOfHeapRegionGrainBytes(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: markOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_markOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_markOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.markOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_markOffset(GeneratedPluginInjectionProvider injection) {
        super("markOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: markOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_markOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_markOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.markOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: markWordHashCodeShift(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_markWordHashCodeShift extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_markWordHashCodeShift.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.markWordHashCodeShift(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_markWordHashCodeShift(GeneratedPluginInjectionProvider injection) {
        super("markWordHashCodeShift", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: markWordHashCodeShift(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_markWordHashCodeShift implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_markWordHashCodeShift();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.markWordHashCodeShift(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: markWordHashMark(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_markWordHashMark extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_markWordHashMark.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.markWordHashMark(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_markWordHashMark(GeneratedPluginInjectionProvider injection) {
        super("markWordHashMark", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: markWordHashMark(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_markWordHashMark implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_markWordHashMark();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.markWordHashMark(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: markWordKlassShift(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_markWordKlassShift extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_markWordKlassShift.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.markWordKlassShift(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_markWordKlassShift(GeneratedPluginInjectionProvider injection) {
        super("markWordKlassShift", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: markWordKlassShift(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_markWordKlassShift implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_markWordKlassShift();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.markWordKlassShift(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: markWordLockMaskInPlace(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_markWordLockMaskInPlace extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_markWordLockMaskInPlace.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.markWordLockMaskInPlace(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_markWordLockMaskInPlace(GeneratedPluginInjectionProvider injection) {
        super("markWordLockMaskInPlace", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: markWordLockMaskInPlace(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_markWordLockMaskInPlace implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_markWordLockMaskInPlace();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.markWordLockMaskInPlace(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: metaspaceArrayBaseOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_metaspaceArrayBaseOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_metaspaceArrayBaseOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.metaspaceArrayBaseOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_metaspaceArrayBaseOffset(GeneratedPluginInjectionProvider injection) {
        super("metaspaceArrayBaseOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: metaspaceArrayBaseOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_metaspaceArrayBaseOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_metaspaceArrayBaseOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.metaspaceArrayBaseOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: metaspaceArrayLengthOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_metaspaceArrayLengthOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_metaspaceArrayLengthOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.metaspaceArrayLengthOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_metaspaceArrayLengthOffset(GeneratedPluginInjectionProvider injection) {
        super("metaspaceArrayLengthOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: metaspaceArrayLengthOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_metaspaceArrayLengthOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_metaspaceArrayLengthOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.metaspaceArrayLengthOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: monitorValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_monitorValue extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_monitorValue.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.monitorValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_monitorValue(GeneratedPluginInjectionProvider injection) {
        super("monitorValue", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: monitorValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_monitorValue implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_monitorValue();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.monitorValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectAlignment(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_objectAlignment extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_objectAlignment.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectAlignment(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_objectAlignment(GeneratedPluginInjectionProvider injection) {
        super("objectAlignment", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectAlignment(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_objectAlignment implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_objectAlignment();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectAlignment(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectMonitorCxqOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_objectMonitorCxqOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorCxqOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectMonitorCxqOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_objectMonitorCxqOffset(GeneratedPluginInjectionProvider injection) {
        super("objectMonitorCxqOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectMonitorCxqOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorCxqOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorCxqOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectMonitorCxqOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectMonitorEntryListOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_objectMonitorEntryListOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorEntryListOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectMonitorEntryListOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_objectMonitorEntryListOffset(GeneratedPluginInjectionProvider injection) {
        super("objectMonitorEntryListOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectMonitorEntryListOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorEntryListOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorEntryListOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectMonitorEntryListOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectMonitorOwnerOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_objectMonitorOwnerOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorOwnerOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectMonitorOwnerOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_objectMonitorOwnerOffset(GeneratedPluginInjectionProvider injection) {
        super("objectMonitorOwnerOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectMonitorOwnerOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorOwnerOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorOwnerOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectMonitorOwnerOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectMonitorRecursionsOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_objectMonitorRecursionsOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorRecursionsOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectMonitorRecursionsOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_objectMonitorRecursionsOffset(GeneratedPluginInjectionProvider injection) {
        super("objectMonitorRecursionsOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectMonitorRecursionsOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorRecursionsOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorRecursionsOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectMonitorRecursionsOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectMonitorSuccOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_objectMonitorSuccOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorSuccOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectMonitorSuccOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_objectMonitorSuccOffset(GeneratedPluginInjectionProvider injection) {
        super("objectMonitorSuccOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: objectMonitorSuccOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorSuccOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_objectMonitorSuccOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.objectMonitorSuccOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: omCacheOopToMonitorDifference(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_omCacheOopToMonitorDifference extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_omCacheOopToMonitorDifference.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.omCacheOopToMonitorDifference(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_omCacheOopToMonitorDifference(GeneratedPluginInjectionProvider injection) {
        super("omCacheOopToMonitorDifference", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: omCacheOopToMonitorDifference(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_omCacheOopToMonitorDifference implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_omCacheOopToMonitorDifference();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.omCacheOopToMonitorDifference(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: omCacheOopToOopDifference(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_omCacheOopToOopDifference extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_omCacheOopToOopDifference.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.omCacheOopToOopDifference(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_omCacheOopToOopDifference(GeneratedPluginInjectionProvider injection) {
        super("omCacheOopToOopDifference", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: omCacheOopToOopDifference(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_omCacheOopToOopDifference implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_omCacheOopToOopDifference();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.omCacheOopToOopDifference(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: pageSize(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_pageSize extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_pageSize.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.pageSize(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_pageSize(GeneratedPluginInjectionProvider injection) {
        super("pageSize", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: pageSize(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_pageSize implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_pageSize();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.pageSize(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: readLayoutHelper(jdk.graal.compiler.hotspot.word.KlassPointer)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$CustomFactoryPlugin
final class Plugin_HotSpotReplacementsUtil_readLayoutHelper extends GeneratedNodeIntrinsicInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        ValueNode arg1 = args[0];
        if (jdk.graal.compiler.hotspot.replacements.KlassLayoutHelperNode.intrinsify(b, arg0, arg1)) {
            return true;
        }
        return false;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.graph.Node.NodeIntrinsic.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_readLayoutHelper(GeneratedPluginInjectionProvider injection) {
        super("readLayoutHelper", jdk.graal.compiler.hotspot.word.KlassPointer.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: registerAsWord(jdk.vm.ci.code.Register,boolean,boolean)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$ConstructorPlugin
final class Plugin_HotSpotReplacementsUtil_registerAsWord extends GeneratedNodeIntrinsicInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        jdk.graal.compiler.core.common.type.Stamp arg0 = stamp;
        jdk.vm.ci.code.Register arg1;
        if (args[0].isConstant()) {
            arg1 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(jdk.vm.ci.code.Register.class, args[0].asJavaConstant());
            assert arg1 != null;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_registerAsWord.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[0];
            return false;
        }
        boolean arg2;
        if (args[1].isConstant()) {
            arg2 = args[1].asJavaConstant().asInt() != 0;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_registerAsWord.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[1];
            return false;
        }
        boolean arg3;
        if (args[2].isConstant()) {
            arg3 = args[2].asJavaConstant().asInt() != 0;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_registerAsWord.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[2];
            return false;
        }
        jdk.graal.compiler.replacements.nodes.ReadRegisterNode node = new jdk.graal.compiler.replacements.nodes.ReadRegisterNode(arg0, arg1, arg2, arg3);
        b.addPush(JavaKind.Object, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.graph.Node.NodeIntrinsic.class;
    }

    private final jdk.graal.compiler.core.common.type.Stamp stamp;
    private final jdk.graal.compiler.api.replacements.SnippetReflectionProvider snippetReflection;

    Plugin_HotSpotReplacementsUtil_registerAsWord(GeneratedPluginInjectionProvider injection) {
        super("registerAsWord", jdk.vm.ci.code.Register.class, boolean.class, boolean.class);
        this.stamp = injection.getInjectedStamp(jdk.graal.compiler.word.Word.class);
        this.snippetReflection = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: registerAsWord(jdk.vm.ci.code.Register,boolean,boolean)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$ConstructorPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_registerAsWord implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_registerAsWord();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        jdk.graal.compiler.core.common.type.Stamp arg0 = injection.getInjectedStamp(jdk.graal.compiler.word.Word.class);
        jdk.vm.ci.code.Register arg1;
        if (args.get(0).isConstant()) {
            arg1 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(jdk.vm.ci.code.Register.class, args.get(0).asJavaConstant());
            assert arg1 != null;
        } else {
            return false;
        }
        boolean arg2;
        if (args.get(1).isConstant()) {
            arg2 = args.get(1).asJavaConstant().asInt() != 0;
        } else {
            return false;
        }
        boolean arg3;
        if (args.get(2).isConstant()) {
            arg3 = args.get(2).asJavaConstant().asInt() != 0;
        } else {
            return false;
        }
        jdk.graal.compiler.replacements.nodes.ReadRegisterNode node = new jdk.graal.compiler.replacements.nodes.ReadRegisterNode(arg0, arg1, arg2, arg3);
        b.addPush(JavaKind.Object, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: secondarySuperCacheOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_secondarySuperCacheOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_secondarySuperCacheOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.secondarySuperCacheOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_secondarySuperCacheOffset(GeneratedPluginInjectionProvider injection) {
        super("secondarySuperCacheOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: secondarySuperCacheOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_secondarySuperCacheOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_secondarySuperCacheOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.secondarySuperCacheOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: secondarySupersOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_secondarySupersOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_secondarySupersOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.secondarySupersOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_secondarySupersOffset(GeneratedPluginInjectionProvider injection) {
        super("secondarySupersOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: secondarySupersOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_secondarySupersOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_secondarySupersOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.secondarySupersOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: shouldUseKlassMiscFlags()
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_shouldUseKlassMiscFlags extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_shouldUseKlassMiscFlags.FUNCTION);
            return true;
        }
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.shouldUseKlassMiscFlags();
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    Plugin_HotSpotReplacementsUtil_shouldUseKlassMiscFlags() {
        super("shouldUseKlassMiscFlags");
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: shouldUseKlassMiscFlags()
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_shouldUseKlassMiscFlags implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_shouldUseKlassMiscFlags();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.shouldUseKlassMiscFlags();
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: superCheckOffsetOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_superCheckOffsetOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_superCheckOffsetOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.superCheckOffsetOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_superCheckOffsetOffset(GeneratedPluginInjectionProvider injection) {
        super("superCheckOffsetOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: superCheckOffsetOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_superCheckOffsetOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_superCheckOffsetOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.superCheckOffsetOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadCarrierThreadOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_threadCarrierThreadOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_threadCarrierThreadOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadCarrierThreadOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_threadCarrierThreadOffset(GeneratedPluginInjectionProvider injection) {
        super("threadCarrierThreadOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadCarrierThreadOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_threadCarrierThreadOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_threadCarrierThreadOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadCarrierThreadOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadExceptionOopOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_threadExceptionOopOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_threadExceptionOopOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadExceptionOopOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_threadExceptionOopOffset(GeneratedPluginInjectionProvider injection) {
        super("threadExceptionOopOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadExceptionOopOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_threadExceptionOopOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_threadExceptionOopOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadExceptionOopOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadExceptionPcOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_threadExceptionPcOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_threadExceptionPcOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadExceptionPcOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_threadExceptionPcOffset(GeneratedPluginInjectionProvider injection) {
        super("threadExceptionPcOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadExceptionPcOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_threadExceptionPcOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_threadExceptionPcOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadExceptionPcOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadPendingExceptionOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_threadPendingExceptionOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_threadPendingExceptionOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadPendingExceptionOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_threadPendingExceptionOffset(GeneratedPluginInjectionProvider injection) {
        super("threadPendingExceptionOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadPendingExceptionOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_threadPendingExceptionOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_threadPendingExceptionOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadPendingExceptionOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadTlabEndOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_threadTlabEndOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_threadTlabEndOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadTlabEndOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_threadTlabEndOffset(GeneratedPluginInjectionProvider injection) {
        super("threadTlabEndOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadTlabEndOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_threadTlabEndOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_threadTlabEndOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadTlabEndOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadTlabTopOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_threadTlabTopOffset extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_threadTlabTopOffset.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadTlabTopOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_threadTlabTopOffset(GeneratedPluginInjectionProvider injection) {
        super("threadTlabTopOffset", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: threadTlabTopOffset(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_threadTlabTopOffset implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_threadTlabTopOffset();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.threadTlabTopOffset(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: uninitializedIdentityHashCodeValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_uninitializedIdentityHashCodeValue extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_uninitializedIdentityHashCodeValue.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.uninitializedIdentityHashCodeValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_uninitializedIdentityHashCodeValue(GeneratedPluginInjectionProvider injection) {
        super("uninitializedIdentityHashCodeValue", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: uninitializedIdentityHashCodeValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_uninitializedIdentityHashCodeValue implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_uninitializedIdentityHashCodeValue();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.uninitializedIdentityHashCodeValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: unlockedValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_unlockedValue extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_unlockedValue.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.unlockedValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_unlockedValue(GeneratedPluginInjectionProvider injection) {
        super("unlockedValue", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: unlockedValue(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_unlockedValue implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_unlockedValue();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.unlockedValue(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: unusedMark(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_unusedMark extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_unusedMark.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.unusedMark(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_unusedMark(GeneratedPluginInjectionProvider injection) {
        super("unusedMark", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: unusedMark(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_unusedMark implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_unusedMark();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.unusedMark(arg0);
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useCompactObjectHeaders(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_useCompactObjectHeaders extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_useCompactObjectHeaders.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useCompactObjectHeaders(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_useCompactObjectHeaders(GeneratedPluginInjectionProvider injection) {
        super("useCompactObjectHeaders", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useCompactObjectHeaders(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_useCompactObjectHeaders implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_useCompactObjectHeaders();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useCompactObjectHeaders(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useG1GC(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_useG1GC extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_useG1GC.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useG1GC(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_useG1GC(GeneratedPluginInjectionProvider injection) {
        super("useG1GC", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useG1GC(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_useG1GC implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_useG1GC();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useG1GC(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useLightweightLocking(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_useLightweightLocking extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_useLightweightLocking.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useLightweightLocking(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_useLightweightLocking(GeneratedPluginInjectionProvider injection) {
        super("useLightweightLocking", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useLightweightLocking(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_useLightweightLocking implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_useLightweightLocking();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useLightweightLocking(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useObjectMonitorTable(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_useObjectMonitorTable extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_useObjectMonitorTable.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useObjectMonitorTable(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_useObjectMonitorTable(GeneratedPluginInjectionProvider injection) {
        super("useObjectMonitorTable", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useObjectMonitorTable(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_useObjectMonitorTable implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_useObjectMonitorTable();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useObjectMonitorTable(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useSecondarySupersCache(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_useSecondarySupersCache extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_useSecondarySupersCache.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useSecondarySupersCache(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_useSecondarySupersCache(GeneratedPluginInjectionProvider injection) {
        super("useSecondarySupersCache", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useSecondarySupersCache(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_useSecondarySupersCache implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_useSecondarySupersCache();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useSecondarySupersCache(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useSecondarySupersTable(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_useSecondarySupersTable extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_useSecondarySupersTable.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useSecondarySupersTable(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_useSecondarySupersTable(GeneratedPluginInjectionProvider injection) {
        super("useSecondarySupersTable", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useSecondarySupersTable(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_useSecondarySupersTable implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_useSecondarySupersTable();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useSecondarySupersTable(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useSerialGC(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_useSerialGC extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_useSerialGC.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useSerialGC(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_useSerialGC(GeneratedPluginInjectionProvider injection) {
        super("useSerialGC", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useSerialGC(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_useSerialGC implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_useSerialGC();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useSerialGC(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useStackLocking(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_useStackLocking extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_useStackLocking.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useStackLocking(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_useStackLocking(GeneratedPluginInjectionProvider injection) {
        super("useStackLocking", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useStackLocking(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_useStackLocking implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_useStackLocking();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useStackLocking(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useTLAB(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_useTLAB extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_useTLAB.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useTLAB(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_useTLAB(GeneratedPluginInjectionProvider injection) {
        super("useTLAB", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: useTLAB(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_useTLAB implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_useTLAB();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.useTLAB(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyBeforeOrAfterGC(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_verifyBeforeOrAfterGC extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_verifyBeforeOrAfterGC.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.verifyBeforeOrAfterGC(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_verifyBeforeOrAfterGC(GeneratedPluginInjectionProvider injection) {
        super("verifyBeforeOrAfterGC", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyBeforeOrAfterGC(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_verifyBeforeOrAfterGC implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_verifyBeforeOrAfterGC();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.verifyBeforeOrAfterGC(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyOopBits(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_verifyOopBits extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_verifyOopBits.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.verifyOopBits(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_verifyOopBits(GeneratedPluginInjectionProvider injection) {
        super("verifyOopBits", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyOopBits(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_verifyOopBits implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_verifyOopBits();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.verifyOopBits(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyOopCounterAddress(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_verifyOopCounterAddress extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_verifyOopCounterAddress.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.verifyOopCounterAddress(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_verifyOopCounterAddress(GeneratedPluginInjectionProvider injection) {
        super("verifyOopCounterAddress", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyOopCounterAddress(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_verifyOopCounterAddress implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_verifyOopCounterAddress();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.verifyOopCounterAddress(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyOopMask(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_verifyOopMask extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_verifyOopMask.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.verifyOopMask(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_verifyOopMask(GeneratedPluginInjectionProvider injection) {
        super("verifyOopMask", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyOopMask(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_verifyOopMask implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_verifyOopMask();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        long result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.verifyOopMask(arg0);
        JavaConstant constant = JavaConstant.forLong(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Long, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyOopStub(jdk.graal.compiler.core.common.spi.ForeignCallDescriptor,java.lang.Object)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$CustomFactoryPlugin
final class Plugin_HotSpotReplacementsUtil_verifyOopStub extends GeneratedNodeIntrinsicInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        jdk.graal.compiler.core.common.type.Stamp arg0 = stamp;
        jdk.graal.compiler.core.common.spi.ForeignCallDescriptor arg1;
        if (args[0].isConstant()) {
            arg1 = snippetReflection/* A SNIPPET_REFLECTION */.asObject(jdk.graal.compiler.core.common.spi.ForeignCallDescriptor.class, args[0].asJavaConstant());
            assert arg1 != null;
        } else {
            if (b.shouldDeferPlugin(this)) {
                b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_verifyOopStub.FUNCTION);
                return true;
            }
            assert b.canDeferPlugin(this) : b.getClass().toString() + " " + args[0];
            return false;
        }
        assert verifyForeignCallDescriptor(b, targetMethod, arg1) : arg1;
        ValueNode arg2 = args[1];
        if (jdk.graal.compiler.nodes.extended.ForeignCallNode.intrinsify(b, arg0, arg1, arg2)) {
            return true;
        }
        if (b.canDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_verifyOopStub.FUNCTION);
            return true;
        }
        throw GraalError.shouldNotReachHere("Can't inline plugin " + b.getClass().toString());
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.graph.Node.NodeIntrinsic.class;
    }

    private final jdk.graal.compiler.core.common.type.Stamp stamp;
    private final jdk.graal.compiler.api.replacements.SnippetReflectionProvider snippetReflection;

    Plugin_HotSpotReplacementsUtil_verifyOopStub(GeneratedPluginInjectionProvider injection) {
        super("verifyOopStub", jdk.graal.compiler.core.common.spi.ForeignCallDescriptor.class, java.lang.Object.class);
        this.stamp = injection.getInjectedStamp(java.lang.Object.class);
        this.snippetReflection = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyOopStub(jdk.graal.compiler.core.common.spi.ForeignCallDescriptor,java.lang.Object)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedNodeIntrinsicPlugin$CustomFactoryPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_verifyOopStub implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_verifyOopStub();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        jdk.graal.compiler.core.common.type.Stamp arg0 = injection.getInjectedStamp(java.lang.Object.class);
        jdk.graal.compiler.core.common.spi.ForeignCallDescriptor arg1;
        if (args.get(0).isConstant()) {
            arg1 = injection.getInjectedArgument(jdk.graal.compiler.api.replacements.SnippetReflectionProvider.class)/* B SNIPPET_REFLECTION */.asObject(jdk.graal.compiler.core.common.spi.ForeignCallDescriptor.class, args.get(0).asJavaConstant());
            assert arg1 != null;
        } else {
            return false;
        }
        ValueNode arg2 = args.get(1);
        if (jdk.graal.compiler.nodes.extended.ForeignCallNode.intrinsify(b, arg0, arg1, arg2)) {
            return true;
        }
        return false;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyOops(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_verifyOops extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_verifyOops.FUNCTION);
            return true;
        }
        if (!checkInjectedArgument(b, args[0], targetMethod)) {
            return false;
        }
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injectedGraalHotSpotVMConfig;
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.verifyOops(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    private final jdk.graal.compiler.hotspot.GraalHotSpotVMConfig injectedGraalHotSpotVMConfig;

    Plugin_HotSpotReplacementsUtil_verifyOops(GeneratedPluginInjectionProvider injection) {
        super("verifyOops", jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        this.injectedGraalHotSpotVMConfig = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: verifyOops(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig)
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_verifyOops implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_verifyOops();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        assert args.get(0).isNullConstant() : "Must be null constant " + args.get(0);
        jdk.graal.compiler.hotspot.GraalHotSpotVMConfig arg0 = injection.getInjectedArgument(jdk.graal.compiler.hotspot.GraalHotSpotVMConfig.class);
        boolean result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.verifyOops(arg0);
        JavaConstant constant = JavaConstant.forInt(result ? 1 : 0);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: wordSize()
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
final class Plugin_HotSpotReplacementsUtil_wordSize extends GeneratedFoldInvocationPlugin {

    @Override
    public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) {
        if (!b.isPluginEnabled(this)) {
            return false;
        }
        if (b.shouldDeferPlugin(this)) {
            b.replacePlugin(this, targetMethod, args, PluginReplacementNode_HotSpotReplacementsUtil_wordSize.FUNCTION);
            return true;
        }
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.wordSize();
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* A META_ACCESS */, b.getGraph()/* A STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
    @Override
    public Class getSource() {
        return jdk.graal.compiler.api.replacements.Fold.class;
    }

    Plugin_HotSpotReplacementsUtil_wordSize() {
        super("wordSize");
    }
}
//        class: jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil
//       method: wordSize()
// generated-by: jdk.graal.compiler.replacements.processor.GeneratedFoldPlugin
@ExcludeFromJacocoGeneratedReport("deferred plugin support that is only called in libgraal")
final class PluginReplacementNode_HotSpotReplacementsUtil_wordSize implements PluginReplacementNode.ReplacementFunction {
    static PluginReplacementNode.ReplacementFunction FUNCTION = new PluginReplacementNode_HotSpotReplacementsUtil_wordSize();

    @Override
    public boolean replace(GraphBuilderContext b, Replacements injection, Stamp stamp, NodeInputList args) {
        int result = jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.wordSize();
        JavaConstant constant = JavaConstant.forInt(result);
        ConstantNode node = ConstantNode.forConstant(constant, b.getMetaAccess()/* B META_ACCESS */, b.getGraph()/* B STRUCTURED_GRAPH */);
        b.push(JavaKind.Int, node);
        return true;
    }
}

public class PluginFactory_HotSpotReplacementsUtil implements GeneratedPluginFactory {
    @Override
    public void registerPlugins(InvocationPlugins plugins, GeneratedPluginInjectionProvider injection) {
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_allocateInstancePrefetchLines(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_allocatePrefetchDistance(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_allocatePrefetchLines(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_allocatePrefetchStepSize(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_allocatePrefetchStyle(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_arrayClassElementOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_arrayKlassOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_arrayLengthOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_cardTableShift(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_cardTableStart(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_compress(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_defaultPrototypeMarkWord(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_diagnoseSyncOnValueBasedClasses(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_dirtyCardValue(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_doingUnsafeAccessOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_g1CardQueueBufferOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_g1CardQueueIndexOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_g1SATBQueueBufferOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_g1SATBQueueIndexOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_g1SATBQueueMarkingActiveOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_g1YoungCardValue(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_gcTotalCollectionsAddress(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_getFieldOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_getHeapWordSize(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_getWordKind(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_heldMonitorCountOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_hubOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_identityHashCode(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_instanceHeaderSize(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_instanceKlassInitStateOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_instanceKlassInitThreadOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_instanceKlassStateBeingInitialized(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_instanceKlassStateFullyInitialized(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_isCAssertEnabled(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_javaLangThreadJFREpochOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_javaLangThreadTIDOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_javaThreadLockStackEndOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_javaThreadLockStackTopOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_javaThreadMonitorOwnerIDOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_javaThreadOomCacheOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_javaThreadUnlockedInflatedMonitorOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadEpochOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadExcludedOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadIDOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_jfrThreadLocalVthreadOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_jvmAccHasFinalizer(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_jvmAccIsValueBasedClass(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_klassAccessFlagsOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_klassBitmapOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_klassEncoding(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_klassHashSlotOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_klassLayoutHelperNeutralValue(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_klassMiscFlagsOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_layoutHelperHeaderSizeMask(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_layoutHelperHeaderSizeShift(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeMask(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_layoutHelperLog2ElementSizeShift(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_loadHubIntrinsic());
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_loadHubOrNullIntrinsic());
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_loadKlassFromObjectIntrinsic(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_loadWordFromObjectIntrinsic(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_lockMetadataOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_logOfHeapRegionGrainBytes(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_markOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_markWordHashCodeShift(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_markWordHashMark(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_markWordKlassShift(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_markWordLockMaskInPlace(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_metaspaceArrayBaseOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_metaspaceArrayLengthOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_monitorValue(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_objectAlignment(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_objectMonitorCxqOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_objectMonitorEntryListOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_objectMonitorOwnerOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_objectMonitorRecursionsOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_objectMonitorSuccOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_omCacheOopToMonitorDifference(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_omCacheOopToOopDifference(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_pageSize(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_readLayoutHelper(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_registerAsWord(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_secondarySuperCacheOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_secondarySupersOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_shouldUseKlassMiscFlags());
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_superCheckOffsetOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_threadCarrierThreadOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_threadExceptionOopOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_threadExceptionPcOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_threadPendingExceptionOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_threadTlabEndOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_threadTlabTopOffset(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_uninitializedIdentityHashCodeValue(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_unlockedValue(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_unusedMark(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_useCompactObjectHeaders(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_useG1GC(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_useLightweightLocking(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_useObjectMonitorTable(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_useSecondarySupersCache(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_useSecondarySupersTable(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_useSerialGC(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_useStackLocking(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_useTLAB(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_verifyBeforeOrAfterGC(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_verifyOopBits(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_verifyOopCounterAddress(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_verifyOopMask(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_verifyOopStub(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_verifyOops(injection));
        plugins.register(jdk.graal.compiler.hotspot.replacements.HotSpotReplacementsUtil.class, new Plugin_HotSpotReplacementsUtil_wordSize());
    }
}