/* ------------- Two-input Completions --------------
346713
private CompletableFuture<Void> uniRunNow(Object r, Executor e, Runnable f) {
    Throwable x;
    CompletableFuture<Void> d = newIncompleteFuture();
    if (r instanceof AltResult && (x = ((AltResult) r).ex) != null)
      d.result = encodeThrowable(x, r);
    else
      try {
        if (e != null) {
          e.execute(new UniRun<T>(null, d, this, f));
        } else {
          f.run();
          d.result = NIL;
        }
      } catch (Throwable ex) {
        d.result = encodeThrowable(ex);
      }
    return d;
  }
1305489
@Override
	public void beforeFirst() {
		currentScan = null;
		s1.beforeFirst();
		hasMore1 = s1.next();
		if (s2 != null) {
			s2.beforeFirst();
			hasMore2 = s2.next();
		}
	}
983986
@Override
    public int complete(CommandContext ctx, String buffer, int cursor, List<String> candidates) {
        if(!ctx.isDomainMode()) {
            return -1;
        }
        if(buffer.isEmpty()) {
            candidates.add("{rollout");
            return 0;
        }

        try {
            parsedOp.parseOperation(null, buffer, ctx);
        } catch (CommandFormatException e) {
            return -1;
        }
        if(parsedOp.isRequestComplete()) {
            return -1;
        }

        if(parsedOp.endsOnHeaderListStart() || parsedOp.endsOnHeaderSeparator()) {
            candidates.add("rollout");
            return parsedOp.getLastSeparatorIndex() + 1;
        }
        if(parsedOp.getLastHeader() == null) {
            if(ctx.getParsedCommandLine().getOriginalLine().endsWith(" ") /* '{rollout ' */) {
                final String originalLine = ctx.getParsedCommandLine().getOriginalLine();
                int bufferIndex = originalLine.lastIndexOf(buffer);
                if(bufferIndex == -1) { // that's illegal state
                    return -1;
                }
                candidates.add("name=");
                candidates.addAll(Util.getServerGroups(ctx.getModelControllerClient()));
                return originalLine.length() - bufferIndex;
            } else if (ctx.getParsedCommandLine().getOriginalLine().endsWith("rollout")) {
                // In order to have the completion to be allowed to continue
                candidates.add(" ");
            }
            return buffer.length();
        }
        final ParsedOperationRequestHeader lastHeader = parsedOp.getLastHeader();
        if(!(lastHeader instanceof ParsedRolloutPlanHeader)) {
            throw new IllegalStateException("Expected " + ParsedRolloutPlanHeader.class + " but got " + lastHeader.getName() + " of " + lastHeader);
        }
        final ParsedRolloutPlanHeader rollout = (ParsedRolloutPlanHeader) lastHeader;

        if(rollout.endsOnPlanIdValueSeparator()) {
            candidates.addAll(Util.getNodeNames(ctx.getModelControllerClient(), address, Util.ROLLOUT_PLAN));
            return rollout.getLastSeparatorIndex() + 1;
        }

        final String planRef = rollout.getPlanRef();
        if(planRef != null) {
            final List<String> nodeNames = Util.getNodeNames(ctx.getModelControllerClient(), address, Util.ROLLOUT_PLAN);
            for(String name : nodeNames) {
                if(name.startsWith(planRef)) {
                    candidates.add(name);
                }
            }
            return rollout.getLastChunkIndex();
        }

        if(rollout.hasProperties()) {
            final String lastName = rollout.getLastPropertyName();
            if (Util.ROLLBACK_ACROSS_GROUPS.equals(lastName)) {
                if (rollout.getLastPropertyValue() != null) {
                    return -1;
                }
                candidates.add("}");
                candidates.add(";");
                return rollout.getLastChunkIndex() + lastName.length();
            }
            if (Util.ROLLBACK_ACROSS_GROUPS.startsWith(lastName)) {
                candidates.add(Util.ROLLBACK_ACROSS_GROUPS);
            }
            return rollout.getLastChunkIndex();
        }

        final List<String> serverGroups = Util.getServerGroups(ctx.getModelControllerClient());
        boolean containsAllGroups = true;
        for (String group : serverGroups) {
            if (!rollout.containsGroup(group)) {
                containsAllGroups = false;
                break;
            }
        }

        if(rollout.endsOnGroupSeparator()) {
            if (containsAllGroups) {
                return -1;
            }
            for(String group : serverGroups) {
                if(!rollout.containsGroup(group)) {
                    candidates.add(group);
                }
            }
            return buffer.length();
        }

        final SingleRolloutPlanGroup lastGroup = rollout.getLastGroup();
        if(lastGroup == null) {
            return -1;
        }

        if (lastGroup.endsOnPropertyListEnd()) {
            if (!containsAllGroups) {
                candidates.add("^");
                candidates.add(",");
            } else if (Character.isWhitespace(buffer.charAt(buffer.length() - 1))) {
                candidates.add(Util.ROLLBACK_ACROSS_GROUPS);

            } else {
                candidates.add(" ");
            }
            return buffer.length();
        }

        if(lastGroup.endsOnPropertyListStart()) {
            candidates.add(Util.MAX_FAILED_SERVERS);
            candidates.add(Util.MAX_FAILURE_PERCENTAGE);
            candidates.add(Util.ROLLING_TO_SERVERS);
            candidates.add(Util.NOT_OPERATOR);
            return buffer.length();
        }

        // Only return the set of boolean properties
        if (lastGroup.endsOnNotOperator()) {
            candidates.add(Util.ROLLING_TO_SERVERS);
            return buffer.length();
        }

        if (lastGroup.hasProperties()) {
            // To propose the right end character
            boolean containsAll = lastGroup.hasProperty(Util.MAX_FAILED_SERVERS)
                    && lastGroup.hasProperty(Util.MAX_FAILURE_PERCENTAGE)
                    && lastGroup.hasProperty(Util.ROLLING_TO_SERVERS);

            final String propValue = lastGroup.getLastPropertyValue();
            if(propValue != null) {
                if(Util.TRUE.startsWith(propValue)) {
                    candidates.add(Util.TRUE);
                } else if(Util.FALSE.startsWith(propValue)) {
                    candidates.add(Util.FALSE);
                } else {
                    candidates.add(containsAll ? ")" : ",");
                    return buffer.length();
                }
            } else if(lastGroup.endsOnPropertyValueSeparator()) {
                if(Util.ROLLING_TO_SERVERS.equals(lastGroup.getLastPropertyName())) {
                    candidates.add(Util.FALSE);
                    candidates.add(containsAll ? ")" : ",");
                }
                return buffer.length();
            } else if(lastGroup.endsOnPropertySeparator()) {
                if(!lastGroup.hasProperty(Util.MAX_FAILED_SERVERS)) {
                    candidates.add(Util.MAX_FAILED_SERVERS);
                }
                if(!lastGroup.hasProperty(Util.MAX_FAILURE_PERCENTAGE)) {
                    candidates.add(Util.MAX_FAILURE_PERCENTAGE);
                }
                if(!lastGroup.hasProperty(Util.ROLLING_TO_SERVERS)) {
                    candidates.add(Util.ROLLING_TO_SERVERS);
                    candidates.add(Util.NOT_OPERATOR);
                }
                return lastGroup.getLastSeparatorIndex() + 1;
            } else {
                final String propName = lastGroup.getLastPropertyName();
                if(Util.MAX_FAILED_SERVERS.startsWith(propName)) {
                    candidates.add(Util.MAX_FAILED_SERVERS + '=');
                }
                if(Util.MAX_FAILURE_PERCENTAGE.startsWith(propName)) {
                    candidates.add(Util.MAX_FAILURE_PERCENTAGE + '=');
                } else if (Util.ROLLING_TO_SERVERS.equals(propName)) {
                    if (lastGroup.isLastPropertyNegated() && !containsAll) {
                        candidates.add(Util.ROLLING_TO_SERVERS + ",");
                    } else {
                        candidates.add("=" + Util.FALSE);
                        if (!containsAll) {
                            candidates.add(",");
                        } else {
                            candidates.add(")");
                        }
                    }

                } else if (Util.ROLLING_TO_SERVERS.startsWith(propName)) {
                    candidates.add(Util.ROLLING_TO_SERVERS);
                }
            }
            if (candidates.isEmpty() && containsAll) {
                candidates.add(")");
            }
            return lastGroup.getLastChunkIndex();
        }

        if (Character.isWhitespace(buffer.charAt(buffer.length() - 1))) {
            candidates.add(Util.ROLLBACK_ACROSS_GROUPS);
            return buffer.length();
        }

        int result = lastGroup.getLastChunkIndex();

        final String groupName = lastGroup.getGroupName();

        boolean isLastGroup = false;
        for (String group : serverGroups) {
            if (group.equals(groupName)) {
                isLastGroup = true;
            }
            if (!isLastGroup && group.startsWith(groupName)) {
                candidates.add(group);
            }
        }

        if(Util.NAME.startsWith(groupName)) {
            candidates.add("name=");
        } else {
            if (candidates.isEmpty()) {
                if (isLastGroup) {
                    candidates.add("(");
                    if (containsAllGroups) {
                        candidates.add(Util.ROLLBACK_ACROSS_GROUPS);
                    } else {
                        candidates.add(",");
                        candidates.add("^");
                    }
                }
            }
        }

        return result;
    }
1289436
private boolean parseFunction() {
        if (!(curToken instanceof Id) || isELReserved(curToken.toString())) {
            return false;
        }
        String s1 = null; // Function prefix
        String s2 = curToken.toString(); // Function name
        int mark = getIndex();
        if (hasNext()) {
            Token t = nextToken();
            if (t.toChar() == ':') {
                if (hasNext()) {
                    Token t2 = nextToken();
                    if (t2 instanceof Id) {
                        s1 = s2;
                        s2 = t2.toString();
                        if (hasNext()) {
                            t = nextToken();
                        }
                    }
                }
            }
            if (t.toChar() == '(') {
                ELexpr.add(new ELNode.Function(s1, s2));
                return true;
            }
        }
        setIndex(mark);
        return false;
    }
336636
private List<String> completionPattern(List<String> patterns) {
        List<String> result = new ArrayList<String>();
        for (String pattern : patterns) {
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("^");
            stringBuffer.append(pattern);
            stringBuffer.append("$");
            result.add(stringBuffer.toString());
        }
        return result;
    }
137722
@Override
  public String[] synthesize(AnalyzedToken token, String posTag,
      boolean posTagRegExp) throws IOException {

    if (posTag != null && posTagRegExp) {
      String myPosTag = posTag;
      String det = "";
      if (posTag.endsWith(ADD_IND_DETERMINER)) {
        myPosTag = myPosTag.substring(0, myPosTag.indexOf(ADD_IND_DETERMINER) - "\\".length());
        det = aVsAnRule.suggestAorAn(token.getLemma());
        det = det.substring(0, det.indexOf(' ') + " ".length());
      } else if (posTag.endsWith(ADD_DETERMINER)) {
        myPosTag = myPosTag.substring(0, myPosTag.indexOf(ADD_DETERMINER) - "\\".length());
        det = "the ";
      }

      initPossibleTags();
      Pattern p = Pattern.compile(myPosTag);
      List<String> results = new ArrayList<>();

      for (String tag : possibleTags) {
        Matcher m = p.matcher(tag);
        if (m.matches()) {
          lookup(token.getLemma(), tag, results, det);
        }
      }
      return results.toArray(new String[results.size()]);
    }

    return synthesize(token, posTag);
  }
615787
function(preScripture){

      this.stdin.resume();
      this.stdin.setEncoding('utf8');
      this.stdin.on('data', this.checkInput.bind(this));

      var _fillStrBlue = '................................................................................';
      var _lengthOfSprite = _fillStrBlue.length;
      var _fillerStrLengthForConsoleWidth = Math.floor(_lengthOfSprite / 2);

      var _fillerStrForConsolePadding = '';

      for(var oo = 0; oo < _fillerStrLengthForConsoleWidth; oo++){
        _fillerStrForConsolePadding += '.';
      }

      util.puts("Loading PatsyJS...".bold);
      util.print('\n'+
      _fillerStrForConsolePadding.inverse.blue + '................................................................................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '................................................................................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '................................................................................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '................................................................................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '......................................................'.inverse.blue + ',:::::::,,,,'.inverse.yellow + '..............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '................................................'.inverse.blue + ',,::'.inverse.yellow + '~~~~~~======'.inverse.white + '+=,'.inverse.yellow + '.............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '.........................,'.inverse.blue + '$$~I+'.inverse.yellow + '..............'.inverse.blue + ',::'.inverse.yellow + '~~'.inverse.white + '::::::::::::::'.white + '~'.inverse.white + '+=,'.inverse.yellow + '............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '...................'.inverse.blue + '++Z7$7=~~~+?7ZOZZO?'.inverse.yellow + '.....'.inverse.blue + ',:'.inverse.yellow + '~~'.inverse.white + '::::::::::~~~~::'.white + '::'.inverse.white + '+?:'.inverse.yellow + '............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '................'.inverse.blue + 'OZ$~?~'.inverse.yellow + ':::,,:,,,,,,'.inverse.white + '::~IZZ8Z:'.inverse.yellow + '~:'.inverse.white + ':::::::::~:~~~~~:'.white + '::'.inverse.white + '~II:,'.inverse.yellow + '...........'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '..............'.inverse.blue + 'ZZZ~'.inverse.yellow + '::,:,,,,,.,.....,,,,'.inverse.white + '::=78~~'.inverse.yellow + '::::::::::::~~~:'.white + '::'.inverse.white + '~IZI:,'.inverse.yellow + '...........'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '...........'.inverse.blue + 'I:IZO~'.inverse.yellow + ':,,,.,,,,,'.inverse.white + '::~:'.white + ',,,,...,,,'.inverse.white + '::78,'.inverse.yellow + ':::::::::::::'.white + ':::'.inverse.white + '=7ZZI:,'.inverse.yellow + '...........'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '...........'.inverse.blue + '=IZO~'.inverse.yellow + ':,,,.,'.inverse.white + '~~~~~~==~=~~~~'.white + ':,,...,'.inverse.white + ':~DO,'.inverse.yellow + ',,'.inverse.white + '::::::'.white + ':::~'.inverse.white + '=IZZZZ?:'.inverse.yellow + '............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '...........'.inverse.blue + '~Z7$'.inverse.yellow + ':,,,,,'.inverse.white + '=~~=~========~=~~~~'.white + '...,,'.inverse.white + ':IO~'.inverse.yellow + '~~~~~~='.inverse.white + '?I$OOZZZZ$=,'.inverse.yellow + '............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '..........'.inverse.blue + 'Z$O$O~'.inverse.yellow + ':,,,'.inverse.white + '~=~~~==============~~'.white + ',,,,'.inverse.white + '::$O$ZZZOOOOOOOOZZZZ?:'.inverse.yellow + '.............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '..........'.inverse.blue + 'ZO$$Z~'.inverse.yellow + ':,,,'.inverse.white + '=~~~~~~==============~'.white + ':,,'.inverse.white + '::~OOZOOZZOOOOOOOOZ$~'.inverse.yellow + ','.inverse.grey + '.............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '.........'.inverse.blue + '~ZOZOO7'.inverse.yellow + ':,,,'.inverse.white + '=~~~~~~~~=============~'.white + ':,,,'.inverse.white + ':~OZZZOOOOOOOOOOO+'.inverse.yellow + ','.inverse.grey + '..............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '.........'.inverse.blue + 'O8OOOZZ'.inverse.yellow + '::,,:'.inverse.white + '~~~~~~~~~====~~=======~'.white + ',,,,'.inverse.white + '~IZOOOOOOOOOZOZ?:'.inverse.yellow + ',,'.inverse.grey + '.............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '.........'.inverse.blue + 'NZ$788ZI'.inverse.yellow + ':,,,'.inverse.white + '~~~~~~~~~~=~~~~~======~'.white + ',.,,'.inverse.white + ':~OIO8888888Z7+'.inverse.yellow + '~~:::,,,,'.inverse.grey + '........'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '........'.inverse.blue + '=Z$Z8OZ$$7'.inverse.yellow + ':,,,'.inverse.white + '~~~~~~~~=~~~~~~~====~~'.white + ',,,,'.inverse.white + '::ZODDDDD8Z7+='.inverse.yellow + '~~~~::::::,,,'.inverse.grey + '.....'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '........'.inverse.blue + ':$8$OZZOZO7'.inverse.yellow + ':,,,,'.inverse.white + '~~~~~~~~~~~~~~===~~~'.white + ',.,,'.inverse.white + ':~ZO?IIIII?+='.inverse.yellow + '~~~::::::,,,,'.inverse.grey + '......'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '.......'.inverse.blue + '+?Z$O$OZZZOOO'.inverse.yellow + ':,,,,:'.inverse.white + '~~~~~~~~~~~~=~~~~'.white + ',.,,,'.inverse.white + ':~ZI'.inverse.yellow + '::::::::::,,,,,,'.inverse.grey + '............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '.........'.inverse.blue + 'Z78ZO88OZ7$$='.inverse.yellow + ':,,,,'.inverse.white + '~~~~~~~~=~~~~~'.white + '::.,,,,'.inverse.white + ':7Z='.inverse.yellow + ',,,,,,,,,,,,,,,'.inverse.grey + '.............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '.........'.inverse.blue + ':OZ8ZZ8ZZ$?$$$'.inverse.yellow + ':,,,,.,,,'.inverse.white + ':::=::'.white + '...,..,,'.inverse.white + '::~ZI'.inverse.yellow + ',,,,,,,,,,,,,,,'.inverse.grey + '..............'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '.........'.inverse.blue + '.7ZZO88OZ8ZOOZOO'.inverse.yellow + ':,,,,,.....,,,,,,,,,'.inverse.white + '::=ZI'.inverse.yellow + '......'.inverse.blue + ',.,,,,,'.inverse.grey + '.................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '...........'.inverse.blue + 'IZ$88OOOOZZ88Z7OZ~'.inverse.yellow + ':,,,,,,,,,,,'.inverse.white + '::::$OZZ:'.inverse.yellow + '..............................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '............'.inverse.blue + 'ZZZZO$Z$OOOZOO$77OZI77+'.inverse.yellow + ':::ZOOOZZZZ$8'.inverse.yellow + '................................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '............'.inverse.blue + '+878$$ZZDZZOOZZZOO$ZOOZO7Z7$$Z$OO7?'.inverse.yellow + '.................................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '.....'.inverse.blue + ',,,,,,,,,'.inverse.grey + 'Z$OZOZ8ZOOO$O$O7Z$OO$$$8OOOOZZZ7'.inverse.yellow + '..................................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '..'.inverse.blue + ',,,,,,,,,,,,,,'.inverse.grey + 'OOO8Z88OZD8OOO$8Z8$8OZZO7Z7O'.inverse.yellow + '....................................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '..'.inverse.blue + ',,,,,,,,,,,,:~+?'.inverse.grey + 'OD8D$O888OOOOZ$88OZ$Z8O~~'.inverse.yellow + '~::,,'.inverse.grey + '................................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '...'.inverse.blue + ',,,,,,,,,~=+++???'.inverse.grey + '8D8DD8NDDDO88NOD8?7==='.inverse.yellow + '~~~:::::,,,'.inverse.grey + '...........................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '.......'.inverse.blue + ',,,::=++??IZ78O'.inverse.grey + '8NNDDNMNM8MZZ$7I?+'.inverse.yellow + '==~~~::::,,,,,,,,'.inverse.grey + '.......................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '............'.inverse.blue + ',:=+??I7$$$'.inverse.grey + 'ZZZOOO8OOOZ$7I?+'.inverse.yellow + '=~~::::,,,,,,,,,'.inverse.grey + '.........................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue +
      _fillerStrForConsolePadding.inverse.blue + '...............'.inverse.blue + ',,:~~==============~~~~:::::,,,,,,'.inverse.grey + '...............................'.inverse.blue + _fillerStrForConsolePadding.inverse.blue + '\n'.inverse.blue);


      if ((Array.isArray(preScripture)) && (preScripture.length > 0)) {
        for (var i = 0; i < preScripture.length; i++) {
          this.scripture.print(preScripture[i]);
        }
      }

      this.scripture.print('[King Arthur]'.magenta + ': Come Patsy, my trusty servant!!');
      this.scripture.print('[Patsy]'.yellow + ': <banging two half coconuts together> ');

      try{
        var patsy = this;
        /**
         * Require project from the library
         *
         * @var     Object
         * @source  patsy
         */
        var project = require('./project')(opts);
        project.check(patsy);
      } catch(e){
        console.log('>> PatsyStartException'.red + ':', e);
      }
    }
1373035
private Pair<ParserRuleContext, CommonTokenStream> preparePath(final String input) {
		UriLexer lexer = new UriLexer(CharStreams.fromString(input));
		CommonTokenStream tokens = new CommonTokenStream(lexer);
		UriParser parser = new UriParser(tokens);

		parser.removeErrorListeners();
		parser.addErrorListener(new ContentUriBaseErrorListener() {
			@Override
			public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) {
				AssertKripton.assertTrue(false, "unespected char at pos %s of URI '%s'", charPositionInLine, input);
			}
		});

		ParserRuleContext context = parser.path();
		return new Pair<>(context, tokens);
	}
483394
final void orpush(CompletableFuture<?> b, BiCompletion<?,?,?> c) {
        if (c != null) {
            while ((b == null || b.result == null) && result == null) {
                if (tryPushStack(c)) {
                    if (b != null && b != this && b.result == null) {
                        Completion q = new CoCompletion(c);
                        while (result == null && b.result == null &&
                               !b.tryPushStack(q))
                            lazySetNext(q, null); // clear on failure
                    }
                    break;
                }
                lazySetNext(c, null); // clear on failure
            }
        }
    }
592500
public final void quietlyCompleteRoot() {
    for (CountedCompleter<?> a = this, p;;) {
      if ((p = a.completer) == null) {
        a.quietlyComplete();
        return;
      }
      a = p;
    }
  }
909920
public void addInput(Path path, InputFormat inputFormat, TupleMapper inputProcessor) {
		multipleInputs.addInput(new Input(path, inputFormat, inputProcessor, new HashMap<String, String>()));
	}
177963
public static void appendPair(StringBuffer b, String s1, String s2,
                                  String separator, String terminator) {

        b.append(s1);
        b.append(separator);
        b.append(s2);
        b.append(terminator);
    }
260684
private static void processText(NameFinder[] finders, String[] tags, BufferedReader input) throws IOException {
    String[][] finderTags = new String[finders.length][];
    Map[] prevTokenMaps = createPrevTokenMaps(finders); 
    for (String line = input.readLine(); null != line; line = input.readLine()) {
      if (line.equals("")) {
        clearPrevTokenMaps(prevTokenMaps);
        System.out.println();
        continue;
      }
      Span[] spans = tokenizeToSpans(line);
      String[] tokens = spansToStrings(spans,line);
      for (int fi = 0, fl = finders.length; fi < fl; fi++) {
        finderTags[fi] = finders[fi].find(tokens, prevTokenMaps[fi]);
        //System.err.println("EnglighNameFinder.processText: "+tags[fi] + " " + java.util.Arrays.asList(finderTags[fi]));
      }
      updatePrevTokenMaps(prevTokenMaps,tokens,finderTags);
      for (int ti = 0, tl = tokens.length; ti < tl; ti++) {
        for (int fi = 0, fl = finders.length; fi < fl; fi++) {
          //check for end tags
          if (ti != 0) {
            if ((finderTags[fi][ti].equals(NameFinderME.START) || finderTags[fi][ti].equals(NameFinderME.OTHER)) && (finderTags[fi][ti - 1].equals(NameFinderME.START) || finderTags[fi][ti - 1].equals(NameFinderME.CONTINUE))) {
              System.out.print("</" + tags[fi] + ">");
            }
          }
        }
        if (ti > 0 && spans[ti - 1].getEnd() < spans[ti].getStart()) {
          System.out.print(line.substring(spans[ti - 1].getEnd(), spans[ti].getStart()));
        }
        //check for start tags
        for (int fi = 0, fl = finders.length; fi < fl; fi++) {
          if (finderTags[fi][ti].equals(NameFinderME.START)) {
            System.out.print("<" + tags[fi] + ">");
          }
        }
        System.out.print(tokens[ti]);
      }
      //final end tags
      if (tokens.length != 0) {
        for (int fi = 0, fl = finders.length; fi < fl; fi++) {
          if (finderTags[fi][tokens.length - 1].equals(NameFinderME.START) || finderTags[fi][tokens.length - 1].equals(NameFinderME.CONTINUE)) {
            System.out.print("</" + tags[fi] + ">");
          }
        }
      }
      if (tokens.length != 0) {
        if (spans[tokens.length - 1].getEnd() < line.length()) {
          System.out.print(line.substring(spans[tokens.length - 1].getEnd()));
        }
      }
      System.out.println();
    }
  }
1109231
void fillIn(ClassSymbol c) {
        if (completionFailureName == c.fullname) {
            throw new CompletionFailure(c, "user-selected completion failure by class name");
        }
        currentOwner = c;
        JavaFileObject classfile = c.classfile;
        if (classfile != null) {
            JavaFileObject previousClassFile = currentClassFile;
            try {
                if (reader.filling) {
                    Assert.error("Filling " + classfile.toUri() + " during " + previousClassFile);
                }
                currentClassFile = classfile;
                if (verbose) {
                    log.printVerbose("loading", currentClassFile.getName());
                }
                if (classfile.getKind() == JavaFileObject.Kind.CLASS ||
                    classfile.getKind() == JavaFileObject.Kind.OTHER) {
                    reader.readClassFile(c);
                    c.flags_field |= getSupplementaryFlags(c);
                } else {
                    if (!sourceCompleter.isTerminal()) {
                        sourceCompleter.complete(c);
                    } else {
                        throw new IllegalStateException("Source completer required to read "
                                                        + classfile.toUri());
                    }
                }
            } finally {
                currentClassFile = previousClassFile;
            }
        } else {
            throw classFileNotFound(c);
        }
    }
136231
private void handleDone() {
        // Attempt to complete the current token token
        performCompletion();

        // Hide the keyboard
        InputMethodManager imm = (InputMethodManager) getContext().getSystemService(
                Context.INPUT_METHOD_SERVICE);
        if (imm != null) {
            imm.hideSoftInputFromWindow(getWindowToken(), 0);
        }
    }
1340653
public Iterable<? extends Completion> getCompletions(Element element,
                                                         AnnotationMirror annotation,
                                                         ExecutableElement member,
                                                         String userText) {
        return Collections.emptyList();
    }
334241
function(params, callback) {
      var t = this;
      if (typeof(params) !== 'string' || params.length < 1) {
        callback("Autocomplete paramter must be a nonzero string");
      }

      // Forward to the completion mechanism if it can be completed
      if (params.substr(-1).match(/([0-9])|([a-z])|([A-Z])|([_])/)) {
        t.repl.complete(params, callback);
      } else {
        // Return a no-op autocomplete
        callback(null, [[],'']);
      }
    }