Override `getConjugation`
196163
public function getConjugation($transliterationForm, $conjugatedForm, $verbalForm, $languageForm)
  {
    if($verbalForm === Inflector::POTENTIAL_FORM) {
      $conjugatedForm = Inflector::MIZENKEI;
    }

    return parent::getConjugation($transliterationForm, $conjugatedForm, $verbalForm, $languageForm);
  }
1276354
function(language, patterns, bypass) {

            // if there is only one argument then we assume that we want to
            // extend the default language rules
            if (arguments.length == 1) {
                patterns = language;
                language = DEFAULT_LANGUAGE;
            }

            bypass_defaults[language] = bypass;
            language_patterns[language] = patterns.concat(language_patterns[language] || []);
        }
1351062
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return Setting(key)
        if key not in Setting._member_map_:
            extend_enum(Setting, key, default)
        return Setting[key]
394424
public function getConjugation($transliterationForm, $conjugatedForm, $verbalForm, $languageForm)
  {
    if($verbalForm === Inflector::POTENTIAL_FORM) {
      $conjugatedForm = Inflector::MIZENKEI;
    }

    $conjugation = parent::getConjugation($transliterationForm, $conjugatedForm, $verbalForm, $languageForm);

    if($transliterationForm === Inflector::KANJI_FORM && Helper::subString($this->stem[Inflector::KANJI_FORM], -1, 1) === '来') {
      $conjugation = Helper::subString($conjugation, 1, null);
    }

    return $conjugation;
  }
437923
def _get_substitute_element(head, elt, ps):
    '''
    '''
    if not isinstance(head, ElementDeclaration):
        return None

    return ElementDeclaration.getSubstitutionElement(head, elt, ps)
282305
function getInst (bind, args) {
    args = resolveDeps(args);
    return isCtor ? applyCtor(func, args) : func.apply(bind, args);
  }
340041
def _get_parser_compound(cls, *parse_methods):
        
        def parse(value):
            parsed = value

            for method in parse_methods:
                parsed = method(parsed)

            return parsed

        return parse
1130842
def autoconvert(string):
    """"""
    for fn in (boolify, int, float):
        try:
            return fn(string)
        except ValueError:
            pass
    return string
1190037
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return Parameter(key)
        if key not in Parameter._member_map_:
            extend_enum(Parameter, key, default)
        return Parameter[key]
227966
function getSubstitutions( pos ) {
	var substitutions;
	switch ( pos ) {
	case 'n':
		substitutions = _.clone( MORPHY_SUBSTITUTIONS.NOUN );
	break;
	case 'v':
		substitutions = _.clone( MORPHY_SUBSTITUTIONS.VERB );
	break;
	case 'a':
		substitutions = _.clone( MORPHY_SUBSTITUTIONS.ADJECTIVE );
	break;
	default:
		substitutions = [];
	}
	return substitutions;
}
359603
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return TOS_THR(key)
        if key not in TOS_THR._member_map_:
            extend_enum(TOS_THR, key, default)
        return TOS_THR[key]
1086548
def _extract_conjuction_elements_from_expression(expression):
    """"""
    if isinstance(expression, BinaryComposition) and expression.operator == u'&&':
        for element in _extract_conjuction_elements_from_expression(expression.left):
            yield element
        for element in _extract_conjuction_elements_from_expression(expression.right):
            yield element
    else:
        yield expression
958075
private ImmutableTerm getNestedConcat(String str) {
        List<ImmutableTerm> terms;
        terms = addToTermsList(str);
        if (terms.size() == 1) {
            return terms.get(0);
        }

        ImmutableFunctionalTerm f = termFactory.getImmutableFunctionalTerm(ExpressionOperation.CONCAT, terms.get(0), terms.get(1));
        for (int j = 2; j < terms.size(); j++) {
            f = termFactory.getImmutableFunctionalTerm(ExpressionOperation.CONCAT, f, terms.get(j));
        }
        return f;
    }
294648
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return ExtensionHeader(key)
        if key not in ExtensionHeader._member_map_:
            extend_enum(ExtensionHeader, key, default)
        return ExtensionHeader[key]
1250009
def __get_arg(cls, kwds, kwd):
    """"""
    alt_kwd = '_' + kwd
    if alt_kwd in kwds:
      return kwds.pop(alt_kwd)
    if kwd in kwds:
      obj = getattr(cls, kwd, None)
      if not isinstance(obj, Property) or isinstance(obj, ModelKey):
        return kwds.pop(kwd)
    return None
1246109
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return RouterAlert(key)
        if key not in RouterAlert._member_map_:
            extend_enum(RouterAlert, key, default)
        return RouterAlert[key]
309355
public function getConjugation($transliterationForm, $conjugatedForm, $verbalForm, $languageForm)
  {
    $conjugation = parent::getConjugation($transliterationForm, $conjugatedForm, $verbalForm, $languageForm);

    if($this->isIrregularForm_v5ri($verbalForm, $languageForm)) {
      $conjugation = Helper::subString($conjugation, 1, null);
    }

    return $conjugation;
  }