*******************BEGINNING OF FUNCTION********************//
770150
public static boolean is_jhalanta(String str)
    {
        // System.out.print("Entered is_jhalanta, returning: ");
        String s1 = VarnaUtil.getAntyaVarna(str);
        if (is_jhal(s1))
        {
            // Log.logInfo("true");
            return true;
        }
        // Log.logInfo("false");
        return false;
    }
164643
function () {
            var f = {};

            f.valueOf = function () {
                return +n;
            };

            f.text = String(goodFrac(n) || n);

            return f;
        }
699495
function isAtStart(string, index) {
  const before = string.substring(0, index).trim();

  return before.length === 0 || before.search(/[({,]$/) !== -1;
}
104259
@Override
    protected void init(DifferentiableBatchFunction function, IntDoubleVector point) {
        super.init(function, point);
        this.iterOfLastStep = new int[function.getNumDimensions()];
        Arrays.fill(iterOfLastStep, -1);        
        this.gradSumSquares = new double[function.getNumDimensions()];
        Arrays.fill(gradSumSquares, prm.initialSumSquares);
    }
572770
def is_start_of_function(text):
    """"""
    if isinstance(text, str) or isinstance(text, unicode):
        function_prefix = ['def', 'async def']
        text = text.lstrip()

        for prefix in function_prefix:
            if text.startswith(prefix):
                return True

    return False
804450
function prelude(token) {
              token = token.toLowerCase();

              var result = '';
              var i = 0;

              // special case for i = 0 to avoid '-1' index
              if (token[i] === 'y' && isVowel$1(token[i + 1])) {
                result += token[i].toUpperCase();
              } else {
                result += token[i];
              }

              for (i = 1; i < token.length; i++) {
                if ((token[i] === 'u' || token[i] === 'i') && isVowel$1(token[i - 1]) && isVowel$1(token[i + 1])) {
                  result += token[i].toUpperCase();
                } else if (token[i] === 'y' && (isVowel$1(token[i - 1]) || isVowel$1(token[i + 1]))) {
                  result += token[i].toUpperCase();
                } else if (token[i] === 'u' && token[i - 1] === 'q') {
                  result += token[i].toUpperCase();
                } else {
                  result += token[i];
                }
              }

              return result;
            }
569071
function checkFunctionsList(i) {
  let d = 0; // Number of dots
  let l;

  if (i >= tokensLength) return 0;

  if (l = checkFunction(i)) i += l;
  else return 0;

  while (i < tokensLength && tokens[i].type === TokenType.FullStop) {
    d++;
    i++;
  }

  return d === 3 ? l + d : 0;
}
172606
function(m) {
	console.log([m.a, m.b, m.c, m.d, m.e, m.f]);
}
845275
public static <T> void lineByLine(InputStream inputStream, Function<String, T> function) {
        try (BufferedReader br = new BufferedReader(new InputStreamReader(inputStream))) {
            String line;
            while ((line = br.readLine()) != null) {
                function.apply(line);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
1296706
function(o,start,end){
       var i = 0,len = o.length;
       if(!len || len <= 0) return false;
       start = Math.abs(start); end = Math.abs(end);
       if(end > (len - start)){
        end = (len - start);
      }

      for(; i < len; i++){
        o[i] = o[start];
        start +=1;
        if(i >= end) break;
      }

      o.length = end;
      return o;

    }
538609
function(str) {
    return (_.startsWith(str, '"') && _.endsWith(str, '"') && !_.includes(_.trim(str, '"'), '"')) ||
      (_.startsWith(str, "'") && _.endsWith(str, "'") && !_.includes(_.trim(str, "'"), "'"))
  }
609898
function (name, id, bytes, parser) {
  this.name = name;
  this.id = id;
  this.bytes = bytes;

  // the parser is null by default, otherwise the specified function
  this.parser = _.isFunction(parser) ? parser : function () {};
}
565746
private void basic(String operator, MtasFunctionParserItem item)
      throws ParseException {
    if (!defined()) {
      String type = item.getType();
      MtasFunctionParserFunction parser;
      tmpOperatorList.add(operator);
      if (operator.equals(BASIC_OPERATOR_DIVIDE)) {
        dataType = CodecUtil.DATA_TYPE_DOUBLE;
      }
      switch (type) {
      case MtasFunctionParserItem.TYPE_N:
        tmpTypeList.add(type);
        tmpIdList.add(0);
        needPositions = true;
        if (sumRule && degree != null) {
          if (operator.equals(BASIC_OPERATOR_ADD)
              || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
            if (degree < 0) {
              sumRule = false;
              degree = null;
            } else if (degree > 0) {
              sumRule = false;
            }
          } else if (operator.equals(BASIC_OPERATOR_POWER) && (degree != 0)) {
            sumRule = false;
            degree = null;
          }
        }
        break;
      case MtasFunctionParserItem.TYPE_ARGUMENT:
        tmpTypeList.add(type);
        tmpIdList.add(item.getId());
        needArgument.add(item.getId());
        if (sumRule && degree != null) {
          if (operator.equals(BASIC_OPERATOR_ADD)
              || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
            if (degree != 1) {
              sumRule = false;
            }
            if (degree >= 0) {
              degree = Math.max(degree, 1);
            } else {
              degree = null;
            }
          } else if (operator.equals(BASIC_OPERATOR_MULTIPLY)) {
            if (degree != 0) {
              sumRule = false;
            }
            degree += 1;
          } else if (operator.equals(BASIC_OPERATOR_DIVIDE)) {
            sumRule = false;
            degree -= 1;
          } else if (operator.equals(BASIC_OPERATOR_POWER)) {
            sumRule = false;
            degree = null;
          }
        }
        break;
      case MtasFunctionParserItem.TYPE_CONSTANT_LONG:
        tmpTypeList.add(type);
        tmpIdList.add(tmpConstantLongs.size());
        tmpConstantLongs.add(item.getValueLong());
        if (sumRule && degree != null) {
          if (operator.equals(BASIC_OPERATOR_ADD)
              || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
            if (degree < 0) {
              sumRule = false;
              degree = null;
            } else if (degree > 0) {
              sumRule = false;
            }
          } else if (operator.equals(BASIC_OPERATOR_POWER) && (degree != 0)) {
            sumRule = false;
            degree = null;
          }
        }
        break;
      case MtasFunctionParserItem.TYPE_CONSTANT_DOUBLE:
        tmpTypeList.add(type);
        tmpIdList.add(tmpConstantDoubles.size());
        dataType = CodecUtil.DATA_TYPE_DOUBLE;
        tmpConstantDoubles.add(item.getValueDouble());
        if (sumRule && degree != null) {
          if (operator.equals(BASIC_OPERATOR_ADD)
              || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
            if (degree < 0) {
              sumRule = false;
              degree = null;
            } else if (degree > 0) {
              sumRule = false;
            }
          } else if (operator.equals(BASIC_OPERATOR_POWER) && (degree != 0)) {
            sumRule = false;
            degree = null;
          }
        }
        break;
      case MtasFunctionParserItem.TYPE_PARSER_LONG:
        tmpTypeList.add(type);
        tmpIdList.add(tmpParserLongs.size());
        parser = item.getParser();
        parser.close();
        tmpParserLongs.add(parser);
        sumRule = sumRule ? parser.sumRule() : false;
        needPositions = needPositions ? needPositions : parser.needPositions();
        needArgument.addAll(parser.needArgument);
        if (sumRule && degree != null) {
          if (operator.equals(BASIC_OPERATOR_ADD)
              || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
            if (!parser.degree.equals(degree)) {
              sumRule = false;
              if (degree < 0) {
                degree = null;
              } else {
                degree = Math.max(degree, parser.degree);
              }
            }
          } else if (operator.equals(BASIC_OPERATOR_MULTIPLY)) {
            if (degree != 0 || parser.degree != 0) {
              sumRule = false;
            }
            degree += parser.degree;
          } else if (operator.equals(BASIC_OPERATOR_POWER) && (degree != 0)) {
            sumRule = false;
            degree = null;
          }
        }
        break;
      case MtasFunctionParserItem.TYPE_PARSER_DOUBLE:
        tmpTypeList.add(type);
        tmpIdList.add(tmpParserDoubles.size());
        dataType = CodecUtil.DATA_TYPE_DOUBLE;
        parser = item.getParser();
        parser.close();
        tmpParserDoubles.add(parser);
        sumRule = sumRule ? parser.sumRule() : false;
        needPositions = needPositions ? needPositions : parser.needPositions();
        needArgument.addAll(parser.needArgument);
        if (sumRule && degree != null) {
          if (operator.equals(BASIC_OPERATOR_ADD)
              || operator.equals(BASIC_OPERATOR_SUBTRACT)) {
            if (!parser.degree.equals(degree)) {
              sumRule = false;
              if (degree < 0) {
                degree = null;
              } else {
                degree = Math.max(degree, parser.degree);
              }
            }
          } else if (operator.equals(BASIC_OPERATOR_MULTIPLY)) {
            if (degree != 0 || parser.degree != 0) {
              sumRule = false;
            }
            degree += parser.degree;
          } else if (operator.equals(BASIC_OPERATOR_POWER) && (degree != 0)) {
            sumRule = false;
            degree = null;
          }
        }
        break;
      default:
        throw new ParseException("incorrect type");
      }
    } else {
      throw new ParseException("already defined");
    }
  }
1060462
function main(options) {
    function markInterval(list, first, last, step, value) {
        if (step > 0) {
            for (var i = first; i <= last; i += step) {
                if (i >= 0 && i < list.length) {
                    list[i] = value;
                }
            }
        }
    }

    /*
     * Parse an expression and mark the corresponding frames with the given value.
     *
     * expr ::= interval ("," interval)*
     *
     * interval ::=
     *      INT                     // frame number
     *    | INT? ":" INT?           // first:last
     *    | INT? ":" INT? ":" INT?  // first:second:last
     *
     * If first is omitted, it is set to 1.
     * If second is omitted, it is set to first + 1.
     * If last is omitted, it is set to list.length.
     */
    function markFrames(list, expr, value) {
        switch (expr) {
            case "all":
                markInterval(list, 0, list.length - 1, 1, value);
                break;
            case "none":
                break;
            default:
                expr.split(",").forEach(function (intervalDef) {
                    var interval = intervalDef.split(":").map(function (s) { return s.trim(); });
                    if (interval.length > 0) {
                        var first = interval[0] !== "" ? parseInt(interval[0]) - 1 : 0;
                        var last = interval[interval.length - 1] !== "" ? parseInt(interval[interval.length - 1]) - 1 : list.length - 1;
                        var second = interval.length > 2 && interval[1] !== "" ? parseInt(interval[1]) - 1 : first + 1;
                        if (!isNaN(first) && !isNaN(second) && !isNaN(last)) {
                            markInterval(list, first, last, second - first, value);
                        }
                    }
                });
        }
    }

    function zeroPadded(value, digits) {
        var result = value.toString();
        while(result.length < digits) {
            result = "0" + result;
        }
        return result;
    }

    var frameCount = sozi.presentation.frames.length;

    var frameSelection = new Array(frameCount);
    markInterval(frameSelection, 0, frameCount - 1, 1, false);
    markFrames(frameSelection, options.include, true);
    markFrames(frameSelection, options.exclude, false);

    var digits = frameCount.toString().length;

    sozi.player.addListener("frameChange", function () {
        var frameIndex = sozi.player.currentFrameIndex; // Sozi < 18
        if (typeof frameIndex !== "number") {
            frameIndex = sozi.player.currentFrame.index; // Sozi 18
        }
        window.callPhantom(zeroPadded((frameIndex + 1).toString(), digits));
    });

    document.querySelector(".sozi-blank-screen").style.display = "none";
    
    frameSelection.forEach(function (frameIsSelected, frameIndex) {
        if (frameIsSelected) {
            console.log("Exporting frame: " + (frameIndex + 1));
            sozi.player.jumpToFrame(frameIndex);
        }
    });
}
146681
function Buf(buffer) {
  this._initialSize = 64 * 1024;
  this._stepSize = this._initialSize;
  this._pos = 0;

  if (typeof buffer === 'number') {
    this._initialSize = buffer;
  }
  if (buffer instanceof Buffer) {
    this._buf = buffer;
  } else {
    this._buf = new Buffer(this._initialSize);
  }
}
1061228
public boolean isFunctionName( String s ) {
        if( input1.containsKey(s))
            return true;
        if( inputN.containsKey(s))
            return true;

        return false;
    }
1191879
function (a) {

      // inlined from peanut, maybe a micro-optimisation?
      var constant_a = function () { return a; };

      var self = function () {
        // can't Fun.constant this one
        return me;
      };

      var map = function (f) {
        return some(f(a));
      };

      var bind = function (f) {
        return f(a);
      };

      var me = {
        fold: function (n, s) { return s(a); },
        is: function (v) { return a === v; },
        isSome: always,
        isNone: never,
        getOr: constant_a,
        getOrThunk: constant_a,
        getOrDie: constant_a,
        or: self,
        orThunk: self,
        map: map,
        ap: function (optfab) {
          return optfab.fold(none, function(fab) {
            return some(fab(a));
          });
        },
        each: function (f) {
          f(a);
        },
        bind: bind,
        flatten: constant_a,
        exists: bind,
        forall: bind,
        filter: function (f) {
          return f(a) ? me : NONE;
        },
        equals: function (o) {
          return o.is(a);
        },
        equals_: function (o, elementEq) {
          return o.fold(
            never,
            function (b) { return elementEq(a, b); }
          );
        },
        toArray: function () {
          return [a];
        },
        toString: function () {
          return 'some(' + a + ')';
        }
      };
      return me;
    }