anchor.diff:      StringBuilder prepend([$dart$core.String string]) {
           $dart$core.String newString = string + this.toString();
           clear();
  -        _$delegate.write(String.instance(newString));
  +        _$delegate.write($ceylonString(newString));
           return this;
       }
       StringBuilder prependAll([Iterable strings]) {{
  
positive.code: 
  void dartListCopyTo([List val, Array destination, $dart$core.Object sourcePosition = $package$dart$default, $dart$core.Object destinationPosition = $package$dart$default, $dart$core.Object length = $package$dart$default]) => $package$dartListCopyTo(val, destination, sourcePosition, destinationPosition, length);
  
  $dart$core.String $package$dartStringJoin([$dart$core.String val, Iterable objects]) {
      $dart$core.String result = "";
      $dart$core.bool first = true;
      {
          $dart$core.Object element$4;
          Iterator iterator$3 = objects.iterator();
          while ((element$4 = iterator$3.next()) is !Finished) {
              $dart$core.Object el;
              {
                  el = element$4;
              }
              if (first) {
                  first = false;
              } else {
                  result = result + val;
              }
              result = result + el.toString();
          }
      }
      return result;
  }
  
  $dart$core.String dartStringJoin([$dart$core.String val, Iterable objects]) => $package$dartStringJoin(val, objects);
  
  Iterable $package$dartStringLines([$dart$core.String val]) => String.instance(val).split((() {
      Character $r = new Character.$fromInt(10);
      return new dart$Callable(([$dart$core.Object $0]) => $ceylonBoolean($r == $0));
  })(), true, false).map(new dart$Callable(([String s]) => s.trimTrailing((() {
      Character $r = new Character.$fromInt(13);
      return new dart$Callable(([$dart$core.Object $0]) => $ceylonBoolean($r == $0));
  })())));
  
  Iterable dartStringLines([$dart$core.String val]) => $package$dartStringLines(val);
  
  Iterable $package$dartStringLinesWithBreaks([$dart$core.String val]) => String.instance(val).split((() {
      Character $r = new Character.$fromInt(10);
      return new dart$Callable(([$dart$core.Object $0]) => $ceylonBoolean($r == $0));
  })(), false, false).partition(2).map(new dart$Callable(([Sequence lineWithBreak]) => (() {
      $dart$core.String line;
      {
          line = String.nativeValue(lineWithBreak.getFromFirst(0) as String);
      }
      $dart$core.String br;
      {
          br = String.nativeValue(lineWithBreak.getFromFirst(1) as String);
      }
      return (() {
          $dart$core.bool doElse$5 = true;
          if (!(null == br)) {
              doElse$5 = false;
              return String.instance(line + br);
          }
          if (doElse$5) {
              $dart$core.Object br$6;
              br$6 = String.instance(br);
              return String.instance(line);
          }
      })();
  })()));
  
  Iterable dartStringLinesWithBreaks([$dart$core.String val]) => $package$dartStringLinesWithBreaks(val);
  
  class dartStringSplit$$anonymous$2_$iterator$$anonymous$3_ implements dart$$Basic, Iterator {
      dartStringSplit$$anonymous$2_ $outer$ceylon$language$dartStringSplit$$anonymous$2_;
      dartStringSplit$$anonymous$2_$iterator$$anonymous$3_([dartStringSplit$$anonymous$2_ $outer$ceylon$language$dartStringSplit$$anonymous$2_]) {
          this.$outer$ceylon$language$dartStringSplit$$anonymous$2_ = $outer$ceylon$language$dartStringSplit$$anonymous$2_;
          _$seq = String.instance($outer$ceylon$language$dartStringSplit$$anonymous$2_.$capture$dartStringSplit$val).sequence();
          _$it = _$seq.iterator();
          _$index = 0;
          _$first = true;
          _$lastWasSeparator = false;
          _$peeked = false;
          _$peekedWasSeparator = false;
          _$eof = false;
          _$peekSeparator();
      }
      Sequential _$seq;
      Iterator _$it;
      $dart$core.int _$index;
      $dart$core.bool _$first;
      $dart$core.bool _$lastWasSeparator;
      $dart$core.bool _$peeked;
      $dart$core.bool _$peekedWasSeparator;
      $dart$core.bool _$eof;
      $dart$core.bool _$peekSeparator() {
          if (!_$peeked) {
              _$peeked = true;
              {
                  $dart$core.bool doElse$7 = true;
                  {
                      $dart$core.Object next$8 = _$it.next();
                      if (!(next$8 is Finished)) {
                          Character next;
                          next = next$8 as Character;
                          doElse$7 = false;
                          _$peekedWasSeparator = $dartBool(($outer$ceylon$language$dartStringSplit$$anonymous$2_.$capture$dartStringSplit$splitting as Callable).f(next) as Boolean);
                      }
                  }
                  if (doElse$7) {
                      _$eof = true;
                      _$peekedWasSeparator = false;
                  }
              }
          }
          return _$peekedWasSeparator;
      }
      void _$eatChar() {
          _$peeked = false;
          _$peekSeparator();
          _$index = $dartInt($ceylonInteger(_$index).successor);
      }
      $dart$core.bool _$eatSeparator() {
          $dart$core.bool result = _$peekSeparator();
          if (result) {
              _$eatChar();
          }
          return result;
      }
      $dart$core.String _$substring([$dart$core.int start, $dart$core.int end]) => String.nativeValue(new String(_$seq.measure($ceylonInteger(start), end - start) as Iterable));
      $dart$core.Object next() {
          if (!_$eof) {
              $dart$core.int start = _$index;
              if (((_$first && (start == 0)) || _$lastWasSeparator) && _$peekSeparator()) {
                  _$first = false;
                  _$lastWasSeparator = false;
                  return String.instance("");
              }
              if (_$eatSeparator()) {
                  if ($outer$ceylon$language$dartStringSplit$$anonymous$2_.$capture$dartStringSplit$groupSeparators as $dart$core.bool) {
                      while (_$eatSeparator()) {}
                  }
                  if (!($outer$ceylon$language$dartStringSplit$$anonymous$2_.$capture$dartStringSplit$discardSeparators as $dart$core.bool)) {
                      _$lastWasSeparator = true;
                      return String.instance(_$substring(start, _$index));
                  }
                  start = _$index;
              }
              while ((!_$eof) && (!_$peekSeparator())) {
                  _$eatChar();
              }
              _$lastWasSeparator = false;
              return String.instance(_$substring(start, _$index));
          } else if (_$lastWasSeparator) {
              _$lastWasSeparator = false;
              return String.instance("");
          } else {
              return $package$finished;
          }
      }
  }
  class dartStringSplit$$anonymous$2_ implements dart$$Basic, Iterable {
      $dart$core.String $capture$dartStringSplit$val;
      Callable $capture$dartStringSplit$splitting;
      $dart$core.Object $capture$dartStringSplit$groupSeparators;
      $dart$core.Object $capture$dartStringSplit$discardSeparators;
      dartStringSplit$$anonymous$2_([$dart$core.String $capture$dartStringSplit$val, Callable $capture$dartStringSplit$splitting, $dart$core.Object $capture$dartStringSplit$groupSeparators, $dart$core.Object $capture$dartStringSplit$discardSeparators]) {
          this.$capture$dartStringSplit$val = $capture$dartStringSplit$val;
          this.$capture$dartStringSplit$splitting = $capture$dartStringSplit$splitting;
          this.$capture$dartStringSplit$groupSeparators = $capture$dartStringSplit$groupSeparators;
          this.$capture$dartStringSplit$discardSeparators = $capture$dartStringSplit$discardSeparators;
      }
      Iterator iterator() => new dartStringSplit$$anonymous$2_$iterator$$anonymous$3_(this);
      $dart$core.String toString() => Iterable.$get$string(this);
      $dart$core.bool contains([$dart$core.Object element]) => Iterable.$contains(this, element);
      $dart$core.bool get empty => Iterable.$get$empty(this);
      $dart$core.int get size => Iterable.$get$size(this);
      $dart$core.bool longerThan([$dart$core.int length]) => Iterable.$longerThan(this, length);
      $dart$core.bool shorterThan([$dart$core.int length]) => Iterable.$shorterThan(this, length);
      $dart$core.Object get first => Iterable.$get$first(this);
      $dart$core.Object get last => Iterable.$get$last(this);
      $dart$core.Object getFromFirst([$dart$core.int index]) => Iterable.$getFromFirst(this, index);
      Sequential sequence() => Iterable.$sequence(this);
      $dart$core.Object indexes() => Iterable.$indexes(this);
      Iterable get rest => Iterable.$get$rest(this);
      Iterable get exceptLast => Iterable.$get$exceptLast(this);
      void each([Callable step]) => Iterable.$each(this, step);
      Iterable map([Callable collecting]) => Iterable.$map(this, collecting);
      Iterable flatMap([Callable collecting]) => Iterable.$flatMap(this, collecting);
      Iterable filter([Callable selecting]) => Iterable.$filter(this, selecting);
      Iterable narrow() => Iterable.$narrow(this);
      Callable fold([$dart$core.Object initial]) => Iterable.$fold(this, initial);
      $dart$core.Object reduce([Callable accumulating]) => Iterable.$reduce(this, accumulating);
      Callable scan([$dart$core.Object initial]) => Iterable.$scan(this, initial);
      $dart$core.Object find([Callable selecting]) => Iterable.$find(this, selecting);
      $dart$core.Object findLast([Callable selecting]) => Iterable.$findLast(this, selecting);
      Entry locate([Callable selecting]) => Iterable.$locate(this, selecting);
      Entry locateLast([Callable selecting]) => Iterable.$locateLast(this, selecting);
      Iterable locations([Callable selecting]) => Iterable.$locations(this, selecting);
      $dart$core.Object max([Callable comparing]) => Iterable.$max(this, comparing);
      Callable spread([Callable method]) => Iterable.$spread(this, method);
      Sequential sort([Callable comparing]) => Iterable.$sort(this, comparing);
      Sequential collect([Callable collecting]) => Iterable.$collect(this, collecting);
      Sequential select([Callable selecting]) => Iterable.$select(this, selecting);
      $dart$core.int count([Callable selecting]) => Iterable.$count(this, selecting);
      $dart$core.bool any([Callable selecting]) => Iterable.$any(this, selecting);
      $dart$core.bool every([Callable selecting]) => Iterable.$every(this, selecting);
      Iterable skip([$dart$core.int skipping]) => Iterable.$skip(this, skipping);
      Iterable take([$dart$core.int taking]) => Iterable.$take(this, taking);
      Iterable skipWhile([Callable skipping]) => Iterable.$skipWhile(this, skipping);
      Iterable takeWhile([Callable taking]) => Iterable.$takeWhile(this, taking);
      Iterable repeat([$dart$core.int times]) => Iterable.$repeat(this, times);
      Iterable by([$dart$core.int step]) => Iterable.$by(this, step);
      Iterable defaultNullElements([$dart$core.Object defaultValue]) => Iterable.$defaultNullElements(this, defaultValue);
      Iterable get coalesced => Iterable.$get$coalesced(this);
      Iterable get indexed => Iterable.$get$indexed(this);
      Iterable get paired => Iterable.$get$paired(this);
      Iterable partition([$dart$core.int length]) => Iterable.$partition(this, length);
      Iterable follow([$dart$core.Object head]) => Iterable.$follow(this, head);
      Iterable chain([Iterable other]) => Iterable.$chain(this, other);
      Iterable product([Iterable other]) => Iterable.$product(this, other);
      Iterable get cycled => Iterable.$get$cycled(this);
      Iterable interpose([$dart$core.Object element, $dart$core.Object step = $package$dart$default]) => Iterable.$interpose(this, element, step);
      Iterable get distinct => Iterable.$get$distinct(this);
      Map frequencies() => Iterable.$frequencies(this);
      Map tabulate([Callable collecting]) => Iterable.$tabulate(this, collecting);
      Map group([Callable grouping]) => Iterable.$group(this, grouping);
      Map summarize([Callable grouping, Callable accumulating]) => Iterable.$summarize(this, grouping, accumulating);
      $dart$core.bool containsEvery([Iterable elements]) => Category.$containsEvery(this, elements);
      $dart$core.bool containsAny([Iterable elements]) => Category.$containsAny(this, elements);
  }
  Iterable $package$dartStringSplit([$dart$core.String val, $dart$core.Object splitting = $package$dart$default, $dart$core.Object discardSeparators = $package$dart$default, $dart$core.Object groupSeparators = $package$dart$default]) {
      if ($dart$core.identical(splitting, $package$dart$default)) {
          splitting = new dart$Callable(([Character ch]) => $ceylonBoolean(ch.whitespace));
      }
      if ($dart$core.identical(discardSeparators, $package$dart$default)) {
          discardSeparators = true;
      }
      if ($dart$core.identical(groupSeparators, $package$dart$default)) {
          groupSeparators = true;
      }
      return String.instance(val).empty ? new Singleton(String.instance(val)) : new dartStringSplit$$anonymous$2_(val, splitting, groupSeparators, discardSeparators);
  }
  
  Iterable dartStringSplit([$dart$core.String val, $dart$core.Object splitting = $package$dart$default, $dart$core.Object discardSeparators = $package$dart$default, $dart$core.Object groupSeparators = $package$dart$default]) => $package$dartStringSplit(val, splitting, discardSeparators, groupSeparators);
  
  class DartStringIterator implements dart$$Basic, Iterator {
      DartStringIterator([$dart$core.String _$s]) {
          this._$s = _$s;
          _$dString = $ceylon$interop$dart.dartString(this._$s);
          _$runeIterator = _$dString.runes.iterator;
      }
      $dart$core.String _$s;
      $dart$core.String _$dString;
      $dart$core.RuneIterator _$runeIterator;
      $dart$core.Object next() => _$runeIterator.moveNext() ? $package$characterFromInteger(_$runeIterator.current) : $package$finished;
  }
  abstract class Destroyable implements Usable {
      void destroy([Throwable error]);
  }
  
negative.code: abstract class Resource {
      $dart$core.String get name;
      static $dart$core.String $get$name([final Resource $this]) {
          $dart$core.int pos = $ceylonString($this.uri).lastOccurrence(new Character.$fromInt(47));
          if (!(null == pos)) {
              return $dartString($ceylonString($this.uri).spanFrom($ceylonInteger(pos + 1)));
          }
          return $this.uri;
      }
  