/* 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$RubyArray$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.RubyArray$INVOKER$s$0$0$create(singletonClass, Visibility.PUBLIC, "[]");
        populateMethod(javaMethod, -1, "create", true, false, org.jruby.RubyArray.class, "create", org.jruby.runtime.builtin.IRubyObject.class, ARG1_ARY_BLOCK);
        aliasedMethod = singletonClass.putMethod(runtime, "[]", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$s$1$0$try_convert(singletonClass, Visibility.PUBLIC, "try_convert");
        populateMethod(javaMethod, 1, "try_convert", true, false, org.jruby.RubyArray.class, "try_convert", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG2);
        aliasedMethod = singletonClass.putMethod(runtime, "try_convert", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$frozen_p(cls, Visibility.PUBLIC, "frozen?");
        populateMethod(javaMethod, 0, "frozen_p", false, false, org.jruby.RubyArray.class, "frozen_p", org.jruby.RubyBoolean.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "frozen?", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$shift(cls, Visibility.PUBLIC, "shift");
        populateMethod(javaMethod, -1, "shift", false, false, org.jruby.RubyArray.class, "shift", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "shift", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$sum(cls, Visibility.PUBLIC, "sum");
        populateMethod(javaMethod, -1, "sum", false, false, org.jruby.RubyArray.class, "sum", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "sum", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$repeated_permutation(cls, Visibility.PUBLIC, "repeated_permutation");
        populateMethod(javaMethod, 1, "repeated_permutation", false, false, org.jruby.RubyArray.class, "repeated_permutation", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "repeated_permutation", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$select(cls, Visibility.PUBLIC, "select");
        populateMethod(javaMethod, 0, "select", false, false, org.jruby.RubyArray.class, "select", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "select", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$initialize_copy(cls, Visibility.PRIVATE, "initialize_copy");
        populateMethod(javaMethod, 1, "initialize_copy", false, false, org.jruby.RubyArray.class, "initialize_copy", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "initialize_copy", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$values_at(cls, Visibility.PUBLIC, "values_at");
        populateMethod(javaMethod, -1, "values_at", false, false, org.jruby.RubyArray.class, "values_at", org.jruby.runtime.builtin.IRubyObject.class, ARG0_ARY);
        aliasedMethod = cls.putMethod(runtime, "values_at", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$aset(cls, Visibility.PUBLIC, "[]=");
        populateMethod(javaMethod, -1, "aset", false, false, org.jruby.RubyArray.class, "aset", org.jruby.runtime.builtin.IRubyObject.class, ARG2);
        aliasedMethod = cls.putMethod(runtime, "[]=", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$join19(cls, Visibility.PUBLIC, "join");
        populateMethod(javaMethod, -1, "join19", false, false, org.jruby.RubyArray.class, "join19", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "join", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$empty_p(cls, Visibility.PUBLIC, "empty?");
        populateMethod(javaMethod, 0, "empty_p", false, false, org.jruby.RubyArray.class, "empty_p", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "empty?", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$compact_bang(cls, Visibility.PUBLIC, "compact!");
        populateMethod(javaMethod, 0, "compact_bang", false, false, org.jruby.RubyArray.class, "compact_bang", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "compact!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$op_and(cls, Visibility.PUBLIC, "&");
        populateMethod(javaMethod, 1, "op_and", false, false, org.jruby.RubyArray.class, "op_and", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "&", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$index(cls, Visibility.PUBLIC, "index");
        populateMethod(javaMethod, -1, "index", false, false, org.jruby.RubyArray.class, "index", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "index", javaMethod);
        cls.putMethod(runtime, "find_index", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$op_times(cls, Visibility.PUBLIC, "*");
        populateMethod(javaMethod, 1, "op_times", false, false, org.jruby.RubyArray.class, "op_times", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "*", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$concat(cls, Visibility.PUBLIC, "concat");
        populateMethod(javaMethod, -1, "concat", false, false, org.jruby.RubyArray.class, "concat", org.jruby.RubyArray.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "concat", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$op_plus(cls, Visibility.PUBLIC, "+");
        populateMethod(javaMethod, 1, "op_plus", false, false, org.jruby.RubyArray.class, "op_plus", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "+", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$op_diff(cls, Visibility.PUBLIC, "-");
        populateMethod(javaMethod, 1, "op_diff", false, false, org.jruby.RubyArray.class, "op_diff", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "-", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$pack(cls, Visibility.PUBLIC, "pack");
        populateMethod(javaMethod, -1, "pack", false, false, org.jruby.RubyArray.class, "pack", org.jruby.RubyString.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "pack", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$push(cls, Visibility.PUBLIC, "push");
        populateMethod(javaMethod, -1, "push", false, false, org.jruby.RubyArray.class, "push", org.jruby.RubyArray.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "push", javaMethod);
        cls.putAlias("append", aliasedMethod, "push");
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$at(cls, Visibility.PUBLIC, "at");
        populateMethod(javaMethod, 1, "at", false, false, org.jruby.RubyArray.class, "at", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "at", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$repeatedCombination(cls, Visibility.PUBLIC, "repeated_combination");
        populateMethod(javaMethod, 1, "repeatedCombination", false, false, org.jruby.RubyArray.class, "repeatedCombination", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "repeated_combination", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$hash(cls, Visibility.PUBLIC, "hash");
        populateMethod(javaMethod, 0, "hash", false, false, org.jruby.RubyArray.class, "hash", org.jruby.RubyFixnum.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "hash", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$select_bang(cls, Visibility.PUBLIC, "select!");
        populateMethod(javaMethod, 0, "select_bang", false, false, org.jruby.RubyArray.class, "select_bang", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "select!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$reverse_bang(cls, Visibility.PUBLIC, "reverse!");
        populateMethod(javaMethod, 0, "reverse_bang", false, false, org.jruby.RubyArray.class, "reverse_bang", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "reverse!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$cycle(cls, Visibility.PUBLIC, "cycle");
        populateMethod(javaMethod, -1, "cycle", false, false, org.jruby.RubyArray.class, "cycle", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "cycle", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$min(cls, Visibility.PUBLIC, "min");
        populateMethod(javaMethod, -1, "min", false, false, org.jruby.RubyArray.class, "min", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "min", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$map19(cls, Visibility.PUBLIC, "map");
        populateMethod(javaMethod, 0, "map19", false, false, org.jruby.RubyArray.class, "map19", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "map", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$keep_if(cls, Visibility.PUBLIC, "keep_if");
        populateMethod(javaMethod, 0, "keep_if", false, false, org.jruby.RubyArray.class, "keep_if", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "keep_if", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$aref(cls, Visibility.PUBLIC, "[]");
        populateMethod(javaMethod, -1, "aref", false, false, org.jruby.RubyArray.class, "aref", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "[]", javaMethod);
        cls.putMethod(runtime, "slice", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$product(cls, Visibility.PUBLIC, "product");
        populateMethod(javaMethod, -1, "product", false, false, org.jruby.RubyArray.class, "product", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_ARY_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "product", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$collect_bang(cls, Visibility.PUBLIC, "collect!");
        populateMethod(javaMethod, 0, "collect_bang", false, false, org.jruby.RubyArray.class, "collect_bang", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "collect!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$uniq_bang(cls, Visibility.PUBLIC, "uniq!");
        populateMethod(javaMethod, 0, "uniq_bang", false, false, org.jruby.RubyArray.class, "uniq_bang", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "uniq!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$max(cls, Visibility.PUBLIC, "max");
        populateMethod(javaMethod, -1, "max", false, false, org.jruby.RubyArray.class, "max", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "max", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$flatten_bang(cls, Visibility.PUBLIC, "flatten!");
        populateMethod(javaMethod, -1, "flatten_bang", false, false, org.jruby.RubyArray.class, "flatten_bang", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "flatten!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$1$shuffle_bang(cls, Visibility.PUBLIC, "shuffle!");
        populateMethod(javaMethod, -1, "shuffle_bang", false, false, org.jruby.RubyArray.class, "shuffle_bang", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_ARY);
        aliasedMethod = cls.putMethod(runtime, "shuffle!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$reverse(cls, Visibility.PUBLIC, "reverse");
        populateMethod(javaMethod, 0, "reverse", false, false, org.jruby.RubyArray.class, "reverse", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "reverse", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$2$sample(cls, Visibility.PUBLIC, "sample");
        populateMethod(javaMethod, -1, "sample", false, false, org.jruby.RubyArray.class, "sample", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_ARY);
        aliasedMethod = cls.putMethod(runtime, "sample", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$map_bang(cls, Visibility.PUBLIC, "map!");
        populateMethod(javaMethod, 0, "map_bang", false, false, org.jruby.RubyArray.class, "map_bang", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "map!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$fetch(cls, Visibility.PUBLIC, "fetch");
        populateMethod(javaMethod, -1, "fetch", false, false, org.jruby.RubyArray.class, "fetch", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "fetch", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$take_while(cls, Visibility.PUBLIC, "take_while");
        populateMethod(javaMethod, 0, "take_while", false, false, org.jruby.RubyArray.class, "take_while", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "take_while", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$op_or(cls, Visibility.PUBLIC, "|");
        populateMethod(javaMethod, 1, "op_or", false, false, org.jruby.RubyArray.class, "op_or", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "|", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$1$shuffle(cls, Visibility.PUBLIC, "shuffle");
        populateMethod(javaMethod, -1, "shuffle", false, false, org.jruby.RubyArray.class, "shuffle", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_ARY);
        aliasedMethod = cls.putMethod(runtime, "shuffle", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$first(cls, Visibility.PUBLIC, "first");
        populateMethod(javaMethod, -1, "first", false, false, org.jruby.RubyArray.class, "first", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "first", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$append(cls, Visibility.PUBLIC, "<<");
        populateMethod(javaMethod, 1, "append", false, false, org.jruby.RubyArray.class, "append", org.jruby.RubyArray.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "<<", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$drop_while(cls, Visibility.PUBLIC, "drop_while");
        populateMethod(javaMethod, 0, "drop_while", false, false, org.jruby.RubyArray.class, "drop_while", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "drop_while", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$rotate(cls, Visibility.PUBLIC, "rotate");
        populateMethod(javaMethod, -1, "rotate", false, false, org.jruby.RubyArray.class, "rotate", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "rotate", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$dig(cls, Visibility.PUBLIC, "dig");
        populateMethod(javaMethod, -1, "dig", false, false, org.jruby.RubyArray.class, "dig", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_ARY);
        aliasedMethod = cls.putMethod(runtime, "dig", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$compact(cls, Visibility.PUBLIC, "compact");
        populateMethod(javaMethod, 0, "compact", false, false, org.jruby.RubyArray.class, "compact", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "compact", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$reject(cls, Visibility.PUBLIC, "reject");
        populateMethod(javaMethod, 0, "reject", false, false, org.jruby.RubyArray.class, "reject", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "reject", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$reject_bang(cls, Visibility.PUBLIC, "reject!");
        populateMethod(javaMethod, 0, "reject_bang", false, false, org.jruby.RubyArray.class, "reject_bang", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "reject!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$replace(cls, Visibility.PUBLIC, "replace");
        populateMethod(javaMethod, 1, "replace", false, false, org.jruby.RubyArray.class, "replace", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "replace", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$bsearch(cls, Visibility.PUBLIC, "bsearch");
        populateMethod(javaMethod, 0, "bsearch", false, false, org.jruby.RubyArray.class, "bsearch", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "bsearch", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$flatten(cls, Visibility.PUBLIC, "flatten");
        populateMethod(javaMethod, -1, "flatten", false, false, org.jruby.RubyArray.class, "flatten", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "flatten", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$to_h(cls, Visibility.PUBLIC, "to_h");
        populateMethod(javaMethod, 0, "to_h", false, false, org.jruby.RubyArray.class, "to_h", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "to_h", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$delete_if(cls, Visibility.PUBLIC, "delete_if");
        populateMethod(javaMethod, 0, "delete_if", false, false, org.jruby.RubyArray.class, "delete_if", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "delete_if", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$to_s(cls, Visibility.PUBLIC, "to_s");
        populateMethod(javaMethod, 0, "to_s", false, false, org.jruby.RubyArray.class, "to_s", org.jruby.RubyString.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "to_s", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$assoc(cls, Visibility.PUBLIC, "assoc");
        populateMethod(javaMethod, 1, "assoc", false, false, org.jruby.RubyArray.class, "assoc", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "assoc", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$sort_by_bang(cls, Visibility.PUBLIC, "sort_by!");
        populateMethod(javaMethod, 0, "sort_by_bang", false, false, org.jruby.RubyArray.class, "sort_by_bang", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "sort_by!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$each(cls, Visibility.PUBLIC, "each");
        populateMethod(javaMethod, 0, "each", false, false, org.jruby.RubyArray.class, "each", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "each", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$to_ary(cls, Visibility.PUBLIC, "to_ary");
        populateMethod(javaMethod, 0, "to_ary", false, false, org.jruby.RubyArray.class, "to_ary", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "to_ary", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$combination(cls, Visibility.PUBLIC, "combination");
        populateMethod(javaMethod, 1, "combination", false, false, org.jruby.RubyArray.class, "combination", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "combination", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$each_slice(cls, Visibility.PUBLIC, "each_slice");
        populateMethod(javaMethod, 1, "each_slice", false, false, org.jruby.RubyArray.class, "each_slice", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "each_slice", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$op_equal(cls, Visibility.PUBLIC, "==");
        populateMethod(javaMethod, 1, "op_equal", false, false, org.jruby.RubyArray.class, "op_equal", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "==", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$nitems(cls, Visibility.PUBLIC, "nitems");
        populateMethod(javaMethod, 0, "nitems", false, false, org.jruby.RubyArray.class, "nitems", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "nitems", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$last(cls, Visibility.PUBLIC, "last");
        populateMethod(javaMethod, -1, "last", false, false, org.jruby.RubyArray.class, "last", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "last", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$rotate_bang(cls, Visibility.PUBLIC, "rotate!");
        populateMethod(javaMethod, -1, "rotate_bang", false, false, org.jruby.RubyArray.class, "rotate_bang", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "rotate!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$count(cls, Visibility.PUBLIC, "count");
        populateMethod(javaMethod, -1, "count", false, false, org.jruby.RubyArray.class, "count", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "count", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$to_a(cls, Visibility.PUBLIC, "to_a");
        populateMethod(javaMethod, 0, "to_a", false, false, org.jruby.RubyArray.class, "to_a", org.jruby.RubyArray.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "to_a", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$sort(cls, Visibility.PUBLIC, "sort");
        populateMethod(javaMethod, 0, "sort", false, false, org.jruby.RubyArray.class, "sort", org.jruby.RubyArray.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "sort", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$bsearch_index(cls, Visibility.PUBLIC, "bsearch_index");
        populateMethod(javaMethod, 0, "bsearch_index", false, false, org.jruby.RubyArray.class, "bsearch_index", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "bsearch_index", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$slice_bang(cls, Visibility.PUBLIC, "slice!");
        populateMethod(javaMethod, -1, "slice_bang", false, false, org.jruby.RubyArray.class, "slice_bang", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "slice!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$take(cls, Visibility.PUBLIC, "take");
        populateMethod(javaMethod, 1, "take", false, false, org.jruby.RubyArray.class, "take", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "take", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$each_index(cls, Visibility.PUBLIC, "each_index");
        populateMethod(javaMethod, 0, "each_index", false, false, org.jruby.RubyArray.class, "each_index", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "each_index", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$uniq(cls, Visibility.PUBLIC, "uniq");
        populateMethod(javaMethod, 0, "uniq", false, false, org.jruby.RubyArray.class, "uniq", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "uniq", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$inspect(cls, Visibility.PUBLIC, "inspect");
        populateMethod(javaMethod, 0, "inspect", false, false, org.jruby.RubyArray.class, "inspect", org.jruby.RubyString.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "inspect", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$fill(cls, Visibility.PUBLIC, "fill");
        populateMethod(javaMethod, -1, "fill", false, false, org.jruby.RubyArray.class, "fill", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "fill", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$1$zip(cls, Visibility.PUBLIC, "zip");
        populateMethod(javaMethod, -1, "zip", false, false, org.jruby.RubyArray.class, "zip", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_ARY_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "zip", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$collect19(cls, Visibility.PUBLIC, "collect");
        populateMethod(javaMethod, 0, "collect19", false, false, org.jruby.RubyArray.class, "collect19", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "collect", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$initialize(cls, Visibility.PRIVATE, "initialize");
        populateMethod(javaMethod, -1, "initialize", false, false, org.jruby.RubyArray.class, "initialize", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "initialize", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$drop(cls, Visibility.PUBLIC, "drop");
        populateMethod(javaMethod, 1, "drop", false, false, org.jruby.RubyArray.class, "drop", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "drop", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$reverse_each(cls, Visibility.PUBLIC, "reverse_each");
        populateMethod(javaMethod, 0, "reverse_each", false, false, org.jruby.RubyArray.class, "reverse_each", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "reverse_each", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$insert(cls, Visibility.PUBLIC, "insert");
        populateMethod(javaMethod, -1, "insert", false, false, org.jruby.RubyArray.class, "insert", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "insert", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$sort_bang(cls, Visibility.PUBLIC, "sort!");
        populateMethod(javaMethod, 0, "sort_bang", false, false, org.jruby.RubyArray.class, "sort_bang", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "sort!", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$eql(cls, Visibility.PUBLIC, "eql?");
        populateMethod(javaMethod, 1, "eql", false, false, org.jruby.RubyArray.class, "eql", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "eql?", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$indexes(cls, Visibility.PUBLIC, "indexes");
        populateMethod(javaMethod, -1, "indexes", false, false, org.jruby.RubyArray.class, "indexes", org.jruby.runtime.builtin.IRubyObject.class, ARG0_ARY);
        aliasedMethod = cls.putMethod(runtime, "indexes", javaMethod);
        cls.putMethod(runtime, "indices", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$delete_at(cls, Visibility.PUBLIC, "delete_at");
        populateMethod(javaMethod, 1, "delete_at", false, false, org.jruby.RubyArray.class, "delete_at", org.jruby.runtime.builtin.IRubyObject.class, ARG1);
        aliasedMethod = cls.putMethod(runtime, "delete_at", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$pop(cls, Visibility.PUBLIC, "pop");
        populateMethod(javaMethod, -1, "pop", false, false, org.jruby.RubyArray.class, "pop", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0);
        aliasedMethod = cls.putMethod(runtime, "pop", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$op_cmp(cls, Visibility.PUBLIC, "<=>");
        populateMethod(javaMethod, 1, "op_cmp", false, false, org.jruby.RubyArray.class, "op_cmp", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "<=>", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$permutation(cls, Visibility.PUBLIC, "permutation");
        populateMethod(javaMethod, -1, "permutation", false, false, org.jruby.RubyArray.class, "permutation", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "permutation", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$rindex(cls, Visibility.PUBLIC, "rindex");
        populateMethod(javaMethod, -1, "rindex", false, false, org.jruby.RubyArray.class, "rindex", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "rindex", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$length(cls, Visibility.PUBLIC, "length");
        populateMethod(javaMethod, 0, "length", false, false, org.jruby.RubyArray.class, "length", org.jruby.RubyFixnum.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "length", javaMethod);
        cls.putAlias("size", aliasedMethod, "length");
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$rb_clear(cls, Visibility.PUBLIC, "clear");
        populateMethod(javaMethod, 0, "rb_clear", false, false, org.jruby.RubyArray.class, "rb_clear", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "clear", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$delete(cls, Visibility.PUBLIC, "delete");
        populateMethod(javaMethod, 1, "delete", false, false, org.jruby.RubyArray.class, "delete", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "delete", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$include_p(cls, Visibility.PUBLIC, "include?");
        populateMethod(javaMethod, 1, "include_p", false, false, org.jruby.RubyArray.class, "include_p", org.jruby.RubyBoolean.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "include?", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$1$0$rassoc(cls, Visibility.PUBLIC, "rassoc");
        populateMethod(javaMethod, 1, "rassoc", false, false, org.jruby.RubyArray.class, "rassoc", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG1);
        aliasedMethod = cls.putMethod(runtime, "rassoc", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$unshift(cls, Visibility.PUBLIC, "unshift");
        populateMethod(javaMethod, -1, "unshift", false, false, org.jruby.RubyArray.class, "unshift", org.jruby.runtime.builtin.IRubyObject.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "unshift", javaMethod);
        cls.putAlias("prepend", aliasedMethod, "unshift");
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$0$transpose(cls, Visibility.PUBLIC, "transpose");
        populateMethod(javaMethod, 0, "transpose", false, false, org.jruby.RubyArray.class, "transpose", org.jruby.RubyArray.class, ARG0);
        aliasedMethod = cls.putMethod(runtime, "transpose", javaMethod);
        javaMethod = new org.jruby.RubyArray$INVOKER$i$0$1$any_p(cls, Visibility.PUBLIC, "any?");
        populateMethod(javaMethod, -1, "any_p", false, false, org.jruby.RubyArray.class, "any_p", org.jruby.runtime.builtin.IRubyObject.class, CONTEXT_ARG0_ARY_BLOCK);
        aliasedMethod = cls.putMethod(runtime, "any?", javaMethod);

        runtime.addBoundMethods("org.jruby.RubyArray", "append", "<<", "drop_while", "drop_while", "rotate", "rotate", "dig", "dig", "compact", "compact", "frozen_p", "frozen?", "shift", "shift", "reject_bang", "reject!", "replace", "replace", "repeated_permutation", "repeated_permutation", "flatten", "flatten", "to_h", "to_h", "to_s", "to_s", "assoc", "assoc", "initialize_copy", "initialize_copy", "values_at", "values_at", "aset", "[]=", "join19", "join", "sort_by_bang", "sort_by!", "empty_p", "empty?", "compact_bang", "compact!", "to_ary", "to_ary", "combination", "combination", "op_equal", "==", "nitems", "nitems", "last", "last", "op_and", "&", "rotate_bang", "rotate!", "count", "count", "index", "index", "op_times", "*", "concat", "concat", "op_plus", "+", "to_a", "to_a", "sort", "sort", "op_diff", "-", "pack", "pack", "push", "push", "slice_bang", "slice!", "take", "take", "at", "at", "repeatedCombination", "repeated_combination", "uniq", "uniq", "inspect", "inspect", "collect19", "collect", "hash", "hash", "drop", "drop", "select_bang", "select!", "reverse_bang", "reverse!", "insert", "insert", "sort_bang", "sort!", "cycle", "cycle", "eql", "eql?", "min", "min", "indexes", "indexes", "delete_at", "delete_at", "try_convert", "try_convert", "map19", "map", "op_cmp", "<=>", "permutation", "permutation", "create", "[]", "aref", "[]", "product", "product", "collect_bang", "collect!", "uniq_bang", "uniq!", "max", "max", "length", "length", "rb_clear", "clear", "flatten_bang", "flatten!", "shuffle_bang", "shuffle!", "reverse", "reverse", "sample", "sample", "map_bang", "map!", "include_p", "include?", "rassoc", "rassoc", "unshift", "unshift", "take_while", "take_while", "transpose", "transpose", "op_or", "|", "shuffle", "shuffle", "first", "first", "any_p", "any?", "sum", "sum", "select", "select", "keep_if", "keep_if", "fetch", "fetch", "reject", "reject", "bsearch", "bsearch", "delete_if", "delete_if", "each", "each", "each_slice", "each_slice", "bsearch_index", "bsearch_index", "each_index", "each_index", "fill", "fill", "zip", "zip", "initialize", "initialize", "reverse_each", "reverse_each", "pop", "pop", "rindex", "rindex", "delete", "delete");
    }
    static {
    }
}