Not logged in.  Login/Logout/Register | List snippets | | Create snippet | Upload image | Upload data

28551
LINES
[SHOW ALL]

< > BotCompany Repo | #1006722 // Transpiler Translator for #759

JavaX translator [tags: use-pretranspiled]

Uses 1176K of libraries. Click here for Pure Java version (28621L/191K).

1  
lib 1400308 // JavaParser
2  
3  
import java.util.*;
4  
import java.util.zip.*;
5  
import java.util.List;
6  
import java.util.regex.*;
7  
import java.util.concurrent.*;
8  
import java.util.concurrent.atomic.*;
9  
import java.util.concurrent.locks.*;
10  
import javax.swing.*;
11  
import javax.swing.event.*;
12  
import javax.swing.text.*;
13  
import javax.swing.table.*;
14  
import java.io.*;
15  
import java.net.*;
16  
import java.lang.reflect.*;
17  
import java.lang.ref.*;
18  
import java.lang.management.*;
19  
import java.security.*;
20  
import java.security.spec.*;
21  
import java.awt.*;
22  
import java.awt.event.*;
23  
import java.awt.image.*;
24  
import javax.imageio.*;
25  
import java.math.*;
26  
27  
// We don't use #1006722 anymore
28  
//   (but it's still listed in #7!?)
29  
30  
// TODO: deprecate (remove) the "f <id>" syntax
31  
32  
// TODO: skip ifclass blocks in findFunctionInvocations.
33  
//       after main loop completes (including standard functions+
34  
//       classes), run tok_ifclass and if any change, run main loop
35  
//       again.
36  
//       This will allow clean handling of functions like "unnull"
37  
//       which right now _always_ include Symbol (because unnull
38  
//       references emptySymbol inside an ifclass Symbol block).
39  
40  
// Note: Before editing this, transpile #7
41  
// Use 'Very fresh' (R-transpile doesn't seem to work) or Q/M if you haven't screwed yourself currently
42  
// by making your transpiler unable to transpile itself... or
43  
// something
44  
45  
// Note: Don't try hijackPrint, it doesn't seem to work in here
46  
// (because of the way it is called by e.g. transpileForServer_returnPair?)
47  
48  
/* functions to possibly edit when creating/changing JavaX constructs:
49  
  tok_pingify
50  
*/
51  
52  
// new JavaParser includes
53  
import com.github.javaparser.*;
54  
import com.github.javaparser.ast.CompilationUnit;
55  
import com.github.javaparser.ast.Node;
56  
import com.github.javaparser.ast.body.*;
57  
import com.github.javaparser.ast.visitor.*;
58  
import com.github.javaparser.Problem;
59  
import com.github.javaparser.ast.NodeList;
60  
import com.github.javaparser.ast.body.MethodDeclaration;
61  
import com.github.javaparser.ast.body.EnumDeclaration;
62  
import com.github.javaparser.ast.stmt.LocalClassDeclarationStmt;
63  
import com.github.javaparser.printer.*;
64  
import java.text.DecimalFormat;
65  
import java.text.SimpleDateFormat;
66  
import java.text.NumberFormat;
67  
import java.nio.charset.Charset;
68  
import javax.imageio.metadata.*;
69  
import javax.imageio.stream.*;
70  
import static x30_pkg.x30_util.DynamicObject;
71  
import java.nio.file.Files;
72  
import java.nio.file.Path;
73  
74  
class main {
75  
76  
77  
78  
79  
 // JavaParser
80  
81  
82  
83  
84  
85  
86  
87  
static CompilationUnit javaParseCompilationUnit(String java) { return javaParseCompilationUnit(java, false); }
88  
static CompilationUnit javaParseCompilationUnit(String java, boolean withComments) {
89  
  JavaParser p = new JavaParser();
90  
  p.getParserConfiguration().setAttributeComments(withComments);
91  
  ParseResult<CompilationUnit> r = p.parse(java);
92  
  if (!r.isSuccessful())
93  
    throw fail(str(r));
94  
  return r.getResult().get();
95  
}
96  
97  
98  
99  
100  
101  
102  
103  
static String javaParser_makeAllPublic(String src, Object... __) {
104  
  CompilationUnit cu = javaParseCompilationUnit(src);
105  
  PrettyPrinterConfiguration ppconf = new PrettyPrinterConfiguration();
106  
  ppconf.setIndentSize(2);
107  
  ppconf.setIndentType(PrettyPrinterConfiguration.IndentType.SPACES);
108  
  ppconf.setPrintComments(false);
109  
  javaParser_makeAllPublic_Visitor visitor = new javaParser_makeAllPublic_Visitor();
110  
  visitor.notTopLevelClassDecl = boolOptPar("notTopLevelClassDecl", __);
111  
  visitor.visit(cu, null);
112  
  return cu.toString(ppconf);
113  
}
114  
115  
static class javaParser_makeAllPublic_Visitor extends VoidVisitorAdapter {
116  
  boolean notTopLevelClassDecl = false; // don't make top-level class declaration public
117  
  
118  
  void makePublic(NodeList<com.github.javaparser.ast.Modifier> modifiers) {
119  
    // XXX: does this work?
120  
    modifiers.remove(com.github.javaparser.ast.Modifier.privateModifier());
121  
    modifiers.remove(com.github.javaparser.ast.Modifier.protectedModifier());
122  
    if (!modifiers.contains(com.github.javaparser.ast.Modifier.publicModifier()))
123  
      modifiers.add(com.github.javaparser.ast.Modifier.publicModifier());
124  
  }
125  
126  
  public void visit(ClassOrInterfaceDeclaration n, Object arg) {
127  
    Node parent = n.getParentNode().get();
128  
    if (!(parent instanceof LocalClassDeclarationStmt
129  
      || parent instanceof CompilationUnit && neq(n.getName().asString(), "main")))
130  
      if (notTopLevelClassDecl)
131  
        notTopLevelClassDecl = false;
132  
      else
133  
        makePublic(n.getModifiers());
134  
    super.visit(n, arg);
135  
  }
136  
  
137  
  public void visit(FieldDeclaration n, Object arg) {
138  
    makePublic(n.getModifiers());
139  
    super.visit(n, arg);
140  
  }
141  
  
142  
  public void visit(ConstructorDeclaration n, Object arg) {
143  
    Node parent = n.getParentNode().get();
144  
    if (!(parent instanceof EnumDeclaration))
145  
      makePublic(n.getModifiers());
146  
    super.visit(n, arg);
147  
  }
148  
  
149  
  public void visit(MethodDeclaration n, Object arg) {
150  
    NodeList<com.github.javaparser.ast.Modifier> m = n.getModifiers();
151  
    //print("Method found: " + n.getName() + " with modifiers: " + m + ", position: " + n.getRange()->begin);
152  
    if (m.contains(com.github.javaparser.ast.Modifier.privateModifier()) && !m.contains(com.github.javaparser.ast.Modifier.staticModifier()) && !m.contains(com.github.javaparser.ast.Modifier.finalModifier()))
153  
      m.add(com.github.javaparser.ast.Modifier.finalModifier());
154  
    makePublic(m);
155  
    super.visit(n, arg);
156  
  }
157  
}
158  
static String javaParser_reparse_keepComments(String src) {
159  
  CompilationUnit cu = javaParseCompilationUnit(src, true);
160  
  PrettyPrinterConfiguration ppconf = new PrettyPrinterConfiguration();
161  
  ppconf.setPrintComments(true);
162  
  ppconf.setIndentSize(2);
163  
  ppconf.setIndentType(PrettyPrinterConfiguration.IndentType.SPACES);
164  
  return cu.toString(ppconf);
165  
}
166  
167  
static String javaParser_makeAllPublic_keepComments(String src) {
168  
  CompilationUnit cu = javaParseCompilationUnit(src);
169  
  PrettyPrinterConfiguration ppconf = new PrettyPrinterConfiguration();
170  
  ppconf.setPrintComments(true);
171  
  ppconf.setIndentSize(2);
172  
  ppconf.setIndentType(PrettyPrinterConfiguration.IndentType.SPACES);
173  
  new javaParser_makeAllPublic_Visitor().visit(cu, null);
174  
  return cu.toString(ppconf);
175  
}
176  
177  
static int findCodeTokens(List<String> tok, String... tokens) {
178  
  return findCodeTokens(tok, 1, false, tokens);
179  
}
180  
181  
static int findCodeTokens(List<String> tok, boolean ignoreCase, String... tokens) {
182  
  return findCodeTokens(tok, 1, ignoreCase, tokens);
183  
}
184  
185  
static int findCodeTokens(List<String> tok, int startIdx, boolean ignoreCase, String... tokens) {
186  
  return findCodeTokens(tok, startIdx, ignoreCase, tokens, null);
187  
}
188  
189  
static HashSet<String> findCodeTokens_specials = lithashset("*", "<quoted>", "<id>", "<int>", "\\*");
190  
static int findCodeTokens_bails, findCodeTokens_nonbails;
191  
192  
static interface findCodeTokens_Matcher {
193  
  boolean get(String token);
194  
}
195  
196  
static int findCodeTokens(List<String> tok, int startIdx, boolean ignoreCase, String[] tokens, Object condition) {
197  
  int end = tok.size()-tokens.length*2+2, nTokens = tokens.length;
198  
  int i = startIdx | 1;
199  
200  
  findCodeTokens_Matcher[] matchers = new findCodeTokens_Matcher[nTokens];
201  
  IContentsIndexedList2 indexedList = tok instanceof IContentsIndexedList2 ? (IContentsIndexedList2) tok : null;
202  
  
203  
  
204  
  TreeSet<HasIndex> indices = null;
205  
  int indicesOfs = 0;
206  
207  
  for (int j = 0; j < nTokens; j++) {
208  
    String p = tokens[j];
209  
    findCodeTokens_Matcher matcher;
210  
    if (p.equals("*"))
211  
      matcher = t -> true;
212  
    else if (p.equals("<quoted>"))
213  
      matcher = t -> isQuoted(t);
214  
    else if (p.equals("<id>"))
215  
      matcher = t -> isIdentifier(t);
216  
    else if (p.equals("<int>"))
217  
      matcher = t -> isInteger(t);
218  
    else if (p.equals("\\*"))
219  
      matcher = t -> t.equals("*");
220  
    else if (ignoreCase)
221  
      matcher = t -> eqic(p, t);
222  
    else {
223  
      matcher = t -> t.equals(p);
224  
      if (indexedList != null) {
225  
        TreeSet<HasIndex> indices2 = indexedList.indicesOf_treeSetOfHasIndex(p);
226  
        
227  
        if (indices2 == null) return -1;
228  
        if (indices == null || indices2.size() < indices.size()) {
229  
          // found shorter list
230  
          indices = indices2;
231  
          indicesOfs = j;
232  
        }
233  
      }
234  
    }
235  
    matchers[j] = matcher;
236  
  }
237  
  
238  
  // go over shortest index
239  
  if (indices != null) {
240  
    int min = i+indicesOfs*2;
241  
    SortedSet<HasIndex> tailSet = min == 1 ? indices : indices.tailSet(new HasIndex(min));
242  
    
243  
    outer: for (HasIndex h : tailSet) {
244  
      int idx = h.idx-indicesOfs*2;
245  
      if (idx >= end) break;
246  
      
247  
      for (int j = 0; j < nTokens; j++) try {
248  
        if (!matchers[j].get(tok.get(idx+j*2)))
249  
          continue outer;
250  
      } catch (IndexOutOfBoundsException e) {
251  
        print("fct indicesOfs=" + indicesOfs + ", h=" + h + ", idx=" + idx);
252  
        throw e;
253  
      }
254  
255  
      if (condition == null || checkTokCondition(condition, tok, idx-1))
256  
        return idx;
257  
    }
258  
    return -1;
259  
  }
260  
 
261  
  outer: for (; i < end; i += 2) {
262  
    for (int j = 0; j < nTokens; j++)
263  
      if (!matchers[j].get(tok.get(i+j*2)))
264  
        continue outer;
265  
266  
    if (condition == null || checkTokCondition(condition, tok, i-1)) // pass N index
267  
      return i;
268  
  }
269  
  return -1;
270  
}
271  
static boolean autoQuine = true;
272  
static int maxQuineLength = 80;
273  
static boolean assumeTriple = true;
274  
static boolean quickInstanceOfEnabled = false; // interferes with things
275  
static boolean debug_jreplace = false;
276  
277  
// _registerThread usually costs nothing because we need
278  
// the registerWeakHashMap mechanism anyway for ping().
279  
// Anyway - no forced functions for now :)
280  
static List<String> functionsToAlwaysInclude = ll(
281  
  //"_registerThread",
282  
  //"asRuntimeException"
283  
);
284  
285  
// classes with two type parameters that can written with just one
286  
// e.g. Pair<S> => Pair<S, S>
287  
static Set<String> pairClasses = lithashset("Pair", "Either", "Map", "AbstractMap", "HashMap", "TreeMap", "LinkedHashMap", "MultiMap", "CompactHashMap", "WrappedMap", "F1", "IF1", "AllOnAll", "AllOnAllWithUpdates", "MultiSetMap", "AutoMap", "ValueOnDemandMap", "NavigableMap", "SortedMap");
288  
289  
// classes with 3 type parameters that can written with just one
290  
// e.g. T3<S> => T3<S, S, S>
291  
static Set<String> tripleClasses = lithashset("T3", "IF2", "F2", "IVF3", "VF3");
292  
293  
static String transpilingSnippetID;
294  
//static new AtomicInteger varCount;
295  
static ThreadLocal<AtomicInteger> varCountByThread = new ThreadLocal();
296  
static Map<String, String> snippetCache = syncMap();
297  
static boolean useIndexedList2 = false, useTokenIndexedList = true;
298  
static boolean opt_javaTok = true;
299  
static boolean cacheStdFunctions = true, cacheStdClasses = true;
300  
static HashMap<Long, CachedInclude> cachedIncludes = new HashMap();
301  
static ExecutorService executor;
302  
static List lclasses;
303  
static long startTime, lastPrint;
304  
305  
// These variables have to be cleared manually for each transpilation
306  
307  
static HashSet<Long> included = new HashSet();
308  
static NavigableSet<String> definitions = ciSet();
309  
static HashMap<String, String> rewrites = new HashMap();
310  
static HashSet<String> shouldNotIncludeFunction = new HashSet(); // this verifies after the fact that the function was not included
311  
static HashSet<String> shouldNotIncludeClass = new HashSet();
312  
static HashSet<String> doNotIncludeFunction = new HashSet(); // this actually prevents the function from being included
313  
static Map<String, String> functionToPackage = new HashMap();
314  
static HashSet<String> doNotIncludeClass = new HashSet();
315  
static HashSet<String> needLatest = new HashSet(); // this forces a function to be included
316  
static HashSet<String> addedFunctions = new HashSet();
317  
static HashSet<String> addedClasses = new HashSet();
318  
static HashSet<String> hardFunctionReferences = new HashSet();
319  
static HashSet<String> mapLikeFunctions = new HashSet();
320  
static HashSet<String> lambdaMapLikeFunctions = new HashSet();
321  
static HashSet<String> curry1LikeFunctions = new HashSet();
322  
static HashSet<String> mapMethodLikeFunctions = new HashSet();
323  
static HashSet<String> nuLikeFunctions = new HashSet();
324  
static HashSet<String> getLikeFunctions = new HashSet(); // name is slightly misleading. this turns a pre-argument into a fieldLambda
325  
static HashSet<String> lambdaMethod0LikeFunctions = new HashSet(); // we're getting better again with the names (maybe)
326  
static HashSet<String> lambda0LikeFunctions = new HashSet();
327  
static Map<String, String> extraStandardFunctions;
328  
static boolean quickmainDone1, quickmainDone2;
329  
static TreeSet<String> libs = new TreeSet();
330  
static String mainBaseClass, mainPackage, mainClassName;
331  
static boolean localStuffOnly = false; // for transpiling a fragment
332  
static boolean asInclude = false; // for transpiling an include (auto-close scopes, enable all standard class ifclass [todo])
333  
static boolean allowMetaCode = false; // run any embedded meta code
334  
static List<String> metaPostBlocks, metaTransformers;
335  
static boolean dontPrintSource = false;
336  
static boolean dontLoadCachedIncludesFromVM = false; // for benchmarking
337  
static HashSet<String> haveClasses = new HashSet();
338  
339  
static class CachedInclude {
340  
  String javax;
341  
  Future<String> java;
342  
  String realJava;
343  
  long snippetID;
344  
  
345  
  CachedInclude() {}
346  
  CachedInclude(long snippetID) {
347  
  this.snippetID = snippetID;}
348  
  
349  
  String java() {
350  
    return realJava != null ? realJava : getFuture(java);
351  
  }
352  
  
353  
  Future<String> javaFuture() {
354  
    return realJava != null ? nowFuture(realJava) : java;
355  
  }
356  
  
357  
  void clean() {
358  
    if (java != null) {
359  
      realJava = getFuture(java);
360  
      java = null;
361  
    }
362  
  }
363  
}
364  
365  
public static void main(final String[] args) throws Exception {
366  
  startTime = lastPrint = sysNow();
367  
  try {
368  
    if (!dontLoadCachedIncludesFromVM)
369  
      vmKeepWithProgramMD5_get("cachedIncludes");
370  
  } catch (Throwable __e) { _handleException(__e); }
371  
  executor = Executors.newFixedThreadPool(numberOfCores());
372  
  transpilingSnippetID = or(getThreadLocal((ThreadLocal<String>) getOpt(javax(), "transpilingSnippetID")), transpilingSnippetID);
373  
  //print(+transpilingSnippetID);
374  
  transpileRaw_dontCopyFromCreator = true;
375  
  
376  
  final Object oldPrint = or(print_byThread().get(), "print_raw");
377  
   AutoCloseable __17 = tempInterceptPrint(new F1<String, Boolean>() {
378  
    Boolean get(String s) {
379  
      long now = sysNow();
380  
      long time = now-lastPrint; // -startTime;
381  
      lastPrint = now;
382  
      callF(oldPrint, "[" + formatInt(time/1000, 2) + ":" + formatInt(time % 1000, 3) + "] " + s);
383  
      return false;
384  
    }
385  
  }); try {
386  
  
387  
  try {
388  
    _main();
389  
  } finally {
390  
    interceptPrintInThisThread(oldPrint);
391  
    if (executor != null) executor.shutdown();
392  
    executor = null;
393  
    localStuffOnly = false;
394  
    asInclude = false;
395  
  }
396  
} finally { _close(__17); }}
397  
398  
static void _main() { try {
399  
  if (sameSnippetID(programID(), defaultJavaXTranslatorID())) setDefaultJavaXTranslatorID("#7");
400  
  
401  
  //reTok_modify_check = true;
402  
  //if (useIndexedList) findCodeTokens_debug = true;
403  
  javaTok_opt = opt_javaTok;
404  
  //findCodeTokens_indexed = findCodeTokens_unindexed = 0;
405  
  findCodeTokens_bails = findCodeTokens_nonbails = 0;
406  
  javaTok_n = javaTok_elements = 0;
407  
  String in = loadMainJava();
408  
  
409  
  print("759 STARTING " + identityHashCode(main.class));
410  
  // clear things
411  
  includeInMainLoaded_magicComment = null;
412  
  included.clear();
413  
  definitions.clear();
414  
  rewrites.clear();
415  
  // XXX definitions.add("SymbolAsString");
416  
  shouldNotIncludeFunction.clear();
417  
  shouldNotIncludeClass.clear();
418  
  doNotIncludeFunction.clear();
419  
  functionToPackage.clear();
420  
  needLatest.clear();
421  
  doNotIncludeClass.clear();
422  
  addedFunctions.clear();
423  
  addedClasses.clear();
424  
  hardFunctionReferences.clear();
425  
  mapLikeFunctions = cloneHashSet(tok_mapLikeFunctions());
426  
  lambdaMapLikeFunctions = new HashSet();
427  
  curry1LikeFunctions = new HashSet();
428  
  mapMethodLikeFunctions = cloneHashSet(tok_mapMethodLikeFunctions());
429  
  mapMethodLikeFunctions.add("vmBus_send"); // XXX ???
430  
  nuLikeFunctions.clear();
431  
  getLikeFunctions.clear();
432  
  lambdaMethod0LikeFunctions.clear();
433  
  lambda0LikeFunctions.clear();
434  
  extraStandardFunctions = new HashMap();
435  
  libs.clear();
436  
  mainBaseClass = mainPackage = mainClassName = null;
437  
  varCountByThread.set(null);
438  
  quickmainDone1 = quickmainDone2 = false;
439  
  metaPostBlocks = new ArrayList();
440  
  metaTransformers = new ArrayList();
441  
  dontPrintSource = false;
442  
  defaultMaxQuineLength_value = defaultMaxQuineLength_defaultValue;
443  
  debug_jreplace = false;
444  
  haveClasses.clear();
445  
  
446  
  //L ts = findTranslators(toLines(join(tok)));
447  
  //print("Translators in source at start: " + structure(ts));
448  
  
449  
  List<String> tok = jtok(in);
450  
  
451  
  try {
452  
    tok_definitions(tok);
453  
    
454  
    // add m { }
455  
    
456  
    if (!localStuffOnly && !hasCodeTokens(tok, "m", "{") && !hasCodeTokens(tok, "main", "{") && !hasCodeTokens(tok, "class", "main")) {
457  
      if (l(tok) == 1) tok = singlePlusList(first(tok), dropFirst(javaTok("m {}")));
458  
      else {
459  
        replaceTokens_reTok(tok, 1, 2, "m {\n\n" + unnull(get(tok, 1)));
460  
        replaceTokens_reTok(tok, l(tok)-2, l(tok)-1, unnull(get(tok, l(tok)-2)) + "}");
461  
      }
462  
      tok_moveImportsUp(tok);
463  
    }
464  
    
465  
    // standard translate
466  
    
467  
    //ts = findTranslators(toLines(join(tok)));
468  
    //print("Translators in source: " + structure(ts));
469  
    
470  
    if (tok_hasTranslators(tok))
471  
      tok = jtok(defaultTranslate(join(tok)));
472  
    
473  
    //print("end of default translate");
474  
    //print(join(tok));
475  
  
476  
    //tok_autoCloseBrackets(tok);    
477  
    
478  
    tok_metaTransformNow(tok);
479  
    
480  
    tok_processEarlyIncludes(tok);
481  
      
482  
    tok_earlyGeneralStuff(tok);
483  
    
484  
    tok = tok_processIncludes(tok); // before standard functions
485  
    if (processConceptsDot(tok))
486  
      tok = tok_processIncludes(tok);
487  
    tok = localStuff1(tok);
488  
    
489  
   if (!localStuffOnly) {
490  
    int safety = 0;
491  
    boolean same = false;
492  
    do { // BIG LOOP
493  
      ping();
494  
      List<String> before = cloneList(tok);
495  
      
496  
      // do the non-local stuff (flags and rewrites, things that correlate across includes like tok_selfType)
497  
      
498  
      // to allow crazy stuff like "nonStatic !include #someStaticClass"
499  
      tok_processEarlyIncludes(tok);
500  
      
501  
      jreplace(tok, "nonStatic static", "");
502  
      
503  
      tok_selfType(tok);
504  
      tok_mainClassNameAndPackage(tok);
505  
      tok_definitions(tok);
506  
      tok_ifndef(tok);
507  
      tok_ifdef(tok);
508  
      defineMapLikesEtc(tok);
509  
      if (tok_applyAllXLikeFunctions(tok)) {
510  
        functionReferences(tok);
511  
        lambdaReferences(tok);
512  
      }
513  
      
514  
      tok_dropExtraCommas(tok); // from e.g. tok_applyMapMethodLikeFunctions
515  
      tok_delegateTo(tok);
516  
      tok_replaceWith(tok);
517  
      tok_findAndClearRewrites(tok);
518  
      tok_processRewrites(tok);
519  
      
520  
      tok_multiTypeArguments_v2(tok);
521  
      
522  
      // main bla(...) => mainClassName.bla(...)
523  
      // or main ClassName => main.ClassName
524  
      //jreplace(tok, "main <id>(", mainClassName() + ".$2(");
525  
      grabImportedStaticFunctions(tok);
526  
      jreplace_dyn_allowNull(tok, "main <id>", (_tok, cIdx, end) -> {
527  
        String fname = _tok.get(cIdx+2);
528  
        boolean isClass = haveClasses.contains(fname);
529  
        printVars("expandMainRef", "fname", fname, "isClass", isClass);
530  
        if (isClass || eqGet(_tok, cIdx+4, "(")) {
531  
          String pkg = functionToPackage.get(fname);
532  
          printVars("expandMainRef", "pkg", pkg);
533  
          String call = "." + fname;
534  
          return or(pkg, mainClassName()) + call;
535  
        }
536  
        return null;
537  
      });
538  
      
539  
      try {
540  
        if (safety == 0) tok = quickmain(tok);
541  
      } catch (Throwable e) {
542  
        printSources(tok);
543  
        rethrow(e);
544  
      }
545  
      tok_collectMetaPostBlocks(tok, metaPostBlocks);
546  
      tok_collectTransformers(tok, metaTransformers);
547  
      tok_metaTransformNow(tok);
548  
      
549  
      // Hack to allow DynModule to reimplement _registerThread
550  
      /*if (tok.contains("DynModule") && !addedClasses.contains("DynModule"))
551  
        addStandardClasses_v2(tok);*/
552  
      
553  
      defineExtraSF(tok);
554  
      tok = standardFunctions(tok);
555  
      tok = stdstuff(tok); // all the keywords, standard
556  
      String diff;
557  
      long startTime = now();
558  
      //diff = unidiff(before, join(tok));
559  
      //print("unidiff: " + (now()-startTime) + " ms");
560  
      //same = eq(diff, "");
561  
      same = eq(tok, before);
562  
      if (!same) {
563  
        print("Not same " + safety + ".");
564  
        //print(indent(2, diff));
565  
      }
566  
      if (safety++ >= 10) {
567  
        //print(unidiff(before, join(tok)));
568  
        printSources(tok);
569  
        throw fail("safety 10 error!");
570  
      }
571  
    } while (!same); // END OF BIG LOOP
572  
    
573  
    print("Post.");
574  
    
575  
    if (mainBaseClass != null) {
576  
      jreplace1(tok, "class main", "class main extends " + mainBaseClass);
577  
      mainBaseClass = null;
578  
    }
579  
    
580  
    print("moveImportsUp"); tok_moveImportsUp(tok);
581  
    
582  
    print("Indexing"); tok = indexTokenList(tok);
583  
    
584  
    // POST-PROCESSING after stdstuff loop
585  
    
586  
    if (transpilingSnippetID != null)
587  
      jreplace_dyn(tok, "class whatever", 
588  
        new F2<List<String>, Integer, String>() { public String get(List<String> tok, Integer cIndex) { try { 
589  
          try { return "class " + stringToLegalIdentifier(getSnippetTitle(transpilingSnippetID)); } catch (Throwable __e) { _handleException(__e); }
590  
          return "class Whatever";
591  
         } catch (Exception __e) { throw rethrow(__e); } }
592  
  public String toString() { return "pcall { ret \"class \" + stringToLegalIdentifier(getSnippetTitle(transpilingSni..."; }});
593  
    
594  
    //print("Type<A, A>"); // Type<A> to Type<A, A>
595  
    
596  
    print("extendClasses"); tok = extendClasses(tok);
597  
    print("libs"); libs(tok);
598  
    print("sourceCodeLine"); sourceCodeLine(tok);
599  
    
600  
    tok_overridableFunctionDefs(tok, null);
601  
    
602  
    // escaping for lambdas
603  
    //jreplace(tok, "-=>", "->");
604  
  
605  
    // Stuff that depends on the list of inner classes (haveClasses)
606  
    haveClasses = haveClasses_actual(tok);
607  
    print("innerClassesVar"); innerClassesVar(tok, haveClasses);
608  
    fillVar_transpilationDate(tok);
609  
    haveClasses_addImported(tok, haveClasses);
610  
    print("ifclass"); tok_ifclass(tok, haveClasses);
611  
    
612  
    print("slashCasts"); slashCasts(tok, haveClasses);
613  
    print("newWithoutNew"); newWithoutNew(tok, haveClasses);
614  
    
615  
    if (!assumeTriple) {
616  
      print("Triple");
617  
      if (tok.contains("Triple") && !haveClasses.contains("Triple")) {
618  
        jreplace(tok, "Triple", "T3");
619  
        haveClasses.remove("Triple");
620  
        haveClasses.add("T3");
621  
        slashCasts(tok, lithashset("T3"));
622  
        tok_quickInstanceOf(tok, lithashset("T3"));
623  
      }
624  
    }
625  
    
626  
    if (hasDef("SymbolAsString"))
627  
      jreplace(tok, "Symbol", "String");
628  
  
629  
    // using non-lazy version now for cleanImports
630  
    print("classReferences"); expandClassReferences/*_lazy*/(tok, haveClasses);
631  
    
632  
    if (metaCodeAllowed()) runMetaPostBlocks(tok);
633  
634  
    // Error-checking
635  
    print("Error-checking"); 
636  
    Set<String> functions = new HashSet(findFunctions(tok));
637  
    for (String f : hardFunctionReferences)
638  
      if (!functions.contains(f))
639  
        throw fail("Function " + f + " requested, but not supplied");
640  
  
641  
    print("autoImports"); tok = autoImports(tok); // faster to do it at the end
642  
    
643  
    if (hasDef("cleanImports"))
644  
      tok_cleanImports(tok);
645  
    
646  
    if (includeInMainLoaded_magicComment != null) {
647  
      int i = lastIndexOfStartingWith(tok, includeInMainLoaded_magicComment);
648  
      if (i >= 0) tok.set(i, dropPrefix(includeInMainLoaded_magicComment, tok.get(i)));
649  
    }
650  
651  
    print("definitions=" + sfu(definitions));
652  
    if (containsOneOf(definitions, "allpublic", "reparse", "PublicExceptTopClass")) {
653  
      // Fire up the Java parser & pretty printer!
654  
      print(containsIC(definitions, "allpublic")? "Making all public." : "Reparsing.");
655  
      //try {
656  
        String src = join(tok);
657  
        try {
658  
          if (containsIC(definitions, "allpublic"))
659  
            src = javaParser_makeAllPublic(src);
660  
          else if (containsIC(definitions, "PublicExceptTopClass"))
661  
            src = javaParser_makeAllPublic(src, "notTopLevelClassDecl" , true);
662  
          else if (containsIC(definitions, "keepComments"))
663  
            src = javaParser_makeAllPublic_keepComments(src);
664  
          else {
665  
            print("javaParser_reparse_keepComments. size=" + l(src));
666  
            src = javaParser_reparse_keepComments(src);
667  
            print("size=" + l(src));
668  
          }
669  
        } catch (Throwable e) {
670  
          String _src = src;
671  
          String errorContext = extractAndPrintJavaParseError(_src, e);
672  
          File f = transpilerErrorSourceFile();
673  
          saveTextFileVerbose(f, src);
674  
          dontPrintSource = true;
675  
          throw fail("Java parsing error:" + errorContext + innerMessage(e)); // drop the long nested parser stacktraces
676  
        }
677  
        tok = jtok(src);
678  
      /*} catch e {
679  
        S src = join(tok);
680  
        if (!dontPrintSource)
681  
          print(src);
682  
        print(f2s(saveProgramTextFile("error.java", src)));
683  
        throw rethrow(e);
684  
      }*/
685  
    }
686  
    
687  
    // Do this after JavaParser (because it doesn't like package after class)
688  
    
689  
    if (mainPackage != null) {
690  
      print("mainPackage");
691  
      tokPrepend(tok, 1, "package " + mainPackage + ";\n");
692  
      reTok(tok, 1, 2);
693  
    }
694  
    
695  
    if (mainClassName != null) {
696  
      print("mainClassName");
697  
      jreplace(tok, "class main", "class " + mainClassName);
698  
      jreplace(tok, "main.class", mainClassName + ".class");
699  
      //tokPrepend(tok, 1, "class main {}\n"); // so main.class is generated and compiler sanity checks succeed. we can later skip it in the JavaXClassLoader
700  
    }
701  
    
702  
    if (nempty(libs)) {
703  
      print("Adding libs: " + libs);
704  
      tok.add(concatMap_strings(new F1<String, String>() { public String get(String s) { try {  return "\n!" + s;  } catch (Exception __e) { throw rethrow(__e); } }
705  
  public String toString() { return "\"\\n!\" + s"; }}, libs));
706  
    }
707  
   } // if (!localStuffOnly)
708  
  } catch (Throwable e) {
709  
    if (!dontPrintSource)
710  
      printSources(tok);
711  
    String src = join(tok);
712  
    print(f2s(saveProgramTextFile("error.java", src)));
713  
    throw rethrow(e);
714  
  }
715  
  
716  
  /*if (useIndexedList)
717  
    print("Indexed/unindexed lookups: " + findCodeTokens_indexed + "/" + findCodeTokens_unindexed + ", lists made: " + IndexedList2.instances);
718  
  print("findCodeToken bails: " + findCodeTokens_bails + "/" + findCodeTokens_nonbails);
719  
  print("javaToks: " + javaTok_n + "/" + javaTok_elements);*/
720  
  
721  
  print("Saving.");
722  
  
723  
  // for dexcompile.php
724  
  if (mainClassName != null)
725  
    tokPrepend(tok, 0, "//FILENAME: " 
726  
      + (mainPackage != null ? mainPackage.replace(".", "/") + "/" : "") + mainClassName + ".java\n");
727  
    
728  
  if (mainJava != null)
729  
    mainJava = join(tok);
730  
  else if (tok.contains("package"))
731  
    splitJavaFiles(tok);
732  
  else
733  
    saveMainJava(tok);
734  
} catch (Exception __e) { throw rethrow(__e); } }
735  
736  
static List<String> localStuff1(List<String> tok) {
737  
  int safety = 0, i;
738  
  boolean same = false;
739  
  tok = indexTokenList(tok);
740  
  
741  
  tok_scopes(tok, "autoCloseScopes" , true);
742  
    
743  
  do {
744  
    ping();
745  
    List<String> before = cloneList(tok);
746  
    
747  
    //print("localStuff loop " + safety);
748  
    
749  
    earlyStuff(tok);
750  
    
751  
    // EARLY local stuff goes here
752  
    
753  
    tok_dropMetaComments(tok);
754  
    
755  
    tok_earlyGeneralStuff(tok);
756  
    
757  
    conceptDeclarations(tok);
758  
    tok_recordDecls(tok);
759  
    
760  
    tok = multilineStrings(tok);
761  
    tok_singleQuoteIdentifiersToStringConstants(tok);
762  
    tok_inStringEvals(tok);
763  
    tok_listComprehensions(tok);
764  
    
765  
    tok_eventFunctions(tok);
766  
    
767  
    tok_for_single(tok);
768  
    
769  
    tok_for_unpair(tok); // Do this...
770  
    //tok_doubleFor_v2(tok);
771  
    tok_doubleFor_v3(tok); // ...before this
772  
    
773  
    tok_forUnnull(tok);
774  
    tok_ifCast(tok);
775  
    forPing(tok);
776  
    tok_directSnippetRefs(tok);
777  
    quicknu(tok);
778  
    //tok_juxtaposeCalls(tok);
779  
    
780  
    jreplace(tok, "LLS", "L<LS>");
781  
    jreplace(tok, "LS", "L<S>");
782  
    jreplace(tok, "ES", "Ext<S>");
783  
    jreplace(tok, "ExtS", "Ext<S>");
784  
    
785  
    jreplace(tok, "WeakRef", "WeakReference");
786  
    
787  
    jreplace(tok, "dispose <id>;", "{ cleanUp($2); $2 = null; }");
788  
  
789  
    tok_doPing(tok);
790  
      
791  
    replaceKeywordBlock(tok,
792  
      "swing",
793  
      "{ swing(r {",
794  
      "}); }");
795  
      
796  
    replaceKeywordBlock(tok,
797  
      "androidUI",
798  
      "{ androidUI(r {",
799  
      "}); }");
800  
      
801  
    replaceKeywordBlock(tok,
802  
      "withDBLock",
803  
      "{ withDBLock(r {",
804  
      "}); }");
805  
      
806  
    replaceKeywordBlock(tok, "afterwards", "temp tempAfterwards(r {", "});");
807  
      
808  
    for (String keyword : ll("tokcondition", "tokCondition"))
809  
      replaceKeywordBlock(tok,
810  
        keyword,
811  
        "new TokCondition { public bool get(final L<S> tok, final int i) {",
812  
        "}}");
813  
      
814  
    jreplace(tok, "synced <id>", "synchronized $2");
815  
    jreplace(tok, "sync <id>", "synchronized $2");
816  
    
817  
    jreplace(tok, "synchronized {", "synchronized(this) {");
818  
    
819  
    replaceKeywordBlock(tok, "answer",
820  
      "static S answer(S s) {\nfinal new Matches m;\n",
821  
      "\nret null;\n}");
822  
      
823  
    replaceKeywordBlock(tok, "static-pcall",
824  
      "static { pcall {",
825  
      "}}");
826  
      
827  
    replaceKeywordBlock(tok, "loading",
828  
      "{ temp tempShowLoadingAnimation(); ",
829  
      "}");
830  
  
831  
    replaceKeywordPlusQuotedBlock(tok, "loading",
832  
      new Object() { String[] get(List<String> tok, int i) {
833  
        String text = tok.get(i+2);
834  
        return new String[] {
835  
          "{ temp tempShowLoadingAnimation(" + text + "); ",
836  
          "}" };
837  
      }});
838  
      
839  
    while ((i = jfind(tok, "visualize as")) >= 0) {
840  
      int j = tok_findEndOfStatement(tok, i); // expression, rather
841  
      tok.set(i+2, "{ ret");
842  
      tok.set(j-1, "; }");
843  
      reTok(tok, i, j);
844  
    }
845  
      
846  
    for (String pat : ll("visual {", "visualize {"))
847  
      jreplace(tok, pat, "public JComponent visualize() {", tokCondition_beginningOfMethodDeclaration());
848  
  
849  
    jreplace(tok, "visualize2 {", "JComponent visualize2() {", tokCondition_beginningOfMethodDeclaration());
850  
    
851  
    replaceKeywordBlock(tok, "start-thread-printDone", "start-thread {", "printDone(); }");
852  
853  
    replaceKeywordBlock(tok, "start-thread", "start { thread \"Start\" { temp enter(); pcall {", "}}}");
854  
    
855  
    jreplace(tok, "start {", "void start() ctex { super.start();", tokCondition_beginningOfMethodDeclaration());
856  
    
857  
    var notVoidMethod = new TokCondition() { public boolean get(final List<String> tok, final int i) {
858  
      return neqGet(tok, i-1, "void");
859  
    }};
860  
    
861  
    // run { ... } => public void run() { ... }
862  
    // same with close
863  
    jreplace(tok, "run {", "public void run() {", notVoidMethod);
864  
    jreplace(tok, "close {", "public void close() {", notVoidMethod);
865  
    
866  
    replaceKeywordBlock(tok, "html",
867  
      "static O html(S uri, fMap<S, S> params) ctex " + "{\n", "}");
868  
    
869  
    replaceKeywordBlock(tok, "afterVisualize",
870  
      "visualize { JComponent _c = super.visualize();",
871  
      "ret _c; }");
872  
    
873  
    replaceKeywordBlock(tok, "enhanceFrame",
874  
      "void enhanceFrame(Container f) { super.enhanceFrame(f);",
875  
      "}");
876  
    
877  
    if (assumeTriple)
878  
      jreplace(tok, "Triple", "T3");
879  
880  
    tok_shortFinals(tok);
881  
    
882  
    tok_moduleClassDecls(tok);
883  
884  
    jreplace(tok, "static sync", "static synchronized");
885  
    jreplace(tok, "sclass", "static class");
886  
    jreplace(tok, "fclass", "final class");
887  
    jreplace(tok, "fsclass", "final static class");
888  
    jreplace(tok, "srecord", "static record");
889  
    jreplace(tok, "strecord", "static transformable record");
890  
    jreplace(tok, "record noeq", "noeq record");
891  
    jreplace(tok, "asclass", "abstract static class");
892  
    jreplace(tok, "sinterface", "static interface");
893  
    jreplace(tok, "ssynchronized", "static synchronized");
894  
  
895  
    jreplace(tok, "ssvoid", "static synchronized void");
896  
    jreplace(tok, "sbool", "static bool");
897  
    jreplace(tok, "fbool", "final bool");
898  
    jreplace(tok, "sint", "static int");
899  
    jreplace(tok, "snew", "static new");
900  
    jreplace(tok, "sv <id>", "static void $2");
901  
    jreplace(tok, "pvoid", "public void");
902  
  
903  
    // "sS" => static S
904  
    jreplace(tok, "sS", "static S");
905  
  
906  
    // "sO" => static O
907  
    jreplace(tok, "sO", "static O");
908  
  
909  
    // "sL" => static L
910  
    jreplace(tok, "sL", "static L");
911  
  
912  
    // "toString {" => "public S toString() {"
913  
    jreplace(tok, "toString {", "public S toString() {");
914  
    
915  
    jreplace(tok, "Int", "Integer");
916  
    jreplace(tok, "Bool", "Boolean");
917  
    jreplace(tok, "BigInt", "BigInteger");
918  
    jreplace(tok, "Char", "Character");
919  
    
920  
    jreplace(tok, "Sym", "Symbol");
921  
    jreplace(tok, "SymSym", "SymbolSymbol");
922  
    
923  
    jreplace(tok, "SS", "Map<S>");
924  
    jreplace(tok, "SymbolSymbol", "Map<Symbol>");
925  
    
926  
    jreplace(tok, "MapSO", "Map<S, O>");
927  
    
928  
    jreplace(tok, "ByName<", "IF1<S, ");
929  
    
930  
    jreplace(tok, "ITransform<<id>>", "IF1<$3>");
931  
    jreplace(tok, "ITransform", "IF1");
932  
    
933  
    jreplace(tok, "PairS", "Pair<S>");
934  
    jreplace(tok, "LPairS", "L<Pair<S>>");
935  
    
936  
    jreplace(tok, "T3S", "T3<S>");
937  
    jreplace(tok, "F1S", "F1<S>");
938  
    
939  
    jreplace(tok, "ItIt", "IterableIterator");
940  
    jreplace(tok, "CloseableItIt", "CloseableIterableIterator");
941  
942  
    jreplace(tok, "class <id> > <id>", "class $2 extends $4", new TokCondition() { public boolean get(final List<String> tok, final int i) {
943  
      String t = _get(tok, i+1+4*2);
944  
      return eq(t, "{") || isIdentifier(t);
945  
    }});
946  
    jreplace(tok, "class <id> > <id><<id>> {", "class $2 extends $4  $5 $6 $7 {");
947  
    
948  
    jreplace(tok, "ISegmenter", "IF1<BufferedImage, L<Rect>>");
949  
    
950  
    // IPred<A, B> => IF2<A, B, Bool>
951  
    jreplace(tok, "IPred<<id>, <id>>", "IF2<$3, $5, Bool>");
952  
    
953  
    // IPred<A> => IF1<A, Bool>
954  
    jreplace(tok, "IPred<<id>>", "IF1<$3, Bool>");
955  
    jreplace(tok, "IPred<<id>[]>", "IF1<$3[], Bool>");
956  
    
957  
    // Proposition => WithReasoning<S> (should we really define this?)
958  
    jreplace(tok, "Proposition", "WithReasoning<S>");
959  
    
960  
    replaceKeywordBlock(tok, "print exceptions",
961  
      "{ try {",
962  
      "} on fail __e { printStackTrace(__e); } }");
963  
    
964  
    // "on fail {" => "catch (Throwable _e) { ... rethrow(_e); }"
965  
    replaceKeywordBlock(tok, "on fail",
966  
      "catch (Throwable _e) {",
967  
      "\nthrow rethrow(_e); }");
968  
  
969  
    // "on fail e {" => "catch (Throwable e) { ... rethrow(e); }"
970  
    replaceKeywordBlock_dyn2_legacy(tok, "on fail <id>", new Object() {
971  
      String[] get(List<String> tok, int iOpening, int iClosing) {
972  
        String var = tok.get(iOpening-2);
973  
        return new String[] {
974  
          "catch (Throwable " + var + ") {",
975  
          "\nthrow rethrow(" + var + "); }"
976  
        };
977  
      }
978  
    });
979  
980  
    // "on fail Type e {" => "catch (Type e) { ... rethrow(e); }"
981  
    replaceKeywordBlock_dyn2_legacy(tok, "on fail <id> <id>", new Object() {
982  
      String[] get(List<String> tok, int iOpening, int iClosing) {
983  
        String type = tok.get(iOpening-4);
984  
        String var = tok.get(iOpening-2);
985  
        return new String[] {
986  
          "catch (" + type + " " + var + ") {",
987  
          "\nthrow " + var + "; }"
988  
        };
989  
      }
990  
    });
991  
992  
    // "catch {" => "catch (Throwable _e) {"
993  
    jreplace(tok, "catch {", "catch (Throwable _e) {");
994  
  
995  
    // "catch print e {" => "catch e { _handleException(e); "
996  
    jreplace(tok, "catch print <id> {", "catch $3 { _handleException($3);");
997  
  
998  
    // "catch print short e {" => "catch e { printExceptionShort(e); "
999  
    jreplace(tok, "catch print short <id> {", "catch $4 { printExceptionShort($4);");
1000  
    
1001  
    // "catch X e {" => "catch (X e) {"
1002  
    jreplace(tok, "catch <id> <id> {", "catch ($2 $3) {");
1003  
  
1004  
    // "catch e {" => "catch (Throwable e) {" (if e is lowercase)
1005  
    jreplace(tok, "catch <id> {", "catch (Throwable $2) {", new TokCondition() { public boolean get(final List<String> tok, final int i) {
1006  
      String word = tok.get(i+3);
1007  
      return startsWithLowerCaseOrUnderscore(word);
1008  
    }});
1009  
    
1010  
    jreplace(tok, "+ +", "+", new TokCondition() { public boolean get(final List<String> tok, final int i) {
1011  
      //printStructure("++: ", subList(tok, i-1, i+6));
1012  
      if (empty(_get(tok, i+2))) return false; // no space between the pluses
1013  
      if (empty(_get(tok, i)) && eq("+", _get(tok, i-1))) return false;  // an actual "++" at the left
1014  
      if (empty(_get(tok, i+4)) && eq("+", _get(tok, i+5))) return false;  // an actual "++" at the right
1015  
      //print("doing it");
1016  
      return true;
1017  
    }});
1018  
  
1019  
    // single underscore (not allowed in Java anymore) to double underscore
1020  
    jreplace(tok, "_", "__");
1021  
    
1022  
    // [stdEq] -> implementation of equals() and hashCode()
1023  
    jreplace(tok, "[stdEq]",
1024  
      "public bool equals(O o) { ret stdEq2(this, o); }\n" +
1025  
      "public int hashCode() { ret stdHash2(this); }");
1026  
    
1027  
    // [stdToString] -> toString { ret stdToString(this); }
1028  
    jreplace(tok, "[stdToString]",
1029  
      "toString { ret stdToString(this); }");
1030  
    
1031  
    // [concepts] "concept.field!" for dereferencing references
1032  
    
1033  
    // "<id>!", "?!" etc.
1034  
    jreplace(tok, "*!", "$1.get()", new TokCondition() { public boolean get(final List<String> tok, final int i) {
1035  
      String l = tok.get(i+1);
1036  
      if (!(isIdentifier(l) || eqOneOf(l, ")", "?"))) return false;
1037  
      if (tok.get(i+2).contains("\n")) return false; // no line break between <id> and !
1038  
      if (nempty(tok.get(i+4))) return true; // space after = ok
1039  
      String t = _get(tok, i+5);
1040  
      if (t == null) return false;
1041  
      if (isIdentifier(t) || eqOneOf(t, "=", "(")) return false;
1042  
      return true;
1043  
    }});
1044  
    
1045  
    jreplace(tok, "for (<id> :", "for (var $3 :");
1046  
    
1047  
    jreplace(tok, "for (<id> <id>)", "for ($3 $4 : list($3))");
1048  
    jreplace(tok, "for (final <id> <id>)", "for (final $4 $5 : list($4))");
1049  
1050  
    jreplace(tok, "ret", "return", new TokCondition() { public boolean get(final List<String> tok, final int i) {
1051  
      if (eqGetOneOf(tok, i-1, "int", "return")) return false;
1052  
      String next = _get(tok, i+3);
1053  
      if (eq(next, ".")) return isInteger(_get(tok, i+5)); // e.g. "ret .1", but not "ret.bla"
1054  
      return !eqOneOf(next, "=", ")");
1055  
    }});
1056  
    
1057  
    // "continue unless", "break unless"
1058  
    
1059  
    for (String phrase : ll("continue unless", "break unless"))
1060  
      while ((i = jfind(tok, phrase)) >= 0) {
1061  
        String keyword = tok.get(i);
1062  
        int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
1063  
        replaceTokens(tok, i, i+4, "{ if (!(");
1064  
        tok.set(j, ")) " + keyword + "; }");
1065  
        reTok(tok, i, j+1);
1066  
      }
1067  
    
1068  
    // S s = bla(), return if null; => S s = bla(); if (s == null) return;
1069  
    // same with continue, break
1070  
    while ((i = jfind(tok, ", <id> if null;", new TokCondition() { public boolean get(final List<String> tok, final int i) {
1071  
      return eqOneOf(tok.get(i+3), "return", "ret", "continue", "break");
1072  
    }})) >= 0) {
1073  
      String cmd = tok.get(i+2);
1074  
      int j = tok_findBeginningOfStatement(tok, i);
1075  
      print("Found statement " + j + "/" + i + " - " + joinSubList(tok, j-1, i+5*2-1));
1076  
      String var = getVarDeclarationName(subList(tok, j-1, i));
1077  
      replaceTokens_reTok(tok, i, i+5*2-1, "; if (" + var + " == null) " + cmd + ";");
1078  
    }
1079  
    
1080  
    // S s = bla(), return false if null; => S s = bla(); if (s == null) return false;
1081  
    // (with false being any identifier)
1082  
    while ((i = jfind(tok, ", return <id> if null;")) >= 0) {
1083  
      String returnValue = tok.get(i+4);
1084  
      int j = tok_findBeginningOfStatement(tok, i);
1085  
      String var = getVarDeclarationName(subList(tok, j-1, i));
1086  
      replaceTokens_reTok(tok, i, i+6*2-1, "; if (" + var + " == null) return " + returnValue + ";");
1087  
    }
1088  
    
1089  
    // "continue if", "break if"
1090  
    
1091  
    for (String phrase : ll("continue if", "break if"))
1092  
      while ((i = jfind(tok, phrase)) >= 0) {
1093  
        String keyword = tok.get(i);
1094  
        int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
1095  
        replaceTokens(tok, i, i+4, "{ if (");
1096  
        tok.set(j, ") " + keyword + "; }");
1097  
        reTok(tok, i, j+1);
1098  
      }
1099  
    
1100  
    // return unless set <var>; => { if (var) return; set var; }
1101  
    jreplace(tok, "return unless set <id>;", "{ if ($4) return; set $4; }");
1102  
1103  
    // set x; => x = true;
1104  
    // yeah it doesn't save many characters, but I like it
1105  
    jreplace(tok, "set <id>;", "$2 = true;", new TokCondition() { public boolean get(final List<String> tok, final int i) {
1106  
      return !eqGet(tok, i-1, "unless");
1107  
    }});
1108  
    
1109  
    // set !x; => x = false; (did this one day and thought yes it makes sense in a way)
1110  
    jreplace(tok, "set !<id>;", "$3 = false;");
1111  
    
1112  
    // unset x; => x = false;
1113  
    jreplace(tok, "unset <id>;", "$2 = false;");
1114  
    
1115  
    // "return if"
1116  
    
1117  
    while ((i = jfind(tok, "return if")) >= 0) {
1118  
      int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
1119  
      replaceTokens(tok, i, i+4, "{ if (");
1120  
      tok.set(j, ") return; }");
1121  
      reTok(tok, i, j+1);
1122  
    }
1123  
    
1124  
    // "return unless"
1125  
    
1126  
    while ((i = jfind(tok, "return unless")) >= 0) {
1127  
      int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
1128  
      replaceTokens(tok, i, i+4, "{ if (!(");
1129  
      tok.set(j, ")) return; }");
1130  
      reTok(tok, i, j+1);
1131  
    }
1132  
    
1133  
    tok_ifNullAssign(tok);
1134  
1135  
    // "return <id> if"
1136  
    
1137  
    // "return with <statement>" / "continue with <statement>" / "break with <statement>"
1138  
    
1139  
    while ((i = jfind(tok, "<id> with", new TokCondition() { public boolean get(final List<String> tok, final int i) { return eqOneOf(tok.get(i+1), "return", "continue", "break"); }})) >= 0) {
1140  
      // XXX int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
1141  
      int j = tok_findEndOfStatement(tok, i+4)-1;
1142  
      //print("Found statement: " + joinSubList(tok, i+4, j+1));
1143  
      tok.set(j, "; " + tok.get(i) + "; }");
1144  
      replaceTokens(tok, i, i+3, "{");
1145  
      reTok(tok, i, j+1);
1146  
    }
1147  
    
1148  
    while ((i = jfind(tok, "return <id> if")) >= 0) {
1149  
      int j = scanOverExpression(tok, getBracketMap(tok), i+4, ";");
1150  
      tok.set(j, ") return " + tok.get(i+2) + "; }");
1151  
      replaceTokens(tok, i, i+6, "{ if (");
1152  
      reTok(tok, i, j+1);
1153  
    }
1154  
    
1155  
    // return "bla" with <statement>
1156  
    
1157  
    while ((i = jfindOneOf(tok,
1158  
      "return <quoted> with", "return <id> with")) >= 0) {
1159  
      String result = tok.get(i+2);
1160  
      int j = scanOverExpression(tok, getBracketMap(tok), i+6, ";");
1161  
      replaceTokens(tok, i, i+5, "{");
1162  
      tok.set(j, "; return " + result + "; }");
1163  
      reTok(tok, i, j+1);
1164  
    }
1165  
    
1166  
    tok_debugStatements(tok);
1167  
1168  
    // while not null (...) / if not null (...)
1169  
    
1170  
    while ((i = jfind_check("not", tok, "<id> not null (", new TokCondition() { public boolean get(final List<String> tok, final int i) {
1171  
      return eqOneOf(_get(tok, i+1), "if", "while");
1172  
    }})) >= 0) {
1173  
      int closingBracket = findEndOfBracketPart(tok, i+6)-1;
1174  
      replaceTokens(tok, i+2, i+6, "(");
1175  
      tok.set(closingBracket, ") != null)");
1176  
      reTok(tok, i, closingBracket+1);
1177  
    }
1178  
    
1179  
    // while null (...) / if null (...)
1180  
    
1181  
    while ((i = jfind_check("null", tok, "<id> null (", new TokCondition() { public boolean get(final List<String> tok, final int i) {
1182  
      return eqOneOf(_get(tok, i+1), "if", "while");
1183  
    }})) >= 0) {
1184  
      int closingBracket = findEndOfBracketPart(tok, i+4)-1;
1185  
      replaceTokens(tok, i+2, i+4, "(");
1186  
      tok.set(closingBracket, ") == null)");
1187  
      reTok(tok, i, closingBracket+1);
1188  
    }
1189  
    
1190  
    // Replace $1 with m.unq(0) etc. - caveat: this blocks identifiers $1, $2, ...
1191  
    for (i = 1; i < l(tok); i += 2) {
1192  
      String s = tok.get(i);
1193  
      if (s.startsWith("$")) {
1194  
        s = substring(s, 1);
1195  
        if (isInteger(s)) {
1196  
          tok.set(i, "m.unq(" + (parseInt(s)-1) + ")");
1197  
          reTok(tok, i);
1198  
        }
1199  
      }
1200  
    }
1201  
  
1202  
    // instanceof trickery
1203  
    
1204  
    jreplace(tok, "is a <id>", "instanceof $3");
1205  
    jreplace(tok, "!<id> instanceof <id>.<id>", "!($2 instanceof $4.$6)");
1206  
    jreplace(tok, "!<id> instanceof <id>", "!($2 instanceof $4)");
1207  
    jreplace(tok, "<id> !instanceof <id>", "!($1 instanceof $4)");
1208  
    
1209  
    // map func1 func2 func3(...) => mapFGH(f func1, f func2, f func3, ...)
1210  
    jreplace(tok, "map <id> <id> <id>(", "mapFGH(f $2, f $3, f $4,");
1211  
1212  
    // map func1 func2(...) => mapFG(f func1, f func2, ...)
1213  
    jreplace(tok, "map <id> <id>(", "mapFG(f $2, f $3,");
1214  
1215  
    // "ref->bla" for dereferencing Concept.Ref or ThreadLocal or other
1216  
    // For lambdas, use SPACES on the left or right of the arrow!
1217  
    //jreplace(tok, "<id> ->", "$1.get().");
1218  
    jreplace(tok, "->", ".get().", new TokCondition() { public boolean get(final List<String> tok, final int i) {
1219  
      return empty(tok.get(i)) // no space on left of arrow
1220  
        && empty(tok.get(i+2)) // no space inside of arrow
1221  
        && empty(tok.get(i+4)) // no space on right of arrow
1222  
        && !eq(_get(tok, i-1), "-"); // i-->0;
1223  
    }});
1224  
    
1225  
    // shortened subconcept declaration (before star constructors!)
1226  
    shortenedSubconcepts(tok);
1227  
    
1228  
    tok_beaConceptDecls(tok);
1229  
    
1230  
    // "case" as a variable name ( => _case)
1231  
    
1232  
    caseAsVariableName(tok);
1233  
    
1234  
    // "do" as a function name ( => dO)
1235  
    
1236  
    tok_doAsMethodName(tok);
1237  
    
1238  
    // "continue" as a function name ( => _continue)
1239  
    continueAsFunctionName(tok);
1240  
    
1241  
    tok_extend(tok);
1242  
    
1243  
    jreplace(tok, "pn {", "p-noconsole {");
1244  
      
1245  
    // Do these BEFORE awt replacement! ("p-awt" contains "awt" token)
1246  
    replaceKeywordBlock(tok, "r-awt", "r { awt {", "}}");
1247  
    if (hasCodeTokens(tok, "p", "-")) tok_p_old(tok);
1248  
1249  
    replaceKeywordBlock(tok, "awt-messagebox", "awt { pcall-messagebox {", "}}");
1250  
    replaceKeywordBlock(tok, "awt", "swingLater(r {", "});");
1251  
  
1252  
    jreplace(tok, "p-android {", "set flag Android. p {");
1253  
      
1254  
    unswing(tok);
1255  
    lockBlocks(tok);
1256  
    tok_switchTo(tok);
1257  
    
1258  
    // trim x;
1259  
    
1260  
    jreplace(tok, "trim <id>;", "$2 = trim($2);");
1261  
  
1262  
    // iterate with index
1263  
  
1264  
    jreplace (tok, "for <id> over <id>:", "for (int $2 = 0; $2 < l($4); $2++)");
1265  
    jreplace (tok, "for <id> backwards over <id>:", "for (int $2 = l($5)-1; $2 >= 0; $2--)");
1266  
    jreplace (tok, "for <id>, <id> <id> over <id>: {", "for (int $2 = 0; $2 < l($7); $2++) { $4 $5 = $7.get($2);");
1267  
    jreplace (tok, "for <id>, <id> <id> backwards over <id>: {", "for (int $2 = l($8)-1; $2 >= 0; $2--) { $4 $5 = $8.get($2);");
1268  
    jreplace (tok, "for <id> to <id>:", "for (int $2 = 0; $2 < $4; $2++)");
1269  
    jreplace (tok, "for <id> to <int>:", "for (int $2 = 0; $2 < $4; $2++)");
1270  
    
1271  
    tok = expandShortTypes(tok);
1272  
      
1273  
    tok_equalsCast(tok);
1274  
    tok_equalsOptCast(tok);
1275  
1276  
    replaceKeywordBlock(tok, "r-thread-messagebox", "r-thread { pcall-messagebox {", "}}");
1277  
    
1278  
    replaceKeywordBlock(tok, "thread-messagebox", "thread { pcall-messagebox {", "}}");
1279  
    
1280  
    jreplace(tok, "rThread {", "r-thread {");
1281  
    jreplace(tok, "rEnterThread {", "rThreadEnter {");
1282  
    jreplace(tok, "rThreadEnter {", "r-thread { temp enter(); ");
1283  
  
1284  
    replaceKeywordBlock(tok, "r-thread", "runnableThread(r {", "})");
1285  
    rNamedThread(tok);
1286  
    
1287  
    // only works in the scope of a DynModule
1288  
    jreplace(tok, "rEnter {", "r { temp enter(); ");
1289  
  
1290  
    replaceKeywordBlock(tok, "r-pcall", "r { pcall {", "}}");
1291  
  
1292  
    replaceKeywordBlock(tok, "r-messagebox", "r { pcall-messagebox {", "}}");
1293  
    
1294  
    jreplace(tok, "r <id> + r <id>", "r { $2(); $5(); }");
1295  
    
1296  
    // runnable and r - now also with automatic toString if enabled
1297  
    for (String keyword : ll("runnable", "r")) {
1298  
      while ((i = jfind(tok, keyword + " {")) >= 0) {
1299  
        int idx = findCodeTokens(tok, i, false, "{");
1300  
        int j = findEndOfBracketPart(tok, idx);
1301  
        List<String> contents = subList(tok, idx+1, j-1);
1302  
        replaceTokens(tok, i, j+1, "new Runnable {"
1303  
          + "  public void run() ctex { " + tok_addSemicolon(contents) + "\n}"
1304  
          + (autoQuine ? tok_autoQuineFunc(contents) : "")
1305  
          + "}");
1306  
        reTok(tok, i, j+1);
1307  
      }
1308  
      
1309  
      while ((i = jfind(tok, keyword + " <quoted> {")) >= 0) {
1310  
        int idx = findCodeTokens(tok, i, false, "{");
1311  
        int j = findEndOfBracketPart(tok, idx);
1312  
        List<String> contents = subList(tok, idx+1, j-1);
1313  
        replaceTokens(tok, i, j+1, "new Runnable {"
1314  
          + "  public void run() ctex { " + tok_addSemicolon(contents) + "\n}"
1315  
          + "  toString { ret " + tok.get(i+2) + "; }"
1316  
          + (autoQuine ? tok_autoQuineFunc(contents, "_shortenedSourceCode") : "")
1317  
          + "}");
1318  
        reTok(tok, i, j+1);
1319  
      }
1320  
    }
1321  
    
1322  
    replaceKeywordBlock(tok,
1323  
      "expectException",
1324  
      "{ bool __ok = false; try {",
1325  
      "} catch { __ok = true; } assertTrue(\"expected exception\", __ok); }");
1326  
      
1327  
    while ((i = tok.indexOf("tex")) >= 0) {
1328  
      tok.set(i, "throws Exception");
1329  
      tok = jtok(tok);
1330  
    }
1331  
    
1332  
    // shorter & smarter whiles
1333  
    
1334  
    jreplace(tok, "while true", "while (true)");
1335  
    jreplace(tok, "while licensed", "while (licensed())");
1336  
    jreplace(tok, "repeat {", "while (licensed()) {");
1337  
    tok_repeatWithSleep(tok);
1338  
    
1339  
    // null; => return null; etc.
1340  
  
1341  
    Object cond = new TokCondition() { public boolean get(final List<String> tok, final int i) {
1342  
      return tok_tokenBeforeLonelyReturnValue(tok, i-1);
1343  
    }};
1344  
    jreplace(tok, "null;", "return null;", cond);
1345  
    jreplace(tok, "false;", "return false;", cond);
1346  
    jreplace(tok, "true;", "return true;", cond);
1347  
    jreplace(tok, "this;", "return this;", cond);
1348  
    
1349  
    // ok <cmd> => ret "OK" with <cmd>
1350  
    jreplace(tok, "ok <id>", "return \"OK\" with $2");
1351  
    replaceKeywordBlock(tok, "ok", "{", " return \"OK\"; }",
1352  
      new F2<List<String>, Integer, Boolean>() { public Boolean get(List<String> _tok, Integer nIdx) { try {  return !eqGetOneOf(_tok, nIdx-1, "void", "svoid");  } catch (Exception __e) { throw rethrow(__e); } }
1353  
  public String toString() { return "!eqGetOneOf(_tok, nIdx-1, \"void\", \"svoid\")"; }});
1354  
  
1355  
    // "myFunction;" instead of "myFunction();" - quite rough
1356  
    // (isolated identifier as function call)
1357  
    cond = new TokCondition() {
1358  
      public boolean get(List<String> tok, int i) {
1359  
        String word = tok.get(i+3);
1360  
        //print("single word: " + word);
1361  
        return !eqOneOf(word, "break", "continue", "return", "else", "endifdef", "endif");
1362  
      }
1363  
    };
1364  
    for (String pre : litlist("}", ";"))
1365  
      jreplace(tok, pre + " <id>;", "$1 $2();", cond);
1366  
  
1367  
    // shorter match syntax for answer methods
1368  
    
1369  
    tok_expandIfQuoted(tok);
1370  
    
1371  
    jreplace(tok, "if <id> eq <quoted>", "if (eq($2, $4))");
1372  
  
1373  
    tok_dropExtraCommas(tok);
1374  
    
1375  
    // additional translations (if necessary)
1376  
    
1377  
    jreplace(tok, "pcall ping {", "pcall { ping();");
1378  
    
1379  
    replaceKeywordBlock(tok, ") pcall",
1380  
      ") { pcall {",
1381  
      "}}");
1382  
    
1383  
    //jreplace(tok, "void <id> pcall {", "$1 $2() pcall {");
1384  
    
1385  
    replaceKeywordBlock(tok,
1386  
      "pcall",
1387  
      "try {",
1388  
      "} catch (Throwable __e) { _handleException(__e); }");
1389  
  
1390  
    replaceKeywordBlock(tok,
1391  
      "pcall-print",
1392  
      "try {",
1393  
      "} catch (Throwable __e) { printStackTrace(__e); }");
1394  
  
1395  
    replaceKeywordBlock(tok,
1396  
      "pcall-short",
1397  
      "try {",
1398  
      "} catch (Throwable __e) { print(exceptionToStringShort(__e)); }");
1399  
  
1400  
    replaceKeywordBlock(tok,
1401  
      "pcall-silent",
1402  
      "try {",
1403  
      "} catch (Throwable __e) { silentException(__e); }");
1404  
  
1405  
    replaceKeywordBlock(tok,
1406  
      "pcall-messagebox",
1407  
      "try {",
1408  
      "} catch __e { messageBox(__e); }");
1409  
  
1410  
    replaceKeywordBlock(tok,
1411  
      "pcall-infobox",
1412  
      "try {",
1413  
      "} catch __e { infoBox(__e); }");
1414  
  
1415  
    tok = dialogHandler(tok);
1416  
    
1417  
    replaceKeywordBlock(tok, "exceptionToUser",
1418  
      "try {",
1419  
      "} catch (Throwable __e) { ret exceptionToUser(__e); }"); 
1420  
  
1421  
    if (hasCodeTokens(tok, "twice", "{"))
1422  
      replaceKeywordBlock(tok, "twice",
1423  
        "for (int __twice = 0; __twice < 2; __twice++) {",
1424  
        "}"); 
1425  
  
1426  
    while ((i = findCodeTokens(tok, "bench", "*", "{")) >= 0) {
1427  
      int j = findEndOfBracketPart(tok, i+4)-1;
1428  
      String time = makeVar("time");
1429  
      String v = makeVar("bench");
1430  
      String n = tok.get(i+2);
1431  
      tok.set(i, "{ long " + time + " = sysNow(); for (int " + v + " = 0; " + v + " < " + n + "; " + v + "++)");
1432  
      tok.set(i+2, "");
1433  
      tok.set(j, "} printBenchResult(sysNow()-" + time + ", " + n + "); }");
1434  
      reTok(tok, i, j+1);
1435  
    }
1436  
  
1437  
    replaceKeywordBlockDyn(tok,
1438  
      "time",
1439  
      new Object() { String[] get() {
1440  
        String var = makeVar("startTime");
1441  
        return new String[] {
1442  
          "{ long " + var + " = sysNow(); try { ",
1443  
          "} finally { " + var + " = sysNow()-" + var + "; saveTiming(" + var + "); } }"};
1444  
      }});
1445  
    
1446  
    // version without { }
1447  
    replaceKeywordBlockDyn(tok,
1448  
      "time2",
1449  
      new Object() { String[] get() {
1450  
        String var = makeVar("startTime");
1451  
        return new String[] {
1452  
          "long " + var + " = sysNow(); ",
1453  
          " " + var + " = sysNow()-" + var + "; saveTiming(" + var + "); "};
1454  
      }});
1455  
    
1456  
    // time "bla" {
1457  
    // time msg {
1458  
    replaceKeywordPlusQuotedOrIDBlock(tok,
1459  
      "time",
1460  
      new Object() { String[] get(List<String> tok, int i) {
1461  
        String var = makeVar("startTime");
1462  
        return new String[] {
1463  
          "long " + var + " = sysNow(); ",
1464  
          " done2_always(" + tok.get(i+2) + ", " + var + "); "};
1465  
      }});
1466  
    
1467  
    if (hasCodeTokens(tok, "assertFail", "{")) {
1468  
      String var = makeVar("oops");
1469  
      
1470  
      replaceKeywordBlock(tok,
1471  
        "assertFail",
1472  
        "boolean " + var + " = false; try {",
1473  
        "\n" + var + " = true; } catch (Exception e) { /* ok */ } assertFalse(" + var + ");"); 
1474  
    }
1475  
    
1476  
    replaceKeywordBlock(tok,
1477  
      "yo",
1478  
      "try {",
1479  
      "} catch (Exception " + makeVar("e") + ") { ret false; }",
1480  
      new TokCondition() { public boolean get(final List<String> tok, final int i) {
1481  
        return neqOneOf(_get(tok, i-1), "svoid", "void");
1482  
      }});
1483  
  
1484  
    replaceKeywordBlock(tok,
1485  
      "awtIfNecessary",
1486  
      "swingNowOrLater(r " + "{",
1487  
      "});");
1488  
      
1489  
    ctex(tok);
1490  
      
1491  
    replaceKeywordBlock(tok,
1492  
      "actionListener",
1493  
      "new java.awt.event.ActionListener() { " +
1494  
        "public void actionPerformed(java.awt.event.ActionEvent _evt) { pcall-messagebox {",
1495  
      "}}}");
1496  
      
1497  
    for (String keyword : ll("autocloseable", "autoCloseable"))
1498  
      /*replaceKeywordBlock(tok,
1499  
        keyword,
1500  
        "new AutoCloseable() { public void close() throws Exception {",
1501  
        "}}");*/
1502  
        replaceKeywordBlock_dyn2_legacy(tok, keyword, new Object() {
1503  
          String[] get(List<String> tok, int iOpening, int iClosing) {
1504  
            List<String> contents = subList(tok, iOpening+1, iClosing);
1505  
            return new String[] {
1506  
              "new AutoCloseable() { toString { ret " + quote(shorten(defaultMaxQuineLength(), trimJoin(contents))) + "; } public void close() throws Exception {",
1507  
              "}}"
1508  
            };
1509  
          }
1510  
        });
1511  
      
1512  
    // try answer (string, test with nempty)
1513  
    while ((i = findCodeTokens(tok, "try", "answer")) >= 0) {
1514  
      int j = findEndOfStatement(tok, i);
1515  
      String v = makeVar();
1516  
      boolean needCurly = !eqGet(tok, i-2, "{");
1517  
      tok.set(i, (needCurly ? "{" : "") + " S " + v);
1518  
      tok.set(i+2, "=");
1519  
      tok.set(j-1, "; if (!empty(" + v + ")) ret " + v + "; " + (needCurly ? "}" : ""));
1520  
      reTok(tok, i, j);
1521  
    }
1522  
  
1523  
    // try bool[ean] (try answer with Bool type)
1524  
    while ((i = findCodeTokens(tok, "try", "boolean")) >= 0) {
1525  
      int j = findEndOfStatement(tok, i);
1526  
      String v = makeVar();
1527  
      tok.set(i, "{ Bool " + v);
1528  
      tok.set(i+2, "=");
1529  
      tok.set(j-1, "; if (" + v + " != null) ret " + v + "; }");
1530  
      reTok(tok, i, j);
1531  
    }
1532  
    
1533  
    // <statement>, print "..."; => { <statement>; print("..."); }
1534  
    while ((i = jfind(tok, ", print <quoted>;")) >= 0) {
1535  
      int j = tok_findBeginningOfStatement(tok, i);
1536  
      replaceTokens_reTok(tok, i, i+4*2-1, "; print(" + tok.get(i+4) + "); }");
1537  
      tokPrepend_reTok(tok, j, "{ ");
1538  
    }
1539  
    
1540  
    // return if null <expression> => if (<expression> == null) return;
1541  
    while ((i = jfind(tok, "return if null")) >= 0) {
1542  
      int j = findEndOfStatement(tok, i);
1543  
      clearTokens(tok, i, i+2);
1544  
      tok.set(i+4, "((");
1545  
      tok.set(j-1, ") == null) ret;");
1546  
      reTok(tok, i, j);
1547  
    }
1548  
    
1549  
    // return optional (return if not null)
1550  
    while ((i = jfind_check("optional", tok, "return optional <id> =")) >= 0) {
1551  
      int j = findEndOfStatement(tok, i);
1552  
      String v = tok.get(i+4);
1553  
      clearTokens(tok, i+2, i+4);
1554  
      tok.set(i, "{");
1555  
      tok.set(j-1, "; if (" + v + " != null) ret " + v + "; }");
1556  
      reTok(tok, i, j);
1557  
    }
1558  
    
1559  
    // try object (return if not null)
1560  
    
1561  
    jreplace_dyn(tok, "try object (<id>)", (_tok, cIdx) -> {
1562  
      String type = _tok.get(cIdx+6);
1563  
      return "try object " + type + " " + makeVar() + " = (" + type + ")";
1564  
    });
1565  
    
1566  
    while ((i = jfind_check("object", tok, "try object")) >= 0) {
1567  
      int j = findEndOfStatement(tok, i);
1568  
      clearTokens(tok, i, i+3);
1569  
      boolean isDecl = isIdentifier(get(tok, i+4)) && isIdentifier(get(tok, i+6)) && eqGet(tok, i+8, "=");
1570  
      if (isDecl) {
1571  
        String v = get(tok, i+6);
1572  
        tok.set(i, "{");
1573  
        tok.set(j-1, "; if (" + v + " != null) ret " + v + "; }");
1574  
      } else {
1575  
        String v = makeVar();
1576  
        tok.set(i, "{ O " + v + "=");
1577  
        tok.set(j-1, "; if (" + v + " != null) ret " + v + "; }");
1578  
      }
1579  
      reTok(tok, i, j);
1580  
    }
1581  
    
1582  
    // try Int i = ...; (return if not null, shorter version of "try object")
1583  
    /*while ((i = jfind(tok, "try <id> <id> =")) >= 0) {
1584  
      int j = findEndOfStatement(tok, i);
1585  
      S type = tok.get(i+2), v = tok.get(i+4);
1586  
      tok.set(i, "{");
1587  
      tok.set(j-1, "; if (" + v + " != null) ret " + v + "; }");
1588  
      reTok(tok, i, j);
1589  
    }*/
1590  
    while ((i = jfind(tok, "try <id>")) >= 0) {
1591  
      int iType = i+2, iVar = tok_findEndOfType(tok, iType);
1592  
      String v = tok.get(iVar);
1593  
      assertEquals("try object", "=", get(tok, iVar+2));
1594  
      int j = findEndOfStatement(tok, iVar);
1595  
      tok.set(i, "{");
1596  
      tok.set(j-1, "; if (" + v + " != null) ret " + v + "; }");
1597  
      reTok(tok, i, j);
1598  
    }
1599  
    
1600  
    // debug print ...; => if (debug) print(...);
1601  
    while ((i = jfind(tok, "debug print")) >= 0) {
1602  
      int j = findEndOfStatement(tok, i);
1603  
      replaceTokens(tok, i, i+4, "if (debug) print(");
1604  
      tok.set(j-1, ");");
1605  
      reTok(tok, i, j);
1606  
    }
1607  
    
1608  
    functionReferences(tok);
1609  
    tok_expandLPair(tok);
1610  
    tok_expandPairL(tok);
1611  
    tok_expandLT3(tok);
1612  
    tok_quicknew2(tok);
1613  
    
1614  
    // before temp blocks
1615  
    tok_varNamedLikeFunction(tok);
1616  
    
1617  
    tempBlocks(tok); // after quicknew2 for stuff like "temp new X x;"
1618  
1619  
    // X x = nu(+...)  =>  X x = nu X(+...)
1620  
    jreplace(tok, "<id> <id> = nu(+", "$1 $2 = nu $1(+");
1621  
    // X x = nu(a := ...)  =>  X x = nu X(a := ...)
1622  
    jreplace(tok, "<id> <id> = nu(<id> :=", "$1 $2 = nu $1($6 :=");
1623  
    
1624  
    tok_expandVarCopies(tok); // AFTER the lines just above
1625  
    tok_replaceColonEqualsSyntax(tok); // ditto
1626  
1627  
    tok_unpair(tok);
1628  
    tok_cachedFunctions(tok);
1629  
    tok_simplyCachedFunctions(tok);
1630  
    tok_timedCachedFunctions(tok);
1631  
    
1632  
    tok_optPar(tok);
1633  
    
1634  
    throwFailEtc(tok);
1635  
    tok_typeAA(tok, pairClasses);
1636  
    tok_typeAAA(tok, tripleClasses);
1637  
    tok_typeAO(tok, litset("WithTrail"));
1638  
1639  
    // before star constructors so we can define star constructors in a macro
1640  
    tok_localMacro(tok);
1641  
1642  
    // do this after expanding sclass etc.
1643  
    tok = tok_expandStarConstructors(tok);
1644  
    
1645  
    tok_kiloConstants(tok);
1646  
    //tok_colonMessages(tok);
1647  
    
1648  
    while ((i = jfind(tok, "shit:")) >= 0) {
1649  
      int j = tok_findEndOfStatement(tok, i);
1650  
      tok.set(i+2, "(");
1651  
      tok.set(j-1, ");");
1652  
      reTok(tok, i, j);
1653  
    }
1654  
      
1655  
    jreplace(tok, "shit(", "ret with print(");
1656  
    
1657  
    tok_virtualTypes(tok);
1658  
    tok_autoLongConstants(tok);
1659  
    
1660  
    // common misordering of type arguments
1661  
    jreplace(tok, "boolean <A>", "<A> boolean");
1662  
    
1663  
    tok_unimplementedMethods(tok);
1664  
    tok_switchableFields(tok);
1665  
    tok_autoDisposeFields(tok);
1666  
    tok_shortVisualize(tok);
1667  
    tok_whileGreaterThan(tok);
1668  
    tok_ifThenEnd(tok);
1669  
    
1670  
    tok_autoInitVars(tok);
1671  
    
1672  
    tok_fixBadTypeParameterOrder(tok);
1673  
    
1674  
    // shortened method declarations BEFORE standardFunctions
1675  
    tok_svoidEtc(tok);
1676  
    jreplace(tok, "void <id> {", "$1 $2() {");
1677  
    jreplace(tok, "void <id> thread {", "$1 $2() thread {");
1678  
    jreplace(tok, "String <id> {", "$1 $2() {");
1679  
    jreplace(tok, "Object <id> {", "$1 $2() {");
1680  
    jreplace(tok, "List <id> {", "$1 $2() {");
1681  
1682  
    namedThreads(tok);
1683  
    threads(tok);
1684  
    
1685  
    //tok_maxEquals(tok);
1686  
    
1687  
    tok_questionDot(tok);
1688  
    
1689  
    jreplace(tok, "if (<id>?!)", "if ($3 != null && $3!)");
1690  
    
1691  
    tok_embeddedFunctions(tok);
1692  
    
1693  
    // quicknew for arrays
1694  
    
1695  
    jreplace(tok, "<id>[] <id> = new[", "$1[] $4 = new $1[");
1696  
    jreplace(tok, "<id>[] <id> = new {", "$1[] $4 = {");
1697  
    jreplace(tok, "<id><<id>>[] <id> = new[", "$1 $2 $3 $4[] $7 = new $1[");
1698  
    
1699  
    jreplace(tok, "<id> ifNull =", "if ($1 == null) $1 =");
1700  
    
1701  
    jreplace(tok, "class <id> extends <id><.<id>>", "class $2 extends $4<$2.$7>");
1702  
    
1703  
    tok_once(tok); // must come before next line so you can combine them
1704  
    tok_ifRecordMatch(tok);
1705  
    
1706  
    jreplace(tok, "<id> ||=", "$1 = $1 ||");
1707  
    
1708  
    // magicValue followed by a numerical constant
1709  
    jreplace(tok, "magicValue", "", (_tok, _i) -> {
1710  
      String t = _get(_tok, _i+3);
1711  
      return eqOneOf(t, ".", "-") || isInteger(t);
1712  
    });
1713  
    
1714  
    lambdaReferences(tok);
1715  
    
1716  
    tok_returnSelf(tok);
1717  
    
1718  
    // Lua-like print statement
1719  
    jreplace(tok, "print <quoted>", "print($2);");
1720  
    
1721  
    tok_tildeCalls(tok);
1722  
    
1723  
    tok_svoidEtc(tok);
1724  
    tok_swappableFunctions(tok);
1725  
    
1726  
    tok_optParLambda(tok);
1727  
    
1728  
    tok_runnableClasses(tok);
1729  
    
1730  
    tok_swapStatement(tok);
1731  
    
1732  
    defineMapLikesEtc(tok);
1733  
    
1734  
    tok_defaultArguments_debug = isDef("tok_defaultArguments_debug"); 
1735  
    tok_defaultArguments(tok);
1736  
    
1737  
    tok_akaFunctionNames(tok);
1738  
    
1739  
    tok_persistableClasses(tok);
1740  
    
1741  
    tok_transientClasses(tok);
1742  
    
1743  
    tok_shortMethodReferences(tok);
1744  
    
1745  
    jreplace(tok, "== null ?:", "== null ? null :");
1746  
    jreplace(tok, "?:", "== null ? null :");
1747  
    
1748  
    tok_orCase(tok);
1749  
    
1750  
    tok_beforeMethods(tok);
1751  
    tok_afterMethods(tok);
1752  
    
1753  
    tok_returnAsFunctionName(tok);
1754  
    
1755  
    tok_transpileGetSet(tok);
1756  
    
1757  
    tok_pcallPrefix(tok);
1758  
    
1759  
    tok_numberFunctionNames(tok);
1760  
    
1761  
    tok_castToStatements(tok);
1762  
    
1763  
    tok_optionalFields(tok);
1764  
    
1765  
    tok_getFromMap(tok);
1766  
    
1767  
    jreplace(tok, "for <id> : <id> {", "for (var $2 : $4) {");
1768  
    
1769  
    tok_shortLambdas(tok);
1770  
    
1771  
    // end of local stuff
1772  
    
1773  
    tok_processMetaBlocks(tok, metaCodeAllowed());
1774  
    if (metaCodeAllowed()) runMetaTransformers(tok);
1775  
1776  
    same = eq(tok, before);
1777  
    /*if (!same)
1778  
      print("local not same " + safety + " (" + l(tok) + " tokens)");*/
1779  
    if (safety++ >= 10) {
1780  
      printSources(tok);
1781  
      throw fail("safety 10 error!");
1782  
    }
1783  
  } while (!same);
1784  
  
1785  
  return tok;
1786  
}
1787  
1788  
static List<String> reTok_include(List<String> tok, int i, int j) {
1789  
  return reTok_modify(tok, i, j, "localStuff1");
1790  
}
1791  
1792  
static List<String> includeInMainLoaded_reTok(List<String> tok, int i, int j) {
1793  
  return reTok_include(tok, i, j);
1794  
}
1795  
1796  
static List<String> stdstuff(List<String> tok) {
1797  
  //if (++level >= 10) fail("woot? 10");
1798  
  
1799  
  print("stdstuff!");
1800  
  int i;
1801  
  
1802  
  List<String> ts = new ArrayList();
1803  
  tok_findTranslators(tok, ts);
1804  
  if (nempty(ts))
1805  
    print("DROPPING TRANSLATORS: " + structure(ts));
1806  
1807  
  print("quickmain"); tok = quickmain(tok);
1808  
  print("includes"); tok = tok_processIncludes(tok);
1809  
  print("conceptsDot"); if (processConceptsDot(tok))
1810  
  tok = tok_processIncludes(tok);
1811  
  
1812  
  List<String> dontImports = tok_processDontImports(tok, definitions);
1813  
  for (String s : dontImports)
1814  
    doNotIncludeFunction.remove(afterLastDot(s));
1815  
  
1816  
  //print('starConstructors); tok = tok_expandStarConstructors(tok);
1817  
    
1818  
  // drop Java 8 annotations since we're compiling for Java 7
1819  
  jreplace(tok, "@Nullable", "");
1820  
1821  
  // STANDARD CLASSES & INTERFACES
1822  
  
1823  
  print("standard classes");
1824  
  haveClasses = addStandardClasses_v2(tok);
1825  
  
1826  
  tok_quickInstanceOf(tok, haveClasses);
1827  
1828  
  // concept-related stuff
1829  
  
1830  
  // auto-import concepts
1831  
  /*bool _a = tok_hasClassRef2(tok, "Concept") || tok_hasClassRef2(tok, "Concepts"), _b = !haveClasses.contains("Concept");
1832  
  //print("auto-import: " + _a + ", " + _b);
1833  
  if (_a && _b) {
1834  
    print("Auto-including concepts.");
1835  
    if (shouldNotIncludeClass.contains("Concepts")) {
1836  
      print(join(tok));
1837  
      fail("Unwanted concepts import");
1838  
    }
1839  
    printStruct(haveClasses);
1840  
    tok = includeInMainLoaded(tok, "concepts.");
1841  
    reTok(tok, l(tok)-1, l(tok));
1842  
    //processConceptsDot(tok);
1843  
  }*/
1844  
  
1845  
  return tok;
1846  
} // end of stdStuff!
1847  
1848  
static List<String> multilineStrings(List<String> tok) {
1849  
  for (int i = 1; i < tok.size(); i += 2) {
1850  
    String t = tok.get(i);
1851  
    if (isQuoted(t))
1852  
      if (t.startsWith("[") || t.contains("\r") || t.contains("\n"))
1853  
        tok.set(i, quote(unquote(t)));
1854  
  }
1855  
  return tok;
1856  
}
1857  
1858  
static List<String> quickmain(List<String> tok) {
1859  
  if (quickmainDone1 && quickmainDone2) return tok;
1860  
1861  
  int i = findCodeTokens(tok, "main", "{");
1862  
  if (i < 0) i = findCodeTokens(tok, "m", "{");
1863  
  if (i >= 0 && !(i-2 > 0 && tok.get(i-2).equals("class"))) {
1864  
    tokSet_reTok(tok, i, (definitions.contains("mainClassPublic") ? "public " : "") + "class main");
1865  
    quickmainDone1 = true;
1866  
  }
1867  
    
1868  
  i = findCodeTokens(tok, "psvm", "{");
1869  
  if (i < 0) i = findCodeTokens(tok, "p", "{");
1870  
  if (i >= 0) {
1871  
    int idx = i+2;
1872  
    int j = findEndOfBracketPart(tok, idx)-1;
1873  
    List<String> contents = subList(tok, idx+1, j);
1874  
    //print("contents: " + sfu(contents));
1875  
    tok.set(i, "public static void main(final String[] args) throws Exception");
1876  
    replaceTokens(tok, idx+1, j, tok_addSemicolon(contents));
1877  
    reTok(tok, i, j);
1878  
    quickmainDone2 = true;
1879  
  }
1880  
    
1881  
  return tok;
1882  
}
1883  
1884  
static String makeVar(String name) {
1885  
  AtomicInteger counter = varCountByThread.get();
1886  
  if (counter == null)
1887  
    varCountByThread.set(counter = new AtomicInteger());
1888  
  return "_" + name + "_" + getAndInc(counter);
1889  
}
1890  
1891  
static String makeVar() { return makeVar(""); }
1892  
1893  
static List<String> rtq(List<String> tok, String id) {
1894  
  return runTranslatorQuick(tok, id);
1895  
}
1896  
1897  
static List<String> expandShortTypes(List<String> tok) {
1898  
  // replace <int> with <Integer>
1899  
  for (int i = 1; i+4 < tok.size(); i += 2)
1900  
    if (tok.get(i).equals("<")
1901  
      && litlist(">", ",").contains(tok.get(i+4))) {
1902  
      String type = tok.get(i+2);
1903  
      if (type.equals("int")) type = "Integer";
1904  
      else if (type.equals("long")) type = "Long";
1905  
      tok.set(i+2, type);
1906  
    }
1907  
    
1908  
  jreplace(tok, "O", "Object");
1909  
  jreplace(tok, "S", "String");
1910  
  jreplace(tok, "L", "List");
1911  
  jreplace(tok, "Cl", "Collection");
1912  
  
1913  
  // bool -> boolean if it's not a function name
1914  
  jreplace(tok, "bool", "boolean", new TokCondition() { public boolean get(final List<String> tok, final int i) {
1915  
    return neqGetOneOf(tok, i+3, "(", null);
1916  
  }});
1917  
  
1918  
  jreplace(tok, "AtomicBool", "AtomicBoolean");
1919  
  jreplace(tok, "AtomicInt", "AtomicInteger");
1920  
1921  
  jreplace(tok, "LL< <id> >", "L<L<$3>>");
1922  
  jreplace(tok, "LL< <id><<id>> >", "L<L<$3<$5>>>");
1923  
  jreplace(tok, "LL<?>", "L<L<?>>");
1924  
  jreplace(tok, "LL", "L<L>");
1925  
  jreplace(tok, "LPt", "L<Pt>");
1926  
  
1927  
  jreplace(tok, "Clusters< <id> >", "Map<$3, Collection<$3>>");
1928  
  
1929  
  return tok;
1930  
}
1931  
1932  
static List<String> autoImports(List<String> tok) {
1933  
  HashSet<String> imports = new HashSet(tok_findImports(tok));
1934  
  StringBuilder buf = new StringBuilder();
1935  
  for (String c : standardImports())
1936  
    if (!(imports.contains(c)))
1937  
      buf.append("import " + c + ";\n");
1938  
  if (buf.length() == 0) return tok;
1939  
  tok.set(0, buf+tok.get(0));
1940  
  return reTok(tok, 0, 1);
1941  
}
1942  
1943  
static List<String> tok_processIncludes(List<String> tok) {
1944  
  int safety = 0;
1945  
  while (hasCodeTokens(tok, "!", "include") && ++safety < 100)
1946  
    tok = tok_processIncludesSingle(tok);
1947  
  
1948  
  //tok_autoCloseBrackets(tok);
1949  
  return tok;
1950  
}
1951  
1952  
static void tok_processEarlyIncludes(List<String> tok) {
1953  
  int i;
1954  
  while ((i = jfind_check("include", tok, "!include early #<int>")) >= 0) {
1955  
    String id = tok.get(i+8);
1956  
    included.add(parseLong(id));
1957  
    replaceTokens_reTok(tok, i, i+10, "\n" + cacheGet(id) + "\n");
1958  
  }
1959  
}
1960  
1961  
static List<String> tok_processIncludesSingle(List<String> tok) {
1962  
  int i;
1963  
  while ((i = jfind_check("include", tok, "!include #<int>")) >= 0) {
1964  
    String id = tok.get(i+6);
1965  
    included.add(parseLong(id));
1966  
    replaceTokens(tok, i, i+8, "\n" + cacheGet(id) + "\n");
1967  
    reTok_include(tok, i, i+8);
1968  
  }
1969  
  while ((i = jfind_check("include", tok, "!include once #<int>")) >= 0) {
1970  
    String id = tok.get(i+8);
1971  
    boolean isNew = included.add(parseLong(id));
1972  
    replaceTokens(tok, i, i+10, 
1973  
      isNew ? "\n" + cacheGet(id) + "\n" : "");
1974  
    reTok_include(tok, i, i+10);
1975  
  }
1976  
  return tok;
1977  
}
1978  
1979  
// ctex and various other error-related keyword blocks
1980  
static void ctex(List<String> tok) {
1981  
  replaceKeywordBlock(tok, "ctex",
1982  
    "{ try {",
1983  
    "} catch (Exception __e) { throw rethrow(__e); } }");
1984  
  for (String keyword : ll("null on exception", "null on error"))
1985  
    replaceKeywordBlock(tok, keyword,
1986  
      "{ try {",
1987  
      "} catch (Throwable __e) { return null; } }");
1988  
  replaceKeywordBlock(tok, "false on exception",
1989  
    "{ try {",
1990  
    "} catch (Throwable __e) { return false; } }");
1991  
  replaceKeywordBlock(tok, "try-OrError",
1992  
    "{ try {",
1993  
    "} catch (Throwable __e) { return OrError.error(__e); } }");
1994  
}
1995  
  
1996  
static List<String> dialogHandler(List<String> tok) {
1997  
  return replaceKeywordBlock(tok,
1998  
    "dialogHandler",
1999  
    "new DialogHandler() {\n" +
2000  
      "public void run(final DialogIO io) {",
2001  
    "}}");
2002  
}
2003  
2004  
static List<String> extendClasses(List<String> tok) {
2005  
  int i;
2006  
  while ((i = jfind(tok, "extend <id> {")) >= 0) {
2007  
    String className = tok.get(i+2);
2008  
    int idx = findCodeTokens(tok, i, false, "{");
2009  
    int j = findEndOfBracketPart(tok, idx+2);
2010  
    String content = joinSubList(tok, idx+1, j-1);
2011  
    List<String> c = findInnerClassOfMain(tok, className);
2012  
    print("Extending class " + className);
2013  
    clearTokens(subList(tok, i, j+1));
2014  
    if (c == null) {
2015  
      print("Warning: Can't extend class " + className + ", not found");
2016  
      continue;
2017  
    }
2018  
    int startOfClass = indexOfSubList(tok, c);
2019  
    int endOfClass = startOfClass + l(c)-1;
2020  
    //print("Extending class " + className + " ==> " + join(subList(tok, startOfClass, endOfClass)));
2021  
    while (neq(tok.get(endOfClass), "}")) --endOfClass;
2022  
    //print("Extending class " + className + " ==> " + join(subList(tok, startOfClass, endOfClass)));
2023  
    tok.set(endOfClass, content + "\n" + tok.get(endOfClass));
2024  
    
2025  
    doubleReTok(tok, i, j+1, endOfClass, endOfClass+1);
2026  
  }
2027  
  return tok;
2028  
}
2029  
2030  
// for ping / while ping
2031  
static void forPing(List<String> tok) {
2032  
  int i;
2033  
  for (String keyword : ll("for", "fOr", "while"))
2034  
    while ((i = jfind(tok, keyword + " ping (")) >= 0) {
2035  
      int bracketEnd = findEndOfBracketPart(tok, i+4)-1;
2036  
      int iStatement = bracketEnd+2;
2037  
      int iEnd = findEndOfStatement(tok, iStatement);
2038  
      tok.set(i+2, "");
2039  
      
2040  
      // turn into block
2041  
      if (!eq(get(tok, iStatement), "{")) {
2042  
        tok.set(iStatement, "{ " + tok.get(iStatement));
2043  
        tok.set(iEnd-1, tok.get(iEnd-1) + " }");
2044  
      }
2045  
        
2046  
      // add ping
2047  
      tok.set(iStatement, "{ ping(); " + dropPrefixTrim("{", tok.get(iStatement)));
2048  
      reTok(tok, i+2, iEnd);
2049  
    }
2050  
}
2051  
2052  
// lib 123 => !123
2053  
static void libs(List<String> tok) {
2054  
  int i;
2055  
  while ((i = jfind(tok, "lib <int>")) >= 0) {
2056  
    String id = tok.get(i+2);
2057  
    print("lib " + id);
2058  
    if (!libs.contains(id)) {
2059  
      libs.add(id);
2060  
      clearAllTokens(tok, i, i+3);
2061  
      /*tok.set(i, "!");
2062  
      tok.set(i+1, "");*/
2063  
    } else {
2064  
      print("...ignoring (duplicate)");
2065  
      clearAllTokens(tok, i, i+3);
2066  
      reTok(tok, i, i+3);
2067  
    }
2068  
  }
2069  
  print("libs found: " + libs);
2070  
}
2071  
2072  
// sourceCodeLine() => 1234
2073  
static void sourceCodeLine(List<String> tok) {
2074  
  int i ;
2075  
  while ((i = jfind(tok, "sourceCodeLine()")) >= 0) {
2076  
    replaceTokens(tok, i, i+5, str(countChar(joinSubList(tok, 0, i), '\n')+1));
2077  
    reTok(tok, i, i+5);
2078  
  }
2079  
}
2080  
2081  
// done before any other processing
2082  
static void earlyStuff(List<String> tok) {
2083  
  int i;
2084  
  
2085  
  tok_processEarlyIncludes(tok);
2086  
      
2087  
  tok_scopes(tok, "autoCloseScopes" , asInclude);
2088  
  tok_autosemi(tok);
2089  
  tok_autoCloseBrackets(tok);
2090  
  jreplace(tok, "°", "()");
2091  
  
2092  
  // Note: this makes the word "quine" a special operator
2093  
  // (unusable as a function name)
2094  
  
2095  
  while ((i = jfind(tok, "quine(")) >= 0) {
2096  
    int idx = findCodeTokens(tok, i, false, "(");
2097  
    int j = findEndOfBracketPart(tok, idx+2);
2098  
    tok.set(i, "new Quine");
2099  
    tok.set(idx, "(" + quote(joinSubList(tok, idx+1, j-1)) + ", ");
2100  
    reTok(tok, i, idx+1);
2101  
  }
2102  
  
2103  
  jreplace_check("after", tok, "void <id> after super {", "void $2 { super.$2();");
2104  
  
2105  
  replaceKeywordBlock(tok, "r-enter", "r { enter {", "}}");
2106  
    
2107  
  // do this before func & voidfunc because otherwise they swallow it
2108  
  jreplace(tok, "enter {", "{ temp enter();");
2109  
  
2110  
  tok_mutatorMethods(tok);
2111  
  
2112  
  // func keyword for lambdas - now automatically quines toString() if enabled
2113  
  
2114  
  replaceKeywordBlock(tok,
2115  
    "null",
2116  
    "{",
2117  
    "null; }");
2118  
    
2119  
  // do func & voidfunc early to preserve original code as toString
2120  
  
2121  
  while ((i = jfind(tok, "func(")) >= 0) {
2122  
    int argsFrom = i+4, argsTo = findCodeTokens(tok, i, false, ")");
2123  
    int idx = findCodeTokens(tok, argsTo, false, "{");
2124  
    int j = findEndOfBracketPart(tok, idx);
2125  
    List<String> contents = subList(tok, idx+1, j-1);
2126  
    
2127  
    String returnType = "O";
2128  
    if (eq(tok.get(argsTo+2), "-") && eq(tok.get(argsTo+4), ">"))
2129  
      returnType = tok_toNonPrimitiveTypes(joinSubList(tok, argsTo+6, idx-1));
2130  
      
2131  
    String toString = autoQuine ? "  public S toString() { ret " + quote(shorten(defaultMaxQuineLength(), trimJoin(contents))) + "; }" : "";
2132  
    
2133  
    List<String> args = cloneSubList(tok, argsFrom-1, argsTo);
2134  
    tok_shortFinals(args);
2135  
    tok_toNonPrimitiveTypes(args);
2136  
    
2137  
    List<String> types = tok_typesOfParams(args);
2138  
    Object type = "O";
2139  
    if (l(types) <= 3)
2140  
      type = "F" + l(types) + "<" + joinWithComma(types) + ", " + returnType + ">";
2141  
    String body = tok_addReturn(contents);
2142  
    
2143  
    replaceTokens_reTok(tok, i, j,
2144  
      "new " + type + "() { public "
2145  
        + returnType + " get(" + trimJoin(args) + ") ctex { "
2146  
          + body
2147  
        + " }\n" + toString + "}");
2148  
  }
2149  
  
2150  
  while ((i = jfind(tok, "voidfunc(")) >= 0) {
2151  
    int argsFrom = i+4, argsTo = findCodeTokens(tok, i, false, ")");
2152  
    int idx = findCodeTokens(tok, argsTo, false, "{");
2153  
    int j = findEndOfBracketPart(tok, idx);
2154  
    List<String> contents = subList(tok, idx+1, j-1);
2155  
    
2156  
    if (jcontains(subList(tok, argsTo+1, idx), "->"))
2157  
      throw fail("voidfunc with return type: " + joinSubList(tok, i, j+1));
2158  
    
2159  
    List<String> args = cloneSubList(tok, argsFrom-1, argsTo);
2160  
    tok_shortFinals(args);
2161  
    tok_toNonPrimitiveTypes(args);
2162  
    
2163  
    List<String> types = tok_typesOfParams(args);
2164  
    Object type = "O";
2165  
    if (l(types) <= 4)
2166  
      type = "VF" + l(types) + "<" + joinWithComma(types) + ">";
2167  
2168  
    replaceTokens(tok, i, j, "new " + type + "() { public void get(" + trimJoin(args) + ") ctex { " + tok_addSemicolon(contents) + " }\n" +
2169  
    (autoQuine ? "  public S toString() { ret " + quote(shorten(defaultMaxQuineLength(), trim(join(contents)))) + "; }" : "") + "}");
2170  
    reTok(tok, i, j);
2171  
  }
2172  
  
2173  
  jreplace(tok, "func {", "func -> O {");
2174  
  jreplace(tok, "f {", "f -> O {");
2175  
  
2176  
  // swing -> S { ... } => swing(func -> S { ... })
2177  
  while ((i = jfind(tok, "swing ->")) >= 0) {
2178  
    int bracket = findCodeTokens(tok, i, false, "{");
2179  
    int j = findEndOfBracketPart(tok, bracket);
2180  
    tok.set(i, "swing(func");
2181  
    tok.set(j-1, "})");
2182  
    reTok(tok, i, j);
2183  
  }
2184  
  
2185  
  tok_qFunctions(tok);
2186  
  
2187  
  jreplace(tok, "func fullToString {", "func -> O fullToString {");
2188  
  
2189  
  for (String keyword : ll(/*"f",*/ "func")) {
2190  
    while ((i = jfind(tok, keyword + " ->", new TokCondition() { public boolean get(final List<String> tok, final int i) {
2191  
      return isIdentifier(_get(tok, i+7)); // avoid lambda declaration like: f -> { ... }
2192  
    }})) >= 0) {
2193  
      // I think there is a bug here for something like func -> x { new x { } }
2194  
      int idx = findCodeTokens(tok, i, false, "{");
2195  
      int j = findEndOfBracketPart(tok, idx);
2196  
      String returnType = tok_toNonPrimitiveTypes(joinSubList(tok, i+6, idx-1));
2197  
      int quineLength = defaultMaxQuineLength();
2198  
      if (eq(lastJavaToken(returnType), "fullToString")) {
2199  
        quineLength = Integer.MAX_VALUE;
2200  
        returnType = dropLastJavaTokenAndSpacing(returnType);
2201  
      }
2202  
      List<String> contents = subList(tok, idx+1, j-1);
2203  
      replaceTokens(tok, i, j, "new F0<" + returnType + ">() { public " + returnType + " get() ctex { " + tok_addReturn(contents) + " }\n" +
2204  
        (autoQuine ? "  public S toString() { ret " + quote(shorten(quineLength, trimJoin(contents))) + "; }" : "") + "}");
2205  
      reTok(tok, i, j);
2206  
    }
2207  
  }
2208  
    
2209  
  while ((i = jfind(tok, "time repeat * {")) >= 0) {
2210  
    int j = findEndOfBlock(tok, i+6)-1;
2211  
    tok.set(i, "time {");
2212  
    tok.set(j, "}}");
2213  
    reTok(tok, i, j+1);
2214  
  }
2215  
2216  
  // do this before "m {" stuff because "repeat m" [doesn't seem to work yet though)
2217  
  while ((i = findCodeTokens(tok, "repeat", "*", "{")) >= 0) {
2218  
    String v = makeVar("repeat");
2219  
    tok.set(i, "for (int " + v + " = 0; " + v + " < " + tok.get(i+2) + "; " + v + "++)");
2220  
    tok.set(i+2, "");
2221  
    reTok(tok, i, i+3);
2222  
  }
2223  
}
2224  
2225  
static void throwFailEtc(List<String> tok) {
2226  
  boolean anyChange = false;
2227  
  for (int i = 1; i+4 < l(tok); i += 2)
2228  
    if (eqOneOf(get(tok, i+2), "fail", "todo")
2229  
      && eq(get(tok, i+4), "(")
2230  
      && !eqOneOf(get(tok, i), "throw", "RuntimeException", "return", "f", "function", ".", "void", "main", "Throwable")) {
2231  
      tok.set(i+2, "throw " + tok.get(i+2));
2232  
      anyChange = true;
2233  
    }
2234  
  if (anyChange)
2235  
    reTok(tok);
2236  
}
2237  
2238  
static void namedThreads(List<String> tok) {
2239  
  for (int i = 0; i < 100; i++) {
2240  
    int idx = findCodeTokens(tok, "thread", "<quoted>", "{");
2241  
    if (idx < 0) idx = findCodeTokens(tok, "thread", "<id>", "{");
2242  
    if (idx < 0)
2243  
      break;
2244  
    int j = findEndOfBracketPart(tok, idx+4);
2245  
    String tName = tok.get(idx+2);
2246  
    
2247  
    String pre = "startThread(" + tName + ", r { ";
2248  
    String post = "})";
2249  
    if (!tok_tokenLeftOfExpression(tok, idx-2)) post += ";";
2250  
2251  
    tok.set(idx, pre);
2252  
    tok.set(idx+2, "");
2253  
    tok.set(idx+4, "");
2254  
    tok.set(j-1, post);
2255  
    //print(join(subList(tok, idx, j)));
2256  
    reTok(tok, idx, j);
2257  
  }
2258  
}
2259  
2260  
static void rNamedThread(List<String> tok) {
2261  
  for (int i = 0; i < 100; i++) {
2262  
    int idx = findCodeTokens(tok, "r", "-", "thread", "<quoted>", "{");
2263  
    if (idx < 0) idx = findCodeTokens(tok, "r", "-", "thread", "<id>", "{");
2264  
    if (idx < 0)
2265  
      break;
2266  
    int j = findEndOfBracketPart(tok, idx+8);
2267  
    String tName = tok.get(idx+6);
2268  
    
2269  
    String pre = "r { thread " + tName + " {";
2270  
    String post = "}}";
2271  
2272  
    replaceTokens(tok, idx, idx+9, pre);
2273  
    tok.set(j-1, post);
2274  
    reTok(tok, idx, j);
2275  
  }
2276  
}
2277  
2278  
static void threads(List<String> tok) {
2279  
  replaceKeywordBlock(tok, "daemon", "startDaemonThread(r {", "});");
2280  
  //replaceKeywordBlock(tok, "thread", "startThread(r {", "});");
2281  
  
2282  
  // now enclose in { } to allow using like "void bla() thread { ... }" - if it's not used as an expression
2283  
  
2284  
  replaceKeywordBlock_dyn2_legacy(tok, "thread", new Object() { // don't use func here, it can't be transpiled
2285  
    String[] get (List<String> tok, int iOpening, int iClosing) {
2286  
      // is the thread clause used as an expression?
2287  
      boolean isExpression = tok_tokenLeftOfExpression(tok, iOpening-4);
2288  
      return new String[] {
2289  
        (isExpression ? "" : "{ ") + "startThread(r {",
2290  
        "})" +
2291  
        (isExpression ? "" : "; }")
2292  
      };
2293  
    }
2294  
  });
2295  
}
2296  
2297  
static Map<String, String> sf; // standard standard functions (haha)
2298  
static Boolean _761ok;
2299  
2300  
static List<String> standardFunctions(List<String> tok) {
2301  
  if (sf == null) {
2302  
    String _761 = cacheGet("#761");
2303  
    if (_761ok == null)
2304  
      _761ok = isBracketHygienic(_761);
2305  
    assertTrue("Whoa! #761 truncated?", _761ok);
2306  
    List<String> standardFunctions = concatLists(
2307  
      (List) loadVariableDefinition(_761, "standardFunctions"),
2308  
      (List) loadVariableDefinition(cacheGet("#1006654"), "standardFunctions"));
2309  
2310  
    sf = new HashMap();
2311  
    for (String x : standardFunctions) {
2312  
      String[] f = x.split("/");
2313  
      sf.put(f[1], f[0]);
2314  
    }
2315  
  }
2316  
  
2317  
  Map<String, String> sfMap = combinedMap(extraStandardFunctions, sf);
2318  
    
2319  
  for (int i = 0; ; i++) {
2320  
    print("Looking for required functions");
2321  
    Set<String> defd = new HashSet(findFunctions(tok));
2322  
    
2323  
    int j;
2324  
    while ((j = jfind(tok, "should not include function *.")) >= 0) {
2325  
      String fname = tok.get(j+8);
2326  
      shouldNotIncludeFunction.add(fname);
2327  
      clearAllTokens(subList(tok, j, j+12));
2328  
    }
2329  
2330  
    while ((j = jfind(tok, "do not include function *.")) >= 0) {
2331  
      String fname = tok.get(j+8);
2332  
      doNotIncludeFunction.add(fname);
2333  
      clearAllTokens(subList(tok, j, j+12));
2334  
    }
2335  
    
2336  
    while ((j = jfind(tok, "need latest <id>.")) >= 0) {
2337  
      String t = tok.get(j+4);
2338  
      needLatest.add(t);
2339  
      doNotIncludeClass.remove(t);
2340  
      clearAllTokens(subList(tok, j, j+8));
2341  
    }
2342  
    
2343  
    grabImportedStaticFunctions(tok);
2344  
    doNotIncludeFunction.removeAll(needLatest);
2345  
    
2346  
    // changes tok
2347  
    Set<String> invocations = findFunctionInvocations(tok, sfMap, hardFunctionReferences, defd, true, mainClassName());
2348  
    /*if (invocations.contains("str"))
2349  
      print("==STR==" + join(tok) + "==STR==");*/
2350  
    if (!cic(definitions, "leanMode"))
2351  
      invocations.addAll(functionsToAlwaysInclude);
2352  
2353  
    //print("Functions invoked: " + structure(invocations));
2354  
    List<String> needed = diff(invocations, defd);
2355  
    for (String f : doNotIncludeFunction) needed.remove(f);
2356  
    if (needed.isEmpty())
2357  
      break;
2358  
    print("Adding functions: " + join(" " , needed));
2359  
    
2360  
    HashSet neededSet = new HashSet(needed);
2361  
    Collection<String> bad = setIntersection(neededSet, shouldNotIncludeFunction);
2362  
    if (nempty(bad)) {
2363  
      String msg = "INCLUDING BAD FUNCTIONS: " + sfu(bad);
2364  
      print(msg);
2365  
      print(join(tok));
2366  
      throw fail(msg);
2367  
    }
2368  
      
2369  
    List<String> added = new ArrayList();
2370  
    List<Future<String>> parts = new ArrayList();
2371  
    List<String> preload = new ArrayList();
2372  
    
2373  
    for (String x : needed)
2374  
      if (sfMap.containsKey(x))
2375  
        preload.add(sfMap.get(x));
2376  
    print("Preloading: " + preload);
2377  
    cachePreload(preload);
2378  
    
2379  
    for (String x : cloneList(needed)) {
2380  
      if (defd.contains(x)) continue;
2381  
      
2382  
      String id = sfMap.get(x);
2383  
      if (id == null) {
2384  
        print("Standard function " + x + " not found.");
2385  
        needed.remove(x);
2386  
        continue;
2387  
      }
2388  
      //print("Adding function: " + x + " (" + id + ")");
2389  
       
2390  
      String function = cacheGet(id) + "\n";
2391  
      //if (("\n" + function).contains("\n!")) print("Warning: " + id + " contains translators.");
2392  
      
2393  
      if (cacheStdFunctions) {
2394  
        long _id = psI(id);
2395  
        CachedInclude ci = cachedIncludes.get(_id);
2396  
        if (ci == null) {
2397  
          cachedIncludes.put(_id, ci = new CachedInclude(_id));
2398  
          //println("Caching include " + _id + ", l=" + l(cachedIncludes));
2399  
        }
2400  
        function += "\n";
2401  
        final String _function = function;
2402  
        if (neq(ci.javax, function)) {
2403  
          print("Compiling function: " + x);
2404  
          ci.javax = function;
2405  
          ci.java = executor.submit(new Callable<String>() {
2406  
            public String call() {
2407  
              // We assume that variables made with makeVar() will always be local to some block
2408  
              varCountByThread.set(null);
2409  
              return join(localStuff1(jtok(_function)));
2410  
            }
2411  
          });
2412  
          ci.realJava = null;
2413  
        }
2414  
        parts.add(ci.javaFuture());
2415  
      } else
2416  
        parts.add(nowFuture(function));
2417  
        
2418  
      added.add(x);
2419  
      Collection<String> newFunctions = new HashSet(findFunctionDefs(javaTok(function)));
2420  
      defd.addAll(newFunctions);
2421  
      for (String f : newFunctions)
2422  
        if (!addedFunctions.add(f)) {
2423  
          printSources(tok);
2424  
          throw fail("Trying to add function " + f + " again - main class syntax broken!");
2425  
        }
2426  
    }
2427  
    
2428  
    print("Getting " + nParts(parts));
2429  
    String text = lines(getAllFutures(parts));
2430  
    print("Including " + nParts(parts));
2431  
    tok = includeInMainLoaded(tok, text);
2432  
      
2433  
    // defd = new HashSet(findFunctions(tok));
2434  
    //print("Functions added: " + joinWithSpace(added));
2435  
    
2436  
    for (String x : needed)
2437  
      if (!defd.contains(x)) {
2438  
        print(join(tok));
2439  
        throw fail("Function not defined properly: " + x);
2440  
      }
2441  
    //print("Iteration " + (i+2));
2442  
    
2443  
    print("Processing definitions");
2444  
    
2445  
    dontPrint("definitions"); tok_definitions(tok);
2446  
    dontPrint("ifndef"); tok_ifndef(tok);
2447  
    dontPrint("ifdef"); tok_ifdef(tok);
2448  
    
2449  
    if (i >= 1000) throw fail("Too many iterations");
2450  
  }
2451  
  
2452  
  return tok;
2453  
}
2454  
2455  
// TODO: skip functions defined in inner classes!
2456  
static List<String> findFunctions(List<String> tok) {
2457  
  //ret findFunctionDefinitions(join(findMainClass(tok)));
2458  
  return findFunctionDefs(findMainClass(tok));
2459  
}
2460  
2461  
static String cacheGet(String snippetID) {
2462  
  snippetID = formatSnippetID(snippetID);
2463  
  String text = snippetCache.get(snippetID);
2464  
  if (text == null) {
2465  
    text = loadSnippet(snippetID);
2466  
    // very early processing/checks for includes
2467  
    
2468  
    if (hasUnclosedStringLiterals(text))
2469  
      throw fail("Unclosed string literals in " + snippetID);
2470  
      
2471  
    if (regexpContains("\\bscope\\b", text)) {
2472  
      List<String> tok = javaTok(text);
2473  
      tok_scopes(tok, "autoCloseScopes" , true);
2474  
      text = join(tok);
2475  
    }
2476  
    
2477  
    snippetCache.put(snippetID, text);
2478  
  }
2479  
  return text;
2480  
}
2481  
2482  
static void cachePreload(Collection<String> ids) {
2483  
  List<String> needed = new ArrayList();
2484  
  for (String id : ids)
2485  
    if (!snippetCache.containsKey(formatSnippetID(id)))
2486  
      needed.add(formatSnippetID(id));
2487  
  if (l(needed) > 1) {
2488  
    List<String> texts = loadSnippets(needed);
2489  
    for (int i = 0; i < l(needed); i++)
2490  
      if (texts.get(i) != null)
2491  
        snippetCache.put(needed.get(i), texts.get(i));
2492  
  }
2493  
}
2494  
2495  
static List<String> jtok(List<String> tok) {
2496  
  return jtok(join(tok));
2497  
}
2498  
2499  
static List<String> jtok(String s) {
2500  
  return indexTokenList(javaTok(s));
2501  
}
2502  
2503  
static HashSet<String> haveClasses_actual(List<String> tok) {
2504  
  HashSet<String> have = new HashSet();
2505  
  for (List<String> c : innerClassesOfMain(tok))
2506  
    have.add(getClassDeclarationName(c));
2507  
  return have;
2508  
}
2509  
2510  
static HashSet<String> haveClasses_addImported(List<String> tok, HashSet<String> have) { return haveClasses_addImported(tok, have, true); }
2511  
static HashSet<String> haveClasses_addImported(List<String> tok, HashSet<String> have, boolean mainLevel) {
2512  
  have.addAll(tok_importedClassNames(tok, mainLevel ? (__18, __19) -> onImportFound(__18, __19) : null));
2513  
  have.addAll(usualJavaClassNames()); // for S => S.class
2514  
  return have;
2515  
}
2516  
2517  
// works on Java level (no "sclass" etc)
2518  
// returns list of classes we have (useful for other processing)
2519  
static HashSet<String> addStandardClasses_v2(List<String> tok) {
2520  
  if (lclasses == null) {
2521  
    String sc = cacheGet("#1003674");
2522  
    lclasses = new ArrayList();
2523  
    for (String line : tlft_j(sc)) {
2524  
      int idx = line.indexOf('/');
2525  
      lclasses.addAll(ll(line.substring(0, idx), line.substring(idx+1)));
2526  
    }
2527  
  }
2528  
  List<String> definitions = lclasses;
2529  
2530  
  for (int safety = 0; safety < 10; safety++) {
2531  
    HashSet<String> have = haveClasses_actual(tok);
2532  
    haveClasses_addImported(tok, have);
2533  
    have.addAll(keys(rewrites));
2534  
2535  
    int j;
2536  
    while ((j = jfind(tok, "should not include class *.")) >= 0) {
2537  
      String cname = tok.get(j+8);
2538  
      shouldNotIncludeClass.add(cname);
2539  
      clearAllTokens(subList(tok, j, j+12));
2540  
    }
2541  
    
2542  
    while ((j = jfind(tok, "do not include class *.")) >= 0) {
2543  
      String name = tok.get(j+8);
2544  
      if (!needLatest.contains(name)) doNotIncludeClass.add(name);
2545  
      clearAllTokens(subList(tok, j, j+12));
2546  
    }
2547  
    
2548  
    Map<String, String> need = new HashMap();
2549  
    Set<String> snippets = new HashSet();
2550  
    Set<String> idx = tokenIndexWithoutIfclass_forStdClasses(tok);
2551  
    
2552  
    while ((j = jfind(tok, "please include class *.")) >= 0) {
2553  
      String cname = tok.get(j+6);
2554  
      idx.add(cname);
2555  
      clearAllTokens(subList(tok, j, j+10));
2556  
    }
2557  
2558  
    for (int i = 0; i+1 < l(definitions); i += 2) {
2559  
      String className = definitions.get(i);
2560  
      String snippetID = fsI(definitions.get(i+1));
2561  
      if (idx.contains(className) && !have.contains(className) && snippets.add(snippetID))
2562  
        need.put(className, snippetID);
2563  
    }
2564  
    if (hasDef("SymbolAsString")) {
2565  
      print("Have SymbolAsString.");
2566  
      if (need.containsKey("Symbol")) {
2567  
        print("Have Symbol.");
2568  
        need.remove("Symbol");
2569  
      }
2570  
    } else
2571  
      print("No SymbolAsString.");
2572  
      
2573  
    removeAll(need, doNotIncludeClass);
2574  
    if (empty(need)) return have;
2575  
  
2576  
    for (String className : keys(need))
2577  
      if (shouldNotIncludeClass.contains(className)) {
2578  
        String msg = "INCLUDING BAD CLASS: " + className;
2579  
        print(msg);
2580  
        print(join(tok));
2581  
        throw fail(msg);
2582  
      }
2583  
      
2584  
    cachePreload(values(need));
2585  
    
2586  
    List<Pair<String, CachedInclude>> parts = new ArrayList(); // class name, Java code
2587  
    
2588  
    print("Adding classes: " + joinWithSpace(keys(need)));
2589  
    for (String className : keys(need)) {
2590  
      if (have.contains(className)) continue; // intermittent add
2591  
      String snippetID = need.get(className);
2592  
      //print("Adding class " + className + " / " + snippetID);
2593  
      snippetID = fsI(snippetID);
2594  
      String text = cacheGet(snippetID) + "\n";
2595  
      
2596  
      assertTrue(cacheStdClasses);
2597  
      long _id = psI(snippetID);
2598  
      CachedInclude ci = cachedIncludes.get(_id);
2599  
      if (ci == null) cachedIncludes.put(_id, ci = new CachedInclude(_id));
2600  
      if (neq(ci.javax, text)) {
2601  
        print("Compiling class: " + className);
2602  
        ci.javax = text;
2603  
        ci.java = executor.submit(new Callable<String>() {
2604  
          public String call() {
2605  
            // We assume that variables made with makeVar() will always be local to some block
2606  
            varCountByThread.set(null);
2607  
            return join(localStuff1(jtok(text)));
2608  
          }
2609  
        });
2610  
        ci.realJava = null;
2611  
      }
2612  
      parts.add(pair(className, ci));
2613  
    }
2614  
    
2615  
    StringBuilder buf = new StringBuilder();
2616  
    for (Pair<String, CachedInclude> p : parts) {
2617  
      String className = p.a;
2618  
      List<String> ct = javaTok(p.b.java());
2619  
      Map<String, String> rewritten = new HashMap();
2620  
      tok_findAndClearRewrites(ct, rewritten);
2621  
      if (rewritten.containsKey(className))
2622  
        have.add(className);
2623  
      for (List<String> c : allClasses(ct)) {
2624  
        String name = getClassDeclarationName(c);
2625  
        have.add(name);
2626  
      }
2627  
      
2628  
      haveClasses_addImported(ct, have, false);
2629  
      
2630  
      if (!have.contains(className))
2631  
        throw fail("Wrongly defined class: " + className + " / " + p.b.snippetID + "\n\n" + p.b.java());
2632  
      if (!addedClasses.add(className)) {
2633  
        printSources(tok);
2634  
        throw fail("Trying to add class " + className + " again - main class syntax broken!");
2635  
      }
2636  
      buf.append(p.b.java());
2637  
    } // for part
2638  
    
2639  
    tok = includeInMainLoaded(tok, str(buf));
2640  
  }
2641  
  throw fail("safety 10");
2642  
}
2643  
2644  
static Set<String> expandableClassNames = lithashset("BigInteger");
2645  
2646  
// no reTok - leaves tok dirty
2647  
// magically append ".class" to class name references
2648  
static void expandClassReferences_lazy(List<String> tok, Set<String> classNames) { expandClassReferences_lazy(tok, classNames, null); }
2649  
static void expandClassReferences_lazy(List<String> tok, Set<String> classNames, List<IntRange> reToks) {
2650  
  for (int i = 3; i+2 < l(tok); i += 2) {
2651  
    String t = tok.get(i);
2652  
    
2653  
    // skip implements/extends/throws lists
2654  
    if (eqOneOf(t, "implements", "extends", "throws")) {
2655  
      i = tok_endOfImplementsList(tok, i);
2656  
      continue;
2657  
    }
2658  
    
2659  
    if (classNames.contains(t) || expandableClassNames.contains(t)) {
2660  
      String s = tok.get(i-2); t = tok.get(i+2);
2661  
      // Now s is token before class name, t is token after class name
2662  
      // TODO: This whole logic ain't very good
2663  
      // (Hard to distinguish between "Int.class" as an argument
2664  
      // and "Int" as a type parameter.)
2665  
      if (eqOneOf(s, "instanceof", "new", ".", "<", ">", "/", "nu")) continue;
2666  
      if (eq(t, ":")) continue; // e.g. String::concat
2667  
      if (isInteger(s)) continue;
2668  
      if (isIdentifier(s) && !eqOneOf(s, "ret", "return")) continue;
2669  
        
2670  
      if (eq(t, ",") && isIdentifier(get(tok, i+4)) && eqGet(tok, i+6, ">")) continue; // e.g. T3<L<S>, S, S>
2671  
      if (eq(s, ",") && isIdentifier(get(tok, i-4)) &&
2672  
        (eqGet(tok, i-6, "<") || eqGet(tok, i-6, ",")
2673  
        && isIdentifier(get(tok, i-8)) && eqGet(tok, i-10, "<"))) continue; // e.g. T3<S, S, S> or IF3<S, S, S, S>
2674  
      if (eq(s, ",") && eqOneOf(_get(tok, i-6), "implements", "throws")) continue;
2675  
      
2676  
      // check for cast
2677  
      if (eq(s, "(") && eq(t, ")") && i >= 5) {
2678  
        if (!eqOneOf(get(tok, i+4), "{", ";")) {
2679  
          String x = tok.get(i-4);
2680  
          if (!isIdentifier(x)) continue;
2681  
          if (eqOneOf(x, "ret", "return")) continue;
2682  
        }
2683  
      }
2684  
      
2685  
      // check following token
2686  
      if (eqOneOf(t, ",", ")", ";", ":", "|")) {
2687  
        tok.set(i, tok.get(i) + ".class");
2688  
        { if (reToks != null) reToks.add(intRange(i, i+1)); }
2689  
      }
2690  
    }
2691  
  }
2692  
}
2693  
2694  
static void expandClassReferences(List<String> tok, Set<String> classNames) {
2695  
  List<IntRange> reToks = new ArrayList();
2696  
  expandClassReferences_lazy(tok, classNames, reToks);
2697  
  reTok_multi(tok, reToks);
2698  
}
2699  
2700  
// "<id>/<ClassName>" => "((ClassName) <id>)"
2701  
static void slashCasts(List<String> tok, final Set<String> classNames) {
2702  
  /*jreplace(tok, "<id>/<id>", "(($3) $1)", tokcondition {
2703  
    ret classNames.contains(tok.get(i+5));
2704  
  });*/
2705  
  int n = l(tok)-4;
2706  
  for (int i = 1; i < n; i += 2)
2707  
    if (tok.get(i+2).equals("/") && isIdentifier(tok.get(i))
2708  
      && classNames.contains(tok.get(i+4)))
2709  
      replaceTokens_reTok(tok, i, i+5, "((" + tok.get(i+4) + ") " + tok.get(i) + ")");
2710  
}
2711  
2712  
// "<ClassName>(...)" => "new <ClassName>(...)"
2713  
// doesn't work at beginning of statement as we can't easily
2714  
// distinguish it from a constructor declaration.
2715  
static void newWithoutNew(List<String> tok, final Set<String> classNames) {
2716  
  TokCondition cond = newWithoutNew_condition(classNames);
2717  
  jreplace(tok, "<id>(", "new $1(", cond);
2718  
  // just two cases with type args for now
2719  
  jreplace(tok, "<id><<id>>(", "new $1<$3>(", cond);
2720  
  jreplace(tok, "<id><>(", "new $1<>(", cond);
2721  
}
2722  
2723  
static TokCondition newWithoutNew_condition(final Set<String> classNames) {
2724  
  return new TokCondition() { public boolean get(final List<String> tok, final int i) {
2725  
    if (!classNames.contains(tok.get(i+1))) return false;
2726  
    String prev = _get(tok, i-1);
2727  
    boolean ok = //!(eqGet(tok, i-3, "ifclass") && isIdentifier(prev))
2728  
      nempty(prev) // discarded ifclass
2729  
      && (eq(prev, ">") ? eqGet(tok, i-3, "-")
2730  
      : neqOneOf(prev, "new", ";", "}", "{", "public", "protected", "private", "."));
2731  
    //print("newWithoutNew: checking " + struct(subList(tok, i-3, i+2)) + " => " + ok);
2732  
    return ok;
2733  
  }};
2734  
}
2735  
2736  
static boolean processConceptsDot(List<String> tok) {
2737  
  boolean anyChange = false, change;
2738  
  do {
2739  
    change = false;
2740  
    for (int i : jfindAll(tok, "concepts."))
2741  
      if (contains(get(tok, i+3), "\n")) {
2742  
        replaceTokens(tok, i, i+3, "!" + "include once #1004863 // Dynamic Concepts");
2743  
        reTok(tok, i, i+3);
2744  
        change = anyChange = true;
2745  
        break;
2746  
      }
2747  
  } while (change);
2748  
  return anyChange;
2749  
}
2750  
2751  
static void caseAsVariableName(List<String> tok) {
2752  
  if (!tok.contains("case")) return;
2753  
  for (int i = 1; i+2 < l(tok); i += 2) {
2754  
    String t = tok.get(i+2);
2755  
    if (tok.get(i).equals("case")
2756  
      && !(t.startsWith("'") || isInteger(t) || isIdentifier(t) || isQuoted(t)))
2757  
      tok.set(i, "_case");
2758  
  }
2759  
}
2760  
2761  
static void continueAsFunctionName(List<String> tok) {
2762  
  jreplace(tok, "continue(", "_continue(");
2763  
}
2764  
2765  
// f bla => "bla" - and "please include function bla."
2766  
static void functionReferences(List<String> tok) {
2767  
  int i;
2768  
  
2769  
  jreplace_dyn(tok, "f-thread <id>", new F2<List<String>, Integer, Object>() { public Object get(List<String> tok, Integer cIdx) { try { 
2770  
    return "dynamicCallableMC_thread(" + quote(tok.get(cIdx+6)) + ")";
2771  
   } catch (Exception __e) { throw rethrow(__e); } }
2772  
  public String toString() { return "\"dynamicCallableMC_thread(\" + quote(tok.get(cIdx+6)) + \")\""; }});
2773  
  
2774  
  String keyword = "f";
2775  
  while ((i = jfind(tok, keyword + " <id>", new TokCondition() { public boolean get(final List<String> tok, final int i) {
2776  
    return !eqOneOf(tok.get(i+3), "instanceof", "default");
2777  
  }})) >= 0) {
2778  
    String f = tok.get(i+2);
2779  
    clearTokens(tok, i, i+2);
2780  
    tok.set(i+2, quote(f));
2781  
    reTok(tok, i, i+2);
2782  
    tok.set(l(tok)-1, last(tok) + "\nplease include function " + f + ".");
2783  
    reTok(tok, l(tok)-1, l(tok));
2784  
  }
2785  
  
2786  
  // r|rThread|rEnter|rThreadEnter|rEnterThread fname => r|rThread|... { fname() }
2787  
  while ((i = jfindOneOf_cond(tok, new TokCondition() { public boolean get(final List<String> tok, final int i) {
2788  
    return !eq(tok.get(i+3), "instanceof")
2789  
      && !eq(_get(tok, i-1), "cast");
2790  
  }}, "r <id>", "rThread <id>", "rEnter <id>", "rThreadEnter <id>",
2791  
    "rEnterThread <id>")) >= 0) {
2792  
    String f = tok.get(i+2);
2793  
    replaceTokens(tok, i, i+3, tok.get(i) + " { " + f + "(); }");
2794  
    reTok(tok, i, i+3);
2795  
  }
2796  
  
2797  
  // dm_q fname => r_dm_q(r fname)
2798  
  jreplace(tok, "dm_q <id>", "r_dm_q(r $2)");
2799  
  
2800  
  // vf<S> fname => voidfunc(S s) { fname(s) }
2801  
  jreplace(tok, "vf<<id>> <id>", "voidfunc($3 a) { $5(a) }");
2802  
  
2803  
  // vf<L<S>> fname => voidfunc(L<S> a) { fname(a) }
2804  
  jreplace(tok, "vf<<id><<id>>> <id>", "voidfunc($3<$5> a) { $8(a) }");
2805  
  
2806  
  // construct<S> Entry => func(S s) -> Entry { new Entry(s) }
2807  
  jreplace(tok, "construct<<id>> <id>", "func($3 a) -> $5 { new $5(a) }");
2808  
  
2809  
  // f<S> fname => func -> S { fname() }
2810  
  jreplace(tok, "f<<id>> <id>", "func -> $3 { $5() }");
2811  
  
2812  
  // f<S, S> fname => func(S x) -> S { fname(x) }
2813  
  jreplace(tok, "f<<id>, <id>> <id>", "func($3 x) -> $5 { $7(x) }");
2814  
  
2815  
  // f<S, L<S>> fname => func(S x) -> L<S> { fname(x) }
2816  
  jreplace(tok, "f<<id>, <id><<id>>> <id>", "func($3 x) -> $5 $6 $7 $8 { $10(x) }");
2817  
  
2818  
  // f<L<S>, S> fname => func(L<S> x) -> S { fname(x) }
2819  
  jreplace(tok, "f<<id><<id>>, <id>> <id>", "func($3 $4 $5 $6 x) -> $8 { $10(x) }");
2820  
  
2821  
  // f<S, L<S>, S> fname => func(S x, L<S> y) -> S { fname(x, y) }
2822  
  jreplace(tok, "f<<id>, <id><<id>>, <id>> <id>", "func($3 x, $5 $6 $7 $8 y) -> $10 { $12(x, y) }");
2823  
  
2824  
  // if1 fname => a -> fname(a)
2825  
  // ivf1 fname => a -> fname(a)
2826  
  for (String _keyword : ll("if1", "ivf1"))
2827  
    jreplace_dyn(tok, _keyword + " <id>", new F2<List<String>, Integer, String>() { public String get(List<String> tok, Integer i) { try { 
2828  
      String var = makeVar();
2829  
      return var + " -> " + tok.get(i+2) + "(" + var + ")";
2830  
     } catch (Exception __e) { throw rethrow(__e); } }
2831  
  public String toString() { return "S var = makeVar();\r\n      ret var + \" -> \" + tok.get(i+2) + \"(\" + var + \")\";"; }});
2832  
}
2833  
2834  
static void quicknu(List<String> tok) {
2835  
  jreplace(tok, "nu <id>(", "nu($2.class, "); // not needed anymore
2836  
  jreplace(tok, "nu <id>", "new $2");
2837  
}
2838  
2839  
// fill variable innerClasses_list
2840  
static void innerClassesVar(List<String> tok, Set<String> have) {
2841  
  int i = jfind_check("myInnerClasses_list", tok, ">myInnerClasses_list;");
2842  
  if (i < 0) return;
2843  
  tok.set(i+4, "=litlist(\n" + joinQuoted(", ", have) + ");");
2844  
  reTok(tok, i+4, i+5);
2845  
}
2846  
2847  
// fill variable innerClasses_list
2848  
static void fillVar_transpilationDate(List<String> tok) {
2849  
  int i = jfind_check("myTranspilationDate_value", tok, "long myTranspilationDate_value;");
2850  
  if (i < 0) return;
2851  
  tok.set(i+4, " = " + now() + "L;");
2852  
  reTok(tok, i+4, i+5);
2853  
}
2854  
2855  
static boolean ifclass_reTokImmediately = false;
2856  
static boolean ifclass_noReTok = true;
2857  
2858  
// process ifclass x ... endif blocks
2859  
static void tok_ifclass(List<String> tok, Set<String> have) {
2860  
  tok_conditionals(tok, "ifclass", "endif", id -> contains(have, id), ifclass_reTokImmediately, ifclass_noReTok);
2861  
}
2862  
2863  
// returns number of changes
2864  
static int tok_conditionals(List<String> tok, String keyword, String keywordEnd, IF1<String, Boolean> pred, boolean reTokImmediately, boolean noReTok) {
2865  
  int changes = 0;
2866  
  if (tok instanceof IContentsIndexedList) {
2867  
    int[] l = ((IContentsIndexedList) tok).indicesOf(keyword);
2868  
    for (int j = l(l)-1; j >= 0; j--) {
2869  
      int i = l[j];
2870  
      if (isIdentifier(get(tok, i+2))) {
2871  
        processConditional(tok, i, keyword, keywordEnd, pred, reTokImmediately && !noReTok);
2872  
        ++changes;
2873  
      }
2874  
    }
2875  
  } else {
2876  
    if (!tok.contains(keyword)) return changes;
2877  
    int i = l(tok);
2878  
    while ((i = rjfind(tok, 1, i-1, keyword + " <id>")) >= 0) {
2879  
      ++changes;
2880  
      processConditional(tok, i, keyword, keywordEnd, pred, reTokImmediately && !noReTok);
2881  
    }
2882  
  }
2883  
  if (changes != 0 && !reTokImmediately && !noReTok) reTok(tok);
2884  
  //print(keyword + ": " + nChanges(changes));
2885  
  return changes;
2886  
}
2887  
2888  
static void processConditional(List<String> tok, int i, String keyword, String keywordEnd, IF1<String, Boolean> pred, boolean reTokImmediately) {
2889  
  int j = jfind(tok, i+4, keywordEnd);
2890  
  if (j < 0) j = l(tok)-1;
2891  
  String name = tok.get(i+2);
2892  
  boolean has = pred.get(name);
2893  
  //print(keyword + " " + name + " => " + has);
2894  
  if (has) {
2895  
    clearTokens_maybeReTok(tok, j, j+1, reTokImmediately);
2896  
    clearTokens_maybeReTok(tok, i, i+3, reTokImmediately);
2897  
  } else
2898  
    clearTokens_maybeReTok(tok, i, j+1, reTokImmediately); // safer than before
2899  
}
2900  
2901  
// set flag *.
2902  
static void tok_definitions(List<String> tok) {
2903  
  int i;
2904  
  while ((i = jfind_check("flag", tok, "set flag <id>.")) >= 0) {
2905  
    String fname = tok.get(i+4);
2906  
    print("Setting flag " + fname);
2907  
    definitions.add(fname);
2908  
    if (eqic(fname, "debug_jreplace")) debug_jreplace = true;
2909  
    clearAllTokens(subList(tok, i, i+8));
2910  
  }
2911  
  
2912  
  while ((i = jfind_check("flag", tok, "unset flag <id>.")) >= 0) {
2913  
    String fname = tok.get(i+4);
2914  
    print("Unsetting flag " + fname);
2915  
    definitions.remove(fname);
2916  
    clearAllTokens(subList(tok, i, i+8));
2917  
  }
2918  
}
2919  
2920  
// rewrite <id> [=|with|to] <definition>
2921  
// - a global version of "replace <id> with"
2922  
// new version - may not work yet
2923  
/*svoid tok_findAndClearRewrites(LS tok, SS newlyDefined default null) {
2924  
  tok_findRewrites(tok, newlyDefined, f -> {
2925  
    print("Have rewrite: " + f.token + " => " + f.replacement());
2926  
    clearTokens(f.tok, f.startCIdx(), f.endNIdx());
2927  
  });
2928  
}*/
2929  
2930  
2931  
// rewrite <id> [=|with|to] <definition>
2932  
// - a global version of "replace <id> with"
2933  
// old version (works)
2934  
static void tok_findAndClearRewrites(List<String> tok) { tok_findAndClearRewrites(tok, null); }
2935  
static void tok_findAndClearRewrites(List<String> tok, Map<String, String> newlyDefined) {
2936  
  int i;
2937  
  while ((i = jfind(tok, "rewrite <id>", (_tok, nIdx) ->
2938  
    eqGetOneOf(_tok, nIdx+5, "with", "=", "to"))) >= 0) {
2939  
    String token = tok.get(i+2);
2940  
    int repStart = i+6;
2941  
    int repEnd = smartIndexOf(tok, repStart, ".");
2942  
    String replacement = joinSubList(tok, repStart, repEnd-1);
2943  
    clearTokens(tok, i, repEnd+1);
2944  
    mapPut(newlyDefined, token, replacement);
2945  
    rewrites.put(token, replacement);
2946  
    print("Have rewrite: " + token + " => " + replacement);
2947  
  }
2948  
}
2949  
2950  
static void tok_processRewrites(List<String> tok) {
2951  
  for (String token : keys(rewrites))
2952  
    jreplace(tok, token, rewrites.get(token));
2953  
}
2954  
2955  
// extend *. (set base class of main class)
2956  
static void tok_extend(List<String> tok) {
2957  
  int i;
2958  
  while ((i = jfind(tok, "extend <id>.")) >= 0) {
2959  
    mainBaseClass = tok.get(i+2);
2960  
    clearAllTokens(tok, i, i+7);
2961  
  }
2962  
}
2963  
2964  
// process ifndef x ... endifndef blocks
2965  
static void tok_ifndef(List<String> tok) {
2966  
  tok_conditionals(tok, "ifndef", "endifndef", id -> !definitions.contains(id), true, false);
2967  
}
2968  
  
2969  
// process ifdef x ... endifdef blocks
2970  
static void tok_ifdef(List<String> tok) {
2971  
  tok_conditionals(tok, "ifdef", "endifdef", id -> definitions.contains(id), true, false);
2972  
}
2973  
  
2974  
static void conceptDeclarations(List<String> tok) {
2975  
  for (String kw : ll("concept", "sconcept")) {
2976  
    Object cond = new TokCondition() { public boolean get(final List<String> tok, final int i) { tok_addFieldOrder(tok, i+1); return true; }};
2977  
    boolean re = false;
2978  
    if (jreplace(tok, kw + " <id> {", "static class $2 extends Concept {", cond)) re = true;
2979  
    if (jreplace(tok, kw + " <id> implements", "static class $2 extends Concept implements", cond)) re = true;
2980  
    if (jreplace(tok, kw + " <id>", "static class $2", cond)) re = true;
2981  
    if (re) reTok(tok);
2982  
  }
2983  
}
2984  
2985  
static void shortenedSubconcepts(List<String> tok) {
2986  
  jreplace(tok, "<id> > <id> {", "concept $3 extends $1 {", new TokCondition() { public boolean get(final List<String> tok, final int i) {
2987  
    boolean b = (i == 0 || tok.get(i).contains("\n")) || eq(_get(tok, i-1), "abstract"); // only at beginning of line or after "abstract"
2988  
    //print("subconcept " + b + ": " + structure(subList(tok, i-1, i+5)));
2989  
    return b;
2990  
  }});
2991  
}
2992  
2993  
// -slightly experimental
2994  
// -do calculation in another thread, then return to AWT thread
2995  
// -must be placed in a block
2996  
// -transforms rest of block 
2997  
static void unswing(List<String> tok) {
2998  
  int i;
2999  
  while ((i = jfind(tok, "unswing {")) >= 0) {
3000  
    int idx = i+2;
3001  
    int closingBracket = findEndOfBracketPart(tok, idx)-1;
3002  
    int endOfOuterBlock = findEndOfBracketPart(tok, closingBracket)-1;
3003  
    tok.set(i, "thread");
3004  
    tok.set(closingBracket, " awt {");
3005  
    tok.set(endOfOuterBlock, "}}}");
3006  
    reTok(tok, closingBracket-1, endOfOuterBlock+1);
3007  
  }
3008  
}
3009  
3010  
// -Syntax: lock theLock;
3011  
// -lock a lock, unlock at end of current block with finally
3012  
static void lockBlocks(List<String> tok) {
3013  
  int i;
3014  
  while ((i = jfind(tok, "lock <id>", new TokCondition() { public boolean get(final List<String> tok, final int i) { return neq(tok.get(i+3), "instanceof"); }})) >= 0) {
3015  
    int semicolon = findEndOfStatement(tok, i)-1;
3016  
    String var = makeVar();
3017  
    int endOfOuterBlock = findEndOfBracketPart(tok, semicolon)-1;
3018  
    replaceTokens(tok, i, semicolon+1,
3019  
      "Lock " + var + " = " + joinSubList(tok, i+2, semicolon-1) + "; lock(" + var + "); try {");
3020  
    tok.set(endOfOuterBlock, "} finally { unlock(" + var + "); } }");
3021  
    reTok(tok, i, endOfOuterBlock+1);
3022  
  }
3023  
}
3024  
3025  
// -Syntax: temp Bla bla = bla();
3026  
// -expands to try(Bla bla = bla()) { ... } with rest of block inside
3027  
static void tempBlocks(List<String> tok) {
3028  
  int i;
3029  
  jreplace_dyn(tok, "temp (<id>) <id>", (_tok, cIdx) -> {
3030  
    String var = makeVar(), type = tok.get(cIdx+4), firstTokenOfExpr = tok.get(cIdx+8);
3031  
    return ("temp " + type + " " + var + " = cast " + firstTokenOfExpr);
3032  
  });
3033  
  
3034  
  jreplace(tok, "temp <id> =", "temp var $2 =");
3035  
  
3036  
  while ((i = jfind(tok, "temp <id>")) >= 0) {
3037  
    int semicolon = findEndOfStatement(tok, i)-1;
3038  
    int endOfOuterBlock = findEndOfBracketPart(tok, semicolon)-1;
3039  
    List<String> sub = subList(tok, i-1, semicolon);
3040  
    int eq = subList(sub, 0, smartIndexOfOneOf(sub, "{", "(")).indexOf("=");
3041  
    String var;
3042  
    if (eq >= 0)
3043  
      var = sub.get(eq-2);
3044  
    else {
3045  
      // no var name, e.g. temp newThoughtSpace();
3046  
      var = makeVar();
3047  
      tok.set(i+2, "AutoCloseable " + var + " = " + tok.get(i+2));
3048  
    }
3049  
      
3050  
    //tok.set(i, "try (");
3051  
    //tok.set(semicolon, ") {";
3052  
    //tok.set(endOfOuterBlock, "}}");
3053  
    
3054  
    tok.set(i, "");
3055  
    tok.set(semicolon, "; try {");
3056  
    tok.set(endOfOuterBlock, "} finally { _close(" + var + "); }}");
3057  
    
3058  
    reTok(tok, i, endOfOuterBlock+1);
3059  
  }
3060  
}
3061  
3062  
static void forgetCachedIncludes() {
3063  
  cachedIncludes.clear();
3064  
}
3065  
3066  
// TODO: when to do this / merge contents if there are multiple transpilers?
3067  
static void cleanMeUp() {
3068  
  for (CachedInclude ci : values(cachedIncludes))
3069  
    ci.clean();
3070  
  vmKeepWithProgramMD5_save("cachedIncludes");
3071  
}
3072  
3073  
static void printSources(List<String> tok) {
3074  
  String src = join(tok);
3075  
  print("----");
3076  
  print(src);
3077  
  print("----");
3078  
  print("Bracket hygiene: " + testBracketHygiene2(src));
3079  
}
3080  
3081  
static void tok_quickInstanceOf(List<String> tok, final Set<String> haveClasses) {
3082  
  if (!quickInstanceOfEnabled) return;
3083  
  // "x << X" or "x >> X" => "x instanceof X"
3084  
  for (String op : ll("<<", ">>"))
3085  
    jreplace(tok, "<id> " + op + " <id>", "$1 instanceof $4", new TokCondition() { public boolean get(final List<String> tok, final int i) {
3086  
      return haveClasses.contains(tok.get(i+7))
3087  
        && !eqOneOf(tok.get(i-1), "<", "extends", "implements");
3088  
    }});
3089  
}
3090  
3091  
final static boolean isDef(String s) { return hasDef(s); }
3092  
static boolean hasDef(String s) {
3093  
  return definitions.contains(s);
3094  
}
3095  
3096  
static void tok_shortFinals(List<String> tok) {
3097  
  jreplace(tok, "fS", "final S");
3098  
  jreplace(tok, "fO", "final O");
3099  
  jreplace(tok, "fL", "final L");
3100  
  jreplace(tok, "fMap", "final Map");
3101  
  jreplace(tok, "fRunnable", "final Runnable");
3102  
  jreplace(tok, "f int", "final int");
3103  
}
3104  
3105  
static void tok_mainClassNameAndPackage(List<String> tok) {
3106  
  int i;
3107  
  if ((i = jfind(tok, "mainClassName <id>")) >= 0) {
3108  
    mainClassName = tok.get(i+2);
3109  
    if (eqGet(tok, i+4, ".") && isIdentifier(get(tok, i+6))) {
3110  
      mainPackage = mainClassName;
3111  
      mainClassName = tok.get(i+6);
3112  
      clearTokensAndReTok(tok, i, i+7);
3113  
    } else
3114  
      clearTokensAndReTok(tok, i, i+3);
3115  
  }
3116  
  
3117  
  if ((i = jfind(tok, "mainPackage <id>")) >= 0) {
3118  
    int j = i+2;
3119  
    while (subListEquals(tok, j+1, "", ".", "") && isIdentifier(get(tok, j+4)))
3120  
      j += 4;
3121  
    mainPackage = joinSubList(tok, i+2, j+1);
3122  
    clearTokens_reTok(tok, i, j+1);
3123  
  }
3124  
}
3125  
3126  
static void defineMapLikesEtc(List<String> tok) {
3127  
  defineMapLikes(tok);
3128  
  defineLambdaMapLikes(tok);
3129  
  defineCurry1Likes(tok);
3130  
  defineMapMethodLikes(tok);
3131  
  defineNuLikes(tok);
3132  
  defineXLikes(tok, "getLike", getLikeFunctions);
3133  
  defineXLikes(tok, "lambdaMethod0Like", lambdaMethod0LikeFunctions);
3134  
  defineXLikes(tok, "lambda0Like", lambda0LikeFunctions);
3135  
}
3136  
3137  
static void defineMapLikes(List<String> tok) {
3138  
  int i;
3139  
  while ((i = jfind(tok, "mapLike <id>")) >= 0) {
3140  
    mapLikeFunctions.add(printIf(printMapLikes(), "mapLike", tok.get(i+2)));
3141  
    clearTokens_reTok(tok, i, i+2);
3142  
  }
3143  
}
3144  
3145  
static void defineLambdaMapLikes(List<String> tok) {
3146  
  int i;
3147  
  while ((i = jfind(tok, "lambdaMapLike <id>")) >= 0) {
3148  
    lambdaMapLikeFunctions.add(printIf(printMapLikes(), "lambdaMapLike", tok.get(i+2)));
3149  
    clearTokens_reTok(tok, i, i+2);
3150  
  }
3151  
}
3152  
3153  
static void defineCurry1Likes(List<String> tok) {
3154  
  int i;
3155  
  while ((i = jfind(tok, "curry1Like <id>")) >= 0) {
3156  
    curry1LikeFunctions.add(printIf(printMapLikes(), "curry1Like", tok.get(i+2)));
3157  
    clearTokens_reTok(tok, i, i+2);
3158  
  }
3159  
}
3160  
3161  
static void defineMapMethodLikes(List<String> tok) {
3162  
  int i;
3163  
  while ((i = jfind(tok, "mapMethodLike <id>")) >= 0) {
3164  
    mapMethodLikeFunctions.add(printIf(printMapLikes(), "mapMethodLike", tok.get(i+2)));
3165  
    clearTokens_reTok(tok, i, i+2);
3166  
  }
3167  
}
3168  
3169  
// functions that work like "nu" syntactically (accept a class as "super-first" parameter [left of the bracket])
3170  
static void defineNuLikes(List<String> tok) {
3171  
  int i;
3172  
  while ((i = jfind(tok, "nuLike <id>")) >= 0) {
3173  
    nuLikeFunctions.add(printIf(printMapLikes(), "nuLike", tok.get(i+2)));
3174  
    clearTokens_reTok(tok, i, i+2);
3175  
  }
3176  
}
3177  
3178  
static void defineXLikes(List<String> tok, String keyword, Set<String> xLikeFunctions) {
3179  
  int i;
3180  
  while ((i = jfind(tok, keyword + " <id>")) >= 0) {
3181  
    xLikeFunctions.add(printIf(printMapLikes(), keyword, tok.get(i+2)));
3182  
    clearTokens_reTok(tok, i, i+2);
3183  
  }
3184  
}
3185  
3186  
static void defineExtraSF(List<String> tok) {
3187  
  int i;
3188  
  IntRange reTok = null;
3189  
  while ((i = jfind(tok, "function <id> is in *.")) >= 0) {
3190  
    extraStandardFunctions.put(tok.get(i+2), fsI(unquote(tok.get(i+8))));
3191  
    clearTokens(tok, i, i+12);
3192  
    reTok = combineIntRanges(reTok, intRange(i, i+12));
3193  
  }
3194  
  reTok(tok, reTok);
3195  
}
3196  
3197  
static boolean tok_applyAllXLikeFunctions(List<String> tok) {
3198  
  List<IntRange> reToks = new ArrayList();
3199  
  for (int i : jfindAll(tok, "<id> <id> (")) {
3200  
    String f = tok.get(i), arg = tok.get(i+2), replacement = null;
3201  
    if (contains(mapLikeFunctions, f))
3202  
      replacement = (f + "(f " + arg + ",");
3203  
    else if (contains(lambdaMapLikeFunctions, f))
3204  
      replacement = (f + "(lambda1 " + arg + ",");
3205  
    else if (contains(curry1LikeFunctions, f))
3206  
      replacement = (f + "(lambda2 " + arg + ",");
3207  
    else if (contains(mapMethodLikeFunctions, f))
3208  
      replacement = (f + "(" + (quote(arg)) + ",");
3209  
    else if (contains(nuLikeFunctions, f))
3210  
      replacement = (f + "(" + arg + ".class,");
3211  
    else if (contains(getLikeFunctions, f))
3212  
      replacement = (f + "(lambdaField " + arg + ",");
3213  
    else if (contains(lambdaMethod0LikeFunctions, f))
3214  
      replacement = (f + "(methodLambda0 " + arg + ",");
3215  
    else if (contains(lambda0LikeFunctions, f))
3216  
      replacement = (f + "(lambda0 " + arg + ",");
3217  
    
3218  
    if (replacement != null)
3219  
      replaceTokens_reTokLater(tok, reToks, i, i+5, replacement + " ");
3220  
  }
3221  
  reTok_multi(tok, reToks);
3222  
  return nempty(reToks);
3223  
}
3224  
3225  
/*sbool tok_applyMapLikeFunctions(LS tok, final Set<S> mapLikeFunctions) {
3226  
  // map funcname(...) => map(f funcname, ...)
3227  
  // filter funcname(...) => filter(f funcname, ...)
3228  
  // ...
3229  
  ret jreplace(tok, "<id> <id>(", "$1(f $2,", func(L<S> tok, int i) -> bool {
3230  
    contains(mapLikeFunctions, tok.get(i+1))
3231  
  });
3232  
}*/
3233  
3234  
/*sbool tok_applyLambdaMapLikeFunctions(LS tok, final Set<S> lambdaMapLikeFunctions) {
3235  
  // mapNonNulls funcname(...) => mapNonNulls(lambda1 funcname, ...)
3236  
  // mapKeysAndValues funcname(...) => mapKeysAndValues(lambda1 funcname, ...)
3237  
  // ...
3238  
  ret jreplace(tok, "<id> <id>(", "$1(lambda1 $2,", func(L<S> tok, int i) -> bool {
3239  
    contains(lambdaMapLikeFunctions, tok.get(i+1))
3240  
  });
3241  
}*/
3242  
3243  
/*sbool tok_applyCurry1LikeFunctions(LS tok, final Set<S> curry1LikeFunctions) {
3244  
  // curry1 funcname(...) => curry1(lambda2 funcname, ...)
3245  
  ret jreplace(tok, "<id> <id>(", "$1(lambda2 $2,", func(L<S> tok, int i) -> bool {
3246  
    contains(curry1LikeFunctions, tok.get(i+1))
3247  
  });
3248  
}*/
3249  
3250  
/*sbool tok_applyMapMethodLikeFunctions(LS tok, final Set<S> mapMethodLikeFunctions) {
3251  
  // mapMethod funcname(...) => mapMethod('funcname, ...)
3252  
  // collect funcname(...) => collect('funcname, ...)
3253  
  // ...
3254  
  ret jreplace_dyn(tok, "<id> <id>(",
3255  
    func(L<S> tok, int cIdx) -> S { tok.get(cIdx) + "(" + quote(tok.get(cIdx+2)) + "," },
3256  
    func(L<S> tok, int i) -> bool {
3257  
      contains(mapMethodLikeFunctions, tok.get(i+1))
3258  
    });
3259  
}*/
3260  
3261  
static void runMetaPostBlocks(List<String> tok) {
3262  
  for  (String code : unnull(metaPostBlocks)) { ping(); 
3263  
    String snippetID = standardFunctionSnippet(assertIdentifier(code));
3264  
    if (empty(snippetID))
3265  
      throw fail("meta-post function not found: " + code);
3266  
    call(hotwireCached(snippetID), code, tok);
3267  
    //callF(codeToFunctionOnArbitraryType(code, "LS", L, "tok"), tok);
3268  
  }
3269  
}
3270  
3271  
static void runMetaTransformers(List<String> tok) {
3272  
  for  (String code : unnull(metaTransformers))
3273  
    { ping(); tok_runMetaTransformer(tok, code); }
3274  
}
3275  
3276  
/*sbool tok_applyNuLikeFunctions(LS tok, final Set<S> nuLikeFunctions) {
3277  
  // nu ClassName(...) => nu(ClassName, ...)
3278  
  // ...
3279  
  ret jreplace_dyn(tok, "<id> <id>(",
3280  
    func(L<S> tok, int cIdx) -> S { tok.get(cIdx) + "(" + tok.get(cIdx+2) + ".class," },
3281  
    func(L<S> tok, int i) -> bool {
3282  
      contains(nuLikeFunctions, tok.get(i+1))
3283  
    });
3284  
}*/
3285  
3286  
/*sbool tok_applyGetLikeFunctions(LS tok, Set<S> getLikeFunctions) {
3287  
  // get fieldName(...) => get(fieldLambda fieldName, ...)
3288  
  // ...
3289  
  ret jreplace_dyn(tok, "<id> <id>(",
3290  
    func(L<S> tok, int cIdx) -> S { tok.get(cIdx) + "(lambdaField " + tok.get(cIdx+2) + "," },
3291  
    func(L<S> tok, int i) -> bool {
3292  
      contains(getLikeFunctions, tok.get(i+1))
3293  
    });
3294  
}*/
3295  
3296  
static boolean metaCodeAllowed() {
3297  
  return allowMetaCode || containsIC(definitions, "allowMetaCode");
3298  
}
3299  
3300  
static List<String> indexTokenList(List<String> tok) {
3301  
  if (useIndexedList2) return indexedList2(tok);
3302  
  if (useTokenIndexedList) return tokenIndexedList3(tok);
3303  
  return tok;
3304  
}
3305  
3306  
static void tok_earlyGeneralStuff(List<String> tok) {
3307  
  // self-compile construct (TODO)
3308  
  /*jreplace(tok, "self-compile", (tok, iOpening, iClosing) -> S[] {
3309  
  
3310  
    selfCompiling
3311  
  });*/
3312  
  
3313  
  tok_standardBot1(tok);
3314  
  tok_processSimplified(tok);
3315  
  tok_compactModules(tok);
3316  
  
3317  
  tok_metaFor(tok);
3318  
  
3319  
  // is, short for "implements"
3320  
  jreplace(tok, "is <id>", "implements $2", new TokCondition() { public boolean get(final List<String> tok, final int i) {
3321  
    return !eqGetOneOf(tok, i+3, "a", "in"); // "is a", "is in" are defined as something else
3322  
  }});
3323  
}
3324  
3325  
static void lambdaReferences(List<String> tok) {
3326  
  // lambda0 myFunction => () -> myFunction()
3327  
  jreplace(tok, "lambda0 <id>", "() -> $2()");
3328  
  
3329  
  // lambda1 myFunction => var123 -> myFunction(var123)
3330  
  jreplace_dyn(tok, "lambda1 <id>", new F2<List<String>, Integer, Object>() { public Object get(List<String> tok, Integer cIdx) { try { 
3331  
    String var = makeVar();
3332  
    String s = var + " -> " + tok.get(cIdx+2) + "(" + var + ")";
3333  
    return eqGet(tok, cIdx-2, ")") ? roundBracket(s) : s;
3334  
   } catch (Exception __e) { throw rethrow(__e); } }
3335  
  public String toString() { return "S var = makeVar();\r\n    S s = var + \" -> \" + tok.get(cIdx+2) + \"(\" + var + \")..."; }});
3336  
  
3337  
  // lambda2 myFunction => (a, b) -> myFunction(a, b)
3338  
  jreplace_dyn(tok, "lambda2 <id>", new F2<List<String>, Integer, Object>() { public Object get(List<String> tok, Integer cIdx) { try { 
3339  
    String a = makeVar();
3340  
    String b = makeVar();
3341  
    String s = ("(" + a + ", " + b + ") -> " + (tok.get(cIdx+2)) + "(" + a + ", " + b + ")");
3342  
    return eqGet(tok, cIdx-2, ")") ? roundBracket(s) : s;
3343  
   } catch (Exception __e) { throw rethrow(__e); } }
3344  
  public String toString() { return "S a = makeVar();\r\n    S b = makeVar();\r\n    S s = \"(\\*a*/, \\*b*/) -> \\*tok.ge..."; }});
3345  
  
3346  
  // methodLambda0 methodName => var123 -> var123.methodName()
3347  
  jreplace_dyn(tok, "methodLambda0 <id>", new F2<List<String>, Integer, Object>() { public Object get(List<String> tok, Integer cIdx) { try { 
3348  
    String var = makeVar();
3349  
    return var + " -> " + var + "." + tok.get(cIdx+2) + "()";
3350  
   } catch (Exception __e) { throw rethrow(__e); } }
3351  
  public String toString() { return "S var = makeVar();\r\n    ret var + \" -> \" + var + \".\" + tok.get(cIdx+2) + \"()\";"; }});
3352  
  
3353  
  // fieldLambda fieldName => var123 -> var123.fieldName
3354  
  jreplace_dyn(tok, "fieldLambda <id>", new F2<List<String>, Integer, Object>() { public Object get(List<String> tok, Integer cIdx) { try { 
3355  
    String var = makeVar();
3356  
    return var + " -> " + var + "." + tok.get(cIdx+2);
3357  
   } catch (Exception __e) { throw rethrow(__e); } }
3358  
  public String toString() { return "S var = makeVar();\r\n    ret var + \" -> \" + var + \".\" + tok.get(cIdx+2);"; }});
3359  
}
3360  
3361  
static void clearSnippetCache() {
3362  
  snippetCache.clear();
3363  
  sf = null;
3364  
  lclasses = null;
3365  
}
3366  
3367  
static void mediumRefresh() {
3368  
  clearSnippetCache();
3369  
  print("Medium-refreshed transpiler " + mc());
3370  
}
3371  
3372  
static void jreplace_performing(List<String> tok, int i, int end, String expansion) {
3373  
  if (debug_jreplace)
3374  
    print("jreplace: " + quote(joinSubList(tok, i, end)) + " => " + quote(expansion));
3375  
}
3376  
3377  
static String mainClassName() {
3378  
  return or(mainClassName, "main");
3379  
}
3380  
3381  
static void grabImportedStaticFunctions(List<String> tok) {
3382  
  for (String name : tok_importedStaticFunctionNamesWithPackages(tok)) {
3383  
    int idx = lastIndexOf(name, '.');
3384  
    String pkg = takeFirst(idx, name);
3385  
    String functionName = dropFirst(idx+1, name);
3386  
    //print(functionName + " => " + pkg);
3387  
    doNotIncludeFunction.add(functionName);
3388  
    functionToPackage.put(functionName, pkg);
3389  
  }
3390  
}
3391  
3392  
static boolean printMapLikes() {
3393  
  return true; //return contains(definitions, "printMapLikesEtc");
3394  
}
3395  
3396  
// delete import if marked as "need latest"
3397  
static void onImportFound(List<String> tok, IntRange r) {
3398  
  String id = get(tok, r.end-3);
3399  
  if (needLatest.contains(id)) {
3400  
    print("Purging import: " + joinSubList(tok, r));
3401  
    clearTokens(tok, r);
3402  
  }
3403  
}
3404  
static RuntimeException fail() { throw new RuntimeException("fail"); }
3405  
static RuntimeException fail(Throwable e) { throw asRuntimeException(e); }
3406  
static RuntimeException fail(Object msg) { throw new RuntimeException(String.valueOf(msg)); }
3407  
3408  
3409  
static RuntimeException fail(Object... objects) { throw new Fail(objects); }
3410  
3411  
3412  
static RuntimeException fail(String msg) { throw new RuntimeException(msg == null ? "" : msg); }
3413  
static RuntimeException fail(String msg, Throwable innerException) { throw new RuntimeException(msg, innerException); }
3414  
3415  
3416  
3417  
static String str(Object o) {
3418  
  return o == null ? "null" : o.toString();
3419  
}
3420  
3421  
static String str(char[] c) {
3422  
  return new String(c);
3423  
}
3424  
3425  
3426  
static boolean boolOptPar(ThreadLocal<Boolean> tl) {
3427  
  return boolOptParam(tl);
3428  
}
3429  
3430  
3431  
3432  
// defaults to false
3433  
static boolean boolOptPar(Object[] __, String name) {
3434  
  return boolOptParam(__, name);
3435  
}
3436  
3437  
static boolean boolOptPar(String name, Object[] __) {
3438  
  return boolOptParam(__, name);
3439  
}
3440  
3441  
3442  
static boolean neq(Object a, Object b) {
3443  
  return !eq(a, b);
3444  
}
3445  
3446  
3447  
static <A> HashSet<A> lithashset(A... items) {
3448  
  HashSet<A> set = new HashSet();
3449  
  for (A a : items) set.add(a);
3450  
  return set;
3451  
}
3452  
3453  
3454  
// supports the usual quotings (", variable length double brackets) except ' quoting
3455  
static boolean isQuoted(String s) {
3456  
  
3457  
  if (isNormalQuoted_dirty(s)) return true;
3458  
  
3459  
  
3460  
  return isMultilineQuoted(s);
3461  
}
3462  
3463  
3464  
static boolean isIdentifier(String s) {
3465  
  return isJavaIdentifier(s);
3466  
}
3467  
3468  
3469  
static boolean isInteger(String s) {
3470  
  int n = l(s);
3471  
  if (n == 0) return false;
3472  
  int i = 0;
3473  
  if (s.charAt(0) == '-')
3474  
    if (++i >= n) return false;
3475  
  while (i < n) {
3476  
    char c = s.charAt(i);
3477  
    if (c < '0' || c > '9') return false;
3478  
    ++i;
3479  
  }
3480  
  return true;
3481  
}
3482  
3483  
3484  
static boolean eqic(String a, String b) {
3485  
  
3486  
  
3487  
    if ((a == null) != (b == null)) return false;
3488  
    if (a == null) return true;
3489  
    return a.equalsIgnoreCase(b);
3490  
  
3491  
}
3492  
3493  
3494  
static boolean eqic(Symbol a, Symbol b) {
3495  
  return eq(a, b);
3496  
}
3497  
3498  
static boolean eqic(Symbol a, String b) {
3499  
  return eqic(asString(a), b);
3500  
}
3501  
3502  
3503  
static boolean eqic(char a, char b) {
3504  
  if (a == b) return true;
3505  
  
3506  
    char u1 = Character.toUpperCase(a);
3507  
    char u2 = Character.toUpperCase(b);
3508  
    if (u1 == u2) return true;
3509  
  
3510  
  return Character.toLowerCase(u1) == Character.toLowerCase(u2);
3511  
}
3512  
3513  
3514  
static volatile StringBuffer local_log = new StringBuffer(); // not redirected
3515  
3516  
3517  
3518  
3519  
static volatile Appendable print_log = local_log; // might be redirected, e.g. to main bot
3520  
3521  
// in bytes - will cut to half that
3522  
static volatile int print_log_max = 1024*1024;
3523  
static volatile int local_log_max = 100*1024;
3524  
3525  
static boolean print_silent = false; // total mute if set
3526  
3527  
static Object print_byThread_lock = new Object();
3528  
static volatile ThreadLocal<Object> print_byThread; // special handling by thread - prefers F1<S, Bool>
3529  
static volatile Object print_allThreads;
3530  
static volatile Object print_preprocess;
3531  
3532  
static void print() {
3533  
  print("");
3534  
}
3535  
3536  
static <A> A print(String s, A o) {
3537  
  print(combinePrintParameters(s, o));
3538  
  return o;
3539  
}
3540  
3541  
// slightly overblown signature to return original object...
3542  
static <A> A print(A o) {
3543  
  ping_okInCleanUp();
3544  
  if (print_silent) return o;
3545  
  String s = o + "\n";
3546  
  print_noNewLine(s);
3547  
  return o;
3548  
}
3549  
3550  
static void print_noNewLine(String s) {
3551  
  
3552  
  try {
3553  
    Object f = getThreadLocal(print_byThread_dontCreate());
3554  
    if (f == null) f = print_allThreads;
3555  
      if (f != null)
3556  
        // We do need the general callF machinery here as print_byThread is sometimes shared between modules
3557  
        if (isFalse(
3558  
          
3559  
            f instanceof F1 ? ((F1) f).get(s) :
3560  
          
3561  
          callF(f, s))) return;
3562  
  } catch (Throwable e) {
3563  
    System.out.println(getStackTrace(e));
3564  
  }
3565  
  
3566  
3567  
  print_raw(s);
3568  
}
3569  
3570  
static void print_raw(String s) {
3571  
  
3572  
  if (print_preprocess != null) s = (String) callF(print_preprocess, s);
3573  
  s = fixNewLines(s);
3574  
  
3575  
  Appendable loc = local_log;
3576  
  Appendable buf = print_log;
3577  
  int loc_max = print_log_max;
3578  
  if (buf != loc && buf != null) {
3579  
    print_append(buf, s, print_log_max);
3580  
    loc_max = local_log_max;
3581  
  }
3582  
  if (loc != null) 
3583  
    print_append(loc, s, loc_max);
3584  
  
3585  
  
3586  
    System.out.print(s);
3587  
  
3588  
  vmBus_send("printed", mc(), s);
3589  
}
3590  
3591  
static void print_autoRotate() {
3592  
  
3593  
}
3594  
3595  
3596  
static boolean checkTokCondition(Object condition, List<String> tok, int i) {
3597  
  if (condition instanceof TokCondition)
3598  
    return ((TokCondition) condition).get(tok, i);
3599  
  return checkCondition(condition, tok, i);
3600  
}
3601  
3602  
3603  
static <A> List<A> ll(A... a) {
3604  
  ArrayList l = new ArrayList(a.length);
3605  
  if (a != null) for (A x : a) l.add(x);
3606  
  return l;
3607  
}
3608  
3609  
3610  
static List syncMap(Object f, Map map) {
3611  
  return syncMap(map, f);
3612  
}
3613  
3614  
// map: func(key, value) -> list element
3615  
static List syncMap(Map map, Object f) {
3616  
  return map(cloneLinkedHashMap(map), f); // TODO: use a temporary list instead
3617  
}
3618  
3619  
static <A, B> Map<A, B> syncMap() {
3620  
  return synchroHashMap();
3621  
}
3622  
3623  
static <A, B> Map<A, B> syncMap(Map map) {
3624  
  return synchronizedMap(map);
3625  
}
3626  
3627  
3628  
static TreeSet<String> ciSet() {
3629  
  return caseInsensitiveSet();
3630  
}
3631  
3632  
3633  
static <A> A getFuture(Future<A> f) { try {
3634  
  return f == null ? null : f.get();
3635  
} catch (Exception __e) { throw rethrow(__e); } }
3636  
3637  
3638  
static <A> NowFuture<A> nowFuture(A a) {
3639  
  return new NowFuture(a);
3640  
}
3641  
3642  
3643  
static long sysNow() {
3644  
  ping();
3645  
  return System.nanoTime()/1000000;
3646  
}
3647  
3648  
3649  
static void vmKeepWithProgramMD5_get(String varName) {
3650  
  String struct =  (String) (callOpt(javax(), "vmKeep_get", programID(), md5OfMyJavaSource(), varName));
3651  
  if (struct != null)
3652  
    setOpt(mc(), varName, unstructure(struct));
3653  
}
3654  
3655  
3656  
static volatile PersistableThrowable _handleException_lastException;
3657  
static List _handleException_onException = synchroList(ll((IVF1<Throwable>) (__1 -> printStackTrace2(__1))));
3658  
static boolean _handleException_showThreadCancellations = false;
3659  
3660  
static void _handleException(Throwable e) {
3661  
  _handleException_lastException = persistableThrowable(e);
3662  
  
3663  
  Throwable e2 = innerException(e);
3664  
  if (e2.getClass() == RuntimeException.class && eq(e2.getMessage(), "Thread cancelled.") || e2 instanceof InterruptedException) {
3665  
    if (_handleException_showThreadCancellations)
3666  
      System.out.println(getStackTrace_noRecord(e2));
3667  
    return;
3668  
  }
3669  
3670  
  for (Object f : cloneList(_handleException_onException)) try {
3671  
    callF(f, e);
3672  
  } catch (Throwable e3) {
3673  
    try {
3674  
      printStackTrace2(e3); // not using pcall here - it could lead to endless loops
3675  
    } catch (Throwable e4) {
3676  
      System.out.println(getStackTrace(e3));
3677  
      System.out.println(getStackTrace(e4));
3678  
    }
3679  
  }
3680  
}
3681  
3682  
3683  
static volatile int numberOfCores_value;
3684  
3685  
static int numberOfCores() {
3686  
  if (numberOfCores_value == 0)
3687  
    numberOfCores_value = Runtime.getRuntime().availableProcessors();
3688  
  return numberOfCores_value;
3689  
}
3690  
3691  
3692  
static <A> A or(A a, A b) {
3693  
  return a != null ? a : b;
3694  
}
3695  
3696  
3697  
// this syntax should be removed...
3698  
static Object getThreadLocal(Object o, String name) {
3699  
  ThreadLocal t =  (ThreadLocal) (getOpt(o, name));
3700  
  return t != null ? t.get() : null;
3701  
}
3702  
3703  
static <A> A getThreadLocal(ThreadLocal<A> tl) {
3704  
  return tl == null ? null : tl.get();
3705  
}
3706  
3707  
static <A> A getThreadLocal(ThreadLocal<A> tl, A defaultValue) {
3708  
  return or(getThreadLocal(tl), defaultValue);
3709  
}
3710  
3711  
3712  
static Object getOpt(Object o, String field) {
3713  
  return getOpt_cached(o, field);
3714  
}
3715  
3716  
static Object getOpt(String field, Object o) {
3717  
  return getOpt_cached(o, field);
3718  
}
3719  
3720  
static Object getOpt_raw(Object o, String field) { try {
3721  
  Field f = getOpt_findField(o.getClass(), field);
3722  
  if (f == null) return null;
3723  
  makeAccessible(f);
3724  
  return f.get(o);
3725  
} catch (Exception __e) { throw rethrow(__e); } }
3726  
3727  
// access of static fields is not yet optimized
3728  
static Object getOpt(Class c, String field) { try {
3729  
  if (c == null) return null;
3730  
  Field f = getOpt_findStaticField(c, field);
3731  
  if (f == null) return null;
3732  
  makeAccessible(f);
3733  
  return f.get(null);
3734  
} catch (Exception __e) { throw rethrow(__e); } }
3735  
3736  
static Field getOpt_findStaticField(Class<?> c, String field) {
3737  
  Class _c = c;
3738  
  do {
3739  
    for (Field f : _c.getDeclaredFields())
3740  
      if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
3741  
        return f;
3742  
    _c = _c.getSuperclass();
3743  
  } while (_c != null);
3744  
  return null;
3745  
}
3746  
3747  
3748  
3749  
static Class javax() {
3750  
  return getJavaX();
3751  
}
3752  
3753  
3754  
static ThreadLocal<Object> print_byThread() {
3755  
  synchronized(print_byThread_lock) {
3756  
    if (print_byThread == null)
3757  
      print_byThread = new ThreadLocal();
3758  
  }
3759  
  return print_byThread;
3760  
}
3761  
3762  
3763  
// f can return false to suppress regular printing
3764  
// call print_raw within f to actually print something
3765  
static AutoCloseable tempInterceptPrint(F1<String, Boolean> f) {
3766  
  return tempSetThreadLocal(print_byThread(), f);
3767  
}
3768  
3769  
3770  
// get purpose 1: access a list/array/map (safer version of x.get(y))
3771  
3772  
static <A> A get(List<A> l, int idx) {
3773  
  return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;
3774  
}
3775  
3776  
// seems to conflict with other signatures
3777  
/*static <A, B> B get(Map<A, B> map, A key) {
3778  
  ret map != null ? map.get(key) : null;
3779  
}*/
3780  
3781  
static <A> A get(A[] l, int idx) {
3782  
  return idx >= 0 && idx < l(l) ? l[idx] : null;
3783  
}
3784  
3785  
// default to false
3786  
static boolean get(boolean[] l, int idx) {
3787  
  return idx >= 0 && idx < l(l) ? l[idx] : false;
3788  
}
3789  
3790  
// get purpose 2: access a field by reflection or a map
3791  
3792  
static Object get(Object o, String field) {
3793  
  try {
3794  
    if (o == null) return null;
3795  
    if (o instanceof Class) return get((Class) o, field);
3796  
    
3797  
    if (o instanceof Map)
3798  
      return ((Map) o).get(field);
3799  
      
3800  
    Field f = getOpt_findField(o.getClass(), field);
3801  
    if (f != null) {
3802  
      makeAccessible(f);
3803  
      return f.get(o);
3804  
    }
3805  
      
3806  
    
3807  
      if (o instanceof DynamicObject)
3808  
        return getOptDynOnly(((DynamicObject) o), field);
3809  
    
3810  
  } catch (Exception e) {
3811  
    throw asRuntimeException(e);
3812  
  }
3813  
  throw new RuntimeException("Field '" + field + "' not found in " + o.getClass().getName());
3814  
}
3815  
3816  
static Object get_raw(String field, Object o) {
3817  
  return get_raw(o, field);
3818  
}
3819  
3820  
static Object get_raw(Object o, String field) { try {
3821  
  if (o == null) return null;
3822  
  Field f = get_findField(o.getClass(), field);
3823  
  makeAccessible(f);
3824  
  return f.get(o);
3825  
} catch (Exception __e) { throw rethrow(__e); } }
3826  
3827  
static Object get(Class c, String field) {
3828  
  try {
3829  
    Field f = get_findStaticField(c, field);
3830  
    makeAccessible(f);
3831  
    return f.get(null);
3832  
  } catch (Exception e) {
3833  
    throw new RuntimeException(e);
3834  
  }
3835  
}
3836  
3837  
static Field get_findStaticField(Class<?> c, String field) {
3838  
  Class _c = c;
3839  
  do {
3840  
    for (Field f : _c.getDeclaredFields())
3841  
      if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
3842  
        return f;
3843  
    _c = _c.getSuperclass();
3844  
  } while (_c != null);
3845  
  throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
3846  
}
3847  
3848  
static Field get_findField(Class<?> c, String field) {
3849  
  Class _c = c;
3850  
  do {
3851  
    for (Field f : _c.getDeclaredFields())
3852  
      if (f.getName().equals(field))
3853  
        return f;
3854  
    _c = _c.getSuperclass();
3855  
  } while (_c != null);
3856  
  throw new RuntimeException("Field '" + field + "' not found in " + c.getName());
3857  
}
3858  
3859  
static Object get(String field, Object o) {
3860  
  return get(o, field);
3861  
}
3862  
3863  
static boolean get(BitSet bs, int idx) {
3864  
  return bs != null && bs.get(idx);
3865  
}
3866  
3867  
3868  
static Map<Class, ArrayList<Method>> callF_cache = newDangerousWeakHashMap();
3869  
3870  
3871  
  static <A> A callF(F0<A> f) {
3872  
    return f == null ? null : f.get();
3873  
  }
3874  
3875  
3876  
3877  
  static <A, B> B callF(F1<A, B> f, A a) {
3878  
    return f == null ? null : f.get(a);
3879  
  }
3880  
3881  
3882  
3883  
  static <A> A callF(IF0<A> f) {
3884  
    return f == null ? null : f.get();
3885  
  }
3886  
3887  
3888  
3889  
  static <A, B> B callF(IF1<A, B> f, A a) {
3890  
    return f == null ? null : f.get(a);
3891  
  }
3892  
3893  
3894  
3895  
  static <A, B, C> C callF(F2<A, B, C> f, A a, B b) {
3896  
    return f == null ? null : f.get(a, b);
3897  
  }
3898  
3899  
3900  
3901  
  static <A, B, C> C callF(IF2<A, B, C> f, A a, B b) {
3902  
    return f == null ? null : f.get(a, b);
3903  
  }
3904  
3905  
3906  
3907  
  static <A> void callF(VF1<A> f, A a) {
3908  
    if (f != null) f.get(a);
3909  
  }
3910  
3911  
3912  
static Object callF(Runnable r) { { if (r != null) r.run(); } return null; }
3913  
3914  
static Object callF(Object f, Object... args) {
3915  
  if (f instanceof String)
3916  
    return callMCWithVarArgs((String) f, args); // possible SLOWDOWN over callMC
3917  
    
3918  
  return safeCallF(f, args);
3919  
}
3920  
3921  
static Object safeCallF(Object f, Object... args) {
3922  
  if (f instanceof Runnable) {
3923  
    ((Runnable) f).run();
3924  
    return null;
3925  
  }
3926  
  if (f == null) return null;
3927  
  
3928  
  Class c = f.getClass();
3929  
  ArrayList<Method> methods;
3930  
  synchronized(callF_cache) {
3931  
    methods = callF_cache.get(c);
3932  
    if (methods == null)
3933  
      methods = callF_makeCache(c);
3934  
  }
3935  
  
3936  
  int n = l(methods);
3937  
  if (n == 0) {
3938  
    
3939  
    throw fail("No get method in " + getClassName(c));
3940  
  }
3941  
  if (n == 1) return invokeMethod(methods.get(0), f, args);
3942  
  for (int i = 0; i < n; i++) {
3943  
    Method m = methods.get(i);
3944  
    if (call_checkArgs(m, args, false))
3945  
      return invokeMethod(m, f, args);
3946  
  }
3947  
  throw fail("No matching get method in " + getClassName(c));
3948  
}
3949  
3950  
// used internally
3951  
static ArrayList<Method> callF_makeCache(Class c) {
3952  
  ArrayList<Method> l = new ArrayList();
3953  
  Class _c = c;
3954  
  do {
3955  
    for (Method m : _c.getDeclaredMethods())
3956  
      if (m.getName().equals("get")) {
3957  
        makeAccessible(m);
3958  
        l.add(m);
3959  
      }
3960  
    if (!l.isEmpty()) break;
3961  
    _c = _c.getSuperclass();
3962  
  } while (_c != null);
3963  
  callF_cache.put(c, l);
3964  
  return l;
3965  
}
3966  
3967  
3968  
static String formatInt(int i, int digits) {
3969  
  return padLeft(str(i), '0', digits);
3970  
}
3971  
3972  
static String formatInt(long l, int digits) {
3973  
  return padLeft(str(l), '0', digits);
3974  
}
3975  
3976  
3977  
// f can return false to suppress regular printing
3978  
// call print_raw within f to actually print something
3979  
// f preferrably is F1<S, Bool>
3980  
static Object interceptPrintInThisThread(Object f) {
3981  
  Object old = print_byThread().get();
3982  
  print_byThread().set(f);
3983  
  return old;
3984  
}
3985  
3986  
3987  
static void _close(AutoCloseable c) {
3988  
  if (c != null) try {
3989  
    c.close();
3990  
  } catch (Throwable e) {
3991  
    // Some classes stupidly throw an exception on double-closing
3992  
    if (c instanceof javax.imageio.stream.ImageOutputStream)
3993  
      return;
3994  
    else throw rethrow(e);
3995  
  }
3996  
}
3997  
3998  
3999  
static boolean sameSnippetID(String a, String b) {
4000  
  if (!isSnippetID(a) || !isSnippetID(b)) return false;
4001  
  return parseSnippetID(a) == parseSnippetID(b);
4002  
}
4003  
4004  
4005  
static String programID() {
4006  
  return getProgramID();
4007  
}
4008  
4009  
static String programID(Object o) {
4010  
  return getProgramID(o);
4011  
}
4012  
4013  
4014  
static String defaultJavaXTranslatorID_value = "#759";
4015  
4016  
static String defaultJavaXTranslatorID() {
4017  
  return defaultJavaXTranslatorID_value;
4018  
}
4019  
4020  
4021  
static void setDefaultJavaXTranslatorID(String snippetID) {
4022  
  defaultJavaXTranslatorID_value = snippetID;
4023  
}
4024  
4025  
4026  
  static String mainJava;
4027  
  
4028  
  static String loadMainJava() throws IOException {
4029  
    if (mainJava != null) return mainJava;
4030  
    return loadTextFile("input/main.java", "");
4031  
  }
4032  
4033  
4034  
static int identityHashCode(Object o) {
4035  
  return System.identityHashCode(o);
4036  
}
4037  
4038  
4039  
static <A> HashSet<A> cloneHashSet(Collection<A> set) {
4040  
  if (set == null) return new HashSet();
4041  
  synchronized(collectionMutex(set)) {
4042  
    HashSet < A > s = new HashSet<>(l(set));
4043  
    s.addAll(set);
4044  
    return s;
4045  
  }
4046  
}
4047  
4048  
4049  
static Set<String> tok_mapLikeFunctions_set = emptySet();
4050  
  
4051  
static Set<String> tok_mapLikeFunctions() {
4052  
  return tok_mapLikeFunctions_set;
4053  
}
4054  
4055  
4056  
static Set<String> tok_mapMethodLikeFunctions_set = asHashSet(
4057  
  splitAtSpace("mapMethod uniquifyByField indexByField collect"));
4058  
  
4059  
static Set<String> tok_mapMethodLikeFunctions() {
4060  
  return tok_mapMethodLikeFunctions_set;
4061  
}
4062  
4063  
4064  
  static boolean hasCodeTokens(List<String> tok, String... tokens) {
4065  
    return findCodeTokens(tok, tokens) >= 0;
4066  
  }
4067  
4068  
4069  
static int l(Object[] a) { return a == null ? 0 : a.length; }
4070  
static int l(boolean[] a) { return a == null ? 0 : a.length; }
4071  
static int l(byte[] a) { return a == null ? 0 : a.length; }
4072  
static int l(short[] a) { return a == null ? 0 : a.length; }
4073  
static int l(long[] a) { return a == null ? 0 : a.length; }
4074  
static int l(int[] a) { return a == null ? 0 : a.length; }
4075  
static int l(float[] a) { return a == null ? 0 : a.length; }
4076  
static int l(double[] a) { return a == null ? 0 : a.length; }
4077  
static int l(char[] a) { return a == null ? 0 : a.length; }
4078  
static int l(Collection c) { return c == null ? 0 : c.size(); }
4079  
4080  
static int l(Iterator i) { return iteratorCount_int_close(i); } // consumes the iterator && closes it if possible
4081  
4082  
static int l(Map m) { return m == null ? 0 : m.size(); }
4083  
static int l(CharSequence s) { return s == null ? 0 : s.length(); }
4084  
static long l(File f) { return f == null ? 0 : f.length(); }
4085  
4086  
4087  
4088  
static int l(Object o) {
4089  
  return o == null ? 0
4090  
    : o instanceof String ? l((String) o)
4091  
    : o instanceof Map ? l((Map) o)
4092  
    : o instanceof Collection ? l((Collection) o)
4093  
    : o instanceof Object[] ? l((Object[]) o)
4094  
    : o instanceof boolean[] ? l((boolean[]) o)
4095  
    : o instanceof byte[] ? l((byte[]) o)
4096  
    : o instanceof char[] ? l((char[]) o)
4097  
    : o instanceof short[] ? l((short[]) o)
4098  
    : o instanceof int[] ? l((int[]) o)
4099  
    : o instanceof float[] ? l((float[]) o)
4100  
    : o instanceof double[] ? l((double[]) o)
4101  
    : o instanceof long[] ? l((long[]) o)
4102  
    : (Integer) call(o, "size");
4103  
}
4104  
4105  
4106  
4107  
  static int l(MultiSet ms) { return ms == null ? 0 : ms.size(); }
4108  
4109  
4110  
4111  
4112  
4113  
  static int l(IntRange r) { return r == null ? 0 : r.length(); }
4114  
4115  
4116  
4117  
4118  
4119  
4120  
4121  
4122  
4123  
4124  
4125  
4126  
static <A> List<A> singlePlusList(A a, Collection<A> l) {
4127  
  return itemPlusList(a, l);
4128  
}
4129  
4130  
4131  
4132  
static Object first(Object list) {
4133  
  return first((Iterable) list);
4134  
}
4135  
4136  
4137  
static <A> A first(List<A> list) {
4138  
  return empty(list) ? null : list.get(0);
4139  
}
4140  
4141  
static <A> A first(A[] bla) {
4142  
  return bla == null || bla.length == 0 ? null : bla[0];
4143  
}
4144  
4145  
4146  
static <A> A first(IterableIterator<A> i) {
4147  
  return first((Iterator<A>) i);
4148  
}
4149  
4150  
4151  
static <A> A first(Iterator<A> i) {
4152  
  return i == null || !i.hasNext() ? null : i.next();
4153  
}
4154  
4155  
static <A> A first(Iterable<A> i) {
4156  
  if (i == null) return null;
4157  
  Iterator<A> it = i.iterator();
4158  
  return it.hasNext() ? it.next() : null;
4159  
}
4160  
4161  
static Character first(String s) { return empty(s) ? null : s.charAt(0); }
4162  
static Character first(CharSequence s) { return empty(s) ? null : s.charAt(0); }
4163  
4164  
4165  
static <A, B> A first(Pair<A, B> p) {
4166  
  return p == null ? null : p.a;
4167  
}
4168  
4169  
4170  
4171  
static <A, B, C> A first(T3<A, B, C> t) {
4172  
  return t == null ? null : t.a;
4173  
}
4174  
4175  
4176  
static Byte first(byte[] l) { 
4177  
  return empty(l) ? null : l[0];
4178  
}
4179  
4180  
4181  
4182  
4183  
4184  
static <A> A first(A[] l, IF1<A, Boolean> pred) {
4185  
  return firstThat(l, pred);
4186  
}
4187  
4188  
static <A> A first(Iterable<A> l, IF1<A, Boolean> pred) {
4189  
  return firstThat(l, pred);
4190  
}
4191  
4192  
static <A> A first(IF1<A, Boolean> pred, Iterable<A> l) {
4193  
  return firstThat(pred, l);
4194  
}
4195  
4196  
4197  
static String[] dropFirst(int n, String[] a) {
4198  
  return drop(n, a);
4199  
}
4200  
4201  
static String[] dropFirst(String[] a) {
4202  
  return drop(1, a);
4203  
}
4204  
4205  
static Object[] dropFirst(Object[] a) {
4206  
  return drop(1, a);
4207  
}
4208  
4209  
static <A> List<A> dropFirst(List<A> l) {
4210  
  return dropFirst(1, l);
4211  
}
4212  
4213  
static <A> List<A> dropFirst(int n, Iterable<A> i) { return dropFirst(n, toList(i)); }
4214  
static <A> List<A> dropFirst(Iterable<A> i) { return dropFirst(toList(i)); }
4215  
4216  
static <A> List<A> dropFirst(int n, List<A> l) {
4217  
  return n <= 0 ? l : new ArrayList(l.subList(Math.min(n, l.size()), l.size()));
4218  
}
4219  
4220  
static <A> List<A> dropFirst(List<A> l, int n) {
4221  
  return dropFirst(n, l);
4222  
}
4223  
4224  
static String dropFirst(int n, String s) { return substring(s, n); }
4225  
static String dropFirst(String s, int n) { return substring(s, n); }
4226  
static String dropFirst(String s) { return substring(s, 1); }
4227  
4228  
4229  
4230  
4231  
// TODO: extended multi-line strings
4232  
4233  
static int javaTok_n, javaTok_elements;
4234  
static boolean javaTok_opt = false;
4235  
4236  
static List<String> javaTok(String s) {
4237  
  ++javaTok_n;
4238  
  ArrayList<String> tok = new ArrayList();
4239  
  int l = s == null ? 0 : s.length();
4240  
  
4241  
  int i = 0;
4242  
  while (i < l) {
4243  
    int j = i;
4244  
    char c, d;
4245  
    
4246  
        // scan for whitespace
4247  
        while (j < l) {
4248  
          c = s.charAt(j);
4249  
          d = j+1 >= l ? '\0' : s.charAt(j+1);
4250  
          if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
4251  
            ++j;
4252  
          else if (c == '/' && d == '*') {
4253  
            do ++j; while (j < l && !regionMatches(s, j, "*/"));
4254  
            j = Math.min(j+2, l);
4255  
          } else if (c == '/' && d == '/') {
4256  
            do ++j; while (j < l && "\r\n".indexOf(s.charAt(j)) < 0);
4257  
          } else
4258  
            break;
4259  
        }
4260  
        
4261  
        tok.add(javaTok_substringN(s, i, j));
4262  
        i = j;
4263  
        if (i >= l) break;
4264  
        c = s.charAt(i);
4265  
        d = i+1 >= l ? '\0' : s.charAt(i+1);
4266  
    
4267  
        // scan for non-whitespace
4268  
        
4269  
        // Special JavaX syntax: 'identifier
4270  
        if (c == '\'' && Character.isJavaIdentifierStart(d) && i+2 < l && "'\\".indexOf(s.charAt(i+2)) < 0) {
4271  
          j += 2;
4272  
          while (j < l && Character.isJavaIdentifierPart(s.charAt(j)))
4273  
            ++j;
4274  
        } else if (c == '\'' || c == '"') {
4275  
          char opener = c;
4276  
          ++j;
4277  
          while (j < l) {
4278  
            int c2 = s.charAt(j);
4279  
            if (c2 == opener || c2 == '\n' && opener == '\'') { // allow multi-line strings, but not for '
4280  
              ++j;
4281  
              break;
4282  
            } else if (c2 == '\\' && j+1 < l)
4283  
              j += 2;
4284  
            else
4285  
              ++j;
4286  
          }
4287  
        } else if (Character.isJavaIdentifierStart(c))
4288  
          do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || s.charAt(j) == '\'')); // for stuff like "don't"
4289  
        else if (Character.isDigit(c)) {
4290  
          do ++j; while (j < l && Character.isDigit(s.charAt(j)));
4291  
          if (j < l && s.charAt(j) == 'L') ++j; // Long constants like 1L
4292  
        } else if (c == '[' && d == '[') {
4293  
          do ++j; while (j < l && !regionMatches(s, j, "]]"));
4294  
          j = Math.min(j+2, l);
4295  
        } else if (c == '[' && d == '=' && i+2 < l && s.charAt(i+2) == '[') {
4296  
          do ++j; while (j+2 < l && !regionMatches(s, j, "]=]"));
4297  
          j = Math.min(j+3, l);
4298  
        } else
4299  
          ++j;
4300  
      
4301  
    tok.add(javaTok_substringC(s, i, j));
4302  
    i = j;
4303  
  }
4304  
  
4305  
  if ((tok.size() % 2) == 0) tok.add("");
4306  
  javaTok_elements += tok.size();
4307  
  return tok;
4308  
}
4309  
4310  
static List<String> javaTok(List<String> tok) {
4311  
  return javaTokWithExisting(join(tok), tok);
4312  
}
4313  
4314  
4315  
static void replaceTokens_reTok(List<String> tok, int i, int j, String s) {
4316  
  replaceTokens(tok, i, j, s);
4317  
  reTok(tok, i, j);
4318  
}
4319  
4320  
4321  
static String unnull(String s) {
4322  
  return s == null ? "" : s;
4323  
}
4324  
4325  
static <A> Collection<A> unnull(Collection<A> l) {
4326  
  return l == null ? emptyList() : l;
4327  
}
4328  
4329  
static <A> List<A> unnull(List<A> l) { return l == null ? emptyList() : l; }
4330  
static int[] unnull(int[] l) { return l == null ? emptyIntArray() : l; }
4331  
static char[] unnull(char[] l) { return l == null ? emptyCharArray() : l; }
4332  
static double[] unnull(double[] l) { return l == null ? emptyDoubleArray() : l; }
4333  
4334  
static <A, B> Map<A, B> unnull(Map<A, B> l) {
4335  
  return l == null ? emptyMap() : l;
4336  
}
4337  
4338  
static <A> Iterable<A> unnull(Iterable<A> i) {
4339  
  return i == null ? emptyList() : i;
4340  
}
4341  
4342  
static <A> A[] unnull(A[] a) {
4343  
  return a == null ? (A[]) emptyObjectArray() : a;
4344  
}
4345  
4346  
static BitSet unnull(BitSet b) {
4347  
  return b == null ? new BitSet() : b;
4348  
}
4349  
4350  
4351  
4352  
//ifclass Symbol
4353  
4354  
static Symbol unnull(Symbol s) {
4355  
  return s == null ? emptySymbol() : s;
4356  
}
4357  
//endif
4358  
4359  
4360  
4361  
static <A, B> Pair<A, B> unnull(Pair<A, B> p) {
4362  
  return p != null ? p : new Pair(null, null);
4363  
}
4364  
4365  
4366  
static int unnull(Integer i) { return i == null ? 0 : i; }
4367  
static long unnull(Long l) { return l == null ? 0L : l; }
4368  
static double unnull(Double l) { return l == null ? 0.0 : l; }
4369  
4370  
4371  
static List<String> tok_moveImportsUp(List<String> tok) {
4372  
  StringBuilder buf = new StringBuilder();
4373  
  
4374  
  //print("tok_moveImportsUp n=" + l(tok));
4375  
  //print("Source begins: " + quote(shorten(join(tok), 200)));
4376  
  
4377  
  // scan imports on top
4378  
  int i;
4379  
  Set<String> have = new HashSet();
4380  
  for (i = 1; i < l(tok); i += 2)
4381  
    if (eq(tok.get(i), "import")) {
4382  
      int j = indexOf(tok, i+2, ";");
4383  
      if (j < 0) break;
4384  
      String s = joinSubList(tok, i, j+1);
4385  
      have.add(s);
4386  
      i = j;
4387  
    } else break;
4388  
  
4389  
  //print("tok_moveImportsUp have " + l(have) + " after " + i);
4390  
  
4391  
  List<IntRange> reToks = new ArrayList();
4392  
  
4393  
  // scan imports in text
4394  
  for (; i < l(tok); i += 2)
4395  
    if (eq(tok.get(i), "import")) {
4396  
      int j = indexOf(tok, i+2, ";");
4397  
      if (j < 0) continue; // huh?
4398  
      String s = joinSubList(tok, i, j+1);
4399  
      //print("Found import at " + i + ": " + s);
4400  
      if (!have.contains(s)) {
4401  
        buf.append(s).append("\n");
4402  
        have.add(s);
4403  
      }
4404  
      replaceTokens(tok, i, j+1, "");
4405  
      
4406  
      i -= 2;
4407  
    }
4408  
    
4409  
  if (nempty(buf)) {
4410  
    if (l(tok) == 1) addAll(tok, "", "");
4411  
    tok.set(1, str(buf)+"\n"+tok.get(1));
4412  
    reToks.add(intRange(1, 2));
4413  
  }
4414  
    
4415  
  return reTok_multi(tok, reToks);
4416  
}
4417  
4418  
4419  
static boolean tok_hasTranslators(List<String> tok) {
4420  
  int n = l(tok)-2;
4421  
  for (int i = 1; i < n; i += 2)
4422  
    if (tok.get(i).equals("!") && isInteger(tok.get(i+2)))
4423  
      return true;
4424  
  return false;
4425  
}
4426  
4427  
4428  
static String defaultTranslate(String text) {
4429  
  Class javax = getJavaX();
4430  
  File x = makeTempDir();
4431  
  saveTextFile(new File(x, "main.java"), text);
4432  
  List<File> libraries_out = new ArrayList();
4433  
  List<String> libraries2_out = new ArrayList();
4434  
  File y =  (File) (call(javax, "defaultTranslate", x, libraries_out, libraries2_out));
4435  
  if (y == null) return null;
4436  
  return loadTextFile(new File(y, "main.java"));
4437  
}
4438  
4439  
4440  
4441  
public static <A> String join(String glue, Iterable<A> strings) {
4442  
  if (strings == null) return "";
4443  
  if (strings instanceof Collection) {
4444  
    if (((Collection) strings).size() == 1) return str(first((Collection) strings));
4445  
  }
4446  
  StringBuilder buf = new StringBuilder();
4447  
  Iterator<A> i = strings.iterator();
4448  
  if (i.hasNext()) {
4449  
    buf.append(i.next());
4450  
    while (i.hasNext())
4451  
      buf.append(glue).append(i.next());
4452  
  }
4453  
  return buf.toString();
4454  
}
4455  
4456  
public static String join(String glue, String... strings) {
4457  
  return join(glue, Arrays.asList(strings));
4458  
}
4459  
4460  
static <A> String join(Iterable<A> strings) {
4461  
  return join("", strings);
4462  
}
4463  
4464  
static <A> String join(Iterable<A> strings, String glue) {
4465  
  return join(glue, strings);
4466  
}
4467  
4468  
public static String join(String[] strings) {
4469  
  return join("", strings);
4470  
}
4471  
4472  
4473  
static String join(String glue, Pair p) {
4474  
  return p == null ? "" : str(p.a) + glue + str(p.b);
4475  
}
4476  
4477  
4478  
4479  
static void tok_metaTransformNow(List<String> tok) {
4480  
  int i = -1;
4481  
  while ((i = jfind(tok, i+1, "meta-transformNow {")) >= 0) {
4482  
    int iOpening = indexOf(tok, i, "{");
4483  
    int iClosing = findEndOfBracketPart(tok, iOpening)-1;
4484  
    String code = joinSubList(tok, iOpening+2, iClosing-1);
4485  
    clearTokens_reTok(tok, i, iClosing+1);
4486  
    tok_runMetaTransformer(tok, code);
4487  
  }
4488  
}
4489  
4490  
4491  
4492  
4493  
4494  
//sbool ping_actions_shareable = true;
4495  
static volatile boolean ping_pauseAll = false;
4496  
static int ping_sleep = 100; // poll pauseAll flag every 100
4497  
static volatile boolean ping_anyActions = false;
4498  
static Map<Thread, Object> ping_actions = newWeakHashMap();
4499  
static ThreadLocal<Boolean> ping_isCleanUpThread = new ThreadLocal();
4500  
4501  
// always returns true
4502  
static boolean ping() {
4503  
  //ifdef useNewPing
4504  
  newPing();
4505  
  //endifdef
4506  
  if (ping_pauseAll || ping_anyActions) ping_impl(true /* XXX */);
4507  
  //ifndef LeanMode ping_impl(); endifndef
4508  
  return true;
4509  
}
4510  
4511  
// returns true when it slept
4512  
static boolean ping_impl(boolean okInCleanUp) { try {
4513  
  if (ping_pauseAll && !isAWTThread()) {
4514  
    do
4515  
      Thread.sleep(ping_sleep);
4516  
    while (ping_pauseAll);
4517  
    return true;
4518  
  }
4519  
  
4520  
  if (ping_anyActions) { // don't allow sharing ping_actions
4521  
    if (!okInCleanUp && !isTrue(ping_isCleanUpThread.get()))
4522  
      failIfUnlicensed();
4523  
    Object action = null;
4524  
    synchronized(ping_actions) {
4525  
      if (!ping_actions.isEmpty()) {
4526  
        action = ping_actions.get(currentThread());
4527  
        if (action instanceof Runnable)
4528  
          ping_actions.remove(currentThread());
4529  
        if (ping_actions.isEmpty()) ping_anyActions = false;
4530  
      }
4531  
    }
4532  
    
4533  
    if (action instanceof Runnable)
4534  
      ((Runnable) action).run();
4535  
    else if (eq(action, "cancelled"))
4536  
      throw fail("Thread cancelled.");
4537  
  }
4538  
4539  
  return false;
4540  
} catch (Exception __e) { throw rethrow(__e); } }
4541  
4542  
4543  
4544  
static <A> ArrayList<A> cloneList(Iterable<A> l) {
4545  
  return l instanceof Collection ? cloneList((Collection) l) : asList(l);
4546  
}
4547  
4548  
static <A> ArrayList<A> cloneList(Collection<A> l) {
4549  
  if (l == null) return new ArrayList();
4550  
  synchronized(collectionMutex(l)) {
4551  
    return new ArrayList<A>(l);
4552  
  }
4553  
}
4554  
4555  
4556  
4557  
4558  
static String jreplace(String s, String in, String out) {
4559  
  return jreplace(s, in, out, null);
4560  
}
4561  
4562  
static String jreplace(String s, String in, String out, Object condition) {
4563  
  List<String> tok = javaTok(s);
4564  
  return jreplace(tok, in, out, condition) ? join(tok) : s;
4565  
}
4566  
4567  
// leaves tok properly tokenized
4568  
// returns true iff anything was replaced
4569  
static boolean jreplace(List<String> tok, String in, String out) {
4570  
  return jreplace(tok, in, out, false, true, null);
4571  
}
4572  
4573  
static boolean jreplace(List<String> tok, String in, String out, Object condition) {
4574  
  return jreplace(tok, in, out, false, true, condition);
4575  
}
4576  
4577  
static boolean jreplace(List<String> tok, String in, String out, IF2<List<String>, Integer, Boolean> condition) {
4578  
  return jreplace(tok, in, out, (Object) condition);
4579  
}
4580  
4581  
static boolean jreplace(List<String> tok, String in, String out, boolean ignoreCase, boolean reTok, Object condition) {
4582  
  String[] toks = javaTokForJFind_array(in);
4583  
  int lTokin = toks.length*2+1;
4584  
4585  
  boolean anyChange = false;
4586  
  int i = -1;
4587  
  for (int n = 0; n < 10000; n++) { // TODO: don't need this check anymore
4588  
    i = findCodeTokens(tok, i+1, ignoreCase, toks, condition);
4589  
    if (i < 0)
4590  
      return anyChange;
4591  
    List<String> subList = tok.subList(i-1, i+lTokin-1); // N to N
4592  
    String expansion = jreplaceExpandRefs(out, subList);
4593  
    int end = i+lTokin-2;
4594  
    
4595  
    jreplace_performing(tok, i, end, expansion);
4596  
    
4597  
    clearAllTokens(tok, i, end); // C to C
4598  
    tok.set(i, expansion);
4599  
    if (reTok) // would this ever be false??
4600  
      reTok(tok, i, end);
4601  
    i = end;
4602  
    anyChange = true;
4603  
  }
4604  
  throw fail("woot? 10000! " + quote(in) + " => " + quote(out));
4605  
}
4606  
4607  
static boolean jreplace_debug = false;
4608  
4609  
4610  
static void tok_selfType(List<String> tok) {
4611  
  int i;
4612  
  mainLoop: while ((i = jfind(tok, "selfType <id>")) >= 0) {
4613  
    // Now find class name by going backwards.
4614  
    
4615  
    int j = i, level = 1;
4616  
    while (j > 0 && level > 0) {
4617  
      String t = tok.get(j);
4618  
      if (t.equals("}")) ++level;
4619  
      if (t.equals("{")) --level;
4620  
      j -= 2;
4621  
    }
4622  
    
4623  
    // search for class name
4624  
    while (j > 0) {
4625  
      String t = tok.get(j);
4626  
      if (t.equals("class")) {
4627  
        String className = tok.get(j+2);
4628  
        tok.set(i, className);
4629  
        
4630  
        continue mainLoop;
4631  
      }
4632  
      j -= 2;
4633  
    }
4634  
    tok.set(i, "Object"); // avoid endless loop
4635  
  }
4636  
}
4637  
4638  
4639  
// extra commas - e.g. ll(1, 2,) => ll(1, 2)
4640  
static void tok_dropExtraCommas(List<String> tok) {
4641  
  jreplace(tok, ",)", ")");
4642  
}
4643  
4644  
4645  
static void tok_delegateTo(List<String> tok) {
4646  
  jreplace(tok, "delegate <id> to <id>.", "replace $2 with $4.$2.");
4647  
  jreplace(tok, "delegate <id> to <id>().", "replace $2 with $4().$2.");
4648  
  // TODO: general expressions in "to" clause
4649  
}
4650  
4651  
4652  
4653  
static void tok_replaceWith(List<String> tok) {
4654  
  int i;
4655  
  while  ((i = jfind(tok, "replace <id> with")) >= 0) { ping(); 
4656  
    String token = tok.get(i+2);
4657  
    int repStart = i+6;
4658  
    int repEnd = repStart;
4659  
    
4660  
    // Find . with space or line break or EOF afterwards
4661  
    while  (repEnd < l(tok) && !(
4662  
      eqGet(tok, repEnd, ".") && // end when there is a dot
4663  
      (nempty(get(tok, repEnd+1)) || repEnd == l(tok)-2))) // ...and it's the end of the text OR there is a space or newline after the dot
4664  
      { ping(); repEnd += 2; }
4665  
    print("tok_replaceWith: Found " + joinSubList(tok, repStart, repEnd));
4666  
    //int repEnd = smartIndexOf(tok, repStart, ".");
4667  
4668  
    String replacement = joinSubList(tok, repStart, repEnd-1);
4669  
    clearTokens(tok, i, repEnd+1);
4670  
    print("Replacing " + token + " with " + replacement + ".");
4671  
    int end = findEndOfBlock(tok, repEnd)-1;
4672  
    for  (int j = repEnd+2; j < end; j += 2)
4673  
      { ping(); if (eq(tok.get(j), token)) tok.set(j, replacement); }
4674  
    reTok(tok, i, end);
4675  
  }
4676  
}
4677  
4678  
4679  
4680  
// example:
4681  
// sS loadTextFile(File/S file) { ... }
4682  
4683  
static void tok_multiTypeArguments_v2(List<String> tok) {
4684  
  int i;
4685  
  
4686  
  // File/S
4687  
  
4688  
  while ((i = jfind(tok, "File/<id> <id>", (_tok, nIdx) ->
4689  
    eqGetOneOf(_tok, nIdx+5, "S", "String"))) >= 0) {
4690  
      
4691  
    String argName = tok.get(i+6);
4692  
    String mainType = tok.get(i), altType = tok.get(i+4);
4693  
    String converter = "newFile";
4694  
    String expr = converter + "(" + argName + ")";
4695  
    
4696  
    tok_expandMultiTypeArgument(tok,
4697  
      i, i+8,
4698  
      argName,
4699  
      mainType, altType, expr);
4700  
  }
4701  
  
4702  
  // Graphics2D etc, IIntegralImage etc, ...
4703  
  
4704  
  while ((i = jfind(tok, "<id> etc <id>")) >= 0) {
4705  
    String mainType = tok.get(i);
4706  
    String argName = tok.get(i+4);
4707  
    int iArgEnd = i+6;
4708  
 
4709  
    List<Pair<String, String>> alts = new ArrayList(); // altType, converter
4710  
    if (eq(mainType, "Graphics2D"))
4711  
      alts.add(pair("BufferedImage", "graphics"));
4712  
    else if (eq(mainType, "IIntegralImage")) {
4713  
      alts.add(pair("BufferedImage", "IntegralImage"));
4714  
      alts.add(pair("MakesBufferedImage", "IntegralImage"));
4715  
    } else if (eq(mainType, "BufferedImage"))
4716  
      alts.add(pair("MakesBufferedImage", "toBufferedImage"));
4717  
    else if (eq(mainType, "Pt")) {
4718  
      alts.add(pair(("int " + argName + "_x, int " + argName + "_y"),
4719  
        ("pt(" + argName + "_x, " + argName + "_y)")));
4720  
      tok_expandMultiTypeArgument_v3(tok,
4721  
        i, iArgEnd,
4722  
        argName,
4723  
        mainType, alts);
4724  
      continue;
4725  
    }
4726  
    
4727  
    if (empty(alts))
4728  
      throw fail("Unknown multi-type: " + joinSubList(tok, i, iArgEnd));
4729  
      
4730  
    alts = mapPairB(alts, converter -> converter + "(" + argName + ")");
4731  
    
4732  
    tok_expandMultiTypeArgument_v2(tok,
4733  
      i, iArgEnd,
4734  
      argName,
4735  
      mainType, alts);
4736  
  }  
4737  
  
4738  
  // Iterable<X> or X[], Iterable<> or X...
4739  
  
4740  
  IntRange r;
4741  
  for (String modifier : ll("[]", "..."))
4742  
    while ((r = jfind_range(tok, "Iterable<<id>> or <id>" + modifier + " <id>")) != null) {
4743  
      i = r.start+1;
4744  
      String mainType = joinSubList(tok, i, i+7);
4745  
      String altType = joinSubList(tok, i+10, r.end-3);
4746  
      String argName = tok.get(r.end-2);
4747  
      String converter = "asList";
4748  
      String expr = converter + "(" + argName + ")";
4749  
      
4750  
      tok_expandMultiTypeArgument(tok, i, r.end, argName, mainType, altType, expr);
4751  
    }
4752  
    
4753  
  // Iterable or O[], Iterable or X..., Cl/O[], etc
4754  
    
4755  
  for (String modifier : ll("[]", "..."))
4756  
    while ((r = jfind_range(tok, "<id> * *" + modifier + " <id>", new F2<List<String>, Integer, Object>() { public Object get(List<String> tok, Integer nIdx) { try { 
4757  
      return eqOneOf(tok.get(nIdx+1), "Iterable", "Collection", "Cl", "List", "L")
4758  
      && eqGetOneOf(tok, nIdx+3, "or", "/")
4759  
      && eqGetOneOf(tok, nIdx+5, "O", "Object");
4760  
     } catch (Exception __e) { throw rethrow(__e); } }
4761  
  public String toString() { return "eqOneOf(tok.get(nIdx+1), \"Iterable\", \"Collection\", \"Cl\", \"List\", \"L\")\r\n      ..."; }})) != null) {
4762  
      i = r.start+1;
4763  
      String mainType = tok.get(i);
4764  
      String altType = joinSubList(tok, i+4, r.end-3);
4765  
      String argName = tok.get(r.end-2);
4766  
      String converter = "asList";
4767  
      String expr = converter + "(" + argName + ")";
4768  
      
4769  
      tok_expandMultiTypeArgument(tok, i, r.end, argName, mainType, altType, expr);
4770  
    }
4771  
}
4772  
4773  
4774  
// goes over input only once (doesn't start again at 1 like jreplace_dyn)
4775  
4776  
static String jreplace_dyn_allowNull(String s, String in, TokReplacer replacer) { return jreplace_dyn_allowNull(s, in, replacer, null); }
4777  
static String jreplace_dyn_allowNull(String s, String in, TokReplacer replacer, ITokCondition condition) {
4778  
  List<String> tok = javaTok(s);
4779  
  jreplace_dyn_allowNull(tok, in, replacer, condition);
4780  
  return join(tok);
4781  
}
4782  
4783  
static boolean jreplace_dyn_allowNull(List<String> tok, String in, TokReplacer replacer) { return jreplace_dyn_allowNull(tok, in, replacer, null); }
4784  
static boolean jreplace_dyn_allowNull(List<String> tok, String in, TokReplacer replacer, ITokCondition condition) {
4785  
  return jreplace_dyn_allowNull(tok, in, replacer, condition, false, true);
4786  
}
4787  
4788  
static boolean jreplace_dyn_allowNull(List<String> tok, String in, TokReplacer replacer, ITokCondition condition, boolean ignoreCase, boolean reTok) {
4789  
  List<String> tokin = javaTok(in);
4790  
  jfind_preprocess(tokin);
4791  
  String[] toks = toStringArray(codeTokensOnly(tokin));  
4792  
4793  
  boolean anyChange = false;
4794  
  int i = 0;
4795  
  for (int safety = 0; safety < 10000; safety++) {
4796  
    ping();
4797  
    
4798  
    i = findCodeTokens(tok, i, ignoreCase, toks, condition);
4799  
    if (i < 0) return anyChange;
4800  
    int start = i, end = i+l(tokin)-2;
4801  
    i = end+2;
4802  
    String expansion = replacer.get(tok, start, end);
4803  
    if (expansion != null) {
4804  
      clearAllTokens(tok, start, end); // C to C
4805  
      
4806  
      tok.set(start, expansion);
4807  
      if (reTok) { // would this ever be false??
4808  
        int n = l(tok);
4809  
        reTok(tok, start, end);
4810  
        i += l(tok)-n; // adjust for replacement
4811  
      }
4812  
      anyChange = true;
4813  
    }
4814  
  }
4815  
  throw fail("woot? 10000! " + quote(in) + " => " + replacer);
4816  
}
4817  
4818  
4819  
// Use like this: printVars(+x, +y);
4820  
// Or: printVars("bla", +x);
4821  
// Or: printVars bla(, +x);
4822  
static void printVars(Object... params) {
4823  
  printVars_str(params);
4824  
}
4825  
4826  
4827  
static boolean eqGet(List l, int i, Object o) {
4828  
  return eq(get(l, i), o);
4829  
}
4830  
4831  
static <A, B> boolean eqGet(Map<A, B> map, A key, Object o) {
4832  
  return eq(mapGet(map, key), o);
4833  
}
4834  
4835  
4836  
static RuntimeException rethrow(Throwable t) {
4837  
  
4838  
  if (t instanceof Error)
4839  
    _handleError((Error) t);
4840  
  
4841  
  throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
4842  
}
4843  
4844  
static RuntimeException rethrow(String msg, Throwable t) {
4845  
  throw new RuntimeException(msg, t);
4846  
}
4847  
4848  
4849  
static void tok_collectMetaPostBlocks(List<String> tok, List<String> postProcessBlocks_out) {
4850  
  int i = -1;
4851  
  while ((i = jfind(tok, i+1, "meta-postProcess {")) >= 0) {
4852  
    int iOpening = indexOf(tok, i, "{");
4853  
    int iClosing = findEndOfBracketPart(tok, iOpening)-1;
4854  
    add(postProcessBlocks_out, joinSubList(tok, iOpening+2, iClosing-1));
4855  
    clearTokens_reTok(tok, i, iClosing+1);
4856  
  }
4857  
}
4858  
4859  
4860  
static void tok_collectTransformers(List<String> tok, List<String> out) {
4861  
  int i = -1;
4862  
  while ((i = jfind(tok, i+1, "meta-transform {")) >= 0) {
4863  
    int iOpening = indexOf(tok, i, "{");
4864  
    int iClosing = findEndOfBracketPart(tok, iOpening)-1;
4865  
    add(out, joinSubList(tok, iOpening+2, iClosing-1));
4866  
    clearTokens_reTok(tok, i, iClosing+1);
4867  
  }
4868  
}
4869  
4870  
4871  
static long now_virtualTime;
4872  
static long now() {
4873  
  return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
4874  
}
4875  
4876  
4877  
4878  
static boolean eq(Object a, Object b) {
4879  
  return a == b || a != null && b != null && a.equals(b);
4880  
}
4881  
4882  
4883  
// a little kludge for stuff like eq(symbol, "$X")
4884  
static boolean eq(Symbol a, String b) {
4885  
  return eq(str(a), b);
4886  
}
4887  
4888  
4889  
4890  
static String jreplace1(String s, String in, String out) {
4891  
  return jreplace1(s, in, out, null);
4892  
}
4893  
4894  
static String jreplace1(String s, String in, String out, Object condition) {
4895  
  List<String> tok = javaTok(s);
4896  
  return jreplace1(tok, in, out, condition) ? join(tok) : s;
4897  
}
4898  
4899  
// leaves tok properly tokenized
4900  
// returns true iff anything was replaced
4901  
static boolean jreplace1(List<String> tok, String in, String out) {
4902  
  return jreplace1(tok, in, out, false, true, null);
4903  
}
4904  
4905  
static boolean jreplace1(List<String> tok, String in, String out, Object condition) {
4906  
  return jreplace1(tok, in, out, false, true, condition);
4907  
}
4908  
4909  
static boolean jreplace1(List<String> tok, String in, String out, boolean ignoreCase, boolean reTok, Object condition) {
4910  
  List<String> tokin = javaTok(in);
4911  
  jfind_preprocess(tokin);
4912  
4913  
  boolean anyChange = false;
4914  
  int i = 1;
4915  
  while ((i = findCodeTokens(tok, i, ignoreCase, toStringArray(codeTokensOnly(tokin)), condition)) >= 0) {
4916  
    List<String> subList = tok.subList(i-1, i+l(tokin)-1); // N to N
4917  
    String expansion = jreplaceExpandRefs(out, subList);
4918  
    int end = i+l(tokin)-2;
4919  
    clearAllTokens(tok, i, end); // C to C
4920  
    tok.set(i, expansion);
4921  
    if (reTok) // would this ever be false??
4922  
      reTok(tok, i, end);
4923  
    i = end;
4924  
    anyChange = true;
4925  
  }
4926  
  return anyChange;
4927  
}
4928  
4929  
static boolean jreplace1_debug = false;
4930  
4931  
4932  
// out: func(L<S> tok, int cIndex) -> S
4933  
// condition: func(L<S> tok, int nIndex) -> S  [yeah it's inconsistent]
4934  
static String jreplace_dyn(String s, String in, Object out) {
4935  
  return jreplace_dyn(s, in, out, null);
4936  
}
4937  
4938  
static String jreplace_dyn(String s, String in, Object out, Object condition) {
4939  
  List<String> tok = javaTok(s);
4940  
  jreplace_dyn(tok, in, out, condition);
4941  
  return join(tok);
4942  
}
4943  
4944  
// leaves tok properly tokenized
4945  
// returns true iff anything was replaced
4946  
static boolean jreplace_dyn(List<String> tok, String in, Object out) {
4947  
  return jreplace_dyn(tok, in, out, false, true, null);
4948  
}
4949  
4950  
static boolean jreplace_dyn(List<String> tok, String in, IF2<List<String>, Integer, String> out) {
4951  
  return jreplace_dyn(tok, in, (Object) out);
4952  
}
4953  
4954  
static boolean jreplace_dyn(List<String> tok, String in, IF2<List<String>, Integer, String> out, IF2<List<String>, Integer, Boolean> condition) {
4955  
  return jreplace_dyn(tok, in, (Object) out, (Object) condition);
4956  
}
4957  
4958  
static boolean jreplace_dyn(List<String> tok, String in, Object out, Object condition) {
4959  
  return jreplace_dyn(tok, in, out, false, true, condition);
4960  
}
4961  
4962  
static boolean jreplace_dyn(List<String> tok, String in, Object out, boolean ignoreCase, boolean reTok, Object condition) {
4963  
  List<String> tokin = javaTok(in);
4964  
  jfind_preprocess(tokin);
4965  
  
4966  
  String[] toks = toStringArray(codeTokensOnly(tokin));
4967  
4968  
  boolean anyChange = false;
4969  
  for (int n = 0; n < 10000; n++) {
4970  
    int i = findCodeTokens(tok, 1, ignoreCase, toks, condition);
4971  
    if (i < 0)
4972  
      return anyChange;
4973  
    String expansion =  (String) (callF(out, tok, i));
4974  
    int end = i+l(tokin)-2;
4975  
    clearAllTokens(tok, i, end); // C to C
4976  
    tok.set(i, expansion);
4977  
    if (reTok) // would this ever be false??
4978  
      reTok(tok, i, end);
4979  
    anyChange = true;
4980  
  }
4981  
  throw fail("woot? 10000! " + quote(in) + " => " + quote(out));
4982  
}
4983  
4984  
4985  
static String stringToLegalIdentifier(String s) {
4986  
  StringBuilder buf = new StringBuilder();
4987  
  s = dropTrailingSquareBracketStuff(s);
4988  
  for (int i = 0; i < l(s); i++) {
4989  
    char c = s.charAt(i);
4990  
    if (empty(buf) ? Character.isJavaIdentifierStart(c) : Character.isJavaIdentifierPart(c))
4991  
      buf.append(c);
4992  
  }
4993  
  if (empty(buf)) throw fail("Can't convert to legal identifier: " + s);
4994  
  return str(buf);
4995  
}
4996  
4997  
4998  
static String getSnippetTitle(String id) {
4999  
  if (id == null) return null;
5000  
  if (!isSnippetID(id)) return "?";
5001  
  
5002  
  
5003  
  IResourceLoader rl = vm_getResourceLoader();
5004  
  if (rl != null)
5005  
    return rl.getSnippetTitle(id);
5006  
  
5007  
  
5008  
  return getSnippetTitle_noResourceLoader(id);
5009  
}
5010  
  
5011  
static String getSnippetTitle_noResourceLoader(String id) { try {
5012  
  if (isLocalSnippetID(id)) return localSnippetTitle(id);
5013  
  long parsedID = parseSnippetID(id);
5014  
  String url;
5015  
  if (isImageServerSnippet(parsedID))
5016  
    url = imageServerURL() + "title/" + parsedID + muricaCredentialsQuery();
5017  
  else if (isGeneralFileServerSnippet(parsedID))
5018  
    url = "http://butter.botcompany.de:8080/files/name/" + parsedID;
5019  
  else
5020  
    url = tb_mainServer() + "/tb-int/getfield.php?id=" + parsedID + "&field=title" + standardCredentials_noCookies();
5021  
  String title = trim(loadPageSilently(url));
5022  
  if (title != null)
5023  
    try { saveTextFileIfChanged(snippetTitle_cacheFile(id), title); } catch (Throwable __e) { print(exceptionToStringShort(__e)); }
5024  
  return or(title, "?");
5025  
} catch (Exception __e) { throw rethrow(__e); } }
5026  
5027  
static String getSnippetTitle(long id) {
5028  
  return getSnippetTitle(fsI(id));
5029  
}
5030  
5031  
5032  
5033  
static void tok_overridableFunctionDefs(List<String> tok, Set<String> overriableFunctions_out) {
5034  
  int i;
5035  
  while ((i = jfind(tok, "static overridable <id>")) >= 0) {
5036  
    int bracket = indexOf(tok, "(", i);
5037  
    int codeStart = indexOf(tok, "{", bracket);
5038  
    String fName = assertIdentifier(tok.get(bracket-2));
5039  
    String type = joinSubList(tok, i+4, bracket-3);
5040  
    String boxedType = tok_toNonPrimitiveTypes(type);
5041  
    String args = joinWithComma(map(__45 -> tok_lastIdentifier(__45), tok_parseArgsDeclList(subList(tok, i))));
5042  
    String castIt = eq(type, "Object") ? "" : ("(" + type + ")");
5043  
5044  
    replaceTokens(tok, i, bracket-1, ("static Object _override_" + fName + ";\n")
5045  
      + ("static " + type + " " + fName));
5046  
    
5047  
    tokAppend(tok, codeStart, (" if (_override_" + fName + " != null) return " + castIt + " callF(_override_" + fName + ", " + args + ");\n"));
5048  
    reTok(tok, i, codeStart+1);
5049  
    addToCollection(overriableFunctions_out, fName);
5050  
  }
5051  
}
5052  
5053  
5054  
static List<String> tok_cleanImports(List<String> tok) {
5055  
  List<String> index = toContentsIndexedList(tok);
5056  
  List<IntRange> imports = tok_findImports_returnRanges(tok);
5057  
  BitSet exclude = new BitSet();
5058  
  for (IntRange r : imports)
5059  
    set(exclude, r.end-4);
5060  
    
5061  
  List<IntRange> reToks = new ArrayList();
5062  
  loop: for (IntRange r : imports) {
5063  
    String id = get(tok, r.end-4);
5064  
    if (!isIdentifier(id)) continue;
5065  
    for (int i : indicesOf(index, id))
5066  
      if (!get(exclude, i))
5067  
        continue loop; // id is in use
5068  
    // import is unused - delete
5069  
    clearTokens_addToReToks(tok, r.start+1, r.end, reToks);
5070  
  }
5071  
  
5072  
  reTok_multi(tok, reToks);
5073  
  return tok;
5074  
}
5075  
5076  
5077  
static int lastIndexOfStartingWith(List<String> l, String s) {
5078  
  for (int i = l(l)-1; i >= 0; i--)
5079  
    if (startsWith(l.get(i), s))
5080  
      return i;
5081  
  return -1;
5082  
}
5083  
5084  
5085  
static String dropPrefix(String prefix, String s) {
5086  
  return s == null ? null : s.startsWith(prefix) ? s.substring(l(prefix)) : s;
5087  
}
5088  
5089  
5090  
static String sfu(Object o) { return structureForUser(o); }
5091  
5092  
5093  
// unclear semantics when l is a special set (e.g. ciSet)
5094  
5095  
static <A> boolean containsOneOf(Collection<A> l, A... x) {
5096  
  if (l instanceof Set) {
5097  
    if (x != null)
5098  
      for (A a : x)
5099  
        if (l.contains(a))
5100  
          return true;
5101  
  } else {
5102  
    for (A a : unnull(l))
5103  
      if (eqOneOf(a, x))
5104  
        return true;
5105  
  }
5106  
  return false;
5107  
}
5108  
5109  
static <A> boolean containsOneOf(Collection<A> l, Set<A> set) {
5110  
  if (set == null) return false;
5111  
  for (A a : unnull(l))
5112  
    if (set.contains(a))
5113  
      return true;
5114  
  return false;
5115  
}
5116  
5117  
static boolean containsOneOf(String s, String... x) {
5118  
  for (String o : x)
5119  
    if (contains(s, o)) return true;
5120  
  return false;
5121  
}
5122  
5123  
5124  
static boolean containsIC(Collection<String> l, String s) {
5125  
  return containsIgnoreCase(l, s);
5126  
}
5127  
5128  
static boolean containsIC(String[] l, String s) {
5129  
  return containsIgnoreCase(l, s);
5130  
}
5131  
5132  
static boolean containsIC(String s, char c) {
5133  
  return containsIgnoreCase(s, c);
5134  
}
5135  
5136  
static boolean containsIC(String a, String b) {
5137  
  return containsIgnoreCase(a, b);
5138  
}
5139  
5140  
5141  
static boolean containsIC(Producer<String> p, String a) {
5142  
  if (p != null && a != null) while (true) {
5143  
    String x = p.next();
5144  
    if (x == null) break;
5145  
    if (eqic(x, a)) return true;
5146  
  }
5147  
  return false;
5148  
}
5149  
5150  
5151  
5152  
static String extractAndPrintJavaParseError(String src, Throwable e) {
5153  
  StringBuilder buf = new StringBuilder();
5154  
  print_tee(buf);
5155  
  String msg = takeFirstLines(2, innerMessage(e));
5156  
  print_tee(buf, msg);
5157  
  int line = parseIntOpt(regexpFirstGroupIC("line (\\d+)", msg));
5158  
  print_tee(buf);
5159  
  if (line != 0) {
5160  
    List<String> lines = lines(src);
5161  
    for (int i = max(1, line-5); i <= min(l(lines), line+5); i++)
5162  
      print_tee(buf, (i == line ? "* " : "  ") + "LINE " + i + ": " + lines.get(i-1));
5163  
  }
5164  
  print_tee(buf);
5165  
  return str(buf);
5166  
}
5167  
5168  
5169  
static File transpilerErrorSourceFile() {
5170  
  return javaxCachesDir("error-source.java");
5171  
}
5172  
5173  
5174  
static void saveTextFileVerbose(File f, String text) {
5175  
  boolean exists = f.exists();
5176  
  saveTextFile(f, text);
5177  
  print((!exists ? "Created" : "Updated") + " file " + f2s(f) + " (" + f.length() + " bytes)");
5178  
}
5179  
5180  
5181  
static String innerMessage(Throwable e) {
5182  
  return getInnerMessage(e);
5183  
}
5184  
5185  
5186  
static void tokPrepend(List<String> tok, String s) { tokPrepend(tok, 0, s); }
5187  
static void tokPrepend(List<String> tok, int i, String s) {
5188  
  tok.set(i, s + tok.get(i));
5189  
}
5190  
5191  
5192  
static List<String> reTok(List<String> tok) {
5193  
  replaceCollection(tok, javaTok(tok));
5194  
  return tok;
5195  
}
5196  
5197  
static List<String> reTok(List<String> tok, int i) {
5198  
  return reTok(tok, i, i+1);
5199  
}
5200  
5201  
static List<String> reTok(List<String> tok, int i, int j) {
5202  
  // extend i to an "N" token
5203  
  // and j to "C" (so j-1 is an "N" token)
5204  
  i = max(i & ~1, 0);
5205  
  j = min(l(tok), j | 1);
5206  
  if (i >= j) return tok;
5207  
  
5208  
  List<String> t = javaTok(joinSubList(tok, i, j));
5209  
  replaceListPart(tok, i, j, t);
5210  
  
5211  
  // fallback to safety
5212  
  // reTok(tok);
5213  
  
5214  
  return tok;
5215  
}
5216  
5217  
5218  
static List<String> reTok(List<String> tok, IntRange r) {
5219  
  if (r != null) reTok(tok, r.start, r.end);
5220  
  return tok;
5221  
}
5222  
5223  
5224  
5225  
static boolean nempty(Collection c) {
5226  
  return !empty(c);
5227  
}
5228  
5229  
static boolean nempty(CharSequence s) {
5230  
  return !empty(s);
5231  
}
5232  
5233  
static boolean nempty(Object[] o) { return !empty(o); }
5234  
static boolean nempty(byte[] o) { return !empty(o); }
5235  
static boolean nempty(int[] o) { return !empty(o); }
5236  
5237  
static boolean nempty(Map m) {
5238  
  return !empty(m);
5239  
}
5240  
5241  
static boolean nempty(Iterator i) {
5242  
  return i != null && i.hasNext();
5243  
}
5244  
5245  
5246  
static boolean nempty(Object o) { return !empty(o); }
5247  
5248  
5249  
5250  
static boolean nempty(IntRange r) { return !empty(r); }
5251  
5252  
5253  
5254  
5255  
5256  
5257  
5258  
5259  
5260  
5261  
5262  
static String concatMap_strings(Object f, Iterable l) {
5263  
  return join((List<String>) map(f, l));
5264  
}
5265  
5266  
static String concatMap_strings(Object f, Object[] l) {
5267  
  return join((List<String>) map(f, l));
5268  
}
5269  
5270  
static String concatMap_strings(Iterable l, Object f) {
5271  
  return concatMap_strings(f, l);
5272  
}
5273  
5274  
static <A> String concatMap_strings(Iterable<A> l, IF1<A, String> f) {
5275  
  return concatMap_strings(f, l);
5276  
}
5277  
5278  
static <A> String concatMap_strings(IF1<A, String> f, Iterable<A> l) {
5279  
  return concatMap_strings((Object) f, l);
5280  
}
5281  
5282  
5283  
static String f2s(File f) {
5284  
  return f == null ? null : f.getAbsolutePath();
5285  
}
5286  
5287  
static String f2s(String s) { return f2s(newFile(s)); }
5288  
5289  
5290  
 static String f2s(java.nio.file.Path p) {
5291  
  return p == null ? null : f2s(p.toFile());
5292  
}
5293  
5294  
5295  
5296  
static File saveProgramTextFile(String name, String contents) {
5297  
  return saveTextFile(getProgramFile(name), contents);
5298  
}
5299  
5300  
static File saveProgramTextFile(String progID, String name, String contents) {
5301  
  return saveTextFile(getProgramFile(progID, name), contents);
5302  
}
5303  
5304  
5305  
static void splitJavaFiles(List<String> tok) { try {
5306  
  splitJavaFiles(tok, newFile("output"));
5307  
} catch (Exception __e) { throw rethrow(__e); } }
5308  
5309  
static void splitJavaFiles(List<String> tok, File outDir) { try {
5310  
  List<Integer> indexes = jfindAll(tok, "package");
5311  
  if (empty(indexes) || indexes.get(0) != 1)
5312  
    indexes.add(0, 1);
5313  
  for (int i = 0; i < l(indexes); i++) {
5314  
    int from = indexes.get(i);
5315  
    int to = i+1 < l(indexes) ? indexes.get(i+1) : l(tok);
5316  
    List<String> subtok = cncSubList(tok, from, to);
5317  
    String src = join(subtok);
5318  
    //print(shorten(src, 80));
5319  
    String pack = tok_packageName(subtok);
5320  
    print("Package: " + quote(pack));
5321  
    List<List<String>> classes = allClasses(subtok);
5322  
    /*for (L<S> c : classes) {
5323  
      //print("  Class: " + shorten(join(c), 80));
5324  
      print("  Class: " + quote(getClassDeclarationName(c)));
5325  
    }*/
5326  
    if (empty(classes))
5327  
      print("No classes?? " + quote(src));
5328  
    else {
5329  
      String className = getNameOfPublicClass(subtok);
5330  
      if (className == null) className = getNameOfAnyClass(subtok);
5331  
5332  
      String fileName = addSlash(pack.replace('.', '/')) + className + ".java";
5333  
      print("File name: " + fileName);
5334  
      saveTextFile(newFile(outDir, fileName), join(subtok));
5335  
    }
5336  
    print();
5337  
  }
5338  
} catch (Exception __e) { throw rethrow(__e); } }
5339  
5340  
5341  
  static void saveMainJava(String s) throws IOException {
5342  
    if (mainJava != null)
5343  
      mainJava = s;
5344  
    else
5345  
      saveTextFile("output/main.java", s);
5346  
  }
5347  
  
5348  
  static void saveMainJava(List<String> tok) throws IOException {
5349  
    saveMainJava(join(tok));
5350  
  }
5351  
5352  
5353  
5354  
// process scope x. ... end scope blocks
5355  
static void tok_scopes(List<String> tok, Object... __) {
5356  
  if (!tok.contains("scope")) return;
5357  
  boolean autoCloseScopes = boolPar("autoCloseScopes", __);
5358  
  
5359  
  // New syntax: scope bla { ... }
5360  
  replaceKeywordBlock(tok, "scope <id>",
5361  
    "scope $2. ",
5362  
    " end scope ");
5363  
  
5364  
  int i;
5365  
  // Old syntax: scope bla ... end scope
5366  
  while ((i = rjfind(tok, "scope <id>")) >= 0) {
5367  
    String scopeName = tok.get(i+2);
5368  
    int start = i+4;
5369  
    if (eqGet(tok, start, ".")) start += 2;
5370  
    int j = jfind(tok, start, "end scope");
5371  
    if (j < 0)
5372  
      if (autoCloseScopes)
5373  
        j = l(tok);
5374  
      else
5375  
        throw fail("Scope " + scopeName + " opened but not closed");
5376  
    else
5377  
      clearTokens(tok, j, j+3);
5378  
5379  
    HashSet<String> names = new HashSet();
5380  
    HashSet<String> functions = new HashSet();
5381  
    
5382  
    clearTokens(tok, i, start-1);
5383  
    List<String> subTok = subList(tok, start-1, j);
5384  
    
5385  
    // auto-make #lock variable
5386  
    if (jfind(subTok, "lock #lock") >= 0
5387  
      && jfind(subTok, "Lock #lock") < 0)
5388  
        tok.set(i, "static Lock " + scopeName + "_lock = lock();\n");
5389  
    
5390  
    // first pass (find # declarations)
5391  
    for (int k = start; k < j-2; k += 2) {
5392  
      String t = get(tok, k+2);
5393  
      if (eqGet(tok, k, "#") && isIdentifier(t)) {
5394  
        names.add(t);
5395  
        if (eqGetOneOf(tok, k+4, "(", "{", "<", "extends", "implements", ">")) // cover class declarations too
5396  
          functions.add(t); 
5397  
        replaceTokens(tok, k, k+3, scopeName + "_" + t);
5398  
      }
5399  
    }
5400  
    
5401  
    // second pass (references to scoped variables)
5402  
    for (int k = start; k < j; k += 2) {
5403  
      String t = get(tok, k);
5404  
      if (isIdentifier(t)) {
5405  
        if (names.contains(t)) {
5406  
          if (eqGet(tok, k-2, ".")) {}
5407  
          else if (eqGet(tok, k+2, "(") && !functions.contains(t)) {}
5408  
          // avoid lock ... and map ...
5409  
          else if (eqOneOf(t, "lock", "map") && isIdentifier(get(tok, k+2))) {}
5410  
          else
5411  
            tok.set(k, scopeName + "_" + t);
5412  
        } else if (eq(t, "__scope"))
5413  
          tok.set(k, quote(scopeName));
5414  
      }
5415  
    }
5416  
    
5417  
    reTok(tok, i, j+1);
5418  
  }
5419  
}
5420  
5421  
5422  
static void tok_dropMetaComments(List<String> tok) {
5423  
  int i = -1;
5424  
  while ((i = jfind(tok, i+1, "meta-comment {")) >= 0) {
5425  
    int iOpening = indexOf(tok, i, "{");
5426  
    int iClosing = findEndOfBracketPart(tok, iOpening)-1;
5427  
    clearTokens_reTok(tok, i, iClosing+1);
5428  
  }
5429  
}
5430  
5431  
5432  
// TODO: sometimes equals/hashCode is not generated. See an old version of #1026301
5433  
5434  
static boolean tok_recordDecls_autoWithToList = true;
5435  
5436  
static void tok_recordDecls(List<String> tok) {
5437  
  int i;
5438  
  boolean re = false;
5439  
  
5440  
  jreplace(tok, "record <id> > <id> {", "record $2 extends $4 {");
5441  
  jreplace(tok, "record <id> > <id><<id>> {", "record $2 extends $4  $5 $6 $7 {");
5442  
  
5443  
  jreplace(tok, "record <id> {", "record $2() {");
5444  
  jreplace(tok, "record <id> implements", "record $2() implements");
5445  
  jreplace(tok, "record <id> extends", "record $2() extends");
5446  
  
5447  
  while ((i = jfind_any(tok, "record <id>(", "record <id><")) >= 0) {
5448  
    int argsFrom = smartIndexOf(tok, i, "(")+2;
5449  
    int argsTo = findCodeTokens(tok, argsFrom, false, ")");
5450  
    int idx = findCodeTokens(tok, argsTo, false, "{");
5451  
    
5452  
    int j = findEndOfBracketPart(tok, idx);
5453  
    String name = tok.get(i+2);
5454  
    
5455  
    int iMod = tok_leftScanCustomModifiers(tok, i, addAllAndReturnCollection(litset("noeq", "flexeq", "noToString", "withToList", "transformable"), getJavaModifiers()));
5456  
    Set<String> mods = codeTokensAsSet(subList(tok, iMod-1, i));
5457  
    clearTokensExceptFromSet(tok, iMod, i-1, getJavaModifiers());
5458  
5459  
    boolean withToList = mods.contains("withToList");
5460  
    withToList = withToList || tok_recordDecls_autoWithToList;
5461  
    
5462  
    StringBuilder buf = new StringBuilder();
5463  
    
5464  
    List<String> tArgs = subList(tok, argsFrom-1, argsTo);
5465  
    List<Pair<String, String>> args = tok_typesAndNamesOfParams(tArgs, "typelessMeansObject" , true);
5466  
    List<String> contents = subList(tok, idx+1, j);
5467  
    boolean hasDefaultConstructor = tok_hasDefaultConstructor(contents, name);
5468  
    
5469  
    for (Pair<String, String> p : args)
5470  
      buf.append("\n  " + jreplace(p.a, "...", "[]") + " " + p.b + ";");
5471  
      
5472  
    if (nempty(args) && !hasDefaultConstructor) buf.append("\n  *() {}");
5473  
    buf.append("\n  *(" + joinWithComma(map(args, new F1<Pair<String, String>, String>() { public String get(Pair<String, String> p) { try { 
5474  
      return dropPrefix("new ", p.a) + " *" + p.b;  } catch (Exception __e) { throw rethrow(__e); } }
5475  
  public String toString() { return "dropPrefix(\"new \", p.a) + \" *\" + p.b"; }})) + ") {}");
5476  
      
5477  
    if (!mods.contains("noToString") && !(jfind(contents, "toString {") >= 0 || jfind(contents, "toString()") >= 0))
5478  
      buf.append("\n  toString { ret " 
5479  
        + "shortClassName_dropNumberPrefix(this) + \"(\" + "
5480  
        + join(" + \", \" + ", secondOfPairs(args))
5481  
        + " + \")\"; }");
5482  
      
5483  
    if (!mods.contains("noeq")) {
5484  
      //buf.append("\n  [stdEq]");
5485  
      boolean flexEq = mods.contains("flexeq"); // fix for records inside of parameterized classes
5486  
      buf.append(tok_genEqualsAndHashCode(name, args, "flexEq", flexEq));
5487  
    }
5488  
    
5489  
    if (withToList)
5490  
      buf.append(tok_genRecordFieldsToList(args));
5491  
      
5492  
    boolean transformable = mods.contains("transformable");
5493  
    if (transformable)
5494  
      buf.append(tok_genRecordTransformable(name, args));
5495  
      
5496  
    String interfaces = joinNemptiesWithComma(
5497  
      withToList ? "IFieldsToList" : "",
5498  
      transformable ? "Transformable, Visitable" : "");
5499  
5500  
    tok.set(idx, (empty(interfaces) ? ""
5501  
      : (contains(subList(tok, argsTo, idx), "implements") ? "," : "implements") + " " + interfaces)
5502  
      + "{" + buf);
5503  
    
5504  
    tok.set(i, "class");
5505  
    clearTokens(tok, argsFrom-2, argsTo+1);
5506  
    reTok(tok, i, idx+1);
5507  
    
5508  
    // no static fields allowed in non-static classes (for whatever reason)
5509  
    if (contains(tok_modifiersLeftOf(tok, i), "static"))
5510  
      tok_addFieldOrder(tok, i);
5511  
5512  
    
5513  
    re = true;
5514  
  }
5515  
  if (re) reTok(tok);
5516  
}
5517  
5518  
5519  
static void tok_singleQuoteIdentifiersToStringConstants(List<String> tok) {
5520  
  for (int i = 1; i < l(tok); i += 2) {
5521  
    String t = tok.get(i);
5522  
    if (isSingleQuoteIdentifier(t))
5523  
      tok.set(i, quote(substring(t, 1)));
5524  
  }
5525  
}
5526  
5527  
5528  
static void tok_inStringEvals(List<String> tok) {
5529  
  boolean change = false;
5530  
  for (int i = 1; i < tok.size(); i += 2) {
5531  
    String t = tok.get(i);
5532  
    if (!isQuoted(t)) continue;
5533  
    if (t.contains("\\*") && !t.contains("\\\\")) { // << rough
5534  
      tok.set(i, transpile_inStringEval(t));
5535  
      change = true;
5536  
    }
5537  
  }
5538  
  if (change) reTok(tok);
5539  
}
5540  
5541  
5542  
static void tok_listComprehensions(List<String> tok) {
5543  
  if (!tok.contains("[")) return;
5544  
  for (int i = 1; i < l(tok); i += 2) try {
5545  
    { if (!(eq(tok.get(i), "["))) continue; }
5546  
    int iOp = indexOfAny(tok, i+2, "?", ":", "in", "[", "]");
5547  
    if (iOp < 0) return;
5548  
    if (!eqOneOf(tok.get(iOp), ":", "in")) continue; // not a list comprehension
5549  
    if (eqGet(tok, iOp+2, ".")) continue; // "in." (in is a variable name)
5550  
    
5551  
    Map<Integer, Integer> bracketMap = getBracketMap(tok); // XXX - optimize
5552  
    
5553  
    String type = joinSubList(tok, i+2, iOp-3), id = tok.get(iOp-2);
5554  
    int j = scanOverExpression(tok, bracketMap, iOp+2, "|");
5555  
    String exp = join(subList(tok, iOp+2, j));
5556  
    j += 2;
5557  
    int k = scanOverExpression(tok, bracketMap, j, "]");
5558  
    String where = join(subList(tok, j, k));
5559  
    ++k;
5560  
      
5561  
    String code = "filter(" + exp + ", func(" + type + " " + id + ") -> Bool { " + where + " })";
5562  
    replaceTokens(tok, i, k, code);
5563  
    reTok(tok, i, k);
5564  
  } catch (Throwable _e) {
5565  
    print("Was processing list comprehension: " + joinSubList(tok, i, i+30) + "...");
5566  
  
5567  
throw rethrow(_e); }
5568  
}
5569  
5570  
5571  
5572  
5573  
/* event change; =>
5574  
   transient L<Runnable> onChange;
5575  
   selfType onChange(Runnable r) { onChange = syncAddOrCreate(onChange, r); this; }
5576  
   void change() { pcallFAll(onChange); }
5577  
*/
5578  
static void tok_eventFunctions(List<String> tok) {
5579  
  int i;
5580  
5581  
  while ((i = jfind(tok, "event <id>")) >= 0) {
5582  
    int iSemicolon = i+4;
5583  
    List<String> tokArgs = null;
5584  
    if (eqGet(tok, i+4, "(")) {
5585  
      int argsFrom = i+6;
5586  
      int argsTo = findCodeTokens(tok, argsFrom, false, ")");
5587  
      tokArgs = subList(tok, argsFrom-1, argsTo);
5588  
      iSemicolon = argsTo+2;
5589  
    }
5590  
    // TODO for next version: parse modifiers in square brackets
5591  
    //if (eqGet(tok, iSemicolon, "["))
5592  
    
5593  
    if (neqGet(tok, iSemicolon, ";"))
5594  
      throw fail("Semicolon expected at end: " + joinSubList(tok, i, iSemicolon+1));
5595  
    
5596  
    String change = tok.get(i+2);
5597  
    String onChange = "on" + firstToUpper(change);
5598  
    List<Pair<String, String>> args = tok_typesAndNamesOfParams(tokArgs);
5599  
    List<String> types = pairsA(args);
5600  
    String args1 = join(dropFirstAndLast(tokArgs));
5601  
    String args2 = joinWithComma(pairsB(args));
5602  
    String typeParams = joinWithComma(map(__46 -> tok_toNonPrimitiveTypes(__46), types));     String listenerType = empty(args) ? "Runnable" : "IVF" + l(args) + "<" + typeParams + ">";
5603  
    String r = empty(args) ? "r" : "f";
5604  
   
5605  
    replaceTokens_reTok(tok, i, iSemicolon+1, 
5606  
      ("transient L<" + listenerType + "> " + onChange + ";\n") +
5607  
      ("selfType " + onChange + "(" + listenerType + " " + r + ") { " + onChange + " = syncAddOrCreate(" + onChange + ", " + r + "); this; }\n") +
5608  
      ("void " + change + "(" + args1 + ") { pcallFAll(" + (joinNemptiesWithComma(onChange, args2)) + "); }")
5609  
    );
5610  
  }
5611  
}
5612  
5613  
5614  
// for single () iterates once when the expression is not null
5615  
// and zero times when it is null.
5616  
// It was actually used once.
5617  
static void tok_for_single(List<String> tok) {
5618  
  int i = -1;
5619  
  while ((i = jfind(tok, i+1, "for single (")) >= 0) {
5620  
    int iColon = indexOf(tok, ":", i);
5621  
    int iClosing = findEndOfBracketPart(tok, iColon)-1;
5622  
    tok.set(iColon, ": singletonUnlessNull(");
5623  
    tok.set(iClosing, "))");
5624  
    clearTokens(tok, i+2, i+4);
5625  
    reTok(tok, i, iClosing+1);
5626  
  }
5627  
}
5628  
5629  
5630  
static void tok_for_unpair(List<String> tok) {
5631  
  jreplace(tok, "for (unpair <id> <id>, <id> :", "for (unpair $4 $5, $4 $7 :");
5632  
  jreplace(tok, "for (<id> <id>, <id> : unpair", "for (unpair $3 $4, $3 $6 :");
5633  
  jreplace(tok, "for (<id> <id>, <id> <id> : unpair", "for (unpair $3 $4, $6 $7 :");
5634  
  
5635  
  int i = -1;
5636  
  while ((i = jfind(tok, i+1, "for (unpair <id> <id>, <id> <id> :")) >= 0) {
5637  
    String type1 = tok.get(i+6), var1 = tok.get(i+8);
5638  
    String type2 = tok.get(i+12), var2 = tok.get(i+14);
5639  
    int iColon = indexOf(tok, ":", i);
5640  
    int iClosing = findEndOfBracketPart(tok, iColon)-1;
5641  
    int iCurly = iClosing+2;
5642  
    tok_statementToBlock(tok, iCurly);
5643  
    String pairVar = makeVar();
5644  
    replaceTokens(tok, i+4, iColon-1, tok_toNonPrimitiveTypes("Pair<" + type1 + ", " + type2 + ">") + " " + pairVar);
5645  
    tok.set(iCurly, "{ "
5646  
      + type1 + " " + var1 + " = pairA(" + pairVar + "); "
5647  
      + type2 + " " + var2 + " = pairB(" + pairVar + "); ");
5648  
    reTok(tok, i, iCurly+1);
5649  
  }
5650  
}
5651  
5652  
5653  
static boolean tok_doubleFor_v3_debug = false;
5654  
5655  
static void tok_doubleFor_v3(List<String> tok) {
5656  
  for (int i : reversed(indexesOf(tok, "for"))) {
5657  
    if (neq(get(tok, i+2), "(")) continue;
5658  
    int argsFrom = i+4;
5659  
    // move loop label to proper place
5660  
    if (eqGet(tok, i-2, ":") && isIdentifier(get(tok, i-4))) i -= 4;
5661  
    int iColon = indexOfAny(tok, argsFrom, ":", ")");
5662  
    if (neq(get(tok, iColon), ":")) continue;
5663  
    if (tok_doubleFor_v3_debug) print("have colon");
5664  
    tok_typesAndNamesOfParams_keepModifiers.set(true);
5665  
    List<Pair<String, String>> args;
5666  
    try {
5667  
      args = tok_typesAndNamesOfParams(subList(tok, argsFrom-1, iColon-1));
5668  
    } catch (Throwable _e) {
5669  
      print("tok_doubleFor_v3: Skipping parsing complicated for statement (probably not a double for)");
5670  
      continue;
5671  
    }
5672  
    
5673  
    if (l(args) != 2) continue; // simple for or a three-argument for (out of this world!)
5674  
    
5675  
    // S a, b => S a, S b
5676  
    if (eq(second(args).a, "?")) second(args).a = first(args).a;
5677  
    
5678  
    if (tok_doubleFor_v3_debug) print("have 2 args: " + sfu(args));
5679  
    int iClosing = tok_findEndOfForExpression(tok, iColon+2);
5680  
    if (iClosing < 0) continue;
5681  
    if (tok_doubleFor_v3_debug) print("have closing");
5682  
    String exp = trimJoinSubList(tok, iColon+2, iClosing-1);
5683  
    if (tok_doubleFor_v3_debug) print("Expression: " + exp);
5684  
    int iCurly = iClosing+2;
5685  
    tok_statementToBlock(tok, iCurly);
5686  
    int iCurlyEnd = tok_findEndOfStatement(tok, iCurly)-1;
5687  
    if (iCurlyEnd < 0) continue;
5688  
    if (tok_doubleFor_v3_debug) print("have curly end");
5689  
    
5690  
    tokAppend(tok, iColon, " _entrySet(");
5691  
    tokPrepend(tok, iClosing, ")");
5692  
    
5693  
    String entryVar = makeVar();
5694  
    
5695  
    replaceTokens(tok, argsFrom, iColon-1,
5696  
      "Map.Entry<? extends " + tok_toNonPrimitiveTypes(first(first(args))) + ", ? extends "
5697  
        + tok_toNonPrimitiveTypes(first(second(args))) + "> " + entryVar);
5698  
      /*"Map.Entry<" + first(first(args)) + ", "
5699  
        + first(second(args)) + "> " + entryVar);*/
5700  
    
5701  
    tokAppend(tok, iCurly, " " + joinPairWithSpace(first(args)) + " = " + entryVar + ".getKey(); "
5702  
      + joinPairWithSpace(second(args)) + " = " + entryVar + ".getValue(); ");
5703  
    reTok(tok, i, iCurlyEnd+1);
5704  
  }
5705  
}
5706  
5707  
5708  
static void tok_forUnnull(List<String> tok) {
5709  
  jreplace(tok, "fOr (", "for unnull (");
5710  
  
5711  
  int i = -1;
5712  
  while ((i = jfind(tok, i+1, "for unnull (")) >= 0) {
5713  
    int argsFrom = i+4;
5714  
    int iColon = indexOf(tok, i, ":");
5715  
    int iClosing = tok_findEndOfForExpression(tok, iColon+2);
5716  
    
5717  
    clearTokens(tok, i+2, i+4);
5718  
    tokPrepend(tok, iColon+2, "unnullForIteration(");
5719  
    tokPrepend(tok, iClosing, ")");
5720  
    reTok(tok, i+2, iClosing+1);
5721  
    
5722  
  }
5723  
}
5724  
5725  
5726  
static void tok_ifCast(List<String> tok) {
5727  
  int i;
5728  
  while ((i = jfind_check("cast", tok, "if (<id> cast <id>")) >= 0) {
5729  
    int iEndOfType = indexOfAny(tok, i, ")", "&");
5730  
    int iClosing = tok_endOfExpression(tok, i+4)+1;
5731  
    String var = tok.get(i+4), type = joinSubList(tok, i+8, iEndOfType-1);
5732  
    String rawType = tok_dropTypeParameters(type);
5733  
    int start = iClosing+2, end = tok_findEndOfStatement(tok, start);
5734  
    replaceTokens(tok, i+6, iEndOfType-1, "instanceof " + rawType);
5735  
    
5736  
    // replace "var" with "((Type) var)" in enclosed block
5737  
    // unless it's another cast expression or an assignment
5738  
    
5739  
    printVars("iEndOfType", iEndOfType, "iClosing", iClosing, "iClosing" , get(tok, iClosing), "start", start, "start" , get(tok, start), "end", end, "lTok" , l(tok));
5740  
    end = min(end, l(tok));
5741  
    
5742  
    for (int j = iEndOfType; j < end; j += 2)
5743  
      if (eq(tok.get(j), var) && neqGet(tok, j-2, ".")
5744  
        && neqGetOneOf(tok, j+2, "cast", "(")
5745  
        && !tok_isAssignment(tok, j+2))
5746  
        tok_insertCast(tok, j, type);
5747  
    reTok(tok, i+6, end);
5748  
  }
5749  
}
5750  
5751  
5752  
// # 123 => "#123"
5753  
static void tok_directSnippetRefs(List<String> tok) {
5754  
  int i = -1;
5755  
  while ((i = jfind(tok, i+1, "#<int>", new TokCondition() { public boolean get(final List<String> tok, final int i) {
5756  
    return !eqOneOf(_get(tok, i-1), "include", "once");
5757  
  }})) >= 0) {
5758  
    String id = tok.get(i+2);
5759  
    clearTokens(tok, i+1, i+3);
5760  
    tok.set(i, quote("#" + id));
5761  
    reTok(tok, i, i+3);
5762  
  }
5763  
}
5764  
5765  
5766  
static void tok_doPing(List<String> tok) {
5767  
  jreplace(tok, "do ping {", "do { ping();");
5768  
  
5769  
  int i;
5770  
  while ((i = jfind(tok, "do ping <id>")) >= 0) {
5771  
    int j = tok_findEndOfStatement(tok, i+4);
5772  
    tok.set(i+2, "{ ping();");
5773  
    tokAppend(tok, j-1, " }");
5774  
    reTok(tok, i, j);
5775  
  }
5776  
}
5777  
5778  
5779  
// keyword can comprise multiple tokens now (like "p-awt"}
5780  
static List<String> replaceKeywordBlock(List<String> tok, String keyword, String beg, String end) {
5781  
  return replaceKeywordBlock(tok, keyword, beg, end, false, null);
5782  
}
5783  
5784  
static List<String> replaceKeywordBlock(List<String> tok, String keyword, String beg, String end, Object cond) {
5785  
  return replaceKeywordBlock(tok, keyword, beg, end, false, cond);
5786  
}
5787  
5788  
static List<String> replaceKeywordBlock(List<String> tok, String keyword, String beg, String end,
5789  
  boolean debug, Object cond) {
5790  
  for (int n = 0; n < 1000; n++) {
5791  
    int i = jfind(tok, keyword + " {", cond);
5792  
    if (i < 0)
5793  
      break;
5794  
    int idx = findCodeTokens(tok, i, false, "{");
5795  
    int j = findEndOfBracketPart(tok, idx);
5796  
    
5797  
    if (debug) {
5798  
      print(toUpper(keyword) + " BEFORE\n" + join(subList(tok, i, j)));
5799  
      print("  THEN " + join(subList(tok, j, j+10)));
5800  
    }
5801  
    //assertEquals("}", tok.get(j-1));
5802  
    List<String> subList = subList(tok, i-1, idx); // N to somewhere
5803  
    tok.set(j-1, jreplaceExpandRefs(end, subList));
5804  
    replaceTokens(tok, i, idx+1, jreplaceExpandRefs(beg, subList));
5805  
    reTok(tok, i, j);
5806  
    if (debug) print(toUpper(keyword) + "\n" + join(subList(tok, i, j)) + "\n");
5807  
  }
5808  
  return tok;
5809  
}
5810  
5811  
5812  
// finds "<keyword> <quoted> {"
5813  
// func: tok, C token index of keyword -> S[] {beg, end}
5814  
static List<String> replaceKeywordPlusQuotedBlock(List<String> tok, String keyword, Object func) {
5815  
  for (int i = 0; i < 1000; i++) {
5816  
    int idx = jfind(tok, keyword + " <quoted> {");
5817  
    if (idx < 0)
5818  
      break;
5819  
    int j = findEndOfBracketPart(tok, idx+4);
5820  
    
5821  
    String[] be = (String[]) callF(func, tok, idx);
5822  
    tok.set(idx, be[0]);
5823  
    clearTokens(tok, idx+1, idx+5);
5824  
    tok.set(j-1, be[1]);
5825  
    reTok(tok, idx, j);
5826  
  }
5827  
  return tok;
5828  
}
5829  
5830  
5831  
static int jfind(String s, String in) {
5832  
  return jfind(javaTok(s), in);
5833  
}
5834  
5835  
static int jfind(List<String> tok, String in) {
5836  
  return jfind(tok, 1, in);
5837  
}
5838  
5839  
static int jfind(List<String> tok, int startIdx, String in) {
5840  
  return jfind(tok, startIdx, in, null);
5841  
}
5842  
5843  
static int jfind(List<String> tok, String in, Object condition) {
5844  
  return jfind(tok, 1, in, condition);
5845  
}
5846  
5847  
static int jfind(List<String> tok, String in, ITokCondition condition) { return jfind(tok, 1, in, condition); }
5848  
static int jfind(List<String> tok, int startIndex, String in, ITokCondition condition) {
5849  
  return jfind(tok, startIndex, in, (Object) condition);
5850  
}
5851  
5852  
static int jfind(List<String> tok, int startIdx, String in, Object condition) {
5853  
  //LS tokin = jfind_preprocess(javaTok(in));
5854  
  return jfind(tok, startIdx, javaTokForJFind_array(in), condition);
5855  
}
5856  
5857  
// assumes you preprocessed tokin
5858  
static int jfind(List<String> tok, List<String> tokin) {
5859  
  return jfind(tok, 1, tokin);
5860  
}
5861  
5862  
static int jfind(List<String> tok, int startIdx, List<String> tokin) {
5863  
  return jfind(tok, startIdx, tokin, null);
5864  
}
5865  
5866  
static int jfind(List<String> tok, int startIdx, String[] tokinC, Object condition) {
5867  
  return findCodeTokens(tok, startIdx, false, tokinC, condition);
5868  
}
5869  
5870  
static int jfind(List<String> tok, int startIdx, List<String> tokin, Object condition) {
5871  
  return jfind(tok, startIdx, codeTokensAsStringArray(tokin), condition);
5872  
}
5873  
5874  
static List<String> jfind_preprocess(List<String> tok) {
5875  
  for (String type : litlist("quoted", "id", "int"))
5876  
    replaceSublist(tok, ll("<", "", type, "", ">"), ll("<" + type + ">"));
5877  
  replaceSublist(tok, ll("\\", "", "*"), ll("\\*"));
5878  
  return tok;
5879  
}
5880  
5881  
5882  
// Return value is index of semicolon/curly brace+1
5883  
static int tok_findEndOfStatement(List<String> tok, int i) {
5884  
  // Is it a block?
5885  
  if (eq(get(tok, i), "{"))
5886  
    return findEndOfBlock(tok, i);
5887  
    
5888  
  // It's a regular statement. Special handling of "for" and "if"
5889  
  int j = i;
5890  
  boolean special = false;
5891  
  while (j < l(tok) && neq(tok.get(j), ";")) {
5892  
    String t = get(tok, j);
5893  
    if (eqOneOf(t, "for", "if")) special = true;
5894  
    if (eqOneOf(t, "{", "(")) {
5895  
      j = findEndOfBracketPart(tok, j)+1;
5896  
      if (special && eq(t, "{")) return j-1;
5897  
    } else
5898  
      j += 2;
5899  
  }
5900  
  return j+1;
5901  
}
5902  
5903  
5904  
static TokCondition tokCondition_beginningOfMethodDeclaration() {
5905  
  return new TokCondition() { public boolean get(final List<String> tok, final int i) {
5906  
    return eqOneOf(_get(tok, i-1), "}", ";", "{", null, ""); // "" is there to hopefully handle badly re-toked includes preceding the declaration
5907  
  }};
5908  
}
5909  
5910  
5911  
static boolean neqGet(List l, int i, Object o) {
5912  
  return neq(get(l, i), o);
5913  
}
5914  
5915  
5916  
static void tok_moduleClassDecls(List<String> tok) {
5917  
  jreplace(tok, "module <id> {", "module $2 extends DynModule {");
5918  
  jreplace(tok, "module {", "module " + stefansOS_defaultModuleClassName() + " {");
5919  
  jreplace(tok, "module > <id>", "module " + stefansOS_defaultModuleClassName() + " > $3");
5920  
  int i = -1;
5921  
  while ((i = jfind(tok, i+1, "module <id>")) >= 0) {
5922  
    int j = findEndOfBlock(tok, indexOf(tok, "{", i))-1;
5923  
    String name = tok.get(i+2);
5924  
    tok.set(i, "sclass");
5925  
    tokAppend(tok, j, "\nsbool _moduleClass_" + name + " = true;"); // just a marker to quickly find module classes
5926  
    reTok(tok, j, j+1);
5927  
  }
5928  
}
5929  
5930  
5931  
5932  
static <A> A _get(List<A> l, int idx) {
5933  
  return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;
5934  
}
5935  
5936  
static Object _get(Object o, String field) {
5937  
  return get(o, field);
5938  
}
5939  
5940  
static Object _get(String field, Object o) {
5941  
  return get(o, field);
5942  
}
5943  
static <A> A _get(A[] l, int idx) {
5944  
  return idx >= 0 && idx < l(l) ? l[idx] : null;
5945  
}
5946  
5947  
5948  
// func : func(LS tok, int iOpening, int iClosing) -> S[] {beg, end}
5949  
static List<String> replaceKeywordBlock_dyn2_legacy(List<String> tok, String keyword, Object func) {
5950  
  for (int i = 0; i < 1000; i++) {
5951  
    //int idx = findCodeTokens(tok, keyword, "{");
5952  
    int idx = jfind(tok, keyword + " {");
5953  
    if (idx < 0)
5954  
      break;
5955  
    int idx2 = findCodeTokens(tok, idx, false, "{");
5956  
    int j = findEndOfBracketPart(tok, idx2);
5957  
    
5958  
    String[] be = (String[]) callF(func, tok, idx2, j-1);
5959  
    replaceTokens(tok, idx, idx2+2, be[0] + " ");
5960  
    tok.set(j-1, be[1]);
5961  
    reTok(tok, idx, j);
5962  
  }
5963  
  return tok;
5964  
}
5965  
5966  
5967  
static boolean startsWithLowerCaseOrUnderscore(String s) {
5968  
  return nempty(s) && (s.startsWith("_") || Character.isLowerCase(s.charAt(0)));
5969  
}
5970  
5971  
5972  
static boolean empty(Collection c) { return c == null || c.isEmpty(); }
5973  
static boolean empty(Iterable c) { return c == null || !c.iterator().hasNext(); }
5974  
static boolean empty(CharSequence s) { return s == null || s.length() == 0; }
5975  
static boolean empty(Map map) { return map == null || map.isEmpty(); }
5976  
static boolean empty(Object[] o) { return o == null || o.length == 0; }
5977  
5978  
5979  
static boolean empty(Object o) {
5980  
  if (o instanceof Collection) return empty((Collection) o);
5981  
  if (o instanceof String) return empty((String) o);
5982  
  if (o instanceof Map) return empty((Map) o);
5983  
  if (o instanceof Object[]) return empty((Object[]) o);
5984  
  if (o instanceof byte[]) return empty((byte[]) o);
5985  
  if (o == null) return true;
5986  
  throw fail("unknown type for 'empty': " + getType(o));
5987  
}
5988  
5989  
5990  
static boolean empty(Iterator i) { return i == null || !i.hasNext(); }
5991  
5992  
static boolean empty(double[] a) { return a == null || a.length == 0; }
5993  
static boolean empty(float[] a) { return a == null || a.length == 0; }
5994  
static boolean empty(int[] a) { return a == null || a.length == 0; }
5995  
static boolean empty(long[] a) { return a == null || a.length == 0; }
5996  
static boolean empty(byte[] a) { return a == null || a.length == 0; 
5997  
[...]
5998  
5999  
6000  
6001  
6002  
6003  
6004  
6005  
6006  
6007  
6008  
6009  
6010  
6011  
6012  
6013  
6014  
6015  
6016  
6017  
6018  
6019  
6020  
6021  
6022  
6023  
6024  
6025  
6026  
6027  
6028  
6029  
6030  
6031  
6032  
6033  
6034  
6035  
6036  
6037  
6038  
6039  
6040  
6041  
6042  
6043  
6044  
6045  
6046  
6047  
6048  
6049  
6050  
6051  
6052  
6053  
6054  
6055  
6056  
6057  
6058  
6059  
6060  
6061  
6062  
6063  
6064  
6065  
6066  
6067  
6068  
6069  
6070  
6071  
6072  
6073  
6074  
6075  
6076  
6077  
6078  
6079  
6080  
6081  
6082  
6083  
6084  
6085  
6086  
6087  
6088  
6089  
6090  
6091  
6092  
6093  
6094  
6095  
6096  
6097  
6098  
6099  
6100  
6101  
6102  
6103  
6104  
6105  
6106  
6107  
6108  
6109  
6110  
6111  
6112  
6113  
6114  
6115  
6116  
6117  
6118  
6119  
6120  
6121  
6122  
6123  
6124  
6125  
6126  
6127  
6128  
6129  
6130  
6131  
6132  
6133  
6134  
6135  
6136  
6137  
6138  
6139  
6140  
6141  
6142  
6143  
6144  
6145  
6146  
6147  
6148  
6149  
6150  
6151  
6152  
6153  
6154  
6155  
6156  
6157  
6158  
6159  
6160  
6161  
6162  
6163  
6164  
6165  
6166  
6167  
6168  
6169  
6170  
6171  
6172  
6173  
6174  
6175  
6176  
6177  
6178  
6179  
6180  
6181  
6182  
6183  
6184  
6185  
6186  
6187  
6188  
6189  
6190  
6191  
6192  
6193  
6194  
6195  
6196  
6197  
6198  
6199  
6200  
6201  
6202  
6203  
6204  
6205  
6206  
6207  
6208  
6209  
6210  
6211  
6212  
6213  
6214  
6215  
6216  
6217  
6218  
6219  
6220  
6221  
6222  
6223  
6224  
6225  
6226  
6227  
6228  
6229  
6230  
6231  
6232  
6233  
6234  
6235  
6236  
6237  
6238  
6239  
6240  
6241  
6242  
6243  
6244  
6245  
6246  
6247  
6248  
6249  
6250  
6251  
6252  
6253  
6254  
6255  
6256  
6257  
6258  
6259  
6260  
6261  
6262  
6263  
6264  
6265  
6266  
6267  
6268  
6269  
6270  
6271  
6272  
6273  
6274  
6275  
6276  
6277  
6278  
6279  
6280  
6281  
6282  
6283  
6284  
6285  
6286  
6287  
6288  
6289  
6290  
6291  
6292  
6293  
6294  
6295  
6296  
6297  
6298  
6299  
6300  
6301  
6302  
6303  
6304  
6305  
6306  
6307  
6308  
6309  
6310  
6311  
6312  
6313  
6314  
6315  
6316  
6317  
6318  
6319  
6320  
6321  
6322  
6323  
6324  
6325  
6326  
6327  
6328  
6329  
6330  
6331  
6332  
6333  
6334  
6335  
6336  
6337  
6338  
6339  
6340  
6341  
6342  
6343  
6344  
6345  
6346  
6347  
6348  
6349  
6350  
6351  
6352  
6353  
6354  
6355  
6356  
6357  
6358  
6359  
6360  
6361  
6362  
6363  
6364  
6365  
6366  
6367  
6368  
6369  
6370  
6371  
6372  
6373  
6374  
6375  
6376  
6377  
6378  
6379  
6380  
6381  
6382  
6383  
6384  
6385  
6386  
6387  
6388  
6389  
6390  
6391  
6392  
6393  
6394  
6395  
6396  
6397  
6398  
6399  
6400  
6401  
6402  
6403  
6404  
6405  
6406  
6407  
6408  
6409  
6410  
6411  
6412  
6413  
6414  
6415  
6416  
6417  
6418  
6419  
6420  
6421  
6422  
6423  
6424  
6425  
6426  
6427  
6428  
6429  
6430  
6431  
6432  
6433  
6434  
6435  
6436  
6437  
6438  
6439  
6440  
6441  
6442  
6443  
6444  
6445  
6446  
6447  
6448  
6449  
6450  
6451  
6452  
6453  
6454  
6455  
6456  
6457  
6458  
6459  
6460  
6461  
6462  
6463  
6464  
6465  
6466  
6467  
6468  
6469  
6470  
6471  
6472  
6473  
6474  
6475  
6476  
6477  
6478  
6479  
6480  
6481  
6482  
6483  
6484  
6485  
6486  
6487  
6488  
6489  
6490  
6491  
6492  
6493  
6494  
6495  
6496  
6497  
6498  
6499  
6500  
6501  
6502  
6503  
6504  
6505  
6506  
6507  
6508  
6509  
6510  
6511  
6512  
6513  
6514  
6515  
6516  
6517  
6518  
6519  
6520  
6521  
6522  
6523  
6524  
6525  
6526  
6527  
6528  
6529  
6530  
6531  
6532  
6533  
6534  
6535  
6536  
6537  
6538  
6539  
6540  
6541  
6542  
6543  
6544  
6545  
6546  
6547  
6548  
6549  
6550  
6551  
6552  
6553  
6554  
6555  
6556  
6557  
6558  
6559  
6560  
6561  
6562  
6563  
6564  
6565  
6566  
6567  
6568  
6569  
6570  
6571  
6572  
6573  
6574  
6575  
6576  
6577  
6578  
6579  
6580  
6581  
6582  
6583  
6584  
6585  
6586  
6587  
6588  
6589  
6590  
6591  
6592  
6593  
6594  
6595  
6596  
6597  
6598  
6599  
6600  
6601  
6602  
6603  
6604  
6605  
6606  
6607  
6608  
6609  
6610  
6611  
6612  
6613  
6614  
6615  
6616  
6617  
6618  
6619  
6620  
6621  
6622  
6623  
6624  
6625  
6626  
6627  
6628  
6629  
6630  
6631  
6632  
6633  
6634  
6635  
6636  
6637  
6638  
6639  
6640  
6641  
6642  
6643  
6644  
6645  
6646  
6647  
6648  
6649  
6650  
6651  
6652  
6653  
6654  
6655  
6656  
6657  
6658  
6659  
6660  
6661  
6662  
6663  
6664  
6665  
6666  
6667  
6668  
6669  
6670  
6671  
6672  
6673  
6674  
6675  
6676  
6677  
6678  
6679  
6680  
6681  
6682  
6683  
6684  
6685  
6686  
6687  
6688  
6689  
6690  
6691  
6692  
6693  
6694  
6695  
6696  
6697  
6698  
6699  
6700  
6701  
6702  
6703  
6704  
6705  
6706  
6707  
6708  
6709  
6710  
6711  
6712  
6713  
6714  
6715  
6716  
6717  
6718  
6719  
6720  
6721  
6722  
6723  
6724  
6725  
6726  
6727  
6728  
6729  
6730  
6731  
6732  
6733  
6734  
6735  
6736  
6737  
6738  
6739  
6740  
6741  
6742  
6743  
6744  
6745  
6746  
6747  
6748  
6749  
6750  
6751  
6752  
6753  
6754  
6755  
6756  
6757  
6758  
6759  
6760  
6761  
6762  
6763  
6764  
6765  
6766  
6767  
6768  
6769  
6770  
6771  
6772  
6773  
6774  
6775  
6776  
6777  
6778  
6779  
6780  
6781  
6782  
6783  
6784  
6785  
6786  
6787  
6788  
6789  
6790  
6791  
6792  
6793  
6794  
6795  
6796  
6797  
6798  
6799  
6800  
6801  
6802  
6803  
6804  
6805  
6806  
6807  
6808  
6809  
6810  
6811  
6812  
6813  
6814  
6815  
6816  
6817  
6818  
6819  
6820  
6821  
6822  
6823  
6824  
6825  
6826  
6827  
6828  
6829  
6830  
6831  
6832  
6833  
6834  
6835  
6836  
6837  
6838  
6839  
6840  
6841  
6842  
6843  
6844  
6845  
6846  
6847  
6848  
6849  
6850  
6851  
6852  
6853  
6854  
6855  
6856  
6857  
6858  
6859  
6860  
6861  
6862  
6863  
6864  
6865  
6866  
6867  
6868  
6869  
6870  
6871  
6872  
6873  
6874  
6875  
6876  
6877  
6878  
6879  
6880  
6881  
6882  
6883  
6884  
6885  
6886  
6887  
6888  
6889  
6890  
6891  
6892  
6893  
6894  
6895  
6896  
6897  
6898  
6899  
6900  
6901  
6902  
6903  
6904  
6905  
6906  
6907  
6908  
6909  
6910  
6911  
6912  
6913  
6914  
6915  
6916  
6917  
6918  
6919  
6920  
6921  
6922  
6923  
6924  
6925  
6926  
6927  
6928  
6929  
6930  
6931  
6932  
6933  
6934  
6935  
6936  
6937  
6938  
6939  
6940  
6941  
6942  
6943  
6944  
6945  
6946  
6947  
6948  
6949  
6950  
6951  
6952  
6953  
6954  
6955  
6956  
6957  
6958  
6959  
6960  
6961  
6962  
6963  
6964  
6965  
6966  
6967  
6968  
6969  
6970  
6971  
6972  
6973  
6974  
6975  
6976  
6977  
6978  
6979  
6980  
6981  
6982  
6983  
6984  
6985  
6986  
6987  
6988  
6989  
6990  
6991  
6992  
6993  
6994  
6995  
6996  
6997  
6998  
6999  
7000  
7001  
7002  
7003  
7004  
7005  
7006  
7007  
7008  
7009  
7010  
7011  
7012  
7013  
7014  
7015  
7016  
7017  
7018  
7019  
7020  
7021  
7022  
7023  
7024  
7025  
7026  
7027  
7028  
7029  
7030  
7031  
7032  
7033  
7034  
7035  
7036  
7037  
7038  
7039  
7040  
7041  
7042  
7043  
7044  
7045  
7046  
7047  
7048  
7049  
7050  
7051  
7052  
7053  
7054  
7055  
7056  
7057  
7058  
7059  
7060  
7061  
7062  
7063  
7064  
7065  
7066  
7067  
7068  
7069  
7070  
7071  
7072  
7073  
7074  
7075  
7076  
7077  
7078  
7079  
7080  
7081  
7082  
7083  
7084  
7085  
7086  
7087  
7088  
7089  
7090  
7091  
7092  
7093  
7094  
7095  
7096  
7097  
7098  
7099  
7100  
7101  
7102  
7103  
7104  
7105  
7106  
7107  
7108  
7109  
7110  
7111  
7112  
7113  
7114  
7115  
7116  
7117  
7118  
7119  
7120  
7121  
7122  
7123  
7124  
7125  
7126  
7127  
7128  
7129  
7130  
7131  
7132  
7133  
7134  
7135  
7136  
7137  
7138  
7139  
7140  
7141  
7142  
7143  
7144  
7145  
7146  
7147  
7148  
7149  
7150  
7151  
7152  
7153  
7154  
7155  
7156  
7157  
7158  
7159  
7160  
7161  
7162  
7163  
7164  
7165  
7166  
7167  
7168  
7169  
7170  
7171  
7172  
7173  
7174  
7175  
7176  
7177  
7178  
7179  
7180  
7181  
7182  
7183  
7184  
7185  
7186  
7187  
7188  
7189  
7190  
7191  
7192  
7193  
7194  
7195  
7196  
7197  
7198  
7199  
7200  
7201  
7202  
7203  
7204  
7205  
7206  
7207  
7208  
7209  
7210  
7211  
7212  
7213  
7214  
7215  
7216  
7217  
7218  
7219  
7220  
7221  
7222  
7223  
7224  
7225  
7226  
7227  
7228  
7229  
7230  
7231  
7232  
7233  
7234  
7235  
7236  
7237  
7238  
7239  
7240  
7241  
7242  
7243  
7244  
7245  
7246  
7247  
7248  
7249  
7250  
7251  
7252  
7253  
7254  
7255  
7256  
7257  
7258  
7259  
7260  
7261  
7262  
7263  
7264  
7265  
7266  
7267  
7268  
7269  
7270  
7271  
7272  
7273  
7274  
7275  
7276  
7277  
7278  
7279  
7280  
7281  
7282  
7283  
7284  
7285  
7286  
7287  
7288  
7289  
7290  
7291  
7292  
7293  
7294  
7295  
7296  
7297  
7298  
7299  
7300  
7301  
7302  
7303  
7304  
7305  
7306  
7307  
7308  
7309  
7310  
7311  
7312  
7313  
7314  
7315  
7316  
7317  
7318  
7319  
7320  
7321  
7322  
7323  
7324  
7325  
7326  
7327  
7328  
7329  
7330  
7331  
7332  
7333  
7334  
7335  
7336  
7337  
7338  
7339  
7340  
7341  
7342  
7343  
7344  
7345  
7346  
7347  
7348  
7349  
7350  
7351  
7352  
7353  
7354  
7355  
7356  
7357  
7358  
7359  
7360  
7361  
7362  
7363  
7364  
7365  
7366  
7367  
7368  
7369  
7370  
7371  
7372  
7373  
7374  
7375  
7376  
7377  
7378  
7379  
7380  
7381  
7382  
7383  
7384  
7385  
7386  
7387  
7388  
7389  
7390  
7391  
7392  
7393  
7394  
7395  
7396  
7397  
7398  
7399  
7400  
7401  
7402  
7403  
7404  
7405  
7406  
7407  
7408  
7409  
7410  
7411  
7412  
7413  
7414  
7415  
7416  
7417  
7418  
7419  
7420  
7421  
7422  
7423  
7424  
7425  
7426  
7427  
7428  
7429  
7430  
7431  
7432  
7433  
7434  
7435  
7436  
7437  
7438  
7439  
7440  
7441  
7442  
7443  
7444  
7445  
7446  
7447  
7448  
7449  
7450  
7451  
7452  
7453  
7454  
7455  
7456  
7457  
7458  
7459  
7460  
7461  
7462  
7463  
7464  
7465  
7466  
7467  
7468  
7469  
7470  
7471  
7472  
7473  
7474  
7475  
7476  
7477  
7478  
7479  
7480  
7481  
7482  
7483  
7484  
7485  
7486  
7487  
7488  
7489  
7490  
7491  
7492  
7493  
7494  
7495  
7496  
7497  
7498  
7499  
7500  
7501  
7502  
7503  
7504  
7505  
7506  
7507  
7508  
7509  
7510  
7511  
7512  
7513  
7514  
7515  
7516  
7517  
7518  
7519  
7520  
7521  
7522  
7523  
7524  
7525  
7526  
7527  
7528  
7529  
7530  
7531  
7532  
7533  
7534  
7535  
7536  
7537  
7538  
7539  
7540  
7541  
7542  
7543  
7544  
7545  
7546  
7547  
7548  
7549  
7550  
7551  
7552  
7553  
7554  
7555  
7556  
7557  
7558  
7559  
7560  
7561  
7562  
7563  
7564  
7565  
7566  
7567  
7568  
7569  
7570  
7571  
7572  
7573  
7574  
7575  
7576  
7577  
7578  
7579  
7580  
7581  
7582  
7583  
7584  
7585  
7586  
7587  
7588  
7589  
7590  
7591  
7592  
7593  
7594  
7595  
7596  
7597  
7598  
7599  
7600  
7601  
7602  
7603  
7604  
7605  
7606  
7607  
7608  
7609  
7610  
7611  
7612  
7613  
7614  
7615  
7616  
7617  
7618  
7619  
7620  
7621  
7622  
7623  
7624  
7625  
7626  
7627  
7628  
7629  
7630  
7631  
7632  
7633  
7634  
7635  
7636  
7637  
7638  
7639  
7640  
7641  
7642  
7643  
7644  
7645  
7646  
7647  
7648  
7649  
7650  
7651  
7652  
7653  
7654  
7655  
7656  
7657  
7658  
7659  
7660  
7661  
7662  
7663  
7664  
7665  
7666  
7667  
7668  
7669  
7670  
7671  
7672  
7673  
7674  
7675  
7676  
7677  
7678  
7679  
7680  
7681  
7682  
7683  
7684  
7685  
7686  
7687  
7688  
7689  
7690  
7691  
7692  
7693  
7694  
7695  
7696  
7697  
7698  
7699  
7700  
7701  
7702  
7703  
7704  
7705  
7706  
7707  
7708  
7709  
7710  
7711  
7712  
7713  
7714  
7715  
7716  
7717  
7718  
7719  
7720  
7721  
7722  
7723  
7724  
7725  
7726  
7727  
7728  
7729  
7730  
7731  
7732  
7733  
7734  
7735  
7736  
7737  
7738  
7739  
7740  
7741  
7742  
7743  
7744  
7745  
7746  
7747  
7748  
7749  
7750  
7751  
7752  
7753  
7754  
7755  
7756  
7757  
7758  
7759  
7760  
7761  
7762  
7763  
7764  
7765  
7766  
7767  
7768  
7769  
7770  
7771  
7772  
7773  
7774  
7775  
7776  
7777  
7778  
7779  
7780  
7781  
7782  
7783  
7784  
7785  
7786  
7787  
7788  
7789  
7790  
7791  
7792  
7793  
7794  
7795  
7796  
7797  
7798  
7799  
7800  
7801  
7802  
7803  
7804  
7805  
7806  
7807  
7808  
7809  
7810  
7811  
7812  
7813  
7814  
7815  
7816  
7817  
7818  
7819  
7820  
7821  
7822  
7823  
7824  
7825  
7826  
7827  
7828  
7829  
7830  
7831  
7832  
7833  
7834  
7835  
7836  
7837  
7838  
7839  
7840  
7841  
7842  
7843  
7844  
7845  
7846  
7847  
7848  
7849  
7850  
7851  
7852  
7853  
7854  
7855  
7856  
7857  
7858  
7859  
7860  
7861  
7862  
7863  
7864  
7865  
7866  
7867  
7868  
7869  
7870  
7871  
7872  
7873  
7874  
7875  
7876  
7877  
7878  
7879  
7880  
7881  
7882  
7883  
7884  
7885  
7886  
7887  
7888  
7889  
7890  
7891  
7892  
7893  
7894  
7895  
7896  
7897  
7898  
7899  
7900  
7901  
7902  
7903  
7904  
7905  
7906  
7907  
7908  
7909  
7910  
7911  
7912  
7913  
7914  
7915  
7916  
7917  
7918  
7919  
7920  
7921  
7922  
7923  
7924  
7925  
7926  
7927  
7928  
7929  
7930  
7931  
7932  
7933  
7934  
7935  
7936  
7937  
7938  
7939  
7940  
7941  
7942  
7943  
7944  
7945  
7946  
7947  
7948  
7949  
7950  
7951  
7952  
7953  
7954  
7955  
7956  
7957  
7958  
7959  
7960  
7961  
7962  
7963  
7964  
7965  
7966  
7967  
7968  
7969  
7970  
7971  
7972  
7973  
7974  
7975  
7976  
7977  
7978  
7979  
7980  
7981  
7982  
7983  
7984  
7985  
7986  
7987  
7988  
7989  
7990  
7991  
7992  
7993  
7994  
7995  
7996  
7997  
7998  
7999  
8000  
8001  
8002  
8003  
8004  
8005  
8006  
8007  
8008  
8009  
8010  
8011  
8012  
8013  
8014  
8015  
8016  
8017  
8018  
8019  
8020  
8021  
8022  
8023  
8024  
8025  
8026  
8027  
8028  
8029  
8030  
8031  
8032  
8033  
8034  
8035  
8036  
8037  
8038  
8039  
8040  
8041  
8042  
8043  
8044  
8045  
8046  
8047  
8048  
8049  
8050  
8051  
8052  
8053  
8054  
8055  
8056  
8057  
8058  
8059  
8060  
8061  
8062  
8063  
8064  
8065  
8066  
8067  
8068  
8069  
8070  
8071  
8072  
8073  
8074  
8075  
8076  
8077  
8078  
8079  
8080  
8081  
8082  
8083  
8084  
8085  
8086  
8087  
8088  
8089  
8090  
8091  
8092  
8093  
8094  
8095  
8096  
8097  
8098  
8099  
8100  
8101  
8102  
8103  
8104  
8105  
8106  
8107  
8108  
8109  
8110  
8111  
8112  
8113  
8114  
8115  
8116  
8117  
8118  
8119  
8120  
8121  
8122  
8123  
8124  
8125  
8126  
8127  
8128  
8129  
8130  
8131  
8132  
8133  
8134  
8135  
8136  
8137  
8138  
8139  
8140  
8141  
8142  
8143  
8144  
8145  
8146  
8147  
8148  
8149  
8150  
8151  
8152  
8153  
8154  
8155  
8156  
8157  
8158  
8159  
8160  
8161  
8162  
8163  
8164  
8165  
8166  
8167  
8168  
8169  
8170  
8171  
8172  
8173  
8174  
8175  
8176  
8177  
8178  
8179  
8180  
8181  
8182  
8183  
8184  
8185  
8186  
8187  
8188  
8189  
8190  
8191  
8192  
8193  
8194  
8195  
8196  
8197  
8198  
8199  
8200  
8201  
8202  
8203  
8204  
8205  
8206  
8207  
8208  
8209  
8210  
8211  
8212  
8213  
8214  
8215  
8216  
8217  
8218  
8219  
8220  
8221  
8222  
8223  
8224  
8225  
8226  
8227  
8228  
8229  
8230  
8231  
8232  
8233  
8234  
8235  
8236  
8237  
8238  
8239  
8240  
8241  
8242  
8243  
8244  
8245  
8246  
8247  
8248  
8249  
8250  
8251  
8252  
8253  
8254  
8255  
8256  
8257  
8258  
8259  
8260  
8261  
8262  
8263  
8264  
8265  
8266  
8267  
8268  
8269  
8270  
8271  
8272  
8273  
8274  
8275  
8276  
8277  
8278  
8279  
8280  
8281  
8282  
8283  
8284  
8285  
8286  
8287  
8288  
8289  
8290  
8291  
8292  
8293  
8294  
8295  
8296  
8297  
8298  
8299  
8300  
8301  
8302  
8303  
8304  
8305  
8306  
8307  
8308  
8309  
8310  
8311  
8312  
8313  
8314  
8315  
8316  
8317  
8318  
8319  
8320  
8321  
8322  
8323  
8324  
8325  
8326  
8327  
8328  
8329  
8330  
8331  
8332  
8333  
8334  
8335  
8336  
8337  
8338  
8339  
8340  
8341  
8342  
8343  
8344  
8345  
8346  
8347  
8348  
8349  
8350  
8351  
8352  
8353  
8354  
8355  
8356  
8357  
8358  
8359  
8360  
8361  
8362  
8363  
8364  
8365  
8366  
8367  
8368  
8369  
8370  
8371  
8372  
8373  
8374  
8375  
8376  
8377  
8378  
8379  
8380  
8381  
8382  
8383  
8384  
8385  
8386  
8387  
8388  
8389  
8390  
8391  
8392  
8393  
8394  
8395  
8396  
8397  
8398  
8399  
8400  
8401  
8402  
8403  
8404  
8405  
8406  
8407  
8408  
8409  
8410  
8411  
8412  
8413  
8414  
8415  
8416  
8417  
8418  
8419  
8420  
8421  
8422  
8423  
8424  
8425  
8426  
8427  
8428  
8429  
8430  
8431  
8432  
8433  
8434  
8435  
8436  
8437  
8438  
8439  
8440  
8441  
8442  
8443  
8444  
8445  
8446  
8447  
8448  
8449  
8450  
8451  
8452  
8453  
8454  
8455  
8456  
8457  
8458  
8459  
8460  
8461  
8462  
8463  
8464  
8465  
8466  
8467  
8468  
8469  
8470  
8471  
8472  
8473  
8474  
8475  
8476  
8477  
8478  
8479  
8480  
8481  
8482  
8483  
8484  
8485  
8486  
8487  
8488  
8489  
8490  
8491  
8492  
8493  
8494  
8495  
8496  
8497  
8498  
8499  
8500  
8501  
8502  
8503  
8504  
8505  
8506  
8507  
8508  
8509  
8510  
8511  
8512  
8513  
8514  
8515  
8516  
8517  
8518  
8519  
8520  
8521  
8522  
8523  
8524  
8525  
8526  
8527  
8528  
8529  
8530  
8531  
8532  
8533  
8534  
8535  
8536  
8537  
8538  
8539  
8540  
8541  
8542  
8543  
8544  
8545  
8546  
8547  
8548  
8549  
8550  
8551  
8552  
8553  
8554  
8555  
8556  
8557  
8558  
8559  
8560  
8561  
8562  
8563  
8564  
8565  
8566  
8567  
8568  
8569  
8570  
8571  
8572  
8573  
8574  
8575  
8576  
8577  
8578  
8579  
8580  
8581  
8582  
8583  
8584  
8585  
8586  
8587  
8588  
8589  
8590  
8591  
8592  
8593  
8594  
8595  
8596  
8597  
8598  
8599  
8600  
8601  
8602  
8603  
8604  
8605  
8606  
8607  
8608  
8609  
8610  
8611  
8612  
8613  
8614  
8615  
8616  
8617  
8618  
8619  
8620  
8621  
8622  
8623  
8624  
8625  
8626  
8627  
8628  
8629  
8630  
8631  
8632  
8633  
8634  
8635  
8636  
8637  
8638  
8639  
8640  
8641  
8642  
8643  
8644  
8645  
8646  
8647  
8648  
8649  
8650  
8651  
8652  
8653  
8654  
8655  
8656  
8657  
8658  
8659  
8660  
8661  
8662  
8663  
8664  
8665  
8666  
8667  
8668  
8669  
8670  
8671  
8672  
8673  
8674  
8675  
8676  
8677  
8678  
8679  
8680  
8681  
8682  
8683  
8684  
8685  
8686  
8687  
8688  
8689  
8690  
8691  
8692  
8693  
8694  
8695  
8696  
8697  
8698  
8699  
8700  
8701  
8702  
8703  
8704  
8705  
8706  
8707  
8708  
8709  
8710  
8711  
8712  
8713  
8714  
8715  
8716  
8717  
8718  
8719  
8720  
8721  
8722  
8723  
8724  
8725  
8726  
8727  
8728  
8729  
8730  
8731  
8732  
8733  
8734  
8735  
8736  
8737  
8738  
8739  
8740  
8741  
8742  
8743  
8744  
8745  
8746  
8747  
8748  
8749  
8750  
8751  
8752  
8753  
8754  
8755  
8756  
8757  
8758  
8759  
8760  
8761  
8762  
8763  
8764  
8765  
8766  
8767  
8768  
8769  
8770  
8771  
8772  
8773  
8774  
8775  
8776  
8777  
8778  
8779  
8780  
8781  
8782  
8783  
8784  
8785  
8786  
8787  
8788  
8789  
8790  
8791  
8792  
8793  
8794  
8795  
8796  
8797  
8798  
8799  
8800  
8801  
8802  
8803  
8804  
8805  
8806  
8807  
8808  
8809  
8810  
8811  
8812  
8813  
8814  
8815  
8816  
8817  
8818  
8819  
8820  
8821  
8822  
8823  
8824  
8825  
8826  
8827  
8828  
8829  
8830  
8831  
8832  
8833  
8834  
8835  
8836  
8837  
8838  
8839  
8840  
8841  
8842  
8843  
8844  
8845  
8846  
8847  
8848  
8849  
8850  
8851  
8852  
8853  
8854  
8855  
8856  
8857  
8858  
8859  
8860  
8861  
8862  
8863  
8864  
8865  
8866  
8867  
8868  
8869  
8870  
8871  
8872  
8873  
8874  
8875  
8876  
8877  
8878  
8879  
8880  
8881  
8882  
8883  
8884  
8885  
8886  
8887  
8888  
8889  
8890  
8891  
8892  
8893  
8894  
8895  
8896  
8897  
8898  
8899  
8900  
8901  
8902  
8903  
8904  
8905  
8906  
8907  
8908  
8909  
8910  
8911  
8912  
8913  
8914  
8915  
8916  
8917  
8918  
8919  
8920  
8921  
8922  
8923  
8924  
8925  
8926  
8927  
8928  
8929  
8930  
8931  
8932  
8933  
8934  
8935  
8936  
8937  
8938  
8939  
8940  
8941  
8942  
8943  
8944  
8945  
8946  
8947  
8948  
8949  
8950  
8951  
8952  
8953  
8954  
8955  
8956  
8957  
8958  
8959  
8960  
8961  
8962  
8963  
8964  
8965  
8966  
8967  
8968  
8969  
8970  
8971  
8972  
8973  
8974  
8975  
8976  
8977  
8978  
8979  
8980  
8981  
8982  
8983  
8984  
8985  
8986  
8987  
8988  
8989  
8990  
8991  
8992  
8993  
8994  
8995  
8996  
8997  
8998  
8999  
9000  
9001  
9002  
9003  
9004  
9005  
9006  
9007  
9008  
9009  
9010  
9011  
9012  
9013  
9014  
9015  
9016  
9017  
9018  
9019  
9020  
9021  
9022  
9023  
9024  
9025  
9026  
9027  
9028  
9029  
9030  
9031  
9032  
9033  
9034  
9035  
9036  
9037  
9038  
9039  
9040  
9041  
9042  
9043  
9044  
9045  
9046  
9047  
9048  
9049  
9050  
9051  
9052  
9053  
9054  
9055  
9056  
9057  
9058  
9059  
9060  
9061  
9062  
9063  
9064  
9065  
9066  
9067  
9068  
9069  
9070  
9071  
9072  
9073  
9074  
9075  
9076  
9077  
9078  
9079  
9080  
9081  
9082  
9083  
9084  
9085  
9086  
9087  
9088  
9089  
9090  
9091  
9092  
9093  
9094  
9095  
9096  
9097  
9098  
9099  
9100  
9101  
9102  
9103  
9104  
9105  
9106  
9107  
9108  
9109  
9110  
9111  
9112  
9113  
9114  
9115  
9116  
9117  
9118  
9119  
9120  
9121  
9122  
9123  
9124  
9125  
9126  
9127  
9128  
9129  
9130  
9131  
9132  
9133  
9134  
9135  
9136  
9137  
9138  
9139  
9140  
9141  
9142  
9143  
9144  
9145  
9146  
9147  
9148  
9149  
9150  
9151  
9152  
9153  
9154  
9155  
9156  
9157  
9158  
9159  
9160  
9161  
9162  
9163  
9164  
9165  
9166  
9167  
9168  
9169  
9170  
9171  
9172  
9173  
9174  
9175  
9176  
9177  
9178  
9179  
9180  
9181  
9182  
9183  
9184  
9185  
9186  
9187  
9188  
9189  
9190  
9191  
9192  
9193  
9194  
9195  
9196  
9197  
9198  
9199  
9200  
9201  
9202  
9203  
9204  
9205  
9206  
9207  
9208  
9209  
9210  
9211  
9212  
9213  
9214  
9215  
9216  
9217  
9218  
9219  
9220  
9221  
9222  
9223  
9224  
9225  
9226  
9227  
9228  
9229  
9230  
9231  
9232  
9233  
9234  
9235  
9236  
9237  
9238  
9239  
9240  
9241  
9242  
9243  
9244  
9245  
9246  
9247  
9248  
9249  
9250  
9251  
9252  
9253  
9254  
9255  
9256  
9257  
9258  
9259  
9260  
9261  
9262  
9263  
9264  
9265  
9266  
9267  
9268  
9269  
9270  
9271  
9272  
9273  
9274  
9275  
9276  
9277  
9278  
9279  
9280  
9281  
9282  
9283  
9284  
9285  
9286  
9287  
9288  
9289  
9290  
9291  
9292  
9293  
9294  
9295  
9296  
9297  
9298  
9299  
9300  
9301  
9302  
9303  
9304  
9305  
9306  
9307  
9308  
9309  
9310  
9311  
9312  
9313  
9314  
9315  
9316  
9317  
9318  
9319  
9320  
9321  
9322  
9323  
9324  
9325  
9326  
9327  
9328  
9329  
9330  
9331  
9332  
9333  
9334  
9335  
9336  
9337  
9338  
9339  
9340  
9341  
9342  
9343  
9344  
9345  
9346  
9347  
9348  
9349  
9350  
9351  
9352  
9353  
9354  
9355  
9356  
9357  
9358  
9359  
9360  
9361  
9362  
9363  
9364  
9365  
9366  
9367  
9368  
9369  
9370  
9371  
9372  
9373  
9374  
9375  
9376  
9377  
9378  
9379  
9380  
9381  
9382  
9383  
9384  
9385  
9386  
9387  
9388  
9389  
9390  
9391  
9392  
9393  
9394  
9395  
9396  
9397  
9398  
9399  
9400  
9401  
9402  
9403  
9404  
9405  
9406  
9407  
9408  
9409  
9410  
9411  
9412  
9413  
9414  
9415  
9416  
9417  
9418  
9419  
9420  
9421  
9422  
9423  
9424  
9425  
9426  
9427  
9428  
9429  
9430  
9431  
9432  
9433  
9434  
9435  
9436  
9437  
9438  
9439  
9440  
9441  
9442  
9443  
9444  
9445  
9446  
9447  
9448  
9449  
9450  
9451  
9452  
9453  
9454  
9455  
9456  
9457  
9458  
9459  
9460  
9461  
9462  
9463  
9464  
9465  
9466  
9467  
9468  
9469  
9470  
9471  
9472  
9473  
9474  
9475  
9476  
9477  
9478  
9479  
9480  
9481  
9482  
9483  
9484  
9485  
9486  
9487  
9488  
9489  
9490  
9491  
9492  
9493  
9494  
9495  
9496  
9497  
9498  
9499  
9500  
9501  
9502  
9503  
9504  
9505  
9506  
9507  
9508  
9509  
9510  
9511  
9512  
9513  
9514  
9515  
9516  
9517  
9518  
9519  
9520  
9521  
9522  
9523  
9524  
9525  
9526  
9527  
9528  
9529  
9530  
9531  
9532  
9533  
9534  
9535  
9536  
9537  
9538  
9539  
9540  
9541  
9542  
9543  
9544  
9545  
9546  
9547  
9548  
9549  
9550  
9551  
9552  
9553  
9554  
9555  
9556  
9557  
9558  
9559  
9560  
9561  
9562  
9563  
9564  
9565  
9566  
9567  
9568  
9569  
9570  
9571  
9572  
9573  
9574  
9575  
9576  
9577  
9578  
9579  
9580  
9581  
9582  
9583  
9584  
9585  
9586  
9587  
9588  
9589  
9590  
9591  
9592  
9593  
9594  
9595  
9596  
9597  
9598  
9599  
9600  
9601  
9602  
9603  
9604  
9605  
9606  
9607  
9608  
9609  
9610  
9611  
9612  
9613  
9614  
9615  
9616  
9617  
9618  
9619  
9620  
9621  
9622  
9623  
9624  
9625  
9626  
9627  
9628  
9629  
9630  
9631  
9632  
9633  
9634  
9635  
9636  
9637  
9638  
9639  
9640  
9641  
9642  
9643  
9644  
9645  
9646  
9647  
9648  
9649  
9650  
9651  
9652  
9653  
9654  
9655  
9656  
9657  
9658  
9659  
9660  
9661  
9662  
9663  
9664  
9665  
9666  
9667  
9668  
9669  
9670  
9671  
9672  
9673  
9674  
9675  
9676  
9677  
9678  
9679  
9680  
9681  
9682  
9683  
9684  
9685  
9686  
9687  
9688  
9689  
9690  
9691  
9692  
9693  
9694  
9695  
9696  
9697  
9698  
9699  
9700  
9701  
9702  
9703  
9704  
9705  
9706  
9707  
9708  
9709  
9710  
9711  
9712  
9713  
9714  
9715  
9716  
9717  
9718  
9719  
9720  
9721  
9722  
9723  
9724  
9725  
9726  
9727  
9728  
9729  
9730  
9731  
9732  
9733  
9734  
9735  
9736  
9737  
9738  
9739  
9740  
9741  
9742  
9743  
9744  
9745  
9746  
9747  
9748  
9749  
9750  
9751  
9752  
9753  
9754  
9755  
9756  
9757  
9758  
9759  
9760  
9761  
9762  
9763  
9764  
9765  
9766  
9767  
9768  
9769  
9770  
9771  
9772  
9773  
9774  
9775  
9776  
9777  
9778  
9779  
9780  
9781  
9782  
9783  
9784  
9785  
9786  
9787  
9788  
9789  
9790  
9791  
9792  
9793  
9794  
9795  
9796  
9797  
9798  
9799  
9800  
9801  
9802  
9803  
9804  
9805  
9806  
9807  
9808  
9809  
9810  
9811  
9812  
9813  
9814  
9815  
9816  
9817  
9818  
9819  
9820  
9821  
9822  
9823  
9824  
9825  
9826  
9827  
9828  
9829  
9830  
9831  
9832  
9833  
9834  
9835  
9836  
9837  
9838  
9839  
9840  
9841  
9842  
9843  
9844  
9845  
9846  
9847  
9848  
9849  
9850  
9851  
9852  
9853  
9854  
9855  
9856  
9857  
9858  
9859  
9860  
9861  
9862  
9863  
9864  
9865  
9866  
9867  
9868  
9869  
9870  
9871  
9872  
9873  
9874  
9875  
9876  
9877  
9878  
9879  
9880  
9881  
9882  
9883  
9884  
9885  
9886  
9887  
9888  
9889  
9890  
9891  
9892  
9893  
9894  
9895  
9896  
9897  
9898  
9899  
9900  
9901  
9902  
9903  
9904  
9905  
9906  
9907  
9908  
9909  
9910  
9911  
9912  
9913  
9914  
9915  
9916  
9917  
9918  
9919  
9920  
9921  
9922  
9923  
9924  
9925  
9926  
9927  
9928  
9929  
9930  
9931  
9932  
9933  
9934  
9935  
9936  
9937  
9938  
9939  
9940  
9941  
9942  
9943  
9944  
9945  
9946  
9947  
9948  
9949  
9950  
9951  
9952  
9953  
9954  
9955  
9956  
9957  
9958  
9959  
9960  
9961  
9962  
9963  
9964  
9965  
9966  
9967  
9968  
9969  
9970  
9971  
9972  
9973  
9974  
9975  
9976  
9977  
9978  
9979  
9980  
9981  
9982  
9983  
9984  
9985  
9986  
9987  
9988  
9989  
9990  
9991  
9992  
9993  
9994  
9995  
9996  
9997  
9998  
9999  
10000  
10001  
10002  
10003  
10004  
10005  
10006  
10007  
10008  
10009  
10010  
10011  
10012  
10013  
10014  
10015  
10016  
10017  
10018  
10019  
10020  
10021  
10022  
10023  
10024  
10025  
10026  
10027  
10028  
10029  
10030  
10031  
10032  
10033  
10034  
10035  
10036  
10037  
10038  
10039  
10040  
10041  
10042  
10043  
10044  
10045  
10046  
10047  
10048  
10049  
10050  
10051  
10052  
10053  
10054  
10055  
10056  
10057  
10058  
10059  
10060  
10061  
10062  
10063  
10064  
10065  
10066  
10067  
10068  
10069  
10070  
10071  
10072  
10073  
10074  
10075  
10076  
10077  
10078  
10079  
10080  
10081  
10082  
10083  
10084  
10085  
10086  
10087  
10088  
10089  
10090  
10091  
10092  
10093  
10094  
10095  
10096  
10097  
10098  
10099  
10100  
10101  
10102  
10103  
10104  
10105  
10106  
10107  
10108  
10109  
10110  
10111  
10112  
10113  
10114  
10115  
10116  
10117  
10118  
10119  
10120  
10121  
10122  
10123  
10124  
10125  
10126  
10127  
10128  
10129  
10130  
10131  
10132  
10133  
10134  
10135  
10136  
10137  
10138  
10139  
10140  
10141  
10142  
10143  
10144  
10145  
10146  
10147  
10148  
10149  
10150  
10151  
10152  
10153  
10154  
10155  
10156  
10157  
10158  
10159  
10160  
10161  
10162  
10163  
10164  
10165  
10166  
10167  
10168  
10169  
10170  
10171  
10172  
10173  
10174  
10175  
10176  
10177  
10178  
10179  
10180  
10181  
10182  
10183  
10184  
10185  
10186  
10187  
10188  
10189  
10190  
10191  
10192  
10193  
10194  
10195  
10196  
10197  
10198  
10199  
10200  
10201  
10202  
10203  
10204  
10205  
10206  
10207  
10208  
10209  
10210  
10211  
10212  
10213  
10214  
10215  
10216  
10217  
10218  
10219  
10220  
10221  
10222  
10223  
10224  
10225  
10226  
10227  
10228  
10229  
10230  
10231  
10232  
10233  
10234  
10235  
10236  
10237  
10238  
10239  
10240  
10241  
10242  
10243  
10244  
10245  
10246  
10247  
10248  
10249  
10250  
10251  
10252  
10253  
10254  
10255  
10256  
10257  
10258  
10259  
10260  
10261  
10262  
10263  
10264  
10265  
10266  
10267  
10268  
10269  
10270  
10271  
10272  
10273  
10274  
10275  
10276  
10277  
10278  
10279  
10280  
10281  
10282  
10283  
10284  
10285  
10286  
10287  
10288  
10289  
10290  
10291  
10292  
10293  
10294  
10295  
10296  
10297  
10298  
10299  
10300  
10301  
10302  
10303  
10304  
10305  
10306  
10307  
10308  
10309  
10310  
10311  
10312  
10313  
10314  
10315  
10316  
10317  
10318  
10319  
10320  
10321  
10322  
10323  
10324  
10325  
10326  
10327  
10328  
10329  
10330  
10331  
10332  
10333  
10334  
10335  
10336  
10337  
10338  
10339  
10340  
10341  
10342  
10343  
10344  
10345  
10346  
10347  
10348  
10349  
10350  
10351  
10352  
10353  
10354  
10355  
10356  
10357  
10358  
10359  
10360  
10361  
10362  
10363  
10364  
10365  
10366  
10367  
10368  
10369  
10370  
10371  
10372  
10373  
10374  
10375  
10376  
10377  
10378  
10379  
10380  
10381  
10382  
10383  
10384  
10385  
10386  
10387  
10388  
10389  
10390  
10391  
10392  
10393  
10394  
10395  
10396  
10397  
10398  
10399  
10400  
10401  
10402  
10403  
10404  
10405  
10406  
10407  
10408  
10409  
10410  
10411  
10412  
10413  
10414  
10415  
10416  
10417  
10418  
10419  
10420  
10421  
10422  
10423  
10424  
10425  
10426  
10427  
10428  
10429  
10430  
10431  
10432  
10433  
10434  
10435  
10436  
10437  
10438  
10439  
10440  
10441  
10442  
10443  
10444  
10445  
10446  
10447  
10448  
10449  
10450  
10451  
10452  
10453  
10454  
10455  
10456  
10457  
10458  
10459  
10460  
10461  
10462  
10463  
10464  
10465  
10466  
10467  
10468  
10469  
10470  
10471  
10472  
10473  
10474  
10475  
10476  
10477  
10478  
10479  
10480  
10481  
10482  
10483  
10484  
10485  
10486  
10487  
10488  
10489  
10490  
10491  
10492  
10493  
10494  
10495  
10496  
10497  
10498  
10499  
10500  
10501  
10502  
10503  
10504  
10505  
10506  
10507  
10508  
10509  
10510  
10511  
10512  
10513  
10514  
10515  
10516  
10517  
10518  
10519  
10520  
10521  
10522  
10523  
10524  
10525  
10526  
10527  
10528  
10529  
10530  
10531  
10532  
10533  
10534  
10535  
10536  
10537  
10538  
10539  
10540  
10541  
10542  
10543  
10544  
10545  
10546  
10547  
10548  
10549  
10550  
10551  
10552  
10553  
10554  
10555  
10556  
10557  
10558  
10559  
10560  
10561  
10562  
10563  
10564  
10565  
10566  
10567  
10568  
10569  
10570  
10571  
10572  
10573  
10574  
10575  
10576  
10577  
10578  
10579  
10580  
10581  
10582  
10583  
10584  
10585  
10586  
10587  
10588  
10589  
10590  
10591  
10592  
10593  
10594  
10595  
10596  
10597  
10598  
10599  
10600  
10601  
10602  
10603  
10604  
10605  
10606  
10607  
10608  
10609  
10610  
10611  
10612  
10613  
10614  
10615  
10616  
10617  
10618  
10619  
10620  
10621  
10622  
10623  
10624  
10625  
10626  
10627  
10628  
10629  
10630  
10631  
10632  
10633  
10634  
10635  
10636  
10637  
10638  
10639  
10640  
10641  
10642  
10643  
10644  
10645  
10646  
10647  
10648  
10649  
10650  
10651  
10652  
10653  
10654  
10655  
10656  
10657  
10658  
10659  
10660  
10661  
10662  
10663  
10664  
10665  
10666  
10667  
10668  
10669  
10670  
10671  
10672  
10673  
10674  
10675  
10676  
10677  
10678  
10679  
10680  
10681  
10682  
10683  
10684  
10685  
10686  
10687  
10688  
10689  
10690  
10691  
10692  
10693  
10694  
10695  
10696  
10697  
10698  
10699  
10700  
10701  
10702  
10703  
10704  
10705  
10706  
10707  
10708  
10709  
10710  
10711  
10712  
10713  
10714  
10715  
10716  
10717  
10718  
10719  
10720  
10721  
10722  
10723  
10724  
10725  
10726  
10727  
10728  
10729  
10730  
10731  
10732  
10733  
10734  
10735  
10736  
10737  
10738  
10739  
10740  
10741  
10742  
10743  
10744  
10745  
10746  
10747  
10748  
10749  
10750  
10751  
10752  
10753  
10754  
10755  
10756  
10757  
10758  
10759  
10760  
10761  
10762  
10763  
10764  
10765  
10766  
10767  
10768  
10769  
10770  
10771  
10772  
10773  
10774  
10775  
10776  
10777  
10778  
10779  
10780  
10781  
10782  
10783  
10784  
10785  
10786  
10787  
10788  
10789  
10790  
10791  
10792  
10793  
10794  
10795  
10796  
10797  
10798  
10799  
10800  
10801  
10802  
10803  
10804  
10805  
10806  
10807  
10808  
10809  
10810  
10811  
10812  
10813  
10814  
10815  
10816  
10817  
10818  
10819  
10820  
10821  
10822  
10823  
10824  
10825  
10826  
10827  
10828  
10829  
10830  
10831  
10832  
10833  
10834  
10835  
10836  
10837  
10838  
10839  
10840  
10841  
10842  
10843  
10844  
10845  
10846  
10847  
10848  
10849  
10850  
10851  
10852  
10853  
10854  
10855  
10856  
10857  
10858  
10859  
10860  
10861  
10862  
10863  
10864  
10865  
10866  
10867  
10868  
10869  
10870  
10871  
10872  
10873  
10874  
10875  
10876  
10877  
10878  
10879  
10880  
10881  
10882  
10883  
10884  
10885  
10886  
10887  
10888  
10889  
10890  
10891  
10892  
10893  
10894  
10895  
10896  
10897  
10898  
10899  
10900  
10901  
10902  
10903  
10904  
10905  
10906  
10907  
10908  
10909  
10910  
10911  
10912  
10913  
10914  
10915  
10916  
10917  
10918  
10919  
10920  
10921  
10922  
10923  
10924  
10925  
10926  
10927  
10928  
10929  
10930  
10931  
10932  
10933  
10934  
10935  
10936  
10937  
10938  
10939  
10940  
10941  
10942  
10943  
10944  
10945  
10946  
10947  
10948  
10949  
10950  
10951  
10952  
10953  
10954  
10955  
10956  
10957  
10958  
10959  
10960  
10961  
10962  
10963  
10964  
10965  
10966  
10967  
10968  
10969  
10970  
10971  
10972  
10973  
10974  
10975  
10976  
10977  
10978  
10979  
10980  
10981  
10982  
10983  
10984  
10985  
10986  
10987  
10988  
10989  
10990  
10991  
10992  
10993  
10994  
10995  
10996  
10997  
10998  
10999  
11000  
11001  
11002  
11003  
11004  
11005  
11006  
11007  
11008  
11009  
11010  
11011  
11012  
11013  
11014  
11015  
11016  
11017  
11018  
11019  
11020  
11021  
11022  
11023  
11024  
11025  
11026  
11027  
11028  
11029  
11030  
11031  
11032  
11033  
11034  
11035  
11036  
11037  
11038  
11039  
11040  
11041  
11042  
11043  
11044  
11045  
11046  
11047  
11048  
11049  
11050  
11051  
11052  
11053  
11054  
11055  
11056  
11057  
11058  
11059  
11060  
11061  
11062  
11063  
11064  
11065  
11066  
11067  
11068  
11069  
11070  
11071  
11072  
11073  
11074  
11075  
11076  
11077  
11078  
11079  
11080  
11081  
11082  
11083  
11084  
11085  
11086  
11087  
11088  
11089  
11090  
11091  
11092  
11093  
11094  
11095  
11096  
11097  
11098  
11099  
11100  
11101  
11102  
11103  
11104  
11105  
11106  
11107  
11108  
11109  
11110  
11111  
11112  
11113  
11114  
11115  
11116  
11117  
11118  
11119  
11120  
11121  
11122  
11123  
11124  
11125  
11126  
11127  
11128  
11129  
11130  
11131  
11132  
11133  
11134  
11135  
11136  
11137  
11138  
11139  
11140  
11141  
11142  
11143  
11144  
11145  
11146  
11147  
11148  
11149  
11150  
11151  
11152  
11153  
11154  
11155  
11156  
11157  
11158  
11159  
11160  
11161  
11162  
11163  
11164  
11165  
11166  
11167  
11168  
11169  
11170  
11171  
11172  
11173  
11174  
11175  
11176  
11177  
11178  
11179  
11180  
11181  
11182  
11183  
11184  
11185  
11186  
11187  
11188  
11189  
11190  
11191  
11192  
11193  
11194  
11195  
11196  
11197  
11198  
11199  
11200  
11201  
11202  
11203  
11204  
11205  
11206  
11207  
11208  
11209  
11210  
11211  
11212  
11213  
11214  
11215  
11216  
11217  
11218  
11219  
11220  
11221  
11222  
11223  
11224  
11225  
11226  
11227  
11228  
11229  
11230  
11231  
11232  
11233  
11234  
11235  
11236  
11237  
11238  
11239  
11240  
11241  
11242  
11243  
11244  
11245  
11246  
11247  
11248  
11249  
11250  
11251  
11252  
11253  
11254  
11255  
11256  
11257  
11258  
11259  
11260  
11261  
11262  
11263  
11264  
11265  
11266  
11267  
11268  
11269  
11270  
11271  
11272  
11273  
11274  
11275  
11276  
11277  
11278  
11279  
11280  
11281  
11282  
11283  
11284  
11285  
11286  
11287  
11288  
11289  
11290  
11291  
11292  
11293  
11294  
11295  
11296  
11297  
11298  
11299  
11300  
11301  
11302  
11303  
11304  
11305  
11306  
11307  
11308  
11309  
11310  
11311  
11312  
11313  
11314  
11315  
11316  
11317  
11318  
11319  
11320  
11321  
11322  
11323  
11324  
11325  
11326  
11327  
11328  
11329  
11330  
11331  
11332  
11333  
11334  
11335  
11336  
11337  
11338  
11339  
11340  
11341  
11342  
11343  
11344  
11345  
11346  
11347  
11348  
11349  
11350  
11351  
11352  
11353  
11354  
11355  
11356  
11357  
11358  
11359  
11360  
11361  
11362  
11363  
11364  
11365  
11366  
11367  
11368  
11369  
11370  
11371  
11372  
11373  
11374  
11375  
11376  
11377  
11378  
11379  
11380  
11381  
11382  
11383  
11384  
11385  
11386  
11387  
11388  
11389  
11390  
11391  
11392  
11393  
11394  
11395  
11396  
11397  
11398  
11399  
11400  
11401  
11402  
11403  
11404  
11405  
11406  
11407  
11408  
11409  
11410  
11411  
11412  
11413  
11414  
11415  
11416  
11417  
11418  
11419  
11420  
11421  
11422  
11423  
11424  
11425  
11426  
11427  
11428  
11429  
11430  
11431  
11432  
11433  
11434  
11435  
11436  
11437  
11438  
11439  
11440  
11441  
11442  
11443  
11444  
11445  
11446  
11447  
11448  
11449  
11450  
11451  
11452  
11453  
11454  
11455  
11456  
11457  
11458  
11459  
11460  
11461  
11462  
11463  
11464  
11465  
11466  
11467  
11468  
11469  
11470  
11471  
11472  
11473  
11474  
11475  
11476  
11477  
11478  
11479  
11480  
11481  
11482  
11483  
11484  
11485  
11486  
11487  
11488  
11489  
11490  
11491  
11492  
11493  
11494  
11495  
11496  
11497  
11498  
11499  
11500  
11501  
11502  
11503  
11504  
11505  
11506  
11507  
11508  
11509  
11510  
11511  
11512  
11513  
11514  
11515  
11516  
11517  
11518  
11519  
11520  
11521  
11522  
11523  
11524  
11525  
11526  
11527  
11528  
11529  
11530  
11531  
11532  
11533  
11534  
11535  
11536  
11537  
11538  
11539  
11540  
11541  
11542  
11543  
11544  
11545  
11546  
11547  
11548  
11549  
11550  
11551  
11552  
11553  
11554  
11555  
11556  
11557  
11558  
11559  
11560  
11561  
11562  
11563  
11564  
11565  
11566  
11567  
11568  
11569  
11570  
11571  
11572  
11573  
11574  
11575  
11576  
11577  
11578  
11579  
11580  
11581  
11582  
11583  
11584  
11585  
11586  
11587  
11588  
11589  
11590  
11591  
11592  
11593  
11594  
11595  
11596  
11597  
11598  
11599  
11600  
11601  
11602  
11603  
11604  
11605  
11606  
11607  
11608  
11609  
11610  
11611  
11612  
11613  
11614  
11615  
11616  
11617  
11618  
11619  
11620  
11621  
11622  
11623  
11624  
11625  
11626  
11627  
11628  
11629  
11630  
11631  
11632  
11633  
11634  
11635  
11636  
11637  
11638  
11639  
11640  
11641  
11642  
11643  
11644  
11645  
11646  
11647  
11648  
11649  
11650  
11651  
11652  
11653  
11654  
11655  
11656  
11657  
11658  
11659  
11660  
11661  
11662  
11663  
11664  
11665  
11666  
11667  
11668  
11669  
11670  
11671  
11672  
11673  
11674  
11675  
11676  
11677  
11678  
11679  
11680  
11681  
11682  
11683  
11684  
11685  
11686  
11687  
11688  
11689  
11690  
11691  
11692  
11693  
11694  
11695  
11696  
11697  
11698  
11699  
11700  
11701  
11702  
11703  
11704  
11705  
11706  
11707  
11708  
11709  
11710  
11711  
11712  
11713  
11714  
11715  
11716  
11717  
11718  
11719  
11720  
11721  
11722  
11723  
11724  
11725  
11726  
11727  
11728  
11729  
11730  
11731  
11732  
11733  
11734  
11735  
11736  
11737  
11738  
11739  
11740  
11741  
11742  
11743  
11744  
11745  
11746  
11747  
11748  
11749  
11750  
11751  
11752  
11753  
11754  
11755  
11756  
11757  
11758  
11759  
11760  
11761  
11762  
11763  
11764  
11765  
11766  
11767  
11768  
11769  
11770  
11771  
11772  
11773  
11774  
11775  
11776  
11777  
11778  
11779  
11780  
11781  
11782  
11783  
11784  
11785  
11786  
11787  
11788  
11789  
11790  
11791  
11792  
11793  
11794  
11795  
11796  
11797  
11798  
11799  
11800  
11801  
11802  
11803  
11804  
11805  
11806  
11807  
11808  
11809  
11810  
11811  
11812  
11813  
11814  
11815  
11816  
11817  
11818  
11819  
11820  
11821  
11822  
11823  
11824  
11825  
11826  
11827  
11828  
11829  
11830  
11831  
11832  
11833  
11834  
11835  
11836  
11837  
11838  
11839  
11840  
11841  
11842  
11843  
11844  
11845  
11846  
11847  
11848  
11849  
11850  
11851  
11852  
11853  
11854  
11855  
11856  
11857  
11858  
11859  
11860  
11861  
11862  
11863  
11864  
11865  
11866  
11867  
11868  
11869  
11870  
11871  
11872  
11873  
11874  
11875  
11876  
11877  
11878  
11879  
11880  
11881  
11882  
11883  
11884  
11885  
11886  
11887  
11888  
11889  
11890  
11891  
11892  
11893  
11894  
11895  
11896  
11897  
11898  
11899  
11900  
11901  
11902  
11903  
11904  
11905  
11906  
11907  
11908  
11909  
11910  
11911  
11912  
11913  
11914  
11915  
11916  
11917  
11918  
11919  
11920  
11921  
11922  
11923  
11924  
11925  
11926  
11927  
11928  
11929  
11930  
11931  
11932  
11933  
11934  
11935  
11936  
11937  
11938  
11939  
11940  
11941  
11942  
11943  
11944  
11945  
11946  
11947  
11948  
11949  
11950  
11951  
11952  
11953  
11954  
11955  
11956  
11957  
11958  
11959  
11960  
11961  
11962  
11963  
11964  
11965  
11966  
11967  
11968  
11969  
11970  
11971  
11972  
11973  
11974  
11975  
11976  
11977  
11978  
11979  
11980  
11981  
11982  
11983  
11984  
11985  
11986  
11987  
11988  
11989  
11990  
11991  
11992  
11993  
11994  
11995  
11996  
11997  
11998  
11999  
12000  
12001  
12002  
12003  
12004  
12005  
12006  
12007  
12008  
12009  
12010  
12011  
12012  
12013  
12014  
12015  
12016  
12017  
12018  
12019  
12020  
12021  
12022  
12023  
12024  
12025  
12026  
12027  
12028  
12029  
12030  
12031  
12032  
12033  
12034  
12035  
12036  
12037  
12038  
12039  
12040  
12041  
12042  
12043  
12044  
12045  
12046  
12047  
12048  
12049  
12050  
12051  
12052  
12053  
12054  
12055  
12056  
12057  
12058  
12059  
12060  
12061  
12062  
12063  
12064  
12065  
12066  
12067  
12068  
12069  
12070  
12071  
12072  
12073  
12074  
12075  
12076  
12077  
12078  
12079  
12080  
12081  
12082  
12083  
12084  
12085  
12086  
12087  
12088  
12089  
12090  
12091  
12092  
12093  
12094  
12095  
12096  
12097  
12098  
12099  
12100  
12101  
12102  
12103  
12104  
12105  
12106  
12107  
12108  
12109  
12110  
12111  
12112  
12113  
12114  
12115  
12116  
12117  
12118  
12119  
12120  
12121  
12122  
12123  
12124  
12125  
12126  
12127  
12128  
12129  
12130  
12131  
12132  
12133  
12134  
12135  
12136  
12137  
12138  
12139  
12140  
12141  
12142  
12143  
12144  
12145  
12146  
12147  
12148  
12149  
12150  
12151  
12152  
12153  
12154  
12155  
12156  
12157  
12158  
12159  
12160  
12161  
12162  
12163  
12164  
12165  
12166  
12167  
12168  
12169  
12170  
12171  
12172  
12173  
12174  
12175  
12176  
12177  
12178  
12179  
12180  
12181  
12182  
12183  
12184  
12185  
12186  
12187  
12188  
12189  
12190  
12191  
12192  
12193  
12194  
12195  
12196  
12197  
12198  
12199  
12200  
12201  
12202  
12203  
12204  
12205  
12206  
12207  
12208  
12209  
12210  
12211  
12212  
12213  
12214  
12215  
12216  
12217  
12218  
12219  
12220  
12221  
12222  
12223  
12224  
12225  
12226  
12227  
12228  
12229  
12230  
12231  
12232  
12233  
12234  
12235  
12236  
12237  
12238  
12239  
12240  
12241  
12242  
12243  
12244  
12245  
12246  
12247  
12248  
12249  
12250  
12251  
12252  
12253  
12254  
12255  
12256  
12257  
12258  
12259  
12260  
12261  
12262  
12263  
12264  
12265  
12266  
12267  
12268  
12269  
12270  
12271  
12272  
12273  
12274  
12275  
12276  
12277  
12278  
12279  
12280  
12281  
12282  
12283  
12284  
12285  
12286  
12287  
12288  
12289  
12290  
12291  
12292  
12293  
12294  
12295  
12296  
12297  
12298  
12299  
12300  
12301  
12302  
12303  
12304  
12305  
12306  
12307  
12308  
12309  
12310  
12311  
12312  
12313  
12314  
12315  
12316  
12317  
12318  
12319  
12320  
12321  
12322  
12323  
12324  
12325  
12326  
12327  
12328  
12329  
12330  
12331  
12332  
12333  
12334  
12335  
12336  
12337  
12338  
12339  
12340  
12341  
12342  
12343  
12344  
12345  
12346  
12347  
12348  
12349  
12350  
12351  
12352  
12353  
12354  
12355  
12356  
12357  
12358  
12359  
12360  
12361  
12362  
12363  
12364  
12365  
12366  
12367  
12368  
12369  
12370  
12371  
12372  
12373  
12374  
12375  
12376  
12377  
12378  
12379  
12380  
12381  
12382  
12383  
12384  
12385  
12386  
12387  
12388  
12389  
12390  
12391  
12392  
12393  
12394  
12395  
12396  
12397  
12398  
12399  
12400  
12401  
12402  
12403  
12404  
12405  
12406  
12407  
12408  
12409  
12410  
12411  
12412  
12413  
12414  
12415  
12416  
12417  
12418  
12419  
12420  
12421  
12422  
12423  
12424  
12425  
12426  
12427  
12428  
12429  
12430  
12431  
12432  
12433  
12434  
12435  
12436  
12437  
12438  
12439  
12440  
12441  
12442  
12443  
12444  
12445  
12446  
12447  
12448  
12449  
12450  
12451  
12452  
12453  
12454  
12455  
12456  
12457  
12458  
12459  
12460  
12461  
12462  
12463  
12464  
12465  
12466  
12467  
12468  
12469  
12470  
12471  
12472  
12473  
12474  
12475  
12476  
12477  
12478  
12479  
12480  
12481  
12482  
12483  
12484  
12485  
12486  
12487  
12488  
12489  
12490  
12491  
12492  
12493  
12494  
12495  
12496  
12497  
12498  
12499  
12500  
12501  
12502  
12503  
12504  
12505  
12506  
12507  
12508  
12509  
12510  
12511  
12512  
12513  
12514  
12515  
12516  
12517  
12518  
12519  
12520  
12521  
12522  
12523  
12524  
12525  
12526  
12527  
12528  
12529  
12530  
12531  
12532  
12533  
12534  
12535  
12536  
12537  
12538  
12539  
12540  
12541  
12542  
12543  
12544  
12545  
12546  
12547  
12548  
12549  
12550  
12551  
12552  
12553  
12554  
12555  
12556  
12557  
12558  
12559  
12560  
12561  
12562  
12563  
12564  
12565  
12566  
12567  
12568  
12569  
12570  
12571  
12572  
12573  
12574  
12575  
12576  
12577  
12578  
12579  
12580  
12581  
12582  
12583  
12584  
12585  
12586  
12587  
12588  
12589  
12590  
12591  
12592  
12593  
12594  
12595  
12596  
12597  
12598  
12599  
12600  
12601  
12602  
12603  
12604  
12605  
12606  
12607  
12608  
12609  
12610  
12611  
12612  
12613  
12614  
12615  
12616  
12617  
12618  
12619  
12620  
12621  
12622  
12623  
12624  
12625  
12626  
12627  
12628  
12629  
12630  
12631  
12632  
12633  
12634  
12635  
12636  
12637  
12638  
12639  
12640  
12641  
12642  
12643  
12644  
12645  
12646  
12647  
12648  
12649  
12650  
12651  
12652  
12653  
12654  
12655  
12656  
12657  
12658  
12659  
12660  
12661  
12662  
12663  
12664  
12665  
12666  
12667  
12668  
12669  
12670  
12671  
12672  
12673  
12674  
12675  
12676  
12677  
12678  
12679  
12680  
12681  
12682  
12683  
12684  
12685  
12686  
12687  
12688  
12689  
12690  
12691  
12692  
12693  
12694  
12695  
12696  
12697  
12698  
12699  
12700  
12701  
12702  
12703  
12704  
12705  
12706  
12707  
12708  
12709  
12710  
12711  
12712  
12713  
12714  
12715  
12716  
12717  
12718  
12719  
12720  
12721  
12722  
12723  
12724  
12725  
12726  
12727  
12728  
12729  
12730  
12731  
12732  
12733  
12734  
12735  
12736  
12737  
12738  
12739  
12740  
12741  
12742  
12743  
12744  
12745  
12746  
12747  
12748  
12749  
12750  
12751  
12752  
12753  
12754  
12755  
12756  
12757  
12758  
12759  
12760  
12761  
12762  
12763  
12764  
12765  
12766  
12767  
12768  
12769  
12770  
12771  
12772  
12773  
12774  
12775  
12776  
12777  
12778  
12779  
12780  
12781  
12782  
12783  
12784  
12785  
12786  
12787  
12788  
12789  
12790  
12791  
12792  
12793  
12794  
12795  
12796  
12797  
12798  
12799  
12800  
12801  
12802  
12803  
12804  
12805  
12806  
12807  
12808  
12809  
12810  
12811  
12812  
12813  
12814  
12815  
12816  
12817  
12818  
12819  
12820  
12821  
12822  
12823  
12824  
12825  
12826  
12827  
12828  
12829  
12830  
12831  
12832  
12833  
12834  
12835  
12836  
12837  
12838  
12839  
12840  
12841  
12842  
12843  
12844  
12845  
12846  
12847  
12848  
12849  
12850  
12851  
12852  
12853  
12854  
12855  
12856  
12857  
12858  
12859  
12860  
12861  
12862  
12863  
12864  
12865  
12866  
12867  
12868  
12869  
12870  
12871  
12872  
12873  
12874  
12875  
12876  
12877  
12878  
12879  
12880  
12881  
12882  
12883  
12884  
12885  
12886  
12887  
12888  
12889  
12890  
12891  
12892  
12893  
12894  
12895  
12896  
12897  
12898  
12899  
12900  
12901  
12902  
12903  
12904  
12905  
12906  
12907  
12908  
12909  
12910  
12911  
12912  
12913  
12914  
12915  
12916  
12917  
12918  
12919  
12920  
12921  
12922  
12923  
12924  
12925  
12926  
12927  
12928  
12929  
12930  
12931  
12932  
12933  
12934  
12935  
12936  
12937  
12938  
12939  
12940  
12941  
12942  
12943  
12944  
12945  
12946  
12947  
12948  
12949  
12950  
12951  
12952  
12953  
12954  
12955  
12956  
12957  
12958  
12959  
12960  
12961  
12962  
12963  
12964  
12965  
12966  
12967  
12968  
12969  
12970  
12971  
12972  
12973  
12974  
12975  
12976  
12977  
12978  
12979  
12980  
12981  
12982  
12983  
12984  
12985  
12986  
12987  
12988  
12989  
12990  
12991  
12992  
12993  
12994  
12995  
12996  
12997  
12998  
12999  
13000  
13001  
13002  
13003  
13004  
13005  
13006  
13007  
13008  
13009  
13010  
13011  
13012  
13013  
13014  
13015  
13016  
13017  
13018  
13019  
13020  
13021  
13022  
13023  
13024  
13025  
13026  
13027  
13028  
13029  
13030  
13031  
13032  
13033  
13034  
13035  
13036  
13037  
13038  
13039  
13040  
13041  
13042  
13043  
13044  
13045  
13046  
13047  
13048  
13049  
13050  
13051  
13052  
13053  
13054  
13055  
13056  
13057  
13058  
13059  
13060  
13061  
13062  
13063  
13064  
13065  
13066  
13067  
13068  
13069  
13070  
13071  
13072  
13073  
13074  
13075  
13076  
13077  
13078  
13079  
13080  
13081  
13082  
13083  
13084  
13085  
13086  
13087  
13088  
13089  
13090  
13091  
13092  
13093  
13094  
13095  
13096  
13097  
13098  
13099  
13100  
13101  
13102  
13103  
13104  
13105  
13106  
13107  
13108  
13109  
13110  
13111  
13112  
13113  
13114  
13115  
13116  
13117  
13118  
13119  
13120  
13121  
13122  
13123  
13124  
13125  
13126  
13127  
13128  
13129  
13130  
13131  
13132  
13133  
13134  
13135  
13136  
13137  
13138  
13139  
13140  
13141  
13142  
13143  
13144  
13145  
13146  
13147  
13148  
13149  
13150  
13151  
13152  
13153  
13154  
13155  
13156  
13157  
13158  
13159  
13160  
13161  
13162  
13163  
13164  
13165  
13166  
13167  
13168  
13169  
13170  
13171  
13172  
13173  
13174  
13175  
13176  
13177  
13178  
13179  
13180  
13181  
13182  
13183  
13184  
13185  
13186  
13187  
13188  
13189  
13190  
13191  
13192  
13193  
13194  
13195  
13196  
13197  
13198  
13199  
13200  
13201  
13202  
13203  
13204  
13205  
13206  
13207  
13208  
13209  
13210  
13211  
13212  
13213  
13214  
13215  
13216  
13217  
13218  
13219  
13220  
13221  
13222  
13223  
13224  
13225  
13226  
13227  
13228  
13229  
13230  
13231  
13232  
13233  
13234  
13235  
13236  
13237  
13238  
13239  
13240  
13241  
13242  
13243  
13244  
13245  
13246  
13247  
13248  
13249  
13250  
13251  
13252  
13253  
13254  
13255  
13256  
13257  
13258  
13259  
13260  
13261  
13262  
13263  
13264  
13265  
13266  
13267  
13268  
13269  
13270  
13271  
13272  
13273  
13274  
13275  
13276  
13277  
13278  
13279  
13280  
13281  
13282  
13283  
13284  
13285  
13286  
13287  
13288  
13289  
13290  
13291  
13292  
13293  
13294  
13295  
13296  
13297  
13298  
13299  
13300  
13301  
13302  
13303  
13304  
13305  
13306  
13307  
13308  
13309  
13310  
13311  
13312  
13313  
13314  
13315  
13316  
13317  
13318  
13319  
13320  
13321  
13322  
13323  
13324  
13325  
13326  
13327  
13328  
13329  
13330  
13331  
13332  
13333  
13334  
13335  
13336  
13337  
13338  
13339  
13340  
13341  
13342  
13343  
13344  
13345  
13346  
13347  
13348  
13349  
13350  
13351  
13352  
13353  
13354  
13355  
13356  
13357  
13358  
13359  
13360  
13361  
13362  
13363  
13364  
13365  
13366  
13367  
13368  
13369  
13370  
13371  
13372  
13373  
13374  
13375  
13376  
13377  
13378  
13379  
13380  
13381  
13382  
13383  
13384  
13385  
13386  
13387  
13388  
13389  
13390  
13391  
13392  
13393  
13394  
13395  
13396  
13397  
13398  
13399  
13400  
13401  
13402  
13403  
13404  
13405  
13406  
13407  
13408  
13409  
13410  
13411  
13412  
13413  
13414  
13415  
13416  
13417  
13418  
13419  
13420  
13421  
13422  
13423  
13424  
13425  
13426  
13427  
13428  
13429  
13430  
13431  
13432  
13433  
13434  
13435  
13436  
13437  
13438  
13439  
13440  
13441  
13442  
13443  
13444  
13445  
13446  
13447  
13448  
13449  
13450  
13451  
13452  
13453  
13454  
13455  
13456  
13457  
13458  
13459  
13460  
13461  
13462  
13463  
13464  
13465  
13466  
13467  
13468  
13469  
13470  
13471  
13472  
13473  
13474  
13475  
13476  
13477  
13478  
13479  
13480  
13481  
13482  
13483  
13484  
13485  
13486  
13487  
13488  
13489  
13490  
13491  
13492  
13493  
13494  
13495  
13496  
13497  
13498  
13499  
13500  
13501  
13502  
13503  
13504  
13505  
13506  
13507  
13508  
13509  
13510  
13511  
13512  
13513  
13514  
13515  
13516  
13517  
13518  
13519  
13520  
13521  
13522  
13523  
13524  
13525  
13526  
13527  
13528  
13529  
13530  
13531  
13532  
13533  
13534  
13535  
13536  
13537  
13538  
13539  
13540  
13541  
13542  
13543  
13544  
13545  
13546  
13547  
13548  
13549  
13550  
13551  
13552  
13553  
13554  
13555  
13556  
13557  
13558  
13559  
13560  
13561  
13562  
13563  
13564  
13565  
13566  
13567  
13568  
13569  
13570  
13571  
13572  
13573  
13574  
13575  
13576  
13577  
13578  
13579  
13580  
13581  
13582  
13583  
13584  
13585  
13586  
13587  
13588  
13589  
13590  
13591  
13592  
13593  
13594  
13595  
13596  
13597  
13598  
13599  
13600  
13601  
13602  
13603  
13604  
13605  
13606  
13607  
13608  
13609  
13610  
13611  
13612  
13613  
13614  
13615  
13616  
13617  
13618  
13619  
13620  
13621  
13622  
13623  
13624  
13625  
13626  
13627  
13628  
13629  
13630  
13631  
13632  
13633  
13634  
13635  
13636  
13637  
13638  
13639  
13640  
13641  
13642  
13643  
13644  
13645  
13646  
13647  
13648  
13649  
13650  
13651  
13652  
13653  
13654  
13655  
13656  
13657  
13658  
13659  
13660  
13661  
13662  
13663  
13664  
13665  
13666  
13667  
13668  
13669  
13670  
13671  
13672  
13673  
13674  
13675  
13676  
13677  
13678  
13679  
13680  
13681  
13682  
13683  
13684  
13685  
13686  
13687  
13688  
13689  
13690  
13691  
13692  
13693  
13694  
13695  
13696  
13697  
13698  
13699  
13700  
13701  
13702  
13703  
13704  
13705  
13706  
13707  
13708  
13709  
13710  
13711  
13712  
13713  
13714  
13715  
13716  
13717  
13718  
13719  
13720  
13721  
13722  
13723  
13724  
13725  
13726  
13727  
13728  
13729  
13730  
13731  
13732  
13733  
13734  
13735  
13736  
13737  
13738  
13739  
13740  
13741  
13742  
13743  
13744  
13745  
13746  
13747  
13748  
13749  
13750  
13751  
13752  
13753  
13754  
13755  
13756  
13757  
13758  
13759  
13760  
13761  
13762  
13763  
13764  
13765  
13766  
13767  
13768  
13769  
13770  
13771  
13772  
13773  
13774  
13775  
13776  
13777  
13778  
13779  
13780  
13781  
13782  
13783  
13784  
13785  
13786  
13787  
13788  
13789  
13790  
13791  
13792  
13793  
13794  
13795  
13796  
13797  
13798  
13799  
13800  
13801  
13802  
13803  
13804  
13805  
13806  
13807  
13808  
13809  
13810  
13811  
13812  
13813  
13814  
13815  
13816  
13817  
13818  
13819  
13820  
13821  
13822  
13823  
13824  
13825  
13826  
13827  
13828  
13829  
13830  
13831  
13832  
13833  
13834  
13835  
13836  
13837  
13838  
13839  
13840  
13841  
13842  
13843  
13844  
13845  
13846  
13847  
13848  
13849  
13850  
13851  
13852  
13853  
13854  
13855  
13856  
13857  
13858  
13859  
13860  
13861  
13862  
13863  
13864  
13865  
13866  
13867  
13868  
13869  
13870  
13871  
13872  
13873  
13874  
13875  
13876  
13877  
13878  
13879  
13880  
13881  
13882  
13883  
13884  
13885  
13886  
13887  
13888  
13889  
13890  
13891  
13892  
13893  
13894  
13895  
13896  
13897  
13898  
13899  
13900  
13901  
13902  
13903  
13904  
13905  
13906  
13907  
13908  
13909  
13910  
13911  
13912  
13913  
13914  
13915  
13916  
13917  
13918  
13919  
13920  
13921  
13922  
13923  
13924  
13925  
13926  
13927  
13928  
13929  
13930  
13931  
13932  
13933  
13934  
13935  
13936  
13937  
13938  
13939  
13940  
13941  
13942  
13943  
13944  
13945  
13946  
13947  
13948  
13949  
13950  
13951  
13952  
13953  
13954  
13955  
13956  
13957  
13958  
13959  
13960  
13961  
13962  
13963  
13964  
13965  
13966  
13967  
13968  
13969  
13970  
13971  
13972  
13973  
13974  
13975  
13976  
13977  
13978  
13979  
13980  
13981  
13982  
13983  
13984  
13985  
13986  
13987  
13988  
13989  
13990  
13991  
13992  
13993  
13994  
13995  
13996  
13997  
13998  
13999  
14000  
14001  
14002  
14003  
14004  
14005  
14006  
14007  
14008  
14009  
14010  
14011  
14012  
14013  
14014  
14015  
14016  
14017  
14018  
14019  
14020  
14021  
14022  
14023  
14024  
14025  
14026  
14027  
14028  
14029  
14030  
14031  
14032  
14033  
14034  
14035  
14036  
14037  
14038  
14039  
14040  
14041  
14042  
14043  
14044  
14045  
14046  
14047  
14048  
14049  
14050  
14051  
14052  
14053  
14054  
14055  
14056  
14057  
14058  
14059  
14060  
14061  
14062  
14063  
14064  
14065  
14066  
14067  
14068  
14069  
14070  
14071  
14072  
14073  
14074  
14075  
14076  
14077  
14078  
14079  
14080  
14081  
14082  
14083  
14084  
14085  
14086  
14087  
14088  
14089  
14090  
14091  
14092  
14093  
14094  
14095  
14096  
14097  
14098  
14099  
14100  
14101  
14102  
14103  
14104  
14105  
14106  
14107  
14108  
14109  
14110  
14111  
14112  
14113  
14114  
14115  
14116  
14117  
14118  
14119  
14120  
14121  
14122  
14123  
14124  
14125  
14126  
14127  
14128  
14129  
14130  
14131  
14132  
14133  
14134  
14135  
14136  
14137  
14138  
14139  
14140  
14141  
14142  
14143  
14144  
14145  
14146  
14147  
14148  
14149  
14150  
14151  
14152  
14153  
14154  
14155  
14156  
14157  
14158  
14159  
14160  
14161  
14162  
14163  
14164  
14165  
14166  
14167  
14168  
14169  
14170  
14171  
14172  
14173  
14174  
14175  
14176  
14177  
14178  
14179  
14180  
14181  
14182  
14183  
14184  
14185  
14186  
14187  
14188  
14189  
14190  
14191  
14192  
14193  
14194  
14195  
14196  
14197  
14198  
14199  
14200  
14201  
14202  
14203  
14204  
14205  
14206  
14207  
14208  
14209  
14210  
14211  
14212  
14213  
14214  
14215  
14216  
14217  
14218  
14219  
14220  
14221  
14222  
14223  
14224  
14225  
14226  
14227  
14228  
14229  
14230  
14231  
14232  
14233  
14234  
14235  
14236  
14237  
14238  
14239  
14240  
14241  
14242  
14243  
14244  
14245  
14246  
14247  
14248  
14249  
14250  
14251  
14252  
14253  
14254  
14255  
14256  
14257  
14258  
14259  
14260  
14261  
14262  
14263  
14264  
14265  
14266  
14267  
14268  
14269  
14270  
14271  
14272  
14273  
14274  
14275  
14276  
14277  
14278  
14279  
14280  
14281  
14282  
14283  
14284  
14285  
14286  
14287  
14288  
14289  
14290  
14291  
14292  
14293  
14294  
14295  
14296  
14297  
14298  
14299  
14300  
14301  
14302  
14303  
14304  
14305  
14306  
14307  
14308  
14309  
14310  
14311  
14312  
14313  
14314  
14315  
14316  
14317  
14318  
14319  
14320  
14321  
14322  
14323  
14324  
14325  
14326  
14327  
14328  
14329  
14330  
14331  
14332  
14333  
14334  
14335  
14336  
14337  
14338  
14339  
14340  
14341  
14342  
14343  
14344  
14345  
14346  
14347  
14348  
14349  
14350  
14351  
14352  
14353  
14354  
14355  
14356  
14357  
14358  
14359  
14360  
14361  
14362  
14363  
14364  
14365  
14366  
14367  
14368  
14369  
14370  
14371  
14372  
14373  
14374  
14375  
14376  
14377  
14378  
14379  
14380  
14381  
14382  
14383  
14384  
14385  
14386  
14387  
14388  
14389  
14390  
14391  
14392  
14393  
14394  
14395  
14396  
14397  
14398  
14399  
14400  
14401  
14402  
14403  
14404  
14405  
14406  
14407  
14408  
14409  
14410  
14411  
14412  
14413  
14414  
14415  
14416  
14417  
14418  
14419  
14420  
14421  
14422  
14423  
14424  
14425  
14426  
14427  
14428  
14429  
14430  
14431  
14432  
14433  
14434  
14435  
14436  
14437  
14438  
14439  
14440  
14441  
14442  
14443  
14444  
14445  
14446  
14447  
14448  
14449  
14450  
14451  
14452  
14453  
14454  
14455  
14456  
14457  
14458  
14459  
14460  
14461  
14462  
14463  
14464  
14465  
14466  
14467  
14468  
14469  
14470  
14471  
14472  
14473  
14474  
14475  
14476  
14477  
14478  
14479  
14480  
14481  
14482  
14483  
14484  
14485  
14486  
14487  
14488  
14489  
14490  
14491  
14492  
14493  
14494  
14495  
14496  
14497  
14498  
14499  
14500  
14501  
14502  
14503  
14504  
14505  
14506  
14507  
14508  
14509  
14510  
14511  
14512  
14513  
14514  
14515  
14516  
14517  
14518  
14519  
14520  
14521  
14522  
14523  
14524  
14525  
14526  
14527  
14528  
14529  
14530  
14531  
14532  
14533  
14534  
14535  
14536  
14537  
14538  
14539  
14540  
14541  
14542  
14543  
14544  
14545  
14546  
14547  
14548  
14549  
14550  
14551  
14552  
14553  
14554  
14555  
14556  
14557  
14558  
14559  
14560  
14561  
14562  
14563  
14564  
14565  
14566  
14567  
14568  
14569  
14570  
14571  
14572  
14573  
14574  
14575  
14576  
14577  
14578  
14579  
14580  
14581  
14582  
14583  
14584  
14585  
14586  
14587  
14588  
14589  
14590  
14591  
14592  
14593  
14594  
14595  
14596  
14597  
14598  
14599  
14600  
14601  
14602  
14603  
14604  
14605  
14606  
14607  
14608  
14609  
14610  
14611  
14612  
14613  
14614  
14615  
14616  
14617  
14618  
14619  
14620  
14621  
14622  
14623  
14624  
14625  
14626  
14627  
14628  
14629  
14630  
14631  
14632  
14633  
14634  
14635  
14636  
14637  
14638  
14639  
14640  
14641  
14642  
14643  
14644  
14645  
14646  
14647  
14648  
14649  
14650  
14651  
14652  
14653  
14654  
14655  
14656  
14657  
14658  
14659  
14660  
14661  
14662  
14663  
14664  
14665  
14666  
14667  
14668  
14669  
14670  
14671  
14672  
14673  
14674  
14675  
14676  
14677  
14678  
14679  
14680  
14681  
14682  
14683  
14684  
14685  
14686  
14687  
14688  
14689  
14690  
14691  
14692  
14693  
14694  
14695  
14696  
14697  
14698  
14699  
14700  
14701  
14702  
14703  
14704  
14705  
14706  
14707  
14708  
14709  
14710  
14711  
14712  
14713  
14714  
14715  
14716  
14717  
14718  
14719  
14720  
14721  
14722  
14723  
14724  
14725  
14726  
14727  
14728  
14729  
14730  
14731  
14732  
14733  
14734  
14735  
14736  
14737  
14738  
14739  
14740  
14741  
14742  
14743  
14744  
14745  
14746  
14747  
14748  
14749  
14750  
14751  
14752  
14753  
14754  
14755  
14756  
14757  
14758  
14759  
14760  
14761  
14762  
14763  
14764  
14765  
14766  
14767  
14768  
14769  
14770  
14771  
14772  
14773  
14774  
14775  
14776  
14777  
14778  
14779  
14780  
14781  
14782  
14783  
14784  
14785  
14786  
14787  
14788  
14789  
14790  
14791  
14792  
14793  
14794  
14795  
14796  
14797  
14798  
14799  
14800  
14801  
14802  
14803  
14804  
14805  
14806  
14807  
14808  
14809  
14810  
14811  
14812  
14813  
14814  
14815  
14816  
14817  
14818  
14819  
14820  
14821  
14822  
14823  
14824  
14825  
14826  
14827  
14828  
14829  
14830  
14831  
14832  
14833  
14834  
14835  
14836  
14837  
14838  
14839  
14840  
14841  
14842  
14843  
14844  
14845  
14846  
14847  
14848  
14849  
14850  
14851  
14852  
14853  
14854  
14855  
14856  
14857  
14858  
14859  
14860  
14861  
14862  
14863  
14864  
14865  
14866  
14867  
14868  
14869  
14870  
14871  
14872  
14873  
14874  
14875  
14876  
14877  
14878  
14879  
14880  
14881  
14882  
14883  
14884  
14885  
14886  
14887  
14888  
14889  
14890  
14891  
14892  
14893  
14894  
14895  
14896  
14897  
14898  
14899  
14900  
14901  
14902  
14903  
14904  
14905  
14906  
14907  
14908  
14909  
14910  
14911  
14912  
14913  
14914  
14915  
14916  
14917  
14918  
14919  
14920  
14921  
14922  
14923  
14924  
14925  
14926  
14927  
14928  
14929  
14930  
14931  
14932  
14933  
14934  
14935  
14936  
14937  
14938  
14939  
14940  
14941  
14942  
14943  
14944  
14945  
14946  
14947  
14948  
14949  
14950  
14951  
14952  
14953  
14954  
14955  
14956  
14957  
14958  
14959  
14960  
14961  
14962  
14963  
14964  
14965  
14966  
14967  
14968  
14969  
14970  
14971  
14972  
14973  
14974  
14975  
14976  
14977  
14978  
14979  
14980  
14981  
14982  
14983  
14984  
14985  
14986  
14987  
14988  
14989  
14990  
14991  
14992  
14993  
14994  
14995  
14996  
14997  
14998  
14999  
15000  
15001  
15002  
15003  
15004  
15005  
15006  
15007  
15008  
15009  
15010  
15011  
15012  
15013  
15014  
15015  
15016  
15017  
15018  
15019  
15020  
15021  
15022  
15023  
15024  
15025  
15026  
15027  
15028  
15029  
15030  
15031  
15032  
15033  
15034  
15035  
15036  
15037  
15038  
15039  
15040  
15041  
15042  
15043  
15044  
15045  
15046  
15047  
15048  
15049  
15050  
15051  
15052  
15053  
15054  
15055  
15056  
15057  
15058  
15059  
15060  
15061  
15062  
15063  
15064  
15065  
15066  
15067  
15068  
15069  
15070  
15071  
15072  
15073  
15074  
15075  
15076  
15077  
15078  
15079  
15080  
15081  
15082  
15083  
15084  
15085  
15086  
15087  
15088  
15089  
15090  
15091  
15092  
15093  
15094  
15095  
15096  
15097  
15098  
15099  
15100  
15101  
15102  
15103  
15104  
15105  
15106  
15107  
15108  
15109  
15110  
15111  
15112  
15113  
15114  
15115  
15116  
15117  
15118  
15119  
15120  
15121  
15122  
15123  
15124  
15125  
15126  
15127  
15128  
15129  
15130  
15131  
15132  
15133  
15134  
15135  
15136  
15137  
15138  
15139  
15140  
15141  
15142  
15143  
15144  
15145  
15146  
15147  
15148  
15149  
15150  
15151  
15152  
15153  
15154  
15155  
15156  
15157  
15158  
15159  
15160  
15161  
15162  
15163  
15164  
15165  
15166  
15167  
15168  
15169  
15170  
15171  
15172  
15173  
15174  
15175  
15176  
15177  
15178  
15179  
15180  
15181  
15182  
15183  
15184  
15185  
15186  
15187  
15188  
15189  
15190  
15191  
15192  
15193  
15194  
15195  
15196  
15197  
15198  
15199  
15200  
15201  
15202  
15203  
15204  
15205  
15206  
15207  
15208  
15209  
15210  
15211  
15212  
15213  
15214  
15215  
15216  
15217  
15218  
15219  
15220  
15221  
15222  
15223  
15224  
15225  
15226  
15227  
15228  
15229  
15230  
15231  
15232  
15233  
15234  
15235  
15236  
15237  
15238  
15239  
15240  
15241  
15242  
15243  
15244  
15245  
15246  
15247  
15248  
15249  
15250  
15251  
15252  
15253  
15254  
15255  
15256  
15257  
15258  
15259  
15260  
15261  
15262  
15263  
15264  
15265  
15266  
15267  
15268  
15269  
15270  
15271  
15272  
15273  
15274  
15275  
15276  
15277  
15278  
15279  
15280  
15281  
15282  
15283  
15284  
15285  
15286  
15287  
15288  
15289  
15290  
15291  
15292  
15293  
15294  
15295  
15296  
15297  
15298  
15299  
15300  
15301  
15302  
15303  
15304  
15305  
15306  
15307  
15308  
15309  
15310  
15311  
15312  
15313  
15314  
15315  
15316  
15317  
15318  
15319  
15320  
15321  
15322  
15323  
15324  
15325  
15326  
15327  
15328  
15329  
15330  
15331  
15332  
15333  
15334  
15335  
15336  
15337  
15338  
15339  
15340  
15341  
15342  
15343  
15344  
15345  
15346  
15347  
15348  
15349  
15350  
15351  
15352  
15353  
15354  
15355  
15356  
15357  
15358  
15359  
15360  
15361  
15362  
15363  
15364  
15365  
15366  
15367  
15368  
15369  
15370  
15371  
15372  
15373  
15374  
15375  
15376  
15377  
15378  
15379  
15380  
15381  
15382  
15383  
15384  
15385  
15386  
15387  
15388  
15389  
15390  
15391  
15392  
15393  
15394  
15395  
15396  
15397  
15398  
15399  
15400  
15401  
15402  
15403  
15404  
15405  
15406  
15407  
15408  
15409  
15410  
15411  
15412  
15413  
15414  
15415  
15416  
15417  
15418  
15419  
15420  
15421  
15422  
15423  
15424  
15425  
15426  
15427  
15428  
15429  
15430  
15431  
15432  
15433  
15434  
15435  
15436  
15437  
15438  
15439  
15440  
15441  
15442  
15443  
15444  
15445  
15446  
15447  
15448  
15449  
15450  
15451  
15452  
15453  
15454  
15455  
15456  
15457  
15458  
15459  
15460  
15461  
15462  
15463  
15464  
15465  
15466  
15467  
15468  
15469  
15470  
15471  
15472  
15473  
15474  
15475  
15476  
15477  
15478  
15479  
15480  
15481  
15482  
15483  
15484  
15485  
15486  
15487  
15488  
15489  
15490  
15491  
15492  
15493  
15494  
15495  
15496  
15497  
15498  
15499  
15500  
15501  
15502  
15503  
15504  
15505  
15506  
15507  
15508  
15509  
15510  
15511  
15512  
15513  
15514  
15515  
15516  
15517  
15518  
15519  
15520  
15521  
15522  
15523  
15524  
15525  
15526  
15527  
15528  
15529  
15530  
15531  
15532  
15533  
15534  
15535  
15536  
15537  
15538  
15539  
15540  
15541  
15542  
15543  
15544  
15545  
15546  
15547  
15548  
15549  
15550  
15551  
15552  
15553  
15554  
15555  
15556  
15557  
15558  
15559  
15560  
15561  
15562  
15563  
15564  
15565  
15566  
15567  
15568  
15569  
15570  
15571  
15572  
15573  
15574  
15575  
15576  
15577  
15578  
15579  
15580  
15581  
15582  
15583  
15584  
15585  
15586  
15587  
15588  
15589  
15590  
15591  
15592  
15593  
15594  
15595  
15596  
15597  
15598  
15599  
15600  
15601  
15602  
15603  
15604  
15605  
15606  
15607  
15608  
15609  
15610  
15611  
15612  
15613  
15614  
15615  
15616  
15617  
15618  
15619  
15620  
15621  
15622  
15623  
15624  
15625  
15626  
15627  
15628  
15629  
15630  
15631  
15632  
15633  
15634  
15635  
15636  
15637  
15638  
15639  
15640  
15641  
15642  
15643  
15644  
15645  
15646  
15647  
15648  
15649  
15650  
15651  
15652  
15653  
15654  
15655  
15656  
15657  
15658  
15659  
15660  
15661  
15662  
15663  
15664  
15665  
15666  
15667  
15668  
15669  
15670  
15671  
15672  
15673  
15674  
15675  
15676  
15677  
15678  
15679  
15680  
15681  
15682  
15683  
15684  
15685  
15686  
15687  
15688  
15689  
15690  
15691  
15692  
15693  
15694  
15695  
15696  
15697  
15698  
15699  
15700  
15701  
15702  
15703  
15704  
15705  
15706  
15707  
15708  
15709  
15710  
15711  
15712  
15713  
15714  
15715  
15716  
15717  
15718  
15719  
15720  
15721  
15722  
15723  
15724  
15725  
15726  
15727  
15728  
15729  
15730  
15731  
15732  
15733  
15734  
15735  
15736  
15737  
15738  
15739  
15740  
15741  
15742  
15743  
15744  
15745  
15746  
15747  
15748  
15749  
15750  
15751  
15752  
15753  
15754  
15755  
15756  
15757  
15758  
15759  
15760  
15761  
15762  
15763  
15764  
15765  
15766  
15767  
15768  
15769  
15770  
15771  
15772  
15773  
15774  
15775  
15776  
15777  
15778  
15779  
15780  
15781  
15782  
15783  
15784  
15785  
15786  
15787  
15788  
15789  
15790  
15791  
15792  
15793  
15794  
15795  
15796  
15797  
15798  
15799  
15800  
15801  
15802  
15803  
15804  
15805  
15806  
15807  
15808  
15809  
15810  
15811  
15812  
15813  
15814  
15815  
15816  
15817  
15818  
15819  
15820  
15821  
15822  
15823  
15824  
15825  
15826  
15827  
15828  
15829  
15830  
15831  
15832  
15833  
15834  
15835  
15836  
15837  
15838  
15839  
15840  
15841  
15842  
15843  
15844  
15845  
15846  
15847  
15848  
15849  
15850  
15851  
15852  
15853  
15854  
15855  
15856  
15857  
15858  
15859  
15860  
15861  
15862  
15863  
15864  
15865  
15866  
15867  
15868  
15869  
15870  
15871  
15872  
15873  
15874  
15875  
15876  
15877  
15878  
15879  
15880  
15881  
15882  
15883  
15884  
15885  
15886  
15887  
15888  
15889  
15890  
15891  
15892  
15893  
15894  
15895  
15896  
15897  
15898  
15899  
15900  
15901  
15902  
15903  
15904  
15905  
15906  
15907  
15908  
15909  
15910  
15911  
15912  
15913  
15914  
15915  
15916  
15917  
15918  
15919  
15920  
15921  
15922  
15923  
15924  
15925  
15926  
15927  
15928  
15929  
15930  
15931  
15932  
15933  
15934  
15935  
15936  
15937  
15938  
15939  
15940  
15941  
15942  
15943  
15944  
15945  
15946  
15947  
15948  
15949  
15950  
15951  
15952  
15953  
15954  
15955  
15956  
15957  
15958  
15959  
15960  
15961  
15962  
15963  
15964  
15965  
15966  
15967  
15968  
15969  
15970  
15971  
15972  
15973  
15974  
15975  
15976  
15977  
15978  
15979  
15980  
15981  
15982  
15983  
15984  
15985  
15986  
15987  
15988  
15989  
15990  
15991  
15992  
15993  
15994  
15995  
15996  
15997  
15998  
15999  
16000  
16001  
16002  
16003  
16004  
16005  
16006  
16007  
16008  
16009  
16010  
16011  
16012  
16013  
16014  
16015  
16016  
16017  
16018  
16019  
16020  
16021  
16022  
16023  
16024  
16025  
16026  
16027  
16028  
16029  
16030  
16031  
16032  
16033  
16034  
16035  
16036  
16037  
16038  
16039  
16040  
16041  
16042  
16043  
16044  
16045  
16046  
16047  
16048  
16049  
16050  
16051  
16052  
16053  
16054  
16055  
16056  
16057  
16058  
16059  
16060  
16061  
16062  
16063  
16064  
16065  
16066  
16067  
16068  
16069  
16070  
16071  
16072  
16073  
16074  
16075  
16076  
16077  
16078  
16079  
16080  
16081  
16082  
16083  
16084  
16085  
16086  
16087  
16088  
16089  
16090  
16091  
16092  
16093  
16094  
16095  
16096  
16097  
16098  
16099  
16100  
16101  
16102  
16103  
16104  
16105  
16106  
16107  
16108  
16109  
16110  
16111  
16112  
16113  
16114  
16115  
16116  
16117  
16118  
16119  
16120  
16121  
16122  
16123  
16124  
16125  
16126  
16127  
16128  
16129  
16130  
16131  
16132  
16133  
16134  
16135  
16136  
16137  
16138  
16139  
16140  
16141  
16142  
16143  
16144  
16145  
16146  
16147  
16148  
16149  
16150  
16151  
16152  
16153  
16154  
16155  
16156  
16157  
16158  
16159  
16160  
16161  
16162  
16163  
16164  
16165  
16166  
16167  
16168  
16169  
16170  
16171  
16172  
16173  
16174  
16175  
16176  
16177  
16178  
16179  
16180  
16181  
16182  
16183  
16184  
16185  
16186  
16187  
16188  
16189  
16190  
16191  
16192  
16193  
16194  
16195  
16196  
16197  
16198  
16199  
16200  
16201  
16202  
16203  
16204  
16205  
16206  
16207  
16208  
16209  
16210  
16211  
16212  
16213  
16214  
16215  
16216  
16217  
16218  
16219  
16220  
16221  
16222  
16223  
16224  
16225  
16226  
16227  
16228  
16229  
16230  
16231  
16232  
16233  
16234  
16235  
16236  
16237  
16238  
16239  
16240  
16241  
16242  
16243  
16244  
16245  
16246  
16247  
16248  
16249  
16250  
16251  
16252  
16253  
16254  
16255  
16256  
16257  
16258  
16259  
16260  
16261  
16262  
16263  
16264  
16265  
16266  
16267  
16268  
16269  
16270  
16271  
16272  
16273  
16274  
16275  
16276  
16277  
16278  
16279  
16280  
16281  
16282  
16283  
16284  
16285  
16286  
16287  
16288  
16289  
16290  
16291  
16292  
16293  
16294  
16295  
16296  
16297  
16298  
16299  
16300  
16301  
16302  
16303  
16304  
16305  
16306  
16307  
16308  
16309  
16310  
16311  
16312  
16313  
16314  
16315  
16316  
16317  
16318  
16319  
16320  
16321  
16322  
16323  
16324  
16325  
16326  
16327  
16328  
16329  
16330  
16331  
16332  
16333  
16334  
16335  
16336  
16337  
16338  
16339  
16340  
16341  
16342  
16343  
16344  
16345  
16346  
16347  
16348  
16349  
16350  
16351  
16352  
16353  
16354  
16355  
16356  
16357  
16358  
16359  
16360  
16361  
16362  
16363  
16364  
16365  
16366  
16367  
16368  
16369  
16370  
16371  
16372  
16373  
16374  
16375  
16376  
16377  
16378  
16379  
16380  
16381  
16382  
16383  
16384  
16385  
16386  
16387  
16388  
16389  
16390  
16391  
16392  
16393  
16394  
16395  
16396  
16397  
16398  
16399  
16400  
16401  
16402  
16403  
16404  
16405  
16406  
16407  
16408  
16409  
16410  
16411  
16412  
16413  
16414  
16415  
16416  
16417  
16418  
16419  
16420  
16421  
16422  
16423  
16424  
16425  
16426  
16427  
16428  
16429  
16430  
16431  
16432  
16433  
16434  
16435  
16436  
16437  
16438  
16439  
16440  
16441  
16442  
16443  
16444  
16445  
16446  
16447  
16448  
16449  
16450  
16451  
16452  
16453  
16454  
16455  
16456  
16457  
16458  
16459  
16460  
16461  
16462  
16463  
16464  
16465  
16466  
16467  
16468  
16469  
16470  
16471  
16472  
16473  
16474  
16475  
16476  
16477  
16478  
16479  
16480  
16481  
16482  
16483  
16484  
16485  
16486  
16487  
16488  
16489  
16490  
16491  
16492  
16493  
16494  
16495  
16496  
16497  
16498  
16499  
16500  
16501  
16502  
16503  
16504  
16505  
16506  
16507  
16508  
16509  
16510  
16511  
16512  
16513  
16514  
16515  
16516  
16517  
16518  
16519  
16520  
16521  
16522  
16523  
16524  
16525  
16526  
16527  
16528  
16529  
16530  
16531  
16532  
16533  
16534  
16535  
16536  
16537  
16538  
16539  
16540  
16541  
16542  
16543  
16544  
16545  
16546  
16547  
16548  
16549  
16550  
16551  
16552  
16553  
16554  
16555  
16556  
16557  
16558  
16559  
16560  
16561  
16562  
16563  
16564  
16565  
16566  
16567  
16568  
16569  
16570  
16571  
16572  
16573  
16574  
16575  
16576  
16577  
16578  
16579  
16580  
16581  
16582  
16583  
16584  
16585  
16586  
16587  
16588  
16589  
16590  
16591  
16592  
16593  
16594  
16595  
16596  
16597  
16598  
16599  
16600  
16601  
16602  
16603  
16604  
16605  
16606  
16607  
16608  
16609  
16610  
16611  
16612  
16613  
16614  
16615  
16616  
16617  
16618  
16619  
16620  
16621  
16622  
16623  
16624  
16625  
16626  
16627  
16628  
16629  
16630  
16631  
16632  
16633  
16634  
16635  
16636  
16637  
16638  
16639  
16640  
16641  
16642  
16643  
16644  
16645  
16646  
16647  
16648  
16649  
16650  
16651  
16652  
16653  
16654  
16655  
16656  
16657  
16658  
16659  
16660  
16661  
16662  
16663  
16664  
16665  
16666  
16667  
16668  
16669  
16670  
16671  
16672  
16673  
16674  
16675  
16676  
16677  
16678  
16679  
16680  
16681  
16682  
16683  
16684  
16685  
16686  
16687  
16688  
16689  
16690  
16691  
16692  
16693  
16694  
16695  
16696  
16697  
16698  
16699  
16700  
16701  
16702  
16703  
16704  
16705  
16706  
16707  
16708  
16709  
16710  
16711  
16712  
16713  
16714  
16715  
16716  
16717  
16718  
16719  
16720  
16721  
16722  
16723  
16724  
16725  
16726  
16727  
16728  
16729  
16730  
16731  
16732  
16733  
16734  
16735  
16736  
16737  
16738  
16739  
16740  
16741  
16742  
16743  
16744  
16745  
16746  
16747  
16748  
16749  
16750  
16751  
16752  
16753  
16754  
16755  
16756  
16757  
16758  
16759  
16760  
16761  
16762  
16763  
16764  
16765  
16766  
16767  
16768  
16769  
16770  
16771  
16772  
16773  
16774  
16775  
16776  
16777  
16778  
16779  
16780  
16781  
16782  
16783  
16784  
16785  
16786  
16787  
16788  
16789  
16790  
16791  
16792  
16793  
16794  
16795  
16796  
16797  
16798  
16799  
16800  
16801  
16802  
16803  
16804  
16805  
16806  
16807  
16808  
16809  
16810  
16811  
16812  
16813  
16814  
16815  
16816  
16817  
16818  
16819  
16820  
16821  
16822  
16823  
16824  
16825  
16826  
16827  
16828  
16829  
16830  
16831  
16832  
16833  
16834  
16835  
16836  
16837  
16838  
16839  
16840  
16841  
16842  
16843  
16844  
16845  
16846  
16847  
16848  
16849  
16850  
16851  
16852  
16853  
16854  
16855  
16856  
16857  
16858  
16859  
16860  
16861  
16862  
16863  
16864  
16865  
16866  
16867  
16868  
16869  
16870  
16871  
16872  
16873  
16874  
16875  
16876  
16877  
16878  
16879  
16880  
16881  
16882  
16883  
16884  
16885  
16886  
16887  
16888  
16889  
16890  
16891  
16892  
16893  
16894  
16895  
16896  
16897  
16898  
16899  
16900  
16901  
16902  
16903  
16904  
16905  
16906  
16907  
16908  
16909  
16910  
16911  
16912  
16913  
16914  
16915  
16916  
16917  
16918  
16919  
16920  
16921  
16922  
16923  
16924  
16925  
16926  
16927  
16928  
16929  
16930  
16931  
16932  
16933  
16934  
16935  
16936  
16937  
16938  
16939  
16940  
16941  
16942  
16943  
16944  
16945  
16946  
16947  
16948  
16949  
16950  
16951  
16952  
16953  
16954  
16955  
16956  
16957  
16958  
16959  
16960  
16961  
16962  
16963  
16964  
16965  
16966  
16967  
16968  
16969  
16970  
16971  
16972  
16973  
16974  
16975  
16976  
16977  
16978  
16979  
16980  
16981  
16982  
16983  
16984  
16985  
16986  
16987  
16988  
16989  
16990  
16991  
16992  
16993  
16994  
16995  
16996  
16997  
16998  
16999  
17000  
17001  
17002  
17003  
17004  
17005  
17006  
17007  
17008  
17009  
17010  
17011  
17012  
17013  
17014  
17015  
17016  
17017  
17018  
17019  
17020  
17021  
17022  
17023  
17024  
17025  
17026  
17027  
17028  
17029  
17030  
17031  
17032  
17033  
17034  
17035  
17036  
17037  
17038  
17039  
17040  
17041  
17042  
17043  
17044  
17045  
17046  
17047  
17048  
17049  
17050  
17051  
17052  
17053  
17054  
17055  
17056  
17057  
17058  
17059  
17060  
17061  
17062  
17063  
17064  
17065  
17066  
17067  
17068  
17069  
17070  
17071  
17072  
17073  
17074  
17075  
17076  
17077  
17078  
17079  
17080  
17081  
17082  
17083  
17084  
17085  
17086  
17087  
17088  
17089  
17090  
17091  
17092  
17093  
17094  
17095  
17096  
17097  
17098  
17099  
17100  
17101  
17102  
17103  
17104  
17105  
17106  
17107  
17108  
17109  
17110  
17111  
17112  
17113  
17114  
17115  
17116  
17117  
17118  
17119  
17120  
17121  
17122  
17123  
17124  
17125  
17126  
17127  
17128  
17129  
17130  
17131  
17132  
17133  
17134  
17135  
17136  
17137  
17138  
17139  
17140  
17141  
17142  
17143  
17144  
17145  
17146  
17147  
17148  
17149  
17150  
17151  
17152  
17153  
17154  
17155  
17156  
17157  
17158  
17159  
17160  
17161  
17162  
17163  
17164  
17165  
17166  
17167  
17168  
17169  
17170  
17171  
17172  
17173  
17174  
17175  
17176  
17177  
17178  
17179  
17180  
17181  
17182  
17183  
17184  
17185  
17186  
17187  
17188  
17189  
17190  
17191  
17192  
17193  
17194  
17195  
17196  
17197  
17198  
17199  
17200  
17201  
17202  
17203  
17204  
17205  
17206  
17207  
17208  
17209  
17210  
17211  
17212  
17213  
17214  
17215  
17216  
17217  
17218  
17219  
17220  
17221  
17222  
17223  
17224  
17225  
17226  
17227  
17228  
17229  
17230  
17231  
17232  
17233  
17234  
17235  
17236  
17237  
17238  
17239  
17240  
17241  
17242  
17243  
17244  
17245  
17246  
17247  
17248  
17249  
17250  
17251  
17252  
17253  
17254  
17255  
17256  
17257  
17258  
17259  
17260  
17261  
17262  
17263  
17264  
17265  
17266  
17267  
17268  
17269  
17270  
17271  
17272  
17273  
17274  
17275  
17276  
17277  
17278  
17279  
17280  
17281  
17282  
17283  
17284  
17285  
17286  
17287  
17288  
17289  
17290  
17291  
17292  
17293  
17294  
17295  
17296  
17297  
17298  
17299  
17300  
17301  
17302  
17303  
17304  
17305  
17306  
17307  
17308  
17309  
17310  
17311  
17312  
17313  
17314  
17315  
17316  
17317  
17318  
17319  
17320  
17321  
17322  
17323  
17324  
17325  
17326  
17327  
17328  
17329  
17330  
17331  
17332  
17333  
17334  
17335  
17336  
17337  
17338  
17339  
17340  
17341  
17342  
17343  
17344  
17345  
17346  
17347  
17348  
17349  
17350  
17351  
17352  
17353  
17354  
17355  
17356  
17357  
17358  
17359  
17360  
17361  
17362  
17363  
17364  
17365  
17366  
17367  
17368  
17369  
17370  
17371  
17372  
17373  
17374  
17375  
17376  
17377  
17378  
17379  
17380  
17381  
17382  
17383  
17384  
17385  
17386  
17387  
17388  
17389  
17390  
17391  
17392  
17393  
17394  
17395  
17396  
17397  
17398  
17399  
17400  
17401  
17402  
17403  
17404  
17405  
17406  
17407  
17408  
17409  
17410  
17411  
17412  
17413  
17414  
17415  
17416  
17417  
17418  
17419  
17420  
17421  
17422  
17423  
17424  
17425  
17426  
17427  
17428  
17429  
17430  
17431  
17432  
17433  
17434  
17435  
17436  
17437  
17438  
17439  
17440  
17441  
17442  
17443  
17444  
17445  
17446  
17447  
17448  
17449  
17450  
17451  
17452  
17453  
17454  
17455  
17456  
17457  
17458  
17459  
17460  
17461  
17462  
17463  
17464  
17465  
17466  
17467  
17468  
17469  
17470  
17471  
17472  
17473  
17474  
17475  
17476  
17477  
17478  
17479  
17480  
17481  
17482  
17483  
17484  
17485  
17486  
17487  
17488  
17489  
17490  
17491  
17492  
17493  
17494  
17495  
17496  
17497  
17498  
17499  
17500  
17501  
17502  
17503  
17504  
17505  
17506  
17507  
17508  
17509  
17510  
17511  
17512  
17513  
17514  
17515  
17516  
17517  
17518  
17519  
17520  
17521  
17522  
17523  
17524  
17525  
17526  
17527  
17528  
17529  
17530  
17531  
17532  
17533  
17534  
17535  
17536  
17537  
17538  
17539  
17540  
17541  
17542  
17543  
17544  
17545  
17546  
17547  
17548  
17549  
17550  
17551  
17552  
17553  
17554  
17555  
17556  
17557  
17558  
17559  
17560  
17561  
17562  
17563  
17564  
17565  
17566  
17567  
17568  
17569  
17570  
17571  
17572  
17573  
17574  
17575  
17576  
17577  
17578  
17579  
17580  
17581  
17582  
17583  
17584  
17585  
17586  
17587  
17588  
17589  
17590  
17591  
17592  
17593  
17594  
17595  
17596  
17597  
17598  
17599  
17600  
17601  
17602  
17603  
17604  
17605  
17606  
17607  
17608  
17609  
17610  
17611  
17612  
17613  
17614  
17615  
17616  
17617  
17618  
17619  
17620  
17621  
17622  
17623  
17624  
17625  
17626  
17627  
17628  
17629  
17630  
17631  
17632  
17633  
17634  
17635  
17636  
17637  
17638  
17639  
17640  
17641  
17642  
17643  
17644  
17645  
17646  
17647  
17648  
17649  
17650  
17651  
17652  
17653  
17654  
17655  
17656  
17657  
17658  
17659  
17660  
17661  
17662  
17663  
17664  
17665  
17666  
17667  
17668  
17669  
17670  
17671  
17672  
17673  
17674  
17675  
17676  
17677  
17678  
17679  
17680  
17681  
17682  
17683  
17684  
17685  
17686  
17687  
17688  
17689  
17690  
17691  
17692  
17693  
17694  
17695  
17696  
17697  
17698  
17699  
17700  
17701  
17702  
17703  
17704  
17705  
17706  
17707  
17708  
17709  
17710  
17711  
17712  
17713  
17714  
17715  
17716  
17717  
17718  
17719  
17720  
17721  
17722  
17723  
17724  
17725  
17726  
17727  
17728  
17729  
17730  
17731  
17732  
17733  
17734  
17735  
17736  
17737  
17738  
17739  
17740  
17741  
17742  
17743  
17744  
17745  
17746  
17747  
17748  
17749  
17750  
17751  
17752  
17753  
17754  
17755  
17756  
17757  
17758  
17759  
17760  
17761  
17762  
17763  
17764  
17765  
17766  
17767  
17768  
17769  
17770  
17771  
17772  
17773  
17774  
17775  
17776  
17777  
17778  
17779  
17780  
17781  
17782  
17783  
17784  
17785  
17786  
17787  
17788  
17789  
17790  
17791  
17792  
17793  
17794  
17795  
17796  
17797  
17798  
17799  
17800  
17801  
17802  
17803  
17804  
17805  
17806  
17807  
17808  
17809  
17810  
17811  
17812  
17813  
17814  
17815  
17816  
17817  
17818  
17819  
17820  
17821  
17822  
17823  
17824  
17825  
17826  
17827  
17828  
17829  
17830  
17831  
17832  
17833  
17834  
17835  
17836  
17837  
17838  
17839  
17840  
17841  
17842  
17843  
17844  
17845  
17846  
17847  
17848  
17849  
17850  
17851  
17852  
17853  
17854  
17855  
17856  
17857  
17858  
17859  
17860  
17861  
17862  
17863  
17864  
17865  
17866  
17867  
17868  
17869  
17870  
17871  
17872  
17873  
17874  
17875  
17876  
17877  
17878  
17879  
17880  
17881  
17882  
17883  
17884  
17885  
17886  
17887  
17888  
17889  
17890  
17891  
17892  
17893  
17894  
17895  
17896  
17897  
17898  
17899  
17900  
17901  
17902  
17903  
17904  
17905  
17906  
17907  
17908  
17909  
17910  
17911  
17912  
17913  
17914  
17915  
17916  
17917  
17918  
17919  
17920  
17921  
17922  
17923  
17924  
17925  
17926  
17927  
17928  
17929  
17930  
17931  
17932  
17933  
17934  
17935  
17936  
17937  
17938  
17939  
17940  
17941  
17942  
17943  
17944  
17945  
17946  
17947  
17948  
17949  
17950  
17951  
17952  
17953  
17954  
17955  
17956  
17957  
17958  
17959  
17960  
17961  
17962  
17963  
17964  
17965  
17966  
17967  
17968  
17969  
17970  
17971  
17972  
17973  
17974  
17975  
17976  
17977  
17978  
17979  
17980  
17981  
17982  
17983  
17984  
17985  
17986  
17987  
17988  
17989  
17990  
17991  
17992  
17993  
17994  
17995  
17996  
17997  
17998  
17999  
18000  
18001  
18002  
18003  
18004  
18005  
18006  
18007  
18008  
18009  
18010  
18011  
18012  
18013  
18014  
18015  
18016  
18017  
18018  
18019  
18020  
18021  
18022  
18023  
18024  
18025  
18026  
18027  
18028  
18029  
18030  
18031  
18032  
18033  
18034  
18035  
18036  
18037  
18038  
18039  
18040  
18041  
18042  
18043  
18044  
18045  
18046  
18047  
18048  
18049  
18050  
18051  
18052  
18053  
18054  
18055  
18056  
18057  
18058  
18059  
18060  
18061  
18062  
18063  
18064  
18065  
18066  
18067  
18068  
18069  
18070  
18071  
18072  
18073  
18074  
18075  
18076  
18077  
18078  
18079  
18080  
18081  
18082  
18083  
18084  
18085  
18086  
18087  
18088  
18089  
18090  
18091  
18092  
18093  
18094  
18095  
18096  
18097  
18098  
18099  
18100  
18101  
18102  
18103  
18104  
18105  
18106  
18107  
18108  
18109  
18110  
18111  
18112  
18113  
18114  
18115  
18116  
18117  
18118  
18119  
18120  
18121  
18122  
18123  
18124  
18125  
18126  
18127  
18128  
18129  
18130  
18131  
18132  
18133  
18134  
18135  
18136  
18137  
18138  
18139  
18140  
18141  
18142  
18143  
18144  
18145  
18146  
18147  
18148  
18149  
18150  
18151  
18152  
18153  
18154  
18155  
18156  
18157  
18158  
18159  
18160  
18161  
18162  
18163  
18164  
18165  
18166  
18167  
18168  
18169  
18170  
18171  
18172  
18173  
18174  
18175  
18176  
18177  
18178  
18179  
18180  
18181  
18182  
18183  
18184  
18185  
18186  
18187  
18188  
18189  
18190  
18191  
18192  
18193  
18194  
18195  
18196  
18197  
18198  
18199  
18200  
18201  
18202  
18203  
18204  
18205  
18206  
18207  
18208  
18209  
18210  
18211  
18212  
18213  
18214  
18215  
18216  
18217  
18218  
18219  
18220  
18221  
18222  
18223  
18224  
18225  
18226  
18227  
18228  
18229  
18230  
18231  
18232  
18233  
18234  
18235  
18236  
18237  
18238  
18239  
18240  
18241  
18242  
18243  
18244  
18245  
18246  
18247  
18248  
18249  
18250  
18251  
18252  
18253  
18254  
18255  
18256  
18257  
18258  
18259  
18260  
18261  
18262  
18263  
18264  
18265  
18266  
18267  
18268  
18269  
18270  
18271  
18272  
18273  
18274  
18275  
18276  
18277  
18278  
18279  
18280  
18281  
18282  
18283  
18284  
18285  
18286  
18287  
18288  
18289  
18290  
18291  
18292  
18293  
18294  
18295  
18296  
18297  
18298  
18299  
18300  
18301  
18302  
18303  
18304  
18305  
18306  
18307  
18308  
18309  
18310  
18311  
18312  
18313  
18314  
18315  
18316  
18317  
18318  
18319  
18320  
18321  
18322  
18323  
18324  
18325  
18326  
18327  
18328  
18329  
18330  
18331  
18332  
18333  
18334  
18335  
18336  
18337  
18338  
18339  
18340  
18341  
18342  
18343  
18344  
18345  
18346  
18347  
18348  
18349  
18350  
18351  
18352  
18353  
18354  
18355  
18356  
18357  
18358  
18359  
18360  
18361  
18362  
18363  
18364  
18365  
18366  
18367  
18368  
18369  
18370  
18371  
18372  
18373  
18374  
18375  
18376  
18377  
18378  
18379  
18380  
18381  
18382  
18383  
18384  
18385  
18386  
18387  
18388  
18389  
18390  
18391  
18392  
18393  
18394  
18395  
18396  
18397  
18398  
18399  
18400  
18401  
18402  
18403  
18404  
18405  
18406  
18407  
18408  
18409  
18410  
18411  
18412  
18413  
18414  
18415  
18416  
18417  
18418  
18419  
18420  
18421  
18422  
18423  
18424  
18425  
18426  
18427  
18428  
18429  
18430  
18431  
18432  
18433  
18434  
18435  
18436  
18437  
18438  
18439  
18440  
18441  
18442  
18443  
18444  
18445  
18446  
18447  
18448  
18449  
18450  
18451  
18452  
18453  
18454  
18455  
18456  
18457  
18458  
18459  
18460  
18461  
18462  
18463  
18464  
18465  
18466  
18467  
18468  
18469  
18470  
18471  
18472  
18473  
18474  
18475  
18476  
18477  
18478  
18479  
18480  
18481  
18482  
18483  
18484  
18485  
18486  
18487  
18488  
18489  
18490  
18491  
18492  
18493  
18494  
18495  
18496  
18497  
18498  
18499  
18500  
18501  
18502  
18503  
18504  
18505  
18506  
18507  
18508  
18509  
18510  
18511  
18512  
18513  
18514  
18515  
18516  
18517  
18518  
18519  
18520  
18521  
18522  
18523  
18524  
18525  
18526  
18527  
18528  
18529  
18530  
18531  
18532  
18533  
18534  
18535  
18536  
18537  
18538  
18539  
18540  
18541  
18542  
18543  
18544  
18545  
18546  
18547  
18548  
18549  
18550  
18551  
18552  
18553  
18554  
18555  
18556  
18557  
18558  
18559  
18560  
18561  
18562  
18563  
18564  
18565  
18566  
18567  
18568  
18569  
18570  
18571  
18572  
18573  
18574  
18575  
18576  
18577  
18578  
18579  
18580  
18581  
18582  
18583  
18584  
18585  
18586  
18587  
18588  
18589  
18590  
18591  
18592  
18593  
18594  
18595  
18596  
18597  
18598  
18599  
18600  
18601  
18602  
18603  
18604  
18605  
18606  
18607  
18608  
18609  
18610  
18611  
18612  
18613  
18614  
18615  
18616  
18617  
18618  
18619  
18620  
18621  
18622  
18623  
18624  
18625  
18626  
18627  
18628  
18629  
18630  
18631  
18632  
18633  
18634  
18635  
18636  
18637  
18638  
18639  
18640  
18641  
18642  
18643  
18644  
18645  
18646  
18647  
18648  
18649  
18650  
18651  
18652  
18653  
18654  
18655  
18656  
18657  
18658  
18659  
18660  
18661  
18662  
18663  
18664  
18665  
18666  
18667  
18668  
18669  
18670  
18671  
18672  
18673  
18674  
18675  
18676  
18677  
18678  
18679  
18680  
18681  
18682  
18683  
18684  
18685  
18686  
18687  
18688  
18689  
18690  
18691  
18692  
18693  
18694  
18695  
18696  
18697  
18698  
18699  
18700  
18701  
18702  
18703  
18704  
18705  
18706  
18707  
18708  
18709  
18710  
18711  
18712  
18713  
18714  
18715  
18716  
18717  
18718  
18719  
18720  
18721  
18722  
18723  
18724  
18725  
18726  
18727  
18728  
18729  
18730  
18731  
18732  
18733  
18734  
18735  
18736  
18737  
18738  
18739  
18740  
18741  
18742  
18743  
18744  
18745  
18746  
18747  
18748  
18749  
18750  
18751  
18752  
18753  
18754  
18755  
18756  
18757  
18758  
18759  
18760  
18761  
18762  
18763  
18764  
18765  
18766  
18767  
18768  
18769  
18770  
18771  
18772  
18773  
18774  
18775  
18776  
18777  
18778  
18779  
18780  
18781  
18782  
18783  
18784  
18785  
18786  
18787  
18788  
18789  
18790  
18791  
18792  
18793  
18794  
18795  
18796  
18797  
18798  
18799  
18800  
18801  
18802  
18803  
18804  
18805  
18806  
18807  
18808  
18809  
18810  
18811  
18812  
18813  
18814  
18815  
18816  
18817  
18818  
18819  
18820  
18821  
18822  
18823  
18824  
18825  
18826  
18827  
18828  
18829  
18830  
18831  
18832  
18833  
18834  
18835  
18836  
18837  
18838  
18839  
18840  
18841  
18842  
18843  
18844  
18845  
18846  
18847  
18848  
18849  
18850  
18851  
18852  
18853  
18854  
18855  
18856  
18857  
18858  
18859  
18860  
18861  
18862  
18863  
18864  
18865  
18866  
18867  
18868  
18869  
18870  
18871  
18872  
18873  
18874  
18875  
18876  
18877  
18878  
18879  
18880  
18881  
18882  
18883  
18884  
18885  
18886  
18887  
18888  
18889  
18890  
18891  
18892  
18893  
18894  
18895  
18896  
18897  
18898  
18899  
18900  
18901  
18902  
18903  
18904  
18905  
18906  
18907  
18908  
18909  
18910  
18911  
18912  
18913  
18914  
18915  
18916  
18917  
18918  
18919  
18920  
18921  
18922  
18923  
18924  
18925  
18926  
18927  
18928  
18929  
18930  
18931  
18932  
18933  
18934  
18935  
18936  
18937  
18938  
18939  
18940  
18941  
18942  
18943  
18944  
18945  
18946  
18947  
18948  
18949  
18950  
18951  
18952  
18953  
18954  
18955  
18956  
18957  
18958  
18959  
18960  
18961  
18962  
18963  
18964  
18965  
18966  
18967  
18968  
18969  
18970  
18971  
18972  
18973  
18974  
18975  
18976  
18977  
18978  
18979  
18980  
18981  
18982  
18983  
18984  
18985  
18986  
18987  
18988  
18989  
18990  
18991  
18992  
18993  
18994  
18995  
18996  
18997  
18998  
18999  
19000  
19001  
19002  
19003  
19004  
19005  
19006  
19007  
19008  
19009  
19010  
19011  
19012  
19013  
19014  
19015  
19016  
19017  
19018  
19019  
19020  
19021  
19022  
19023  
19024  
19025  
19026  
19027  
19028  
19029  
19030  
19031  
19032  
19033  
19034  
19035  
19036  
19037  
19038  
19039  
19040  
19041  
19042  
19043  
19044  
19045  
19046  
19047  
19048  
19049  
19050  
19051  
19052  
19053  
19054  
19055  
19056  
19057  
19058  
19059  
19060  
19061  
19062  
19063  
19064  
19065  
19066  
19067  
19068  
19069  
19070  
19071  
19072  
19073  
19074  
19075  
19076  
19077  
19078  
19079  
19080  
19081  
19082  
19083  
19084  
19085  
19086  
19087  
19088  
19089  
19090  
19091  
19092  
19093  
19094  
19095  
19096  
19097  
19098  
19099  
19100  
19101  
19102  
19103  
19104  
19105  
19106  
19107  
19108  
19109  
19110  
19111  
19112  
19113  
19114  
19115  
19116  
19117  
19118  
19119  
19120  
19121  
19122  
19123  
19124  
19125  
19126  
19127  
19128  
19129  
19130  
19131  
19132  
19133  
19134  
19135  
19136  
19137  
19138  
19139  
19140  
19141  
19142  
19143  
19144  
19145  
19146  
19147  
19148  
19149  
19150  
19151  
19152  
19153  
19154  
19155  
19156  
19157  
19158  
19159  
19160  
19161  
19162  
19163  
19164  
19165  
19166  
19167  
19168  
19169  
19170  
19171  
19172  
19173  
19174  
19175  
19176  
19177  
19178  
19179  
19180  
19181  
19182  
19183  
19184  
19185  
19186  
19187  
19188  
19189  
19190  
19191  
19192  
19193  
19194  
19195  
19196  
19197  
19198  
19199  
19200  
19201  
19202  
19203  
19204  
19205  
19206  
19207  
19208  
19209  
19210  
19211  
19212  
19213  
19214  
19215  
19216  
19217  
19218  
19219  
19220  
19221  
19222  
19223  
19224  
19225  
19226  
19227  
19228  
19229  
19230  
19231  
19232  
19233  
19234  
19235  
19236  
19237  
19238  
19239  
19240  
19241  
19242  
19243  
19244  
19245  
19246  
19247  
19248  
19249  
19250  
19251  
19252  
19253  
19254  
19255  
19256  
19257  
19258  
19259  
19260  
19261  
19262  
19263  
19264  
19265  
19266  
19267  
19268  
19269  
19270  
19271  
19272  
19273  
19274  
19275  
19276  
19277  
19278  
19279  
19280  
19281  
19282  
19283  
19284  
19285  
19286  
19287  
19288  
19289  
19290  
19291  
19292  
19293  
19294  
19295  
19296  
19297  
19298  
19299  
19300  
19301  
19302  
19303  
19304  
19305  
19306  
19307  
19308  
19309  
19310  
19311  
19312  
19313  
19314  
19315  
19316  
19317  
19318  
19319  
19320  
19321  
19322  
19323  
19324  
19325  
19326  
19327  
19328  
19329  
19330  
19331  
19332  
19333  
19334  
19335  
19336  
19337  
19338  
19339  
19340  
19341  
19342  
19343  
19344  
19345  
19346  
19347  
19348  
19349  
19350  
19351  
19352  
19353  
19354  
19355  
19356  
19357  
19358  
19359  
19360  
19361  
19362  
19363  
19364  
19365  
19366  
19367  
19368  
19369  
19370  
19371  
19372  
19373  
19374  
19375  
19376  
19377  
19378  
19379  
19380  
19381  
19382  
19383  
19384  
19385  
19386  
19387  
19388  
19389  
19390  
19391  
19392  
19393  
19394  
19395  
19396  
19397  
19398  
19399  
19400  
19401  
19402  
19403  
19404  
19405  
19406  
19407  
19408  
19409  
19410  
19411  
19412  
19413  
19414  
19415  
19416  
19417  
19418  
19419  
19420  
19421  
19422  
19423  
19424  
19425  
19426  
19427  
19428  
19429  
19430  
19431  
19432  
19433  
19434  
19435  
19436  
19437  
19438  
19439  
19440  
19441  
19442  
19443  
19444  
19445  
19446  
19447  
19448  
19449  
19450  
19451  
19452  
19453  
19454  
19455  
19456  
19457  
19458  
19459  
19460  
19461  
19462  
19463  
19464  
19465  
19466  
19467  
19468  
19469  
19470  
19471  
19472  
19473  
19474  
19475  
19476  
19477  
19478  
19479  
19480  
19481  
19482  
19483  
19484  
19485  
19486  
19487  
19488  
19489  
19490  
19491  
19492  
19493  
19494  
19495  
19496  
19497  
19498  
19499  
19500  
19501  
19502  
19503  
19504  
19505  
19506  
19507  
19508  
19509  
19510  
19511  
19512  
19513  
19514  
19515  
19516  
19517  
19518  
19519  
19520  
19521  
19522  
19523  
19524  
19525  
19526  
19527  
19528  
19529  
19530  
19531  
19532  
19533  
19534  
19535  
19536  
19537  
19538  
19539  
19540  
19541  
19542  
19543  
19544  
19545  
19546  
19547  
19548  
19549  
19550  
19551  
19552  
19553  
19554  
19555  
19556  
19557  
19558  
19559  
19560  
19561  
19562  
19563  
19564  
19565  
19566  
19567  
19568  
19569  
19570  
19571  
19572  
19573  
19574  
19575  
19576  
19577  
19578  
19579  
19580  
19581  
19582  
19583  
19584  
19585  
19586  
19587  
19588  
19589  
19590  
19591  
19592  
19593  
19594  
19595  
19596  
19597  
19598  
19599  
19600  
19601  
19602  
19603  
19604  
19605  
19606  
19607  
19608  
19609  
19610  
19611  
19612  
19613  
19614  
19615  
19616  
19617  
19618  
19619  
19620  
19621  
19622  
19623  
19624  
19625  
19626  
19627  
19628  
19629  
19630  
19631  
19632  
19633  
19634  
19635  
19636  
19637  
19638  
19639  
19640  
19641  
19642  
19643  
19644  
19645  
19646  
19647  
19648  
19649  
19650  
19651  
19652  
19653  
19654  
19655  
19656  
19657  
19658  
19659  
19660  
19661  
19662  
19663  
19664  
19665  
19666  
19667  
19668  
19669  
19670  
19671  
19672  
19673  
19674  
19675  
19676  
19677  
19678  
19679  
19680  
19681  
19682  
19683  
19684  
19685  
19686  
19687  
19688  
19689  
19690  
19691  
19692  
19693  
19694  
19695  
19696  
19697  
19698  
19699  
19700  
19701  
19702  
19703  
19704  
19705  
19706  
19707  
19708  
19709  
19710  
19711  
19712  
19713  
19714  
19715  
19716  
19717  
19718  
19719  
19720  
19721  
19722  
19723  
19724  
19725  
19726  
19727  
19728  
19729  
19730  
19731  
19732  
19733  
19734  
19735  
19736  
19737  
19738  
19739  
19740  
19741  
19742  
19743  
19744  
19745  
19746  
19747  
19748  
19749  
19750  
19751  
19752  
19753  
19754  
19755  
19756  
19757  
19758  
19759  
19760  
19761  
19762  
19763  
19764  
19765  
19766  
19767  
19768  
19769  
19770  
19771  
19772  
19773  
19774  
19775  
19776  
19777  
19778  
19779  
19780  
19781  
19782  
19783  
19784  
19785  
19786  
19787  
19788  
19789  
19790  
19791  
19792  
19793  
19794  
19795  
19796  
19797  
19798  
19799  
19800  
19801  
19802  
19803  
19804  
19805  
19806  
19807  
19808  
19809  
19810  
19811  
19812  
19813  
19814  
19815  
19816  
19817  
19818  
19819  
19820  
19821  
19822  
19823  
19824  
19825  
19826  
19827  
19828  
19829  
19830  
19831  
19832  
19833  
19834  
19835  
19836  
19837  
19838  
19839  
19840  
19841  
19842  
19843  
19844  
19845  
19846  
19847  
19848  
19849  
19850  
19851  
19852  
19853  
19854  
19855  
19856  
19857  
19858  
19859  
19860  
19861  
19862  
19863  
19864  
19865  
19866  
19867  
19868  
19869  
19870  
19871  
19872  
19873  
19874  
19875  
19876  
19877  
19878  
19879  
19880  
19881  
19882  
19883  
19884  
19885  
19886  
19887  
19888  
19889  
19890  
19891  
19892  
19893  
19894  
19895  
19896  
19897  
19898  
19899  
19900  
19901  
19902  
19903  
19904  
19905  
19906  
19907  
19908  
19909  
19910  
19911  
19912  
19913  
19914  
19915  
19916  
19917  
19918  
19919  
19920  
19921  
19922  
19923  
19924  
19925  
19926  
19927  
19928  
19929  
19930  
19931  
19932  
19933  
19934  
19935  
19936  
19937  
19938  
19939  
19940  
19941  
19942  
19943  
19944  
19945  
19946  
19947  
19948  
19949  
19950  
19951  
19952  
19953  
19954  
19955  
19956  
19957  
19958  
19959  
19960  
19961  
19962  
19963  
19964  
19965  
19966  
19967  
19968  
19969  
19970  
19971  
19972  
19973  
19974  
19975  
19976  
19977  
19978  
19979  
19980  
19981  
19982  
19983  
19984  
19985  
19986  
19987  
19988  
19989  
19990  
19991  
19992  
19993  
19994  
19995  
19996  
19997  
19998  
19999  
20000  
20001  
20002  
20003  
20004  
20005  
20006  
20007  
20008  
20009  
20010  
20011  
20012  
20013  
20014  
20015  
20016  
20017  
20018  
20019  
20020  
20021  
20022  
20023  
20024  
20025  
20026  
20027  
20028  
20029  
20030  
20031  
20032  
20033  
20034  
20035  
20036  
20037  
20038  
20039  
20040  
20041  
20042  
20043  
20044  
20045  
20046  
20047  
20048  
20049  
20050  
20051  
20052  
20053  
20054  
20055  
20056  
20057  
20058  
20059  
20060  
20061  
20062  
20063  
20064  
20065  
20066  
20067  
20068  
20069  
20070  
20071  
20072  
20073  
20074  
20075  
20076  
20077  
20078  
20079  
20080  
20081  
20082  
20083  
20084  
20085  
20086  
20087  
20088  
20089  
20090  
20091  
20092  
20093  
20094  
20095  
20096  
20097  
20098  
20099  
20100  
20101  
20102  
20103  
20104  
20105  
20106  
20107  
20108  
20109  
20110  
20111  
20112  
20113  
20114  
20115  
20116  
20117  
20118  
20119  
20120  
20121  
20122  
20123  
20124  
20125  
20126  
20127  
20128  
20129  
20130  
20131  
20132  
20133  
20134  
20135  
20136  
20137  
20138  
20139  
20140  
20141  
20142  
20143  
20144  
20145  
20146  
20147  
20148  
20149  
20150  
20151  
20152  
20153  
20154  
20155  
20156  
20157  
20158  
20159  
20160  
20161  
20162  
20163  
20164  
20165  
20166  
20167  
20168  
20169  
20170  
20171  
20172  
20173  
20174  
20175  
20176  
20177  
20178  
20179  
20180  
20181  
20182  
20183  
20184  
20185  
20186  
20187  
20188  
20189  
20190  
20191  
20192  
20193  
20194  
20195  
20196  
20197  
20198  
20199  
20200  
20201  
20202  
20203  
20204  
20205  
20206  
20207  
20208  
20209  
20210  
20211  
20212  
20213  
20214  
20215  
20216  
20217  
20218  
20219  
20220  
20221  
20222  
20223  
20224  
20225  
20226  
20227  
20228  
20229  
20230  
20231  
20232  
20233  
20234  
20235  
20236  
20237  
20238  
20239  
20240  
20241  
20242  
20243  
20244  
20245  
20246  
20247  
20248  
20249  
20250  
20251  
20252  
20253  
20254  
20255  
20256  
20257  
20258  
20259  
20260  
20261  
20262  
20263  
20264  
20265  
20266  
20267  
20268  
20269  
20270  
20271  
20272  
20273  
20274  
20275  
20276  
20277  
20278  
20279  
20280  
20281  
20282  
20283  
20284  
20285  
20286  
20287  
20288  
20289  
20290  
20291  
20292  
20293  
20294  
20295  
20296  
20297  
20298  
20299  
20300  
20301  
20302  
20303  
20304  
20305  
20306  
20307  
20308  
20309  
20310  
20311  
20312  
20313  
20314  
20315  
20316  
20317  
20318  
20319  
20320  
20321  
20322  
20323  
20324  
20325  
20326  
20327  
20328  
20329  
20330  
20331  
20332  
20333  
20334  
20335  
20336  
20337  
20338  
20339  
20340  
20341  
20342  
20343  
20344  
20345  
20346  
20347  
20348  
20349  
20350  
20351  
20352  
20353  
20354  
20355  
20356  
20357  
20358  
20359  
20360  
20361  
20362  
20363  
20364  
20365  
20366  
20367  
20368  
20369  
20370  
20371  
20372  
20373  
20374  
20375  
20376  
20377  
20378  
20379  
20380  
20381  
20382  
20383  
20384  
20385  
20386  
20387  
20388  
20389  
20390  
20391  
20392  
20393  
20394  
20395  
20396  
20397  
20398  
20399  
20400  
20401  
20402  
20403  
20404  
20405  
20406  
20407  
20408  
20409  
20410  
20411  
20412  
20413  
20414  
20415  
20416  
20417  
20418  
20419  
20420  
20421  
20422  
20423  
20424  
20425  
20426  
20427  
20428  
20429  
20430  
20431  
20432  
20433  
20434  
20435  
20436  
20437  
20438  
20439  
20440  
20441  
20442  
20443  
20444  
20445  
20446  
20447  
20448  
20449  
20450  
20451  
20452  
20453  
20454  
20455  
20456  
20457  
20458  
20459  
20460  
20461  
20462  
20463  
20464  
20465  
20466  
20467  
20468  
20469  
20470  
20471  
20472  
20473  
20474  
20475  
20476  
20477  
20478  
20479  
20480  
20481  
20482  
20483  
20484  
20485  
20486  
20487  
20488  
20489  
20490  
20491  
20492  
20493  
20494  
20495  
20496  
20497  
20498  
20499  
20500  
20501  
20502  
20503  
20504  
20505  
20506  
20507  
20508  
20509  
20510  
20511  
20512  
20513  
20514  
20515  
20516  
20517  
20518  
20519  
20520  
20521  
20522  
20523  
20524  
20525  
20526  
20527  
20528  
20529  
20530  
20531  
20532  
20533  
20534  
20535  
20536  
20537  
20538  
20539  
20540  
20541  
20542  
20543  
20544  
20545  
20546  
20547  
20548  
20549  
20550  
20551  
20552  
20553  
20554  
20555  
20556  
20557  
20558  
20559  
20560  
20561  
20562  
20563  
20564  
20565  
20566  
20567  
20568  
20569  
20570  
20571  
20572  
20573  
20574  
20575  
20576  
20577  
20578  
20579  
20580  
20581  
20582  
20583  
20584  
20585  
20586  
20587  
20588  
20589  
20590  
20591  
20592  
20593  
20594  
20595  
20596  
20597  
20598  
20599  
20600  
20601  
20602  
20603  
20604  
20605  
20606  
20607  
20608  
20609  
20610  
20611  
20612  
20613  
20614  
20615  
20616  
20617  
20618  
20619  
20620  
20621  
20622  
20623  
20624  
20625  
20626  
20627  
20628  
20629  
20630  
20631  
20632  
20633  
20634  
20635  
20636  
20637  
20638  
20639  
20640  
20641  
20642  
20643  
20644  
20645  
20646  
20647  
20648  
20649  
20650  
20651  
20652  
20653  
20654  
20655  
20656  
20657  
20658  
20659  
20660  
20661  
20662  
20663  
20664  
20665  
20666  
20667  
20668  
20669  
20670  
20671  
20672  
20673  
20674  
20675  
20676  
20677  
20678  
20679  
20680  
20681  
20682  
20683  
20684  
20685  
20686  
20687  
20688  
20689  
20690  
20691  
20692  
20693  
20694  
20695  
20696  
20697  
20698  
20699  
20700  
20701  
20702  
20703  
20704  
20705  
20706  
20707  
20708  
20709  
20710  
20711  
20712  
20713  
20714  
20715  
20716  
20717  
20718  
20719  
20720  
20721  
20722  
20723  
20724  
20725  
20726  
20727  
20728  
20729  
20730  
20731  
20732  
20733  
20734  
20735  
20736  
20737  
20738  
20739  
20740  
20741  
20742  
20743  
20744  
20745  
20746  
20747  
20748  
20749  
20750  
20751  
20752  
20753  
20754  
20755  
20756  
20757  
20758  
20759  
20760  
20761  
20762  
20763  
20764  
20765  
20766  
20767  
20768  
20769  
20770  
20771  
20772  
20773  
20774  
20775  
20776  
20777  
20778  
20779  
20780  
20781  
20782  
20783  
20784  
20785  
20786  
20787  
20788  
20789  
20790  
20791  
20792  
20793  
20794  
20795  
20796  
20797  
20798  
20799  
20800  
20801  
20802  
20803  
20804  
20805  
20806  
20807  
20808  
20809  
20810  
20811  
20812  
20813  
20814  
20815  
20816  
20817  
20818  
20819  
20820  
20821  
20822  
20823  
20824  
20825  
20826  
20827  
20828  
20829  
20830  
20831  
20832  
20833  
20834  
20835  
20836  
20837  
20838  
20839  
20840  
20841  
20842  
20843  
20844  
20845  
20846  
20847  
20848  
20849  
20850  
20851  
20852  
20853  
20854  
20855  
20856  
20857  
20858  
20859  
20860  
20861  
20862  
20863  
20864  
20865  
20866  
20867  
20868  
20869  
20870  
20871  
20872  
20873  
20874  
20875  
20876  
20877  
20878  
20879  
20880  
20881  
20882  
20883  
20884  
20885  
20886  
20887  
20888  
20889  
20890  
20891  
20892  
20893  
20894  
20895  
20896  
20897  
20898  
20899  
20900  
20901  
20902  
20903  
20904  
20905  
20906  
20907  
20908  
20909  
20910  
20911  
20912  
20913  
20914  
20915  
20916  
20917  
20918  
20919  
20920  
20921  
20922  
20923  
20924  
20925  
20926  
20927  
20928  
20929  
20930  
20931  
20932  
20933  
20934  
20935  
20936  
20937  
20938  
20939  
20940  
20941  
20942  
20943  
20944  
20945  
20946  
20947  
20948  
20949  
20950  
20951  
20952  
20953  
20954  
20955  
20956  
20957  
20958  
20959  
20960  
20961  
20962  
20963  
20964  
20965  
20966  
20967  
20968  
20969  
20970  
20971  
20972  
20973  
20974  
20975  
20976  
20977  
20978  
20979  
20980  
20981  
20982  
20983  
20984  
20985  
20986  
20987  
20988  
20989  
20990  
20991  
20992  
20993  
20994  
20995  
20996  
20997  
20998  
20999  
21000  
21001  
21002  
21003  
21004  
21005  
21006  
21007  
21008  
21009  
21010  
21011  
21012  
21013  
21014  
21015  
21016  
21017  
21018  
21019  
21020  
21021  
21022  
21023  
21024  
21025  
21026  
21027  
21028  
21029  
21030  
21031  
21032  
21033  
21034  
21035  
21036  
21037  
21038  
21039  
21040  
21041  
21042  
21043  
21044  
21045  
21046  
21047  
21048  
21049  
21050  
21051  
21052  
21053  
21054  
21055  
21056  
21057  
21058  
21059  
21060  
21061  
21062  
21063  
21064  
21065  
21066  
21067  
21068  
21069  
21070  
21071  
21072  
21073  
21074  
21075  
21076  
21077  
21078  
21079  
21080  
21081  
21082  
21083  
21084  
21085  
21086  
21087  
21088  
21089  
21090  
21091  
21092  
21093  
21094  
21095  
21096  
21097  
21098  
21099  
21100  
21101  
21102  
21103  
21104  
21105  
21106  
21107  
21108  
21109  
21110  
21111  
21112  
21113  
21114  
21115  
21116  
21117  
21118  
21119  
21120  
21121  
21122  
21123  
21124  
21125  
21126  
21127  
21128  
21129  
21130  
21131  
21132  
21133  
21134  
21135  
21136  
21137  
21138  
21139  
21140  
21141  
21142  
21143  
21144  
21145  
21146  
21147  
21148  
21149  
21150  
21151  
21152  
21153  
21154  
21155  
21156  
21157  
21158  
21159  
21160  
21161  
21162  
21163  
21164  
21165  
21166  
21167  
21168  
21169  
21170  
21171  
21172  
21173  
21174  
21175  
21176  
21177  
21178  
21179  
21180  
21181  
21182  
21183  
21184  
21185  
21186  
21187  
21188  
21189  
21190  
21191  
21192  
21193  
21194  
21195  
21196  
21197  
21198  
21199  
21200  
21201  
21202  
21203  
21204  
21205  
21206  
21207  
21208  
21209  
21210  
21211  
21212  
21213  
21214  
21215  
21216  
21217  
21218  
21219  
21220  
21221  
21222  
21223  
21224  
21225  
21226  
21227  
21228  
21229  
21230  
21231  
21232  
21233  
21234  
21235  
21236  
21237  
21238  
21239  
21240  
21241  
21242  
21243  
21244  
21245  
21246  
21247  
21248  
21249  
21250  
21251  
21252  
21253  
21254  
21255  
21256  
21257  
21258  
21259  
21260  
21261  
21262  
21263  
21264  
21265  
21266  
21267  
21268  
21269  
21270  
21271  
21272  
21273  
21274  
21275  
21276  
21277  
21278  
21279  
21280  
21281  
21282  
21283  
21284  
21285  
21286  
21287  
21288  
21289  
21290  
21291  
21292  
21293  
21294  
21295  
21296  
21297  
21298  
21299  
21300  
21301  
21302  
21303  
21304  
21305  
21306  
21307  
21308  
21309  
21310  
21311  
21312  
21313  
21314  
21315  
21316  
21317  
21318  
21319  
21320  
21321  
21322  
21323  
21324  
21325  
21326  
21327  
21328  
21329  
21330  
21331  
21332  
21333  
21334  
21335  
21336  
21337  
21338  
21339  
21340  
21341  
21342  
21343  
21344  
21345  
21346  
21347  
21348  
21349  
21350  
21351  
21352  
21353  
21354  
21355  
21356  
21357  
21358  
21359  
21360  
21361  
21362  
21363  
21364  
21365  
21366  
21367  
21368  
21369  
21370  
21371  
21372  
21373  
21374  
21375  
21376  
21377  
21378  
21379  
21380  
21381  
21382  
21383  
21384  
21385  
21386  
21387  
21388  
21389  
21390  
21391  
21392  
21393  
21394  
21395  
21396  
21397  
21398  
21399  
21400  
21401  
21402  
21403  
21404  
21405  
21406  
21407  
21408  
21409  
21410  
21411  
21412  
21413  
21414  
21415  
21416  
21417  
21418  
21419  
21420  
21421  
21422  
21423  
21424  
21425  
21426  
21427  
21428  
21429  
21430  
21431  
21432  
21433  
21434  
21435  
21436  
21437  
21438  
21439  
21440  
21441  
21442  
21443  
21444  
21445  
21446  
21447  
21448  
21449  
21450  
21451  
21452  
21453  
21454  
21455  
21456  
21457  
21458  
21459  
21460  
21461  
21462  
21463  
21464  
21465  
21466  
21467  
21468  
21469  
21470  
21471  
21472  
21473  
21474  
21475  
21476  
21477  
21478  
21479  
21480  
21481  
21482  
21483  
21484  
21485  
21486  
21487  
21488  
21489  
21490  
21491  
21492  
21493  
21494  
21495  
21496  
21497  
21498  
21499  
21500  
21501  
21502  
21503  
21504  
21505  
21506  
21507  
21508  
21509  
21510  
21511  
21512  
21513  
21514  
21515  
21516  
21517  
21518  
21519  
21520  
21521  
21522  
21523  
21524  
21525  
21526  
21527  
21528  
21529  
21530  
21531  
21532  
21533  
21534  
21535  
21536  
21537  
21538  
21539  
21540  
21541  
21542  
21543  
21544  
21545  
21546  
21547  
21548  
21549  
21550  
21551  
21552  
21553  
21554  
21555  
21556  
21557  
21558  
21559  
21560  
21561  
21562  
21563  
21564  
21565  
21566  
21567  
21568  
21569  
21570  
21571  
21572  
21573  
21574  
21575  
21576  
21577  
21578  
21579  
21580  
21581  
21582  
21583  
21584  
21585  
21586  
21587  
21588  
21589  
21590  
21591  
21592  
21593  
21594  
21595  
21596  
21597  
21598  
21599  
21600  
21601  
21602  
21603  
21604  
21605  
21606  
21607  
21608  
21609  
21610  
21611  
21612  
21613  
21614  
21615  
21616  
21617  
21618  
21619  
21620  
21621  
21622  
21623  
21624  
21625  
21626  
21627  
21628  
21629  
21630  
21631  
21632  
21633  
21634  
21635  
21636  
21637  
21638  
21639  
21640  
21641  
21642  
21643  
21644  
21645  
21646  
21647  
21648  
21649  
21650  
21651  
21652  
21653  
21654  
21655  
21656  
21657  
21658  
21659  
21660  
21661  
21662  
21663  
21664  
21665  
21666  
21667  
21668  
21669  
21670  
21671  
21672  
21673  
21674  
21675  
21676  
21677  
21678  
21679  
21680  
21681  
21682  
21683  
21684  
21685  
21686  
21687  
21688  
21689  
21690  
21691  
21692  
21693  
21694  
21695  
21696  
21697  
21698  
21699  
21700  
21701  
21702  
21703  
21704  
21705  
21706  
21707  
21708  
21709  
21710  
21711  
21712  
21713  
21714  
21715  
21716  
21717  
21718  
21719  
21720  
21721  
21722  
21723  
21724  
21725  
21726  
21727  
21728  
21729  
21730  
21731  
21732  
21733  
21734  
21735  
21736  
21737  
21738  
21739  
21740  
21741  
21742  
21743  
21744  
21745  
21746  
21747  
21748  
21749  
21750  
21751  
21752  
21753  
21754  
21755  
21756  
21757  
21758  
21759  
21760  
21761  
21762  
21763  
21764  
21765  
21766  
21767  
21768  
21769  
21770  
21771  
21772  
21773  
21774  
21775  
21776  
21777  
21778  
21779  
21780  
21781  
21782  
21783  
21784  
21785  
21786  
21787  
21788  
21789  
21790  
21791  
21792  
21793  
21794  
21795  
21796  
21797  
21798  
21799  
21800  
21801  
21802  
21803  
21804  
21805  
21806  
21807  
21808  
21809  
21810  
21811  
21812  
21813  
21814  
21815  
21816  
21817  
21818  
21819  
21820  
21821  
21822  
21823  
21824  
21825  
21826  
21827  
21828  
21829  
21830  
21831  
21832  
21833  
21834  
21835  
21836  
21837  
21838  
21839  
21840  
21841  
21842  
21843  
21844  
21845  
21846  
21847  
21848  
21849  
21850  
21851  
21852  
21853  
21854  
21855  
21856  
21857  
21858  
21859  
21860  
21861  
21862  
21863  
21864  
21865  
21866  
21867  
21868  
21869  
21870  
21871  
21872  
21873  
21874  
21875  
21876  
21877  
21878  
21879  
21880  
21881  
21882  
21883  
21884  
21885  
21886  
21887  
21888  
21889  
21890  
21891  
21892  
21893  
21894  
21895  
21896  
21897  
21898  
21899  
21900  
21901  
21902  
21903  
21904  
21905  
21906  
21907  
21908  
21909  
21910  
21911  
21912  
21913  
21914  
21915  
21916  
21917  
21918  
21919  
21920  
21921  
21922  
21923  
21924  
21925  
21926  
21927  
21928  
21929  
21930  
21931  
21932  
21933  
21934  
21935  
21936  
21937  
21938  
21939  
21940  
21941  
21942  
21943  
21944  
21945  
21946  
21947  
21948  
21949  
21950  
21951  
21952  
21953  
21954  
21955  
21956  
21957  
21958  
21959  
21960  
21961  
21962  
21963  
21964  
21965  
21966  
21967  
21968  
21969  
21970  
21971  
21972  
21973  
21974  
21975  
21976  
21977  
21978  
21979  
21980  
21981  
21982  
21983  
21984  
21985  
21986  
21987  
21988  
21989  
21990  
21991  
21992  
21993  
21994  
21995  
21996  
21997  
21998  
21999  
22000  
22001  
22002  
22003  
22004  
22005  
22006  
22007  
22008  
22009  
22010  
22011  
22012  
22013  
22014  
22015  
22016  
22017  
22018  
22019  
22020  
22021  
22022  
22023  
22024  
22025  
22026  
22027  
22028  
22029  
22030  
22031  
22032  
22033  
22034  
22035  
22036  
22037  
22038  
22039  
22040  
22041  
22042  
22043  
22044  
22045  
22046  
22047  
22048  
22049  
22050  
22051  
22052  
22053  
22054  
22055  
22056  
22057  
22058  
22059  
22060  
22061  
22062  
22063  
22064  
22065  
22066  
22067  
22068  
22069  
22070  
22071  
22072  
22073  
22074  
22075  
22076  
22077  
22078  
22079  
22080  
22081  
22082  
22083  
22084  
22085  
22086  
22087  
22088  
22089  
22090  
22091  
22092  
22093  
22094  
22095  
22096  
22097  
22098  
22099  
22100  
22101  
22102  
22103  
22104  
22105  
22106  
22107  
22108  
22109  
22110  
22111  
22112  
22113  
22114  
22115  
22116  
22117  
22118  
22119  
22120  
22121  
22122  
22123  
22124  
22125  
22126  
22127  
22128  
22129  
22130  
22131  
22132  
22133  
22134  
22135  
22136  
22137  
22138  
22139  
22140  
22141  
22142  
22143  
22144  
22145  
22146  
22147  
22148  
22149  
22150  
22151  
22152  
22153  
22154  
22155  
22156  
22157  
22158  
22159  
22160  
22161  
22162  
22163  
22164  
22165  
22166  
22167  
22168  
22169  
22170  
22171  
22172  
22173  
22174  
22175  
22176  
22177  
22178  
22179  
22180  
22181  
22182  
22183  
22184  
22185  
22186  
22187  
22188  
22189  
22190  
22191  
22192  
22193  
22194  
22195  
22196  
22197  
22198  
22199  
22200  
22201  
22202  
22203  
22204  
22205  
22206  
22207  
22208  
22209  
22210  
22211  
22212  
22213  
22214  
22215  
22216  
22217  
22218  
22219  
22220  
22221  
22222  
22223  
22224  
22225  
22226  
22227  
22228  
22229  
22230  
22231  
22232  
22233  
22234  
22235  
22236  
22237  
22238  
22239  
22240  
22241  
22242  
22243  
22244  
22245  
22246  
22247  
22248  
22249  
22250  
22251  
22252  
22253  
22254  
22255  
22256  
22257  
22258  
22259  
22260  
22261  
22262  
22263  
22264  
22265  
22266  
22267  
22268  
22269  
22270  
22271  
22272  
22273  
22274  
22275  
22276  
22277  
22278  
22279  
22280  
22281  
22282  
22283  
22284  
22285  
22286  
22287  
22288  
22289  
22290  
22291  
22292  
22293  
22294  
22295  
22296  
22297  
22298  
22299  
22300  
22301  
22302  
22303  
22304  
22305  
22306  
22307  
22308  
22309  
22310  
22311  
22312  
22313  
22314  
22315  
22316  
22317  
22318  
22319  
22320  
22321  
22322  
22323  
22324  
22325  
22326  
22327  
22328  
22329  
22330  
22331  
22332  
22333  
22334  
22335  
22336  
22337  
22338  
22339  
22340  
22341  
22342  
22343  
22344  
22345  
22346  
22347  
22348  
22349  
22350  
22351  
22352  
22353  
22354  
22355  
22356  
22357  
22358  
22359  
22360  
22361  
22362  
22363  
22364  
22365  
22366  
22367  
22368  
22369  
22370  
22371  
22372  
22373  
22374  
22375  
22376  
22377  
22378  
22379  
22380  
22381  
22382  
22383  
22384  
22385  
22386  
22387  
22388  
22389  
22390  
22391  
22392  
22393  
22394  
22395  
22396  
22397  
22398  
22399  
22400  
22401  
22402  
22403  
22404  
22405  
22406  
22407  
22408  
22409  
22410  
22411  
22412  
22413  
22414  
22415  
22416  
22417  
22418  
22419  
22420  
22421  
22422  
22423  
22424  
22425  
22426  
22427  
22428  
22429  
22430  
22431  
22432  
22433  
22434  
22435  
22436  
22437  
22438  
22439  
22440  
22441  
22442  
22443  
22444  
22445  
22446  
22447  
22448  
22449  
22450  
22451  
22452  
22453  
22454  
22455  
22456  
22457  
22458  
22459  
22460  
22461  
22462  
22463  
22464  
22465  
22466  
22467  
22468  
22469  
22470  
22471  
22472  
22473  
22474  
22475  
22476  
22477  
22478  
22479  
22480  
22481  
22482  
22483  
22484  
22485  
22486  
22487  
22488  
22489  
22490  
22491  
22492  
22493  
22494  
22495  
22496  
22497  
22498  
22499  
22500  
22501  
22502  
22503  
22504  
22505  
22506  
22507  
22508  
22509  
22510  
22511  
22512  
22513  
22514  
22515  
22516  
22517  
22518  
22519  
22520  
22521  
22522  
22523  
22524  
22525  
22526  
22527  
22528  
22529  
22530  
22531  
22532  
22533  
22534  
22535  
22536  
22537  
22538  
22539  
22540  
22541  
22542  
22543  
22544  
22545  
22546  
22547  
22548  
22549  
22550  
22551  
22552  
22553  
22554  
22555  
22556  
22557  
22558  
22559  
22560  
22561  
22562  
22563  
22564  
22565  
22566  
22567  
22568  
22569  
22570  
22571  
22572  
22573  
22574  
22575  
22576  
22577  
22578  
22579  
22580  
22581  
22582  
22583  
22584  
22585  
22586  
22587  
22588  
22589  
22590  
22591  
22592  
22593  
22594  
22595  
22596  
22597  
22598  
22599  
22600  
22601  
22602  
22603  
22604  
22605  
22606  
22607  
22608  
22609  
22610  
22611  
22612  
22613  
22614  
22615  
22616  
22617  
22618  
22619  
22620  
22621  
22622  
22623  
22624  
22625  
22626  
22627  
22628  
22629  
22630  
22631  
22632  
22633  
22634  
22635  
22636  
22637  
22638  
22639  
22640  
22641  
22642  
22643  
22644  
22645  
22646  
22647  
22648  
22649  
22650  
22651  
22652  
22653  
22654  
22655  
22656  
22657  
22658  
22659  
22660  
22661  
22662  
22663  
22664  
22665  
22666  
22667  
22668  
22669  
22670  
22671  
22672  
22673  
22674  
22675  
22676  
22677  
22678  
22679  
22680  
22681  
22682  
22683  
22684  
22685  
22686  
22687  
22688  
22689  
22690  
22691  
22692  
22693  
22694  
22695  
22696  
22697  
22698  
22699  
22700  
22701  
22702  
22703  
22704  
22705  
22706  
22707  
22708  
22709  
22710  
22711  
22712  
22713  
22714  
22715  
22716  
22717  
22718  
22719  
22720  
22721  
22722  
22723  
22724  
22725  
22726  
22727  
22728  
22729  
22730  
22731  
22732  
22733  
22734  
22735  
22736  
22737  
22738  
22739  
22740  
22741  
22742  
22743  
22744  
22745  
22746  
22747  
22748  
22749  
22750  
22751  
22752  
22753  
22754  
22755  
22756  
22757  
22758  
22759  
22760  
22761  
22762  
22763  
22764  
22765  
22766  
22767  
22768  
22769  
22770  
22771  
22772  
22773  
22774  
22775  
22776  
22777  
22778  
22779  
22780  
22781  
22782  
22783  
22784  
22785  
22786  
22787  
22788  
22789  
22790  
22791  
22792  
22793  
22794  
22795  
22796  
22797  
22798  
22799  
22800  
22801  
22802  
22803  
22804  
22805  
22806  
22807  
22808  
22809  
22810  
22811  
22812  
22813  
22814  
22815  
22816  
22817  
22818  
22819  
22820  
22821  
22822  
22823  
22824  
22825  
22826  
22827  
22828  
22829  
22830  
22831  
22832  
22833  
22834  
22835  
22836  
22837  
22838  
22839  
22840  
22841  
22842  
22843  
22844  
22845  
22846  
22847  
22848  
22849  
22850  
22851  
22852  
22853  
22854  
22855  
22856  
22857  
22858  
22859  
22860  
22861  
22862  
22863  
22864  
22865  
22866  
22867  
22868  
22869  
22870  
22871  
22872  
22873  
22874  
22875  
22876  
22877  
22878  
22879  
22880  
22881  
22882  
22883  
22884  
22885  
22886  
22887  
22888  
22889  
22890  
22891  
22892  
22893  
22894  
22895  
22896  
22897  
22898  
22899  
22900  
22901  
22902  
22903  
22904  
22905  
22906  
22907  
22908  
22909  
22910  
22911  
22912  
22913  
22914  
22915  
22916  
22917  
22918  
22919  
22920  
22921  
22922  
22923  
22924  
22925  
22926  
22927  
22928  
22929  
22930  
22931  
22932  
22933  
22934  
22935  
22936  
22937  
22938  
22939  
22940  
22941  
22942  
22943  
22944  
22945  
22946  
22947  
22948  
22949  
22950  
22951  
22952  
22953  
22954  
22955  
22956  
22957  
22958  
22959  
22960  
22961  
22962  
22963  
22964  
22965  
22966  
22967  
22968  
22969  
22970  
22971  
22972  
22973  
22974  
22975  
22976  
22977  
22978  
22979  
22980  
22981  
22982  
22983  
22984  
22985  
22986  
22987  
22988  
22989  
22990  
22991  
22992  
22993  
22994  
22995  
22996  
22997  
22998  
22999  
23000  
23001  
23002  
23003  
23004  
23005  
23006  
23007  
23008  
23009  
23010  
23011  
23012  
23013  
23014  
23015  
23016  
23017  
23018  
23019  
23020  
23021  
23022  
23023  
23024  
23025  
23026  
23027  
23028  
23029  
23030  
23031  
23032  
23033  
23034  
23035  
23036  
23037  
23038  
23039  
23040  
23041  
23042  
23043  
23044  
23045  
23046  
23047  
23048  
23049  
23050  
23051  
23052  
23053  
23054  
23055  
23056  
23057  
23058  
23059  
23060  
23061  
23062  
23063  
23064  
23065  
23066  
23067  
23068  
23069  
23070  
23071  
23072  
23073  
23074  
23075  
23076  
23077  
23078  
23079  
23080  
23081  
23082  
23083  
23084  
23085  
23086  
23087  
23088  
23089  
23090  
23091  
23092  
23093  
23094  
23095  
23096  
23097  
23098  
23099  
23100  
23101  
23102  
23103  
23104  
23105  
23106  
23107  
23108  
23109  
23110  
23111  
23112  
23113  
23114  
23115  
23116  
23117  
23118  
23119  
23120  
23121  
23122  
23123  
23124  
23125  
23126  
23127  
23128  
23129  
23130  
23131  
23132  
23133  
23134  
23135  
23136  
23137  
23138  
23139  
23140  
23141  
23142  
23143  
23144  
23145  
23146  
23147  
23148  
23149  
23150  
23151  
23152  
23153  
23154  
23155  
23156  
23157  
23158  
23159  
23160  
23161  
23162  
23163  
23164  
23165  
23166  
23167  
23168  
23169  
23170  
23171  
23172  
23173  
23174  
23175  
23176  
23177  
23178  
23179  
23180  
23181  
23182  
23183  
23184  
23185  
23186  
23187  
23188  
23189  
23190  
23191  
23192  
23193  
23194  
23195  
23196  
23197  
23198  
23199  
23200  
23201  
23202  
23203  
23204  
23205  
23206  
23207  
23208  
23209  
23210  
23211  
23212  
23213  
23214  
23215  
23216  
23217  
23218  
23219  
23220  
23221  
23222  
23223  
23224  
23225  
23226  
23227  
23228  
23229  
23230  
23231  
23232  
23233  
23234  
23235  
23236  
23237  
23238  
23239  
23240  
23241  
23242  
23243  
23244  
23245  
23246  
23247  
23248  
23249  
23250  
23251  
23252  
23253  
23254  
23255  
23256  
23257  
23258  
23259  
23260  
23261  
23262  
23263  
23264  
23265  
23266  
23267  
23268  
23269  
23270  
23271  
23272  
23273  
23274  
23275  
23276  
23277  
23278  
23279  
23280  
23281  
23282  
23283  
23284  
23285  
23286  
23287  
23288  
23289  
23290  
23291  
23292  
23293  
23294  
23295  
23296  
23297  
23298  
23299  
23300  
23301  
23302  
23303  
23304  
23305  
23306  
23307  
23308  
23309  
23310  
23311  
23312  
23313  
23314  
23315  
23316  
23317  
23318  
23319  
23320  
23321  
23322  
23323  
23324  
23325  
23326  
23327  
23328  
23329  
23330  
23331  
23332  
23333  
23334  
23335  
23336  
23337  
23338  
23339  
23340  
23341  
23342  
23343  
23344  
23345  
23346  
23347  
23348  
23349  
23350  
23351  
23352  
23353  
23354  
23355  
23356  
23357  
23358  
23359  
23360  
23361  
23362  
23363  
23364  
23365  
23366  
23367  
23368  
23369  
23370  
23371  
23372  
23373  
23374  
23375  
23376  
23377  
23378  
23379  
23380  
23381  
23382  
23383  
23384  
23385  
23386  
23387  
23388  
23389  
23390  
23391  
23392  
23393  
23394  
23395  
23396  
23397  
23398  
23399  
23400  
23401  
23402  
23403  
23404  
23405  
23406  
23407  
23408  
23409  
23410  
23411  
23412  
23413  
23414  
23415  
23416  
23417  
23418  
23419  
23420  
23421  
23422  
23423  
23424  
23425  
23426  
23427  
23428  
23429  
23430  
23431  
23432  
23433  
23434  
23435  
23436  
23437  
23438  
23439  
23440  
23441  
23442  
23443  
23444  
23445  
23446  
23447  
23448  
23449  
23450  
23451  
23452  
23453  
23454  
23455  
23456  
23457  
23458  
23459  
23460  
23461  
23462  
23463  
23464  
23465  
23466  
23467  
23468  
23469  
23470  
23471  
23472  
23473  
23474  
23475  
23476  
23477  
23478  
23479  
23480  
23481  
23482  
23483  
23484  
23485  
23486  
23487  
23488  
23489  
23490  
23491  
23492  
23493  
23494  
23495  
23496  
23497  
23498  
23499  
23500  
23501  
23502  
23503  
23504  
23505  
23506  
23507  
23508  
23509  
23510  
23511  
23512  
23513  
23514  
23515  
23516  
23517  
23518  
23519  
23520  
23521  
23522  
23523  
23524  
23525  
23526  
23527  
23528  
23529  
23530  
23531  
23532  
23533  
23534  
23535  
23536  
23537  
23538  
23539  
23540  
23541  
23542  
23543  
23544  
23545  
23546  
23547  
23548  
23549  
23550  
23551  
23552  
23553  
23554  
23555  
23556  
23557  
23558  
23559  
23560  
23561  
23562  
23563  
23564  
23565  
23566  
23567  
23568  
23569  
23570  
23571  
23572  
23573  
23574  
23575  
23576  
23577  
23578  
23579  
23580  
23581  
23582  
23583  
23584  
23585  
23586  
23587  
23588  
23589  
23590  
23591  
23592  
23593  
23594  
23595  
23596  
23597  
23598  
23599  
23600  
23601  
23602  
23603  
23604  
23605  
23606  
23607  
23608  
23609  
23610  
23611  
23612  
23613  
23614  
23615  
23616  
23617  
23618  
23619  
23620  
23621  
23622  
23623  
23624  
23625  
23626  
23627  
23628  
23629  
23630  
23631  
23632  
23633  
23634  
23635  
23636  
23637  
23638  
23639  
23640  
23641  
23642  
23643  
23644  
23645  
23646  
23647  
23648  
23649  
23650  
23651  
23652  
23653  
23654  
23655  
23656  
23657  
23658  
23659  
23660  
23661  
23662  
23663  
23664  
23665  
23666  
23667  
23668  
23669  
23670  
23671  
23672  
23673  
23674  
23675  
23676  
23677  
23678  
23679  
23680  
23681  
23682  
23683  
23684  
23685  
23686  
23687  
23688  
23689  
23690  
23691  
23692  
23693  
23694  
23695  
23696  
23697  
23698  
23699  
23700  
23701  
23702  
23703  
23704  
23705  
23706  
23707  
23708  
23709  
23710  
23711  
23712  
23713  
23714  
23715  
23716  
23717  
23718  
23719  
23720  
23721  
23722  
23723  
23724  
23725  
23726  
23727  
23728  
23729  
23730  
23731  
23732  
23733  
23734  
23735  
23736  
23737  
23738  
23739  
23740  
23741  
23742  
23743  
23744  
23745  
23746  
23747  
23748  
23749  
23750  
23751  
23752  
23753  
23754  
23755  
23756  
23757  
23758  
23759  
23760  
23761  
23762  
23763  
23764  
23765  
23766  
23767  
23768  
23769  
23770  
23771  
23772  
23773  
23774  
23775  
23776  
23777  
23778  
23779  
23780  
23781  
23782  
23783  
23784  
23785  
23786  
23787  
23788  
23789  
23790  
23791  
23792  
23793  
23794  
23795  
23796  
23797  
23798  
23799  
23800  
23801  
23802  
23803  
23804  
23805  
23806  
23807  
23808  
23809  
23810  
23811  
23812  
23813  
23814  
23815  
23816  
23817  
23818  
23819  
23820  
23821  
23822  
23823  
23824  
23825  
23826  
23827  
23828  
23829  
23830  
23831  
23832  
23833  
23834  
23835  
23836  
23837  
23838  
23839  
23840  
23841  
23842  
23843  
23844  
23845  
23846  
23847  
23848  
23849  
23850  
23851  
23852  
23853  
23854  
23855  
23856  
23857  
23858  
23859  
23860  
23861  
23862  
23863  
23864  
23865  
23866  
23867  
23868  
23869  
23870  
23871  
23872  
23873  
23874  
23875  
23876  
23877  
23878  
23879  
23880  
23881  
23882  
23883  
23884  
23885  
23886  
23887  
23888  
23889  
23890  
23891  
23892  
23893  
23894  
23895  
23896  
23897  
23898  
23899  
23900  
23901  
23902  
23903  
23904  
23905  
23906  
23907  
23908  
23909  
23910  
23911  
23912  
23913  
23914  
23915  
23916  
23917  
23918  
23919  
23920  
23921  
23922  
23923  
23924  
23925  
23926  
23927  
23928  
23929  
23930  
23931  
23932  
23933  
23934  
23935  
23936  
23937  
23938  
23939  
23940  
23941  
23942  
23943  
23944  
23945  
23946  
23947  
23948  
23949  
23950  
23951  
23952  
23953  
23954  
23955  
23956  
23957  
23958  
23959  
23960  
23961  
23962  
23963  
23964  
23965  
23966  
23967  
23968  
23969  
23970  
23971  
23972  
23973  
23974  
23975  
23976  
23977  
23978  
23979  
23980  
23981  
23982  
23983  
23984  
23985  
23986  
23987  
23988  
23989  
23990  
23991  
23992  
23993  
23994  
23995  
23996  
23997  
23998  
23999  
24000  
24001  
24002  
24003  
24004  
24005  
24006  
24007  
24008  
24009  
24010  
24011  
24012  
24013  
24014  
24015  
24016  
24017  
24018  
24019  
24020  
24021  
24022  
24023  
24024  
24025  
24026  
24027  
24028  
24029  
24030  
24031  
24032  
24033  
24034  
24035  
24036  
24037  
24038  
24039  
24040  
24041  
24042  
24043  
24044  
24045  
24046  
24047  
24048  
24049  
24050  
24051  
24052  
24053  
24054  
24055  
24056  
24057  
24058  
24059  
24060  
24061  
24062  
24063  
24064  
24065  
24066  
24067  
24068  
24069  
24070  
24071  
24072  
24073  
24074  
24075  
24076  
24077  
24078  
24079  
24080  
24081  
24082  
24083  
24084  
24085  
24086  
24087  
24088  
24089  
24090  
24091  
24092  
24093  
24094  
24095  
24096  
24097  
24098  
24099  
24100  
24101  
24102  
24103  
24104  
24105  
24106  
24107  
24108  
24109  
24110  
24111  
24112  
24113  
24114  
24115  
24116  
24117  
24118  
24119  
24120  
24121  
24122  
24123  
24124  
24125  
24126  
24127  
24128  
24129  
24130  
24131  
24132  
24133  
24134  
24135  
24136  
24137  
24138  
24139  
24140  
24141  
24142  
24143  
24144  
24145  
24146  
24147  
24148  
24149  
24150  
24151  
24152  
24153  
24154  
24155  
24156  
24157  
24158  
24159  
24160  
24161  
24162  
24163  
24164  
24165  
24166  
24167  
24168  
24169  
24170  
24171  
24172  
24173  
24174  
24175  
24176  
24177  
24178  
24179  
24180  
24181  
24182  
24183  
24184  
24185  
24186  
24187  
24188  
24189  
24190  
24191  
24192  
24193  
24194  
24195  
24196  
24197  
24198  
24199  
24200  
24201  
24202  
24203  
24204  
24205  
24206  
24207  
24208  
24209  
24210  
24211  
24212  
24213  
24214  
24215  
24216  
24217  
24218  
24219  
24220  
24221  
24222  
24223  
24224  
24225  
24226  
24227  
24228  
24229  
24230  
24231  
24232  
24233  
24234  
24235  
24236  
24237  
24238  
24239  
24240  
24241  
24242  
24243  
24244  
24245  
24246  
24247  
24248  
24249  
24250  
24251  
24252  
24253  
24254  
24255  
24256  
24257  
24258  
24259  
24260  
24261  
24262  
24263  
24264  
24265  
24266  
24267  
24268  
24269  
24270  
24271  
24272  
24273  
24274  
24275  
24276  
24277  
24278  
24279  
24280  
24281  
24282  
24283  
24284  
24285  
24286  
24287  
24288  
24289  
24290  
24291  
24292  
24293  
24294  
24295  
24296  
24297  
24298  
24299  
24300  
24301  
24302  
24303  
24304  
24305  
24306  
24307  
24308  
24309  
24310  
24311  
24312  
24313  
24314  
24315  
24316  
24317  
24318  
24319  
24320  
24321  
24322  
24323  
24324  
24325  
24326  
24327  
24328  
24329  
24330  
24331  
24332  
24333  
24334  
24335  
24336  
24337  
24338  
24339  
24340  
24341  
24342  
24343  
24344  
24345  
24346  
24347  
24348  
24349  
24350  
24351  
24352  
24353  
24354  
24355  
24356  
24357  
24358  
24359  
24360  
24361  
24362  
24363  
24364  
24365  
24366  
24367  
24368  
24369  
24370  
24371  
24372  
24373  
24374  
24375  
24376  
24377  
24378  
24379  
24380  
24381  
24382  
24383  
24384  
24385  
24386  
24387  
24388  
24389  
24390  
24391  
24392  
24393  
24394  
24395  
24396  
24397  
24398  
24399  
24400  
24401  
24402  
24403  
24404  
24405  
24406  
24407  
24408  
24409  
24410  
24411  
24412  
24413  
24414  
24415  
24416  
24417  
24418  
24419  
24420  
24421  
24422  
24423  
24424  
24425  
24426  
24427  
24428  
24429  
24430  
24431  
24432  
24433  
24434  
24435  
24436  
24437  
24438  
24439  
24440  
24441  
24442  
24443  
24444  
24445  
24446  
24447  
24448  
24449  
24450  
24451  
24452  
24453  
24454  
24455  
24456  
24457  
24458  
24459  
24460  
24461  
24462  
24463  
24464  
24465  
24466  
24467  
24468  
24469  
24470  
24471  
24472  
24473  
24474  
24475  
24476  
24477  
24478  
24479  
24480  
24481  
24482  
24483  
24484  
24485  
24486  
24487  
24488  
24489  
24490  
24491  
24492  
24493  
24494  
24495  
24496  
24497  
24498  
24499  
24500  
24501  
24502  
24503  
24504  
24505  
24506  
24507  
24508  
24509  
24510  
24511  
24512  
24513  
24514  
24515  
24516  
24517  
24518  
24519  
24520  
24521  
24522  
24523  
24524  
24525  
24526  
24527  
24528  
24529  
24530  
24531  
24532  
24533  
24534  
24535  
24536  
24537  
24538  
24539  
24540  
24541  
24542  
24543  
24544  
24545  
24546  
24547  
24548  
24549  
24550  
24551  
24552  
24553  
24554  
24555  
24556  
24557  
24558  
24559  
24560  
24561  
24562  
24563  
24564  
24565  
24566  
24567  
24568  
24569  
24570  
24571  
24572  
24573  
24574  
24575  
24576  
24577  
24578  
24579  
24580  
24581  
24582  
24583  
24584  
24585  
24586  
24587  
24588  
24589  
24590  
24591  
24592  
24593  
24594  
24595  
24596  
24597  
24598  
24599  
24600  
24601  
24602  
24603  
24604  
24605  
24606  
24607  
24608  
24609  
24610  
24611  
24612  
24613  
24614  
24615  
24616  
24617  
24618  
24619  
24620  
24621  
24622  
24623  
24624  
24625  
24626  
24627  
24628  
24629  
24630  
24631  
24632  
24633  
24634  
24635  
24636  
24637  
24638  
24639  
24640  
24641  
24642  
24643  
24644  
24645  
24646  
24647  
24648  
24649  
24650  
24651  
24652  
24653  
24654  
24655  
24656  
24657  
24658  
24659  
24660  
24661  
24662  
24663  
24664  
24665  
24666  
24667  
24668  
24669  
24670  
24671  
24672  
24673  
24674  
24675  
24676  
24677  
24678  
24679  
24680  
24681  
24682  
24683  
24684  
24685  
24686  
24687  
24688  
24689  
24690  
24691  
24692  
24693  
24694  
24695  
24696  
24697  
24698  
24699  
24700  
24701  
24702  
24703  
24704  
24705  
24706  
24707  
24708  
24709  
24710  
24711  
24712  
24713  
24714  
24715  
24716  
24717  
24718  
24719  
24720  
24721  
24722  
24723  
24724  
24725  
24726  
24727  
24728  
24729  
24730  
24731  
24732  
24733  
24734  
24735  
24736  
24737  
24738  
24739  
24740  
24741  
24742  
24743  
24744  
24745  
24746  
24747  
24748  
24749  
24750  
24751  
24752  
24753  
24754  
24755  
24756  
24757  
24758  
24759  
24760  
24761  
24762  
24763  
24764  
24765  
24766  
24767  
24768  
24769  
24770  
24771  
24772  
24773  
24774  
24775  
24776  
24777  
24778  
24779  
24780  
24781  
24782  
24783  
24784  
24785  
24786  
24787  
24788  
24789  
24790  
24791  
24792  
24793  
24794  
24795  
24796  
24797  
24798  
24799  
24800  
24801  
24802  
24803  
24804  
24805  
24806  
24807  
24808  
24809  
24810  
24811  
24812  
24813  
24814  
24815  
24816  
24817  
24818  
24819  
24820  
24821  
24822  
24823  
24824  
24825  
24826  
24827  
24828  
24829  
24830  
24831  
24832  
24833  
24834  
24835  
24836  
24837  
24838  
24839  
24840  
24841  
24842  
24843  
24844  
24845  
24846  
24847  
24848  
24849  
24850  
24851  
24852  
24853  
24854  
24855  
24856  
24857  
24858  
24859  
24860  
24861  
24862  
24863  
24864  
24865  
24866  
24867  
24868  
24869  
24870  
24871  
24872  
24873  
24874  
24875  
24876  
24877  
24878  
24879  
24880  
24881  
24882  
24883  
24884  
24885  
24886  
24887  
24888  
24889  
24890  
24891  
24892  
24893  
24894  
24895  
24896  
24897  
24898  
24899  
24900  
24901  
24902  
24903  
24904  
24905  
24906  
24907  
24908  
24909  
24910  
24911  
24912  
24913  
24914  
24915  
24916  
24917  
24918  
24919  
24920  
24921  
24922  
24923  
24924  
24925  
24926  
24927  
24928  
24929  
24930  
24931  
24932  
24933  
24934  
24935  
24936  
24937  
24938  
24939  
24940  
24941  
24942  
24943  
24944  
24945  
24946  
24947  
24948  
24949  
24950  
24951  
24952  
24953  
24954  
24955  
24956  
24957  
24958  
24959  
24960  
24961  
24962  
24963  
24964  
24965  
24966  
24967  
24968  
24969  
24970  
24971  
24972  
24973  
24974  
24975  
24976  
24977  
24978  
24979  
24980  
24981  
24982  
24983  
24984  
24985  
24986  
24987  
24988  
24989  
24990  
24991  
24992  
24993  
24994  
24995  
24996  
24997  
24998  
24999  
25000  
25001  
25002  
25003  
25004  
25005  
25006  
25007  
25008  
25009  
25010  
25011  
25012  
25013  
25014  
25015  
25016  
25017  
25018  
25019  
25020  
25021  
25022  
25023  
25024  
25025  
25026  
25027  
25028  
25029  
25030  
25031  
25032  
25033  
25034  
25035  
25036  
25037  
25038  
25039  
25040  
25041  
25042  
25043  
25044  
25045  
25046  
25047  
25048  
25049  
25050  
25051  
25052  
25053  
25054  
25055  
25056  
25057  
25058  
25059  
25060  
25061  
25062  
25063  
25064  
25065  
25066  
25067  
25068  
25069  
25070  
25071  
25072  
25073  
25074  
25075  
25076  
25077  
25078  
25079  
25080  
25081  
25082  
25083  
25084  
25085  
25086  
25087  
25088  
25089  
25090  
25091  
25092  
25093  
25094  
25095  
25096  
25097  
25098  
25099  
25100  
25101  
25102  
25103  
25104  
25105  
25106  
25107  
25108  
25109  
25110  
25111  
25112  
25113  
25114  
25115  
25116  
25117  
25118  
25119  
25120  
25121  
25122  
25123  
25124  
25125  
25126  
25127  
25128  
25129  
25130  
25131  
25132  
25133  
25134  
25135  
25136  
25137  
25138  
25139  
25140  
25141  
25142  
25143  
25144  
25145  
25146  
25147  
25148  
25149  
25150  
25151  
25152  
25153  
25154  
25155  
25156  
25157  
25158  
25159  
25160  
25161  
25162  
25163  
25164  
25165  
25166  
25167  
25168  
25169  
25170  
25171  
25172  
25173  
25174  
25175  
25176  
25177  
25178  
25179  
25180  
25181  
25182  
25183  
25184  
25185  
25186  
25187  
25188  
25189  
25190  
25191  
25192  
25193  
25194  
25195  
25196  
25197  
25198  
25199  
25200  
25201  
25202  
25203  
25204  
25205  
25206  
25207  
25208  
25209  
25210  
25211  
25212  
25213  
25214  
25215  
25216  
25217  
25218  
25219  
25220  
25221  
25222  
25223  
25224  
25225  
25226  
25227  
25228  
25229  
25230  
25231  
25232  
25233  
25234  
25235  
25236  
25237  
25238  
25239  
25240  
25241  
25242  
25243  
25244  
25245  
25246  
25247  
25248  
25249  
25250  
25251  
25252  
25253  
25254  
25255  
25256  
25257  
25258  
25259  
25260  
25261  
25262  
25263  
25264  
25265  
25266  
25267  
25268  
25269  
25270  
25271  
25272  
25273  
25274  
25275  
25276  
25277  
25278  
25279  
25280  
25281  
25282  
25283  
25284  
25285  
25286  
25287  
25288  
25289  
25290  
25291  
25292  
25293  
25294  
25295  
25296  
25297  
25298  
25299  
25300  
25301  
25302  
25303  
25304  
25305  
25306  
25307  
25308  
25309  
25310  
25311  
25312  
25313  
25314  
25315  
25316  
25317  
25318  
25319  
25320  
25321  
25322  
25323  
25324  
25325  
25326  
25327  
25328  
25329  
25330  
25331  
25332  
25333  
25334  
25335  
25336  
25337  
25338  
25339  
25340  
25341  
25342  
25343  
25344  
25345  
25346  
25347  
25348  
25349  
25350  
25351  
25352  
25353  
25354  
25355  
25356  
25357  
25358  
25359  
25360  
25361  
25362  
25363  
25364  
25365  
25366  
25367  
25368  
25369  
25370  
25371  
25372  
25373  
25374  
25375  
25376  
25377  
25378  
25379  
25380  
25381  
25382  
25383  
25384  
25385  
25386  
25387  
25388  
25389  
25390  
25391  
25392  
25393  
25394  
25395  
25396  
25397  
25398  
25399  
25400  
25401  
25402  
25403  
25404  
25405  
25406  
25407  
25408  
25409  
25410  
25411  
25412  
25413  
25414  
25415  
25416  
25417  
25418  
25419  
25420  
25421  
25422  
25423  
25424  
25425  
25426  
25427  
25428  
25429  
25430  
25431  
25432  
25433  
25434  
25435  
25436  
25437  
25438  
25439  
25440  
25441  
25442  
25443  
25444  
25445  
25446  
25447  
25448  
25449  
25450  
25451  
25452  
25453  
25454  
25455  
25456  
25457  
25458  
25459  
25460  
25461  
25462  
25463  
25464  
25465  
25466  
25467  
25468  
25469  
25470  
25471  
25472  
25473  
25474  
25475  
25476  
25477  
25478  
25479  
25480  
25481  
25482  
25483  
25484  
25485  
25486  
25487  
25488  
25489  
25490  
25491  
25492  
25493  
25494  
25495  
25496  
25497  
25498  
25499  
25500  
25501  
25502  
25503  
25504  
25505  
25506  
25507  
25508  
25509  
25510  
25511  
25512  
25513  
25514  
25515  
25516  
25517  
25518  
25519  
25520  
25521  
25522  
25523  
25524  
25525  
25526  
25527  
25528  
25529  
25530  
25531  
25532  
25533  
25534  
25535  
25536  
25537  
25538  
25539  
25540  
25541  
25542  
25543  
25544  
25545  
25546  
25547  
25548  
25549  
25550  
25551  
25552  
25553  
25554  
25555  
25556  
25557  
25558  
25559  
25560  
25561  
25562  
25563  
25564  
25565  
25566  
25567  
25568  
25569  
25570  
25571  
25572  
25573  
25574  
25575  
25576  
25577  
25578  
25579  
25580  
25581  
25582  
25583  
25584  
25585  
25586  
25587  
25588  
25589  
25590  
25591  
25592  
25593  
25594  
25595  
25596  
25597  
25598  
25599  
25600  
25601  
25602  
25603  
25604  
25605  
25606  
25607  
25608  
25609  
25610  
25611  
25612  
25613  
25614  
25615  
25616  
25617  
25618  
25619  
25620  
25621  
25622  
25623  
25624  
25625  
25626  
25627  
25628  
25629  
25630  
25631  
25632  
25633  
25634  
25635  
25636  
25637  
25638  
25639  
25640  
25641  
25642  
25643  
25644  
25645  
25646  
25647  
25648  
25649  
25650  
25651  
25652  
25653  
25654  
25655  
25656  
25657  
25658  
25659  
25660  
25661  
25662  
25663  
25664  
25665  
25666  
25667  
25668  
25669  
25670  
25671  
25672  
25673  
25674  
25675  
25676  
25677  
25678  
25679  
25680  
25681  
25682  
25683  
25684  
25685  
25686  
25687  
25688  
25689  
25690  
25691  
25692  
25693  
25694  
25695  
25696  
25697  
25698  
25699  
25700  
25701  
25702  
25703  
25704  
25705  
25706  
25707  
25708  
25709  
25710  
25711  
25712  
25713  
25714  
25715  
25716  
25717  
25718  
25719  
25720  
25721  
25722  
25723  
25724  
25725  
25726  
25727  
25728  
25729  
25730  
25731  
25732  
25733  
25734  
25735  
25736  
25737  
25738  
25739  
25740  
25741  
25742  
25743  
25744  
25745  
25746  
25747  
25748  
25749  
25750  
25751  
25752  
25753  
25754  
25755  
25756  
25757  
25758  
25759  
25760  
25761  
25762  
25763  
25764  
25765  
25766  
25767  
25768  
25769  
25770  
25771  
25772  
25773  
25774  
25775  
25776  
25777  
25778  
25779  
25780  
25781  
25782  
25783  
25784  
25785  
25786  
25787  
25788  
25789  
25790  
25791  
25792  
25793  
25794  
25795  
25796  
25797  
25798  
25799  
25800  
25801  
25802  
25803  
25804  
25805  
25806  
25807  
25808  
25809  
25810  
25811  
25812  
25813  
25814  
25815  
25816  
25817  
25818  
25819  
25820  
25821  
25822  
25823  
25824  
25825  
25826  
25827  
25828  
25829  
25830  
25831  
25832  
25833  
25834  
25835  
25836  
25837  
25838  
25839  
25840  
25841  
25842  
25843  
25844  
25845  
25846  
25847  
25848  
25849  
25850  
25851  
25852  
25853  
25854  
25855  
25856  
25857  
25858  
25859  
25860  
25861  
25862  
25863  
25864  
25865  
25866  
25867  
25868  
25869  
25870  
25871  
25872  
25873  
25874  
25875  
25876  
25877  
25878  
25879  
25880  
25881  
25882  
25883  
25884  
25885  
25886  
25887  
25888  
25889  
25890  
25891  
25892  
25893  
25894  
25895  
25896  
25897  
25898  
25899  
25900  
25901  
25902  
25903  
25904  
25905  
25906  
25907  
25908  
25909  
25910  
25911  
25912  
25913  
25914  
25915  
25916  
25917  
25918  
25919  
25920  
25921  
25922  
25923  
25924  
25925  
25926  
25927  
25928  
25929  
25930  
25931  
25932  
25933  
25934  
25935  
25936  
25937  
25938  
25939  
25940  
25941  
25942  
25943  
25944  
25945  
25946  
25947  
25948  
25949  
25950  
25951  
25952  
25953  
25954  
25955  
25956  
25957  
25958  
25959  
25960  
25961  
25962  
25963  
25964  
25965  
25966  
25967  
25968  
25969  
25970  
25971  
25972  
25973  
25974  
25975  
25976  
25977  
25978  
25979  
25980  
25981  
25982  
25983  
25984  
25985  
25986  
25987  
25988  
25989  
25990  
25991  
25992  
25993  
25994  
25995  
25996  
25997  
25998  
25999  
26000  
26001  
26002  
26003  
26004  
26005  
26006  
26007  
26008  
26009  
26010  
26011  
26012  
26013  
26014  
26015  
26016  
26017  
26018  
26019  
26020  
26021  
26022  
26023  
26024  
26025  
26026  
26027  
26028  
26029  
26030  
26031  
26032  
26033  
26034  
26035  
26036  
26037  
26038  
26039  
26040  
26041  
26042  
26043  
26044  
26045  
26046  
26047  
26048  
26049  
26050  
26051  
26052  
26053  
26054  
26055  
26056  
26057  
26058  
26059  
26060  
26061  
26062  
26063  
26064  
26065  
26066  
26067  
26068  
26069  
26070  
26071  
26072  
26073  
26074  
26075  
26076  
26077  
26078  
26079  
26080  
26081  
26082  
26083  
26084  
26085  
26086  
26087  
26088  
26089  
26090  
26091  
26092  
26093  
26094  
26095  
26096  
26097  
26098  
26099  
26100  
26101  
26102  
26103  
26104  
26105  
26106  
26107  
26108  
26109  
26110  
26111  
26112  
26113  
26114  
26115  
26116  
26117  
26118  
26119  
26120  
26121  
26122  
26123  
26124  
26125  
26126  
26127  
26128  
26129  
26130  
26131  
26132  
26133  
26134  
26135  
26136  
26137  
26138  
26139  
26140  
26141  
26142  
26143  
26144  
26145  
26146  
26147  
26148  
26149  
26150  
26151  
26152  
26153  
26154  
26155  
26156  
26157  
26158  
26159  
26160  
26161  
26162  
26163  
26164  
26165  
26166  
26167  
26168  
26169  
26170  
26171  
26172  
26173  
26174  
26175  
26176  
26177  
26178  
26179  
26180  
26181  
26182  
26183  
26184  
26185  
26186  
26187  
26188  
26189  
26190  
26191  
26192  
26193  
26194  
26195  
26196  
26197  
26198  
26199  
26200  
26201  
26202  
26203  
26204  
26205  
26206  
26207  
26208  
26209  
26210  
26211  
26212  
26213  
26214  
26215  
26216  
26217  
26218  
26219  
26220  
26221  
26222  
26223  
26224  
26225  
26226  
26227  
26228  
26229  
26230  
26231  
26232  
26233  
26234  
26235  
26236  
26237  
26238  
26239  
26240  
26241  
26242  
26243  
26244  
26245  
26246  
26247  
26248  
26249  
26250  
26251  
26252  
26253  
26254  
26255  
26256  
26257  
26258  
26259  
26260  
26261  
26262  
26263  
26264  
26265  
26266  
26267  
26268  
26269  
26270  
26271  
26272  
26273  
26274  
26275  
26276  
26277  
26278  
26279  
26280  
26281  
26282  
26283  
26284  
26285  
26286  
26287  
26288  
26289  
26290  
26291  
26292  
26293  
26294  
26295  
26296  
26297  
26298  
26299  
26300  
26301  
26302  
26303  
26304  
26305  
26306  
26307  
26308  
26309  
26310  
26311  
26312  
26313  
26314  
26315  
26316  
26317  
26318  
26319  
26320  
26321  
26322  
26323  
26324  
26325  
26326  
26327  
26328  
26329  
26330  
26331  
26332  
26333  
26334  
26335  
26336  
26337  
26338  
26339  
26340  
26341  
26342  
26343  
26344  
26345  
26346  
26347  
26348  
26349  
26350  
26351  
26352  
26353  
26354  
26355  
26356  
26357  
26358  
26359  
26360  
26361  
26362  
26363  
26364  
26365  
26366  
26367  
26368  
26369  
26370  
26371  
26372  
26373  
26374  
26375  
26376  
26377  
26378  
26379  
26380  
26381  
26382  
26383  
26384  
26385  
26386  
26387  
26388  
26389  
26390  
26391  
26392  
26393  
26394  
26395  
26396  
26397  
26398  
26399  
26400  
26401  
26402  
26403  
26404  
26405  
26406  
26407  
26408  
26409  
26410  
26411  
26412  
26413  
26414  
26415  
26416  
26417  
26418  
26419  
26420  
26421  
26422  
26423  
26424  
26425  
26426  
26427  
26428  
26429  
26430  
26431  
26432  
26433  
26434  
26435  
26436  
26437  
26438  
26439  
26440  
26441  
26442  
26443  
26444  
26445  
26446  
26447  
26448  
26449  
26450  
26451  
26452  
26453  
26454  
26455  
26456  
26457  
26458  
26459  
26460  
26461  
26462  
26463  
26464  
26465  
26466  
26467  
26468  
26469  
26470  
26471  
26472  
26473  
26474  
26475  
26476  
26477  
26478  
26479  
26480  
26481  
26482  
26483  
26484  
26485  
26486  
26487  
26488  
26489  
26490  
26491  
26492  
26493  
26494  
26495  
26496  
26497  
26498  
26499  
26500  
26501  
26502  
26503  
26504  
26505  
26506  
26507  
26508  
26509  
26510  
26511  
26512  
26513  
26514  
26515  
26516  
26517  
26518  
26519  
26520  
26521  
26522  
26523  
26524  
26525  
26526  
26527  
26528  
26529  
26530  
26531  
26532  
26533  
26534  
26535  
26536  
26537  
26538  
26539  
26540  
26541  
26542  
26543  
26544  
26545  
26546  
26547  
26548  
26549  
26550  
26551  
26552  
26553  
26554  
26555  
26556  
26557  
26558  
26559  
26560  
26561  
26562  
26563  
26564  
26565  
26566  
26567  
26568  
26569  
26570  
26571  
26572  
26573  
26574  
26575  
26576  
26577  
26578  
26579  
26580  
26581  
26582  
26583  
26584  
26585  
26586  
26587  
26588  
26589  
26590  
26591  
26592  
26593  
26594  
26595  
26596  
26597  
26598  
26599  
26600  
26601  
26602  
26603  
26604  
26605  
26606  
26607  
26608  
26609  
26610  
26611  
26612  
26613  
26614  
26615  
26616  
26617  
26618  
26619  
26620  
26621  
26622  
26623  
26624  
26625  
26626  
26627  
26628  
26629  
26630  
26631  
26632  
26633  
26634  
26635  
26636  
26637  
26638  
26639  
26640  
26641  
26642  
26643  
26644  
26645  
26646  
26647  
26648  
26649  
26650  
26651  
26652  
26653  
26654  
26655  
26656  
26657  
26658  
26659  
26660  
26661  
26662  
26663  
26664  
26665  
26666  
26667  
26668  
26669  
26670  
26671  
26672  
26673  
26674  
26675  
26676  
26677  
26678  
26679  
26680  
26681  
26682  
26683  
26684  
26685  
26686  
26687  
26688  
26689  
26690  
26691  
26692  
26693  
26694  
26695  
26696  
26697  
26698  
26699  
26700  
26701  
26702  
26703  
26704  
26705  
26706  
26707  
26708  
26709  
26710  
26711  
26712  
26713  
26714  
26715  
26716  
26717  
26718  
26719  
26720  
26721  
26722  
26723  
26724  
26725  
26726  
26727  
26728  
26729  
26730  
26731  
26732  
26733  
26734  
26735  
26736  
26737  
26738  
26739  
26740  
26741  
26742  
26743  
26744  
26745  
26746  
26747  
26748  
26749  
26750  
26751  
26752  
26753  
26754  
26755  
26756  
26757  
26758  
26759  
26760  
26761  
26762  
26763  
26764  
26765  
26766  
26767  
26768  
26769  
26770  
26771  
26772  
26773  
26774  
26775  
26776  
26777  
26778  
26779  
26780  
26781  
26782  
26783  
26784  
26785  
26786  
26787  
26788  
26789  
26790  
26791  
26792  
26793  
26794  
26795  
26796  
26797  
26798  
26799  
26800  
26801  
26802  
26803  
26804  
26805  
26806  
26807  
26808  
26809  
26810  
26811  
26812  
26813  
26814  
26815  
26816  
26817  
26818  
26819  
26820  
26821  
26822  
26823  
26824  
26825  
26826  
26827  
26828  
26829  
26830  
26831  
26832  
26833  
26834  
26835  
26836  
26837  
26838  
26839  
26840  
26841  
26842  
26843  
26844  
26845  
26846  
26847  
26848  
26849  
26850  
26851  
26852  
26853  
26854  
26855  
26856  
26857  
26858  
26859  
26860  
26861  
26862  
26863  
26864  
26865  
26866  
26867  
26868  
26869  
26870  
26871  
26872  
26873  
26874  
26875  
26876  
26877  
26878  
26879  
26880  
26881  
26882  
26883  
26884  
26885  
26886  
26887  
26888  
26889  
26890  
26891  
26892  
26893  
26894  
26895  
26896  
26897  
26898  
26899  
26900  
26901  
26902  
26903  
26904  
26905  
26906  
26907  
26908  
26909  
26910  
26911  
26912  
26913  
26914  
26915  
26916  
26917  
26918  
26919  
26920  
26921  
26922  
26923  
26924  
26925  
26926  
26927  
26928  
26929  
26930  
26931  
26932  
26933  
26934  
26935  
26936  
26937  
26938  
26939  
26940  
26941  
26942  
26943  
26944  
26945  
26946  
26947  
26948  
26949  
26950  
26951  
26952  
26953  
26954  
26955  
26956  
26957  
26958  
26959  
26960  
26961  
26962  
26963  
26964  
26965  
26966  
26967  
26968  
26969  
26970  
26971  
26972  
26973  
26974  
26975  
26976  
26977  
26978  
26979  
26980  
26981  
26982  
26983  
26984  
26985  
26986  
26987  
26988  
26989  
26990  
26991  
26992  
26993  
26994  
26995  
26996  
26997  
26998  
26999  
27000  
27001  
27002  
27003  
27004  
27005  
27006  
27007  
27008  
27009  
27010  
27011  
27012  
27013  
27014  
27015  
27016  
27017  
27018  
27019  
27020  
27021  
27022  
27023  
27024  
27025  
27026  
27027  
27028  
27029  
27030  
27031  
27032  
27033  
27034  
27035  
27036  
27037  
27038  
27039  
27040  
27041  
27042  
27043  
27044  
27045  
27046  
27047  
27048  
27049  
27050  
27051  
27052  
27053  
27054  
27055  
27056  
27057  
27058  
27059  
27060  
27061  
27062  
27063  
27064  
27065  
27066  
27067  
27068  
27069  
27070  
27071  
27072  
27073  
27074  
27075  
27076  
27077  
27078  
27079  
27080  
27081  
27082  
27083  
27084  
27085  
27086  
27087  
27088  
27089  
27090  
27091  
27092  
27093  
27094  
27095  
27096  
27097  
27098  
27099  
27100  
27101  
27102  
27103  
27104  
27105  
27106  
27107  
27108  
27109  
27110  
27111  
27112  
27113  
27114  
27115  
27116  
27117  
27118  
27119  
27120  
27121  
27122  
27123  
27124  
27125  
27126  
27127  
27128  
27129  
27130  
27131  
27132  
27133  
27134  
27135  
27136  
27137  
27138  
27139  
27140  
27141  
27142  
27143  
27144  
27145  
27146  
27147  
27148  
27149  
27150  
27151  
27152  
27153  
27154  
27155  
27156  
27157  
27158  
27159  
27160  
27161  
27162  
27163  
27164  
27165  
27166  
27167  
27168  
27169  
27170  
27171  
27172  
27173  
27174  
27175  
27176  
27177  
27178  
27179  
27180  
27181  
27182  
27183  
27184  
27185  
27186  
27187  
27188  
27189  
27190  
27191  
27192  
27193  
27194  
27195  
27196  
27197  
27198  
27199  
27200  
27201  
27202  
27203  
27204  
27205  
27206  
27207  
27208  
27209  
27210  
27211  
27212  
27213  
27214  
27215  
27216  
27217  
27218  
27219  
27220  
27221  
27222  
27223  
27224  
27225  
27226  
27227  
27228  
27229  
27230  
27231  
27232  
27233  
27234  
27235  
27236  
27237  
27238  
27239  
27240  
27241  
27242  
27243  
27244  
27245  
27246  
27247  
27248  
27249  
27250  
27251  
27252  
27253  
27254  
27255  
27256  
27257  
27258  
27259  
27260  
27261  
27262  
27263  
27264  
27265  
27266  
27267  
27268  
27269  
27270  
27271  
27272  
27273  
27274  
27275  
27276  
27277  
27278  
27279  
27280  
27281  
27282  
27283  
27284  
27285  
27286  
27287  
27288  
27289  
27290  
27291  
27292  
27293  
27294  
27295  
27296  
27297  
27298  
27299  
27300  
27301  
27302  
27303  
27304  
27305  
27306  
27307  
27308  
27309  
27310  
27311  
27312  
27313  
27314  
27315  
27316  
27317  
27318  
27319  
27320  
27321  
27322  
27323  
27324  
27325  
27326  
27327  
27328  
27329  
27330  
27331  
27332  
27333  
27334  
27335  
27336  
27337  
27338  
27339  
27340  
27341  
27342  
27343  
27344  
27345  
27346  
27347  
27348  
27349  
27350  
27351  
27352  
27353  
27354  
27355  
27356  
27357  
27358  
27359  
27360  
27361  
27362  
27363  
27364  
27365  
27366  
27367  
27368  
27369  
27370  
27371  
27372  
27373  
27374  
27375  
27376  
27377  
27378  
27379  
27380  
27381  
27382  
27383  
27384  
27385  
27386  
27387  
27388  
27389  
27390  
27391  
27392  
27393  
27394  
27395  
27396  
27397  
27398  
27399  
27400  
27401  
27402  
27403  
27404  
27405  
27406  
27407  
27408  
27409  
27410  
27411  
27412  
27413  
27414  
27415  
27416  
27417  
27418  
27419  
27420  
27421  
27422  
27423  
27424  
27425  
27426  
27427  
27428  
27429  
27430  
27431  
27432  
27433  
27434  
27435  
27436  
27437  
27438  
27439  
27440  
27441  
27442  
27443  
27444  
27445  
27446  
27447  
27448  
27449  
27450  
27451  
27452  
27453  
27454  
27455  
27456  
27457  
27458  
27459  
27460  
27461  
27462  
27463  
27464  
27465  
27466  
27467  
27468  
27469  
27470  
27471  
27472  
27473  
27474  
27475  
27476  
27477  
27478  
27479  
27480  
27481  
27482  
27483  
27484  
27485  
27486  
27487  
27488  
27489  
27490  
27491  
27492  
27493  
27494  
27495  
27496  
27497  
27498  
27499  
27500  
27501  
27502  
27503  
27504  
27505  
27506  
27507  
27508  
27509  
27510  
27511  
27512  
27513  
27514  
27515  
27516  
27517  
27518  
27519  
27520  
27521  
27522  
27523  
27524  
27525  
27526  
27527  
27528  
27529  
27530  
27531  
27532  
27533  
27534  
27535  
27536  
27537  
27538  
27539  
27540  
27541  
27542  
27543  
27544  
27545  
27546  
27547  
27548  
27549  
27550  
27551  
27552  
27553  
27554  
27555  
27556  
27557  
27558  
27559  
27560  
27561  
27562  
27563  
27564  
27565  
27566  
27567  
27568  
27569  
27570  
27571  
27572  
27573  
27574  
27575  
27576  
27577  
27578  
27579  
27580  
27581  
27582  
27583  
27584  
27585  
27586  
27587  
27588  
27589  
27590  
27591  
27592  
27593  
27594  
27595  
27596  
27597  
27598  
27599  
27600  
27601  
27602  
27603  
27604  
27605  
27606  
27607  
27608  
27609  
27610  
27611  
27612  
27613  
27614  
27615  
27616  
27617  
27618  
27619  
27620  
27621  
27622  
27623  
27624  
27625  
27626  
27627  
27628  
27629  
27630  
27631  
27632  
27633  
27634  
27635  
27636  
27637  
27638  
27639  
27640  
27641  
27642  
27643  
27644  
27645  
27646  
27647  
27648  
27649  
27650  
27651  
27652  
27653  
27654  
27655  
27656  
27657  
27658  
27659  
27660  
27661  
27662  
27663  
27664  
27665  
27666  
27667  
27668  
27669  
27670  
27671  
27672  
27673  
27674  
27675  
27676  
27677  
27678  
27679  
27680  
27681  
27682  
27683  
27684  
27685  
27686  
27687  
27688  
27689  
27690  
27691  
27692  
27693  
27694  
27695  
27696  
27697  
27698  
27699  
27700  
27701  
27702  
27703  
27704  
27705  
27706  
27707  
27708  
27709  
27710  
27711  
27712  
27713  
27714  
27715  
27716  
27717  
27718  
27719  
27720  
27721  
27722  
27723  
27724  
27725  
27726  
27727  
27728  
27729  
27730  
27731  
27732  
27733  
27734  
27735  
27736  
27737  
27738  
27739  
27740  
27741  
27742  
27743  
27744  
27745  
27746  
27747  
27748  
27749  
27750  
27751  
27752  
27753  
27754  
27755  
27756  
27757  
27758  
27759  
27760  
27761  
27762  
27763  
27764  
27765  
27766  
27767  
27768  
27769  
27770  
27771  
27772  
27773  
27774  
27775  
27776  
27777  
27778  
27779  
27780  
27781  
27782  
27783  
27784  
27785  
27786  
27787  
27788  
27789  
27790  
27791  
27792  
27793  
27794  
27795  
27796  
27797  
27798  
27799  
27800  
27801  
27802  
27803  
27804  
27805  
27806  
27807  
27808  
27809  
27810  
27811  
27812  
27813  
27814  
27815  
27816  
27817  
27818  
27819  
27820  
27821  
27822  
27823  
27824  
27825  
27826  
27827  
27828  
27829  
27830  
27831  
27832  
27833  
27834  
27835  
27836  
27837  
27838  
27839  
27840  
27841  
27842  
27843  
27844  
27845  
27846  
27847  
27848  
27849  
27850  
27851  
27852  
27853  
27854  
27855  
27856  
27857  
27858  
27859  
27860  
27861  
27862  
27863  
27864  
27865  
27866  
27867  
27868  
27869  
27870  
27871  
27872  
27873  
27874  
27875  
27876  
27877  
27878  
27879  
27880  
27881  
27882  
27883  
27884  
27885  
27886  
27887  
27888  
27889  
27890  
27891  
27892  
27893  
27894  
27895  
27896  
27897  
27898  
27899  
27900  
27901  
27902  
27903  
27904  
27905  
27906  
27907  
27908  
27909  
27910  
27911  
27912  
27913  
27914  
27915  
27916  
27917  
27918  
27919  
27920  
27921  
27922  
27923  
27924  
27925  
27926  
27927  
27928  
27929  
27930  
27931  
27932  
27933  
27934  
27935  
27936  
27937  
27938  
27939  
27940  
27941  
27942  
27943  
27944  
27945  
27946  
27947  
27948  
27949  
27950  
27951  
27952  
27953  
27954  
27955  
27956  
27957  
27958  
27959  
27960  
27961  
27962  
27963  
27964  
27965  
27966  
27967  
27968  
27969  
27970  
27971  
27972  
27973  
27974  
27975  
27976  
27977  
27978  
27979  
27980  
27981  
27982  
27983  
27984  
27985  
27986  
27987  
27988  
27989  
27990  
27991  
27992  
27993  
27994  
27995  
27996  
27997  
27998  
27999  
28000  
28001  
28002  
28003  
28004  
28005  
28006  
28007  
28008  
28009  
28010  
28011  
28012  
28013  
28014  
28015  
28016  
28017  
28018  
28019  
28020  
28021  
28022  
28023  
28024  
28025  
28026  
28027  
28028  
28029  
28030  
28031  
28032  
28033  
28034  
28035  
28036  
28037  
28038  
28039  
28040  
28041  
28042  
28043  
28044  
28045  
28046  
28047  
28048  
28049  
28050  
28051  
28052  
28053  
28054  
28055  
28056  
28057  
28058  
28059  
28060  
28061  
28062  
28063  
28064  
28065  
28066  
28067  
28068  
28069  
28070  
28071  
28072  
28073  
28074  
28075  
28076  
28077  
28078  
28079  
28080  
28081  
28082  
28083  
28084  
28085  
28086  
28087  
28088  
28089  
28090  
28091  
28092  
28093  
28094  
28095  
28096  
28097  
28098  
28099  
28100  
28101  
28102  
28103  
28104  
28105  
28106  
28107  
28108  
28109  
28110  
28111  
28112  
28113  
28114  
28115  
28116  
28117  
28118  
28119  
28120  
28121  
28122  
28123  
28124  
28125  
28126  
28127  
28128  
28129  
28130  
28131  
28132  
28133  
28134  
28135  
28136  
28137  
28138  
28139  
28140  
28141  
28142  
28143  
28144  
28145  
28146  
28147  
28148  
28149  
28150  
28151  
28152  
28153  
28154  
28155  
28156  
28157  
28158  
28159  
28160  
28161  
28162  
28163  
28164  
28165  
28166  
28167  
28168  
28169  
28170  
28171  
28172  
28173  
28174  
28175  
28176  
28177  
28178  
28179  
28180  
28181  
28182  
28183  
28184  
28185  
28186  
28187  
28188  
28189  
28190  
28191  
28192  
28193  
28194  
28195  
28196  
28197  
28198  
28199  
28200  
28201  
28202  
28203  
28204  
28205  
28206  
28207  
28208  
28209  
28210  
28211  
28212  
28213  
28214  
28215  
28216  
28217  
28218  
28219  
28220  
28221  
28222  
28223  
28224  
28225  
28226  
28227  
28228  
28229  
28230  
28231  
28232  
28233  
28234  
28235  
28236  
28237  
28238  
28239  
28240  
28241  
28242  
28243  
28244  
28245  
28246  
28247  
28248  
28249  
28250  
28251  
28252  
28253  
28254  
28255  
28256  
28257  
28258  
28259  
28260  
28261  
28262  
28263  
28264  
28265  
28266  
28267  
28268  
28269  
28270  
28271  
28272  
28273  
28274  
28275  
28276  
28277  
28278  
28279  
28280  
28281  
28282  
28283  
28284  
28285  
28286  
28287  
28288  
28289  
28290  
28291  
28292  
28293  
28294  
28295  
28296  
28297  
28298  
28299  
28300  
28301  
28302  
28303  
28304  
28305  
28306  
28307  
28308  
28309  
28310  
28311  
28312  
28313  
28314  
28315  
28316  
28317  
28318  
28319  
28320  
28321  
28322  
28323  
28324  
28325  
28326  
28327  
28328  
28329  
28330  
28331  
28332  
28333  
28334  
28335  
28336  
28337  
28338  
28339  
28340  
28341  
28342  
28343  
28344  
28345  
28346  
28347  
28348  
28349  
28350  
28351  
28352  
28353  
28354  
28355  
28356  
28357  
28358  
28359  
28360  
28361  
28362  
28363  
28364  
28365  
28366  
28367  
28368  
28369  
28370  
28371  
28372  
28373  
28374  
28375  
28376  
28377  
28378  
28379  
28380  
28381  
28382  
28383  
28384  
28385  
28386  
28387  
28388  
28389  
28390  
28391  
28392  
28393  
28394  
28395  
28396  
28397  
28398  
28399  
28400  
28401  
28402  
28403  
28404  
28405  
28406  
28407  
28408  
28409  
28410  
28411  
28412  
28413  
28414  
28415  
28416  
28417  
28418  
28419  
28420  
28421  
28422  
28423  
28424  
28425  
28426  
28427  
28428  
28429  
28430  
28431  
28432  
28433  
28434  
28435  
28436  
28437  
28438  
28439  
28440  
28441  
28442  
28443  
28444  
28445  
28446  
28447  
28448  
28449  
28450  
28451  
28452  
28453  
28454  
28455  
28456  
28457  
28458  
28459  
28460  
28461  
28462  
28463  
28464  
28465  
28466  
28467  
28468  
28469  
28470  
28471  
28472  
28473  
28474  
28475  
28476  
28477  
28478  
28479  
28480  
28481  
28482  
28483  
28484  
28485  
28486  
28487  
28488  
28489  
28490  
28491  
28492  
28493  
28494  
28495  
28496  
28497  
28498  
28499  
28500  
28501  
28502  
28503  
28504  
28505  
28506  
28507  
28508  
28509  
28510  
28511  
28512  
28513  
28514  
28515  
28516  
28517  
28518  
28519  
28520  
28521  
28522  
28523  
28524  
28525  
28526  
28527  
28528  
28529  
28530  
28531  
28532  
28533  
28534  
28535  
28536  
28537  
28538  
28539  
28540  
28541  
28542  
28543  
28544  
28545  
28546  
28547  
28548  
28549  
28550  
28551  

full source  download  show line numbers  debug dex  old transpilations   

Travelled to 16 computer(s): aoiabmzegqzx, bhatertpkbcr, cbybwowwnfue, cfunsshuasjs, gwrvuhgaqvyk, irmadwmeruwu, ishqpsrjomds, lpdgvwnxivlt, mqqgnosmbjvj, onxytkatvevr, pyentgdyhuwx, pzhvpgtvlbxg, tslmcundralx, tvejysmllsmz, vouqrxazstgt, xrpafgyirdlv

No comments. add comment

Snippet ID: #1006722
Snippet name: Transpiler Translator for #759
Eternal ID of this version: #1006722/67
Text MD5: c534105d37b10f0522d3ca2d7e0b5d9c
Transpilation MD5: 5b10ffba539994c102e473b9d5472971
Author: stefan
Category: javax
Type: JavaX translator
Public (visible to everyone): Yes
Archived (hidden from active list): No
Created/modified: 2021-10-06 10:40:12
Source code size: 831515 bytes / 28551 lines
Pitched / IR pitched: No / No
Views / Downloads: 1067 / 9000
Version history: 66 change(s)
Referenced in: [show references]