/* THIS FILE IS GENERATED. DO NOT EDIT */
package org.jruby.gen;

import org.jruby.Ruby;
import org.jruby.RubyModule;
import org.jruby.RubyClass;
import org.jruby.anno.TypePopulator;
import org.jruby.internal.runtime.methods.JavaMethod;
import org.jruby.internal.runtime.methods.DynamicMethod;
import org.jruby.runtime.Arity;
import org.jruby.runtime.Visibility;
import org.jruby.runtime.MethodIndex;
import java.util.Arrays;
import java.util.List;
import javax.annotation.Generated;

@Generated("org.jruby.anno.AnnotationBinder")
@SuppressWarnings("deprecation")
public class org$jruby$RubyProcess$POPULATOR extends TypePopulator {
    public void populate(RubyModule cls, Class clazz) {
        JavaMethod javaMethod;
        DynamicMethod moduleMethod, aliasedMethod;
        RubyClass singletonClass = cls.getSingletonClass();
        Ruby runtime = cls.getRuntime();
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$wait(cls, Visibility.PRIVATE, "wait");
        populateMethod(javaMethod, -1, "wait", true, false, org.jruby.RubyProcess.class, "wait", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY);
        aliasedMethod = cls.putMethod(runtime, "wait", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "wait", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$1$0$getrlimit(cls, Visibility.PRIVATE, "getrlimit");
        populateMethod(javaMethod, 1, "getrlimit", true, false, org.jruby.RubyProcess.class, "getrlimit", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "getrlimit", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "getrlimit", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$gid(cls, Visibility.PRIVATE, "gid");
        populateMethod(javaMethod, 0, "gid", true, false, org.jruby.RubyProcess.class, "gid", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "gid", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "gid", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$1$exit_bang(cls, Visibility.PRIVATE, "exit!");
        populateMethod(javaMethod, -1, "exit_bang", true, false, org.jruby.RubyProcess.class, "exit_bang", org.jruby.runtime.builtin.IRubyObject.class, ARG1_ARY);
        aliasedMethod = cls.putMethod(runtime, "exit!", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "exit!", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$waitall(cls, Visibility.PRIVATE, "waitall");
        populateMethod(javaMethod, 0, "waitall", true, false, org.jruby.RubyProcess.class, "waitall", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "waitall", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "waitall", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$3$0$setpriority(cls, Visibility.PRIVATE, "setpriority");
        populateMethod(javaMethod, 3, "setpriority", true, false, org.jruby.RubyProcess.class, "setpriority", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG4);
        aliasedMethod = cls.putMethod(runtime, "setpriority", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "setpriority", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$clock_getres(cls, Visibility.PRIVATE, "clock_getres");
        populateMethod(javaMethod, -1, "clock_getres", true, false, org.jruby.RubyProcess.class, "clock_getres", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "clock_getres", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "clock_getres", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$setpgrp(cls, Visibility.PRIVATE, "setpgrp");
        populateMethod(javaMethod, 0, "setpgrp", true, false, org.jruby.RubyProcess.class, "setpgrp", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "setpgrp", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "setpgrp", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$pid(cls, Visibility.PRIVATE, "pid");
        populateMethod(javaMethod, 0, "pid", true, false, org.jruby.RubyProcess.class, "pid", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "pid", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "pid", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$1$0$gid_set(cls, Visibility.PRIVATE, "gid=");
        populateMethod(javaMethod, 1, "gid_set", true, false, org.jruby.RubyProcess.class, "gid_set", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "gid=", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "gid=", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$clock_gettime(cls, Visibility.PRIVATE, "clock_gettime");
        populateMethod(javaMethod, -1, "clock_gettime", true, false, org.jruby.RubyProcess.class, "clock_gettime", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "clock_gettime", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "clock_gettime", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$waitpid2(cls, Visibility.PRIVATE, "waitpid2");
        populateMethod(javaMethod, -1, "waitpid2", true, false, org.jruby.RubyProcess.class, "waitpid2", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY);
        aliasedMethod = cls.putMethod(runtime, "waitpid2", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "waitpid2", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$uid(cls, Visibility.PRIVATE, "uid");
        populateMethod(javaMethod, 0, "uid", true, false, org.jruby.RubyProcess.class, "uid", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "uid", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "uid", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$egid(cls, Visibility.PRIVATE, "egid");
        populateMethod(javaMethod, 0, "egid", true, false, org.jruby.RubyProcess.class, "egid", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "egid", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "egid", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$1$0$groups_set(cls, Visibility.PRIVATE, "groups=");
        populateMethod(javaMethod, 1, "groups_set", true, false, org.jruby.RubyProcess.class, "groups_set", org.jruby.runtime.builtin.IRubyObject.class, ARG2);
        aliasedMethod = cls.putMethod(runtime, "groups=", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "groups=", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$1$0$euid_set(cls, Visibility.PRIVATE, "euid=");
        populateMethod(javaMethod, 1, "euid_set", true, false, org.jruby.RubyProcess.class, "euid_set", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "euid=", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "euid=", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$2$0$initgroups(cls, Visibility.PRIVATE, "initgroups");
        populateMethod(javaMethod, 2, "initgroups", true, false, org.jruby.RubyProcess.class, "initgroups", org.jruby.runtime.builtin.IRubyObject.class, ARG3);
        aliasedMethod = cls.putMethod(runtime, "initgroups", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "initgroups", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$getpgrp(cls, Visibility.PRIVATE, "getpgrp");
        populateMethod(javaMethod, 0, "getpgrp", true, false, org.jruby.RubyProcess.class, "getpgrp", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "getpgrp", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "getpgrp", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$1$0$uid_set(cls, Visibility.PRIVATE, "uid=");
        populateMethod(javaMethod, 1, "uid_set", true, false, org.jruby.RubyProcess.class, "uid_set", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "uid=", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "uid=", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$1$0$egid_set(cls, Visibility.PRIVATE, "egid=");
        populateMethod(javaMethod, 1, "egid_set", true, false, org.jruby.RubyProcess.class, "egid_set", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "egid=", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "egid=", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$exec(singletonClass, Visibility.PUBLIC, "exec");
        populateMethod(javaMethod, -1, "exec", true, false, org.jruby.RubyProcess.class, "exec", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY);
        aliasedMethod = singletonClass.putMethod(runtime, "exec", javaMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$euid(cls, Visibility.PRIVATE, "euid");
        populateMethod(javaMethod, 0, "euid", true, false, org.jruby.RubyProcess.class, "euid", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "euid", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "euid", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$maxgroups(cls, Visibility.PRIVATE, "maxgroups");
        populateMethod(javaMethod, 0, "maxgroups", true, false, org.jruby.RubyProcess.class, "maxgroups", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "maxgroups", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "maxgroups", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$wait2(cls, Visibility.PRIVATE, "wait2");
        populateMethod(javaMethod, -1, "wait2", true, false, org.jruby.RubyProcess.class, "wait2", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY);
        aliasedMethod = cls.putMethod(runtime, "wait2", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "wait2", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$last_status(cls, Visibility.PRIVATE, "last_status");
        populateMethod(javaMethod, 0, "last_status", true, false, org.jruby.RubyProcess.class, "last_status", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "last_status", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "last_status", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$groups(cls, Visibility.PRIVATE, "groups");
        populateMethod(javaMethod, 0, "groups", true, false, org.jruby.RubyProcess.class, "groups", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "groups", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "groups", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$2$0$setpgid(cls, Visibility.PRIVATE, "setpgid");
        populateMethod(javaMethod, 2, "setpgid", true, false, org.jruby.RubyProcess.class, "setpgid", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG3);
        aliasedMethod = cls.putMethod(runtime, "setpgid", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "setpgid", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$kill(cls, Visibility.PRIVATE, "kill");
        populateMethod(javaMethod, -1, "kill", true, false, org.jruby.RubyProcess.class, "kill", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY);
        aliasedMethod = cls.putMethod(runtime, "kill", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "kill", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$setsid(cls, Visibility.PRIVATE, "setsid");
        populateMethod(javaMethod, 0, "setsid", true, false, org.jruby.RubyProcess.class, "setsid", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "setsid", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "setsid", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$ppid(cls, Visibility.PRIVATE, "ppid");
        populateMethod(javaMethod, 0, "ppid", true, false, org.jruby.RubyProcess.class, "ppid", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "ppid", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "ppid", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$1$exit(cls, Visibility.PRIVATE, "exit");
        populateMethod(javaMethod, -1, "exit", true, false, org.jruby.RubyProcess.class, "exit", org.jruby.runtime.builtin.IRubyObject.class, ARG1_ARY);
        aliasedMethod = cls.putMethod(runtime, "exit", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "exit", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$2$0$getpriority(cls, Visibility.PRIVATE, "getpriority");
        populateMethod(javaMethod, 2, "getpriority", true, false, org.jruby.RubyProcess.class, "getpriority", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG3);
        aliasedMethod = cls.putMethod(runtime, "getpriority", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "getpriority", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$fork19(cls, Visibility.PRIVATE, "fork");
        populateMethod(javaMethod, 0, "fork19", true, true, org.jruby.RubyProcess.class, "fork19", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "fork", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "fork", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$1$abort(cls, Visibility.PRIVATE, "abort");
        populateMethod(javaMethod, -1, "abort", true, false, org.jruby.RubyProcess.class, "abort", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY);
        aliasedMethod = cls.putMethod(runtime, "abort", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "abort", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$setrlimit(cls, Visibility.PRIVATE, "setrlimit");
        populateMethod(javaMethod, -1, "setrlimit", true, false, org.jruby.RubyProcess.class, "setrlimit", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG3);
        aliasedMethod = cls.putMethod(runtime, "setrlimit", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "setrlimit", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$1$0$maxgroups_set(cls, Visibility.PRIVATE, "maxgroups=");
        populateMethod(javaMethod, 1, "maxgroups_set", true, false, org.jruby.RubyProcess.class, "maxgroups_set", org.jruby.runtime.builtin.IRubyObject.class, ARG2);
        aliasedMethod = cls.putMethod(runtime, "maxgroups=", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "maxgroups=", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$1$0$detach(cls, Visibility.PRIVATE, "detach");
        populateMethod(javaMethod, 1, "detach", true, false, org.jruby.RubyProcess.class, "detach", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "detach", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "detach", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$1$0$getpgid(cls, Visibility.PRIVATE, "getpgid");
        populateMethod(javaMethod, 1, "getpgid", true, false, org.jruby.RubyProcess.class, "getpgid", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = cls.putMethod(runtime, "getpgid", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "getpgid", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$spawn(cls, Visibility.PRIVATE, "spawn");
        populateMethod(javaMethod, -1, "spawn", true, false, org.jruby.RubyProcess.class, "spawn", org.jruby.RubyFixnum.class, CONTEXT_ARG1_ARY);
        aliasedMethod = cls.putMethod(runtime, "spawn", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "spawn", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$times(cls, Visibility.PRIVATE, "times");
        populateMethod(javaMethod, 0, "times", true, false, org.jruby.RubyProcess.class, "times", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "times", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "times", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$1$0$setproctitle(cls, Visibility.PRIVATE, "setproctitle");
        populateMethod(javaMethod, 1, "setproctitle", true, false, org.jruby.RubyProcess.class, "setproctitle", org.jruby.runtime.builtin.IRubyObject.class, ARG2);
        aliasedMethod = cls.putMethod(runtime, "setproctitle", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "setproctitle", moduleMethod);
        javaMethod = new org.jruby.RubyProcess$INVOKER$s$0$0$waitpid(cls, Visibility.PRIVATE, "waitpid");
        populateMethod(javaMethod, -1, "waitpid", true, false, org.jruby.RubyProcess.class, "waitpid", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_ARY);
        aliasedMethod = cls.putMethod(runtime, "waitpid", javaMethod);
        moduleMethod = populateModuleMethod(cls, javaMethod);
        aliasedMethod = singletonClass.putMethod(runtime, "waitpid", moduleMethod);

        runtime.addBoundMethods("org.jruby.RubyProcess", "wait", "wait", "getrlimit", "getrlimit", "gid", "gid", "exit_bang", "exit!", "waitall", "waitall", "setpriority", "setpriority", "setpgrp", "setpgrp", "pid", "pid", "gid_set", "gid=", "waitpid2", "waitpid2", "uid", "uid", "egid", "egid", "groups_set", "groups=", "euid_set", "euid=", "initgroups", "initgroups", "getpgrp", "getpgrp", "uid_set", "uid=", "egid_set", "egid=", "euid", "euid", "maxgroups", "maxgroups", "wait2", "wait2", "last_status", "last_status", "groups", "groups", "setpgid", "setpgid", "kill", "kill", "setsid", "setsid", "ppid", "ppid", "exit", "exit", "getpriority", "getpriority", "fork19", "fork", "abort", "abort", "setrlimit", "setrlimit", "maxgroups_set", "maxgroups=", "detach", "detach", "getpgid", "getpgid", "setproctitle", "setproctitle", "waitpid", "waitpid", "clock_getres", "clock_getres", "clock_gettime", "clock_gettime", "exec", "exec", "spawn", "spawn", "times", "times");
    }
    static {
    }
}