private functions
177444
private void Analyze() throws IOException {
        // clean-up
        ClearFields();
        m_nTagBytes = 0;

        m_bAnalyzed = true;

        // store the original location
        long nOriginalPosition = m_spIO.getFilePointer();

        // check for a tag
        m_bHasID3Tag = false;
        m_bHasAPETag = false;
        m_nAPETagVersion = -1;
        final ID3Tag tag = ID3Tag.read(m_spIO);

        if (tag != null) {
            m_bHasID3Tag = true;
            m_nTagBytes += ID3Tag.ID3_TAG_BYTES;
        }

        // set the fields
        if (m_bHasID3Tag && tag!=null) {
            SetFieldID3String(APE_TAG_FIELD_ARTIST, tag.Artist);
            SetFieldID3String(APE_TAG_FIELD_ALBUM, tag.Album);
            SetFieldID3String(APE_TAG_FIELD_TITLE, tag.Title);
            SetFieldID3String(APE_TAG_FIELD_COMMENT, tag.Comment);
            SetFieldID3String(APE_TAG_FIELD_YEAR, tag.Year);
            SetFieldString(APE_TAG_FIELD_TRACK, String.valueOf(tag.Track));

            if ((tag.Genre == ID3Genre.GENRE_UNDEFINED) || (tag.Genre >= ID3Genre.genreCount()))
                SetFieldString(APE_TAG_FIELD_GENRE, APE_TAG_GENRE_UNDEFINED);
            else
                SetFieldString(APE_TAG_FIELD_GENRE, ID3Genre.genreString(tag.Genre));
        }

        // try loading the APE tag
        if (!m_bHasID3Tag) {
            m_footer = APETagFooter.read(m_spIO);
            if (m_footer != null && m_footer.GetIsValid(false)) {
                m_bHasAPETag = true;
                m_nAPETagVersion = m_footer.GetVersion();

                int nRawFieldBytes = m_footer.GetFieldBytes();
                m_nTagBytes += m_footer.GetTotalTagBytes();

                m_spIO.seek(m_spIO.length() - m_footer.GetTotalTagBytes() - m_footer.GetFieldsOffset());

                try {
                    final ByteArrayReader reader = new ByteArrayReader(m_spIO, nRawFieldBytes);

                    // parse out the raw fields
                    for (int z = 0; z < m_footer.GetNumberFields(); z++)
                        LoadField(reader);
                } catch (EOFException e) {
                    throw new JMACException("Can't Read APE Tag Fields");
                }
            }
        }

        // restore the file pointer
        m_spIO.seek(nOriginalPosition);
    }
739354
function(func, context){
            for(var x = this.width - 1; x >= 0; x--){
                for(var y = this.height - 1; y >= 0; y--){
                    var val = this.get(x, y);
                    if(context){
                        func.call(context, val, x, y);
                    } else {
                        func(val, x, y);
                    }
                }
            }
        }
634487
function(xs, f) {
      for (var i = 0, len = xs.length; i < len; i++) {
        var x = xs[i];
        f(x, i, xs);
      }
    }
1141777
function functions() {
		extend(Function.prototype, {
			bind: function bind(oThis) {
				if (typeof this !== "function") {
					throw new TypeError("Function bind not callable");
				}
				var fSlice = Array.prototype.slice,
					aArgs = fSlice.call(arguments, 1),
					fToBind = this,
					Fnop = function() {},
					fBound = function() {
						return fToBind.apply(
							this instanceof Fnop ? this : oThis || window,
							aArgs.concat(fSlice.call(arguments))
						);
					};
				Fnop.prototype = this.prototype;
				fBound.prototype = new Fnop();
				return fBound;
			}
		});
	}
1300668
function(object, method) {
      if (object == null) return void 0;
      var func = object[method];
      var args = slice.call(arguments, 2);
      return _.isFunction(func) ? func.apply(object, args) : void 0;
    }
864828
function methodize(fn) {
        return function() { var args
            args = slice.call(arguments)
            return fn.apply(this, [this].concat(args)) }
    }
930344
function(attr) {
			// Create the sort function
			var sortFn;

			// CASE: Simple ascending sort
			if (attr == null) {
				sortFn = function(a, b) { return a - b; };
			}
			// CASE: Simple descending sort
			else if (attr === true) {
				sortFn = function(a, b) { return b - a; };
			}
			// CASE: Sort by an attribute
			else if (typeof attr === 'string') {
				sortFn = function(a, b) { return a[attr] - b[attr]; };
			}
			// CASE: Sort by a function
			else {
				sortFn = attr;
			}

			this.arr = this.arr.sort(sortFn);

			return this;
		}
735759
function () {
	var len, attr, g, args;

	args = arguments;

	len = args.length;

	if (len === 0) {
		g = noop;
	}
	else if (len === 1) {
		attr = args[0];

		g = function (obj) {
			return obj[attr];
		};
	}
	else {
		g = function (obj) {
			var i, tuple;

			tuple = [];

			for (i = 0; i < len; ++i) {
				tuple.push(obj[args[i]]);
			}

			return tuple;
		};
	}



	return g;
}
621888
function(db) {
		function call_func(data, fun, params) {
			try {

				// Parse data
				if(!(data && (data instanceof Array))) {
					throw new TypeError("First argument is not an array");
				}

				// Parse fun
				if(fun.substr(0, 8) === 'function') {
					// FIXME: This is the same code as in nor-function -- should be reused from there.
					fun = new Function('return (' + fun + ')')();
				} else {
					throw new TypeError("Second argument is not valid serialized function");
				}

				// Parse params
				if(!(params && (params instanceof Array))) {
					throw new TypeError("Third argument is not an array");
				}

				return fun.apply(undefined, [].concat(data).concat(params) );

			} catch (e) {
				plv8.elog(ERROR, e);
				return;
			}
		}
		return db.query('CREATE SCHEMA IF NOT EXISTS nopg')
			.query('CREATE OR REPLACE FUNCTION nopg.call_func(data json, fun json, params json) RETURNS json LANGUAGE plv8 STABLE AS ' + NoPg._escapeFunction(call_func, ["data", "fun", "params"]) );
	}
520416
function(arr, func, obj, func2){
					var big = [obj, func2];
					each(arr, function(i, item){
						big.unshift(item, func)
					});
					when.apply(steal, big);
				}
1003358
function () {
    each(dom, function (i, n) {
        var vo = n.two
        var key = n.one;
        _updateDom(key, vo)
    });
}
196813
function(fn) {
            	var n = this.elements.length;
            	for (var i = 0; i < n; i++) {
            	    fn(this.elements[i], i + 1);
            	}
                }
970619
function callFunction (globalObjects, body) {
  var globalKeys = [];
  var globalValues = [];
  for (var key in globalObjects) {
    globalKeys.push(key);
    globalValues.push(globalObjects[key]);
  }
  globalKeys.push(body);

  var result = new (Function.prototype.bind.apply( Function, [ null ].concat( globalKeys) ));
  return result.apply(void 0, globalValues)
}
1254268
function decryptObject(obj, decryptFunction) {
    if (_.isArray(obj)) {
        for (var i = 0; i < obj.length; i++) {
            if (_.isString(obj[i])) {
                if (isEncrypted(obj[i])) {
                    obj[i] = decryptFunction(obj[i]);
                }
            } else {
                decryptObject(obj[i], decryptFunction);
            }
        }
    } else if (_.isObject(obj)) {
        for (var key in obj) {
            if (_.isString(obj[key])) {
                if (isEncrypted(obj[key])) {
                    obj[key] = decryptFunction(obj[key]);
                }
            } else {
                decryptObject(obj[key], decryptFunction);
            }
        }
    }
}
298383
function callFunction (globalObjects, body) {
  const globalKeys = []
  const globalValues = []
  for (const key in globalObjects) {
    globalKeys.push(key)
    globalValues.push(globalObjects[key])
  }
  globalKeys.push(body)

  const result = new Function(...globalKeys)
  return result(...globalValues)
}
258620
def _onFunction( self, name, line, pos, absPosition,
                           keywordLine, keywordPos,
                           colonLine, colonPos, level ):
        "  "
        self.__flushLevel( level )
        self.objectsStack.append( Function( name, line, pos, absPosition,
                                            keywordLine, keywordPos,
                                            colonLine, colonPos ) )
        return
51327
function Name() {
    var key = {}
    return name
    
    function name(object) {
        var privates = object.valueOf(key)
        return privates !== object ? privates : namespace(object, key)
    }
}