----------------- arity -----------------
485414
function inconsistentArity(ruleName, expected, actual, expr) {
  return createError(
      'Rule ' + ruleName + ' involves an alternation which has inconsistent arity ' +
          '(expected ' + expected + ', got ' + actual + ')',
      expr.source);
}
684152
function (callback) {
    return function (new_method, assert_method, arity) {
        return function () {
            var message = arguments[arity - 1];
            var a = exports.assertion({method: new_method, message: message});
            try {
                assert[assert_method].apply(null, arguments);
            }
            catch (e) {
                a.error = e;
            }
            callback(a);
        };
    };
}
868474
function arity (n, fn) {
  switch (n) {
    case 0: return function () { return fn.apply(null, arguments) }
    case 1: return function (a0) { return fn.apply(null, arguments) }
    case 2: return function (a0, a1) { return fn.apply(null, arguments) }
    case 3: return function (a0, a1, a2) { return fn.apply(null, arguments) }
    case 4: return function (a0, a1, a2, a3) { return fn.apply(null, arguments) }
    case 5: return function (a0, a1, a2, a3, a4) { return fn.apply(null, arguments) }
    case 6: return function (a0, a1, a2, a3, a4, a5) { return fn.apply(null, arguments) }
    case 7: return function (a0, a1, a2, a3, a4, a5, a6) { return fn.apply(null, arguments) }
    case 8: return function (a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(null, arguments) }
    default: throw new Error('First argument to _arity must be a non-negative integer no greater than eight')
  }
}
288615
private function verification($args,&$param,&$scene, $r, $app){
        foreach ($args as $v) {
            $scene[] = $v->name;

            if(isset($this->input[$v->name])){
                if(is_array($this->input[$v->name])) {
                    $param[$v->name] = $this->input[$v->name];
                }
                else if(strlen($this->input[$v->name])>0) {
                    $param[$v->name] = $this->input[$v->name];
                }
                else if($v->isDefaultValueAvailable()) {
                    $param[$v->name] = $v->getDefaultValue();
                }
                else {
                    if ($r->hasMethod('__error')) {
                        $app->__error("{$v->name}参数为必须参数!",$v->name);
                    }
                    else {
                        Pool::object('nb\event\Framework')->validate(
                            "{$v->name}参数为必须参数!",
                            $v->name
                        );
                    }
                    quit();
                }
            }
            else if($v->isDefaultValueAvailable()) {
                $param[$v->name]=$v->getDefaultValue();
            }
            else {
                if ($r->hasMethod('__error')) {
                    $app->__error("{$v->name}参数为必须参数!",$v->name);
                }
                else {
                    Pool::object('nb\event\Framework')->validate(
                        "{$v->name}参数为必须参数!",
                        $v->name
                    );
                }
                quit();
            }
        }
    }
1365695
@Override
	public void setAttribute(int semantics, int offset, int ordinate, int value) {
		setAttribute(semantics, offset, ordinate, (double) value);
	}
1043993
public function dispatchSchema()
    {
        foreach ($this->children->getSchema() as $field) {
            if (is_array($field)) {
                foreach ($field as $key => $item) {
                    $item->setValue($item->getArgument('default'))->dispatch();
                }

                continue;
            }

            $field->setValue($field->getArgument('default'))->dispatch();
        }
    }
270131
public function evaluate(Context $context, $arity, $arguments) {

		$rangeSize = intval($arguments[0]);

        $result = array();
        for ($i = 1; $i <= $rangeSize; ++ $i) {
            $result []= $i;
        }

        return $result;
    }
194469
public function defArgCommand(): void
    {
        $this->output->dump($this->input->getArgs(), $this->input->getOpts(), $this->input->getBoolOpt('y'));
    }
31773
public function initFromRgba($r, $g, $b, $a = 1)
    {
        $this->r = intval($r);
        $this->g = intval($g);
        $this->b = intval($b);
        $this->a = $this->alpha2gd($a);
    }
872023
function map(ary, each, done) {
  var result = new Array(ary.length);
  var next = after(ary.length, done);

  for (var i = 0; i < ary.length; i++) {
    each(ary[i], function(error, msg) {
      result[i] = msg;
      next(error, result);
    });
  }
}
136415
@Override
    public void encode(final OtpOutputStream buf) {
        final int arity = arity();

        buf.write_map_head(arity);

        for (final Map.Entry<OtpErlangObject, OtpErlangObject> e : entrySet()) {
            buf.write_any(e.getKey());
            buf.write_any(e.getValue());
        }
    }
32188
public void setHint(final String hint, final Serializable... args) {
		Serializable currHint = getComponentModel().hint;
		Serializable hintToBeSet = I18nUtilities.asMessage(hint, args);

		if (!Objects.equals(hintToBeSet, currHint)) {
			getOrCreateComponentModel().hint = hintToBeSet;
		}
	}
1091272
function (type, args) {
	this.type = type;
	this.single = false;

	// Message is a 'multiple attribute message'.
	if (typeof args === 'object' || typeof args === 'undefined') {
		this.args = args || {};
	}
	// Message is a 'single attribute message'.
	else {
		this.single = true;
		this.args = args;
	}

	if (!this.single) {
		if (this.args.flowId) {
			this.arg('flowId', this.args.flowId);
		}
		else if (index.autoFlowId) {
			this.arg('flowId', Message.flowId);
		}
	}
}
971424
public function cardinality($alias, $field = null, $script = null, $precision = null, $rehash = null)
    {
        $aggregation = new CardinalityAggregation($alias);

        $aggregation->setField($field);

        $aggregation->setScript($script);

        $aggregation->setPrecisionThreshold($precision);

        $aggregation->setRehash($rehash);

        $this->append($aggregation);
    }
243065
function (module, action, params) {
        "use strict";
    
        var log = localStorage.getItem('log');
        if (log) {
            if (!params) params = {};
            params.log = log;
        }
    
        Object.defineProperty(this, 'action', {
            'get': function () {
                return action;
            }
        });
    
        var serialized = {
            'moduleID': module.ID,
            'action': action,
            'params': params
        };
    
        Object.defineProperty(this, 'params', {
            'get': function () {
                return params;
            }
        });
    
        if (module.ID.substr(0, 10) === 'libraries/') {
            serialized.version = module.library.version;
        }
        else {
            serialized.version = beyond.params.version;
        }
    
        Object.defineProperty(this, 'serialized', {
            'get': function () {
    
                var output = {};
                $.extend(output, serialized, true);
                return output;
    
            }
        });
    
    }
162966
function makeMoment(input, format, lang, strict, utc) {
    if (typeof lang === "boolean") {
        utc = strict;
        strict = lang;
        lang = undefined;
    }
    var itsJalaliDate = (isJalali(this));
    if(input && (typeof input === "string") && !format && itsJalaliDate && !moment.useGregorianParser) {
        input = input.replace(/\//g,"-");
        if(/\d{4}\-\d{2}\-\d{2}/.test(input)) {
            format = "jYYYY-jMM-jDD";
        } else if (/\d{4}\-\d{2}\-\d{1}/.test(input)) {
            format = "jYYYY-jMM-jD";
        } else if (/\d{4}\-\d{1}\-\d{1}/.test(input)) {
            format = "jYYYY-jM-jD";
        } else if (/\d{4}\-\d{1}\-\d{2}/.test(input)) {
            format = "jYYYY-jM-jDD";
        } else if (/\d{4}\-W\d{2}\-\d{2}/.test(input)) {
            format = "jYYYY-jW-jDD";
        } else if (/\d{4}\-\d{3}/.test(input)) {
            format = "jYYYY-jDDD";
        } else if (/\d{8}/.test(input)) {
            format = "jYYYYjMMjDD";
        } else if (/\d{4}W\d{2}\d{1}/.test(input)) {
            format = "jYYYYjWWjD";
        } else if (/\d{4}W\d{2}/.test(input)) {
            format = "jYYYYjWW";
        } else if (/\d{4}\d{3}/.test(input)) {
            format = "jYYYYjDDD";
        }
    }
    if (format && itsJalaliDate){
        format = toJalaliFormat(format);
    }
    if (format && typeof format === "string"){
        format = fixFormat(format, moment);
    }

    var config =
        { _i: input
            , _f: format
            , _l: lang
            , _strict: strict
            , _isUTC: utc
        }
        , date
        , m
        , jm
        , origInput = input
        , origFormat = format;
    if (format) {
        if (isArray(format)) {
            return makeDateFromStringAndArray(config, utc);
        } else {
            date = makeDateFromStringAndFormat(config);
            removeParsedTokens(config);
            format = "YYYY-MM-DD-" + config._f;
            input = leftZeroFill(date[0], 4) + "-"
                + leftZeroFill(date[1] + 1, 2) + "-"
                + leftZeroFill(date[2], 2) + "-"
                + config._i;
        }
    }
    if (utc){
        m = moment.utc(input, format, lang, strict);
    }
    else{
        m = moment(input, format, lang, strict);
    }
    if (config._isValid === false || (input && input._isAMomentObject && !input._isValid)){
        m._isValid = false;
    }
    m._jDiff = config._jDiff || 0;
    jm = objectCreate(jMoment.fn);
    extend(jm, m);
    if (strict && jm.isValid()) {
        jm._isValid = jm.format(origFormat) === origInput;
    }
    if (input && input.calSystem) {
        jm.calSystem = input.calSystem;
    }
    return jm;
}
1277797
void error(int pos, String key, Object ... args) {
        log.error(DiagnosticFlag.SYNTAX, pos, key, args);
    }