1 Clazz.load(["java.util.AbstractCollection","$.AbstractMap","$.AbstractSet","$.Iterator","$.MapEntry","$.Set","$.SortedMap"],"java.util.TreeMap",["java.lang.IllegalArgumentException","$.IllegalStateException","java.util.ConcurrentModificationException","$.NoSuchElementException"],function(){
2 c$=Clazz.decorateAsClass(function(){
8 Clazz.instantialize(this,arguments);
9 },java.util,"TreeMap",java.util.AbstractMap,[java.util.SortedMap,Cloneable,java.io.Serializable]);
10 c$.toComparable=Clazz.defineMethod(c$,"toComparable",
13 },$fz.isPrivate=true,$fz),"~O");
14 Clazz.makeConstructor(c$,
16 Clazz.superConstructor(this,java.util.TreeMap,[]);
17 this.$comparator=comparator;
18 },"java.util.Comparator");
19 Clazz.makeConstructor(c$,
24 Clazz.makeConstructor(c$,
26 this.construct(map.comparator());
27 var it=map.entrySet().iterator();
30 var last=new java.util.TreeMap.Entry(entry.getKey(),entry.getValue());
35 var x=new java.util.TreeMap.Entry(entry.getKey(),entry.getValue());
42 }},"java.util.SortedMap");
43 Clazz.defineMethod(c$,"balance",
47 while(x!==this.root&&x.parent.color){
48 if(x.parent===x.parent.parent.left){
49 y=x.parent.parent.right;
53 x.parent.parent.color=true;
56 if(x===x.parent.right){
59 }x.parent.color=false;
60 x.parent.parent.color=true;
61 this.rightRotate(x.parent.parent);
63 y=x.parent.parent.left;
67 x.parent.parent.color=true;
70 if(x===x.parent.left){
73 }x.parent.color=false;
74 x.parent.parent.color=true;
75 this.leftRotate(x.parent.parent);
77 this.root.color=false;
78 },"java.util.TreeMap.Entry");
79 Clazz.overrideMethod(c$,"clear",
85 Clazz.defineMethod(c$,"clone",
88 var clone=Clazz.superCall(this,java.util.TreeMap,"clone",[]);
91 clone.root=this.root.clone(null);
94 if(Clazz.instanceOf(e,CloneNotSupportedException)){
101 Clazz.overrideMethod(c$,"comparator",
103 return this.$comparator;
105 Clazz.overrideMethod(c$,"containsKey",
107 return this.find(key)!=null;
109 Clazz.defineMethod(c$,"containsValue",
112 return this.containsValue(this.root,value);
115 Clazz.defineMethod(c$,"containsValue",
116 ($fz=function(node,value){
117 if(value==null?node.value==null:value.equals(node.value)){
119 }if(node.left!=null){
120 if(this.containsValue(node.left,value)){
122 }}if(node.right!=null){
123 if(this.containsValue(node.right,value)){
126 },$fz.isPrivate=true,$fz),"java.util.TreeMap.Entry,~O");
127 Clazz.overrideMethod(c$,"entrySet",
129 if(this.$entrySet==null){
130 this.$entrySet=((Clazz.isClassDefined("java.util.TreeMap$1")?0:java.util.TreeMap.$TreeMap$1$()),Clazz.innerTypeInstance(java.util.TreeMap$1,this,null));
131 }return this.$entrySet;
133 Clazz.defineMethod(c$,"find",
134 ($fz=function(keyObj){
138 if(this.$comparator==null){
139 object=java.util.TreeMap.toComparable(key);
142 result=object!=null?object.compareTo(x.key):this.$comparator.compare(key,x.key);
145 }x=result<0?x.left:x.right;
148 },$fz.isPrivate=true,$fz),"~O");
149 Clazz.defineMethod(c$,"findAfter",
154 if(this.$comparator==null){
155 object=java.util.TreeMap.toComparable(key);
159 result=object!=null?object.compareTo(x.key):this.$comparator.compare(key,x.key);
170 Clazz.defineMethod(c$,"findBefore",
174 if(this.$comparator==null){
175 object=java.util.TreeMap.toComparable(key);
179 result=object!=null?object.compareTo(x.key):this.$comparator.compare(key,x.key);
188 Clazz.overrideMethod(c$,"firstKey",
191 return java.util.TreeMap.minimum(this.root).key;
192 }throw new java.util.NoSuchElementException();
194 Clazz.defineMethod(c$,"fixup",
197 while(x!==this.root&&!x.color){
198 if(x===x.parent.left){
202 continue;}if(w.color){
205 this.leftRotate(x.parent);
209 continue;}}if((w.left==null||!w.left.color)&&(w.right==null||!w.right.color)){
213 if(w.right==null||!w.right.color){
218 }w.color=x.parent.color;
219 x.parent.color=false;
221 this.leftRotate(x.parent);
227 continue;}if(w.color){
230 this.rightRotate(x.parent);
234 continue;}}if((w.left==null||!w.left.color)&&(w.right==null||!w.right.color)){
238 if(w.left==null||!w.left.color){
243 }w.color=x.parent.color;
244 x.parent.color=false;
246 this.rightRotate(x.parent);
250 },$fz.isPrivate=true,$fz),"java.util.TreeMap.Entry");
251 Clazz.overrideMethod(c$,"get",
253 var node=this.find(key);
258 Clazz.overrideMethod(c$,"headMap",
260 if(this.$comparator==null){
261 java.util.TreeMap.toComparable(endKey).compareTo(endKey);
263 this.$comparator.compare(endKey,endKey);
264 }return new java.util.TreeMap.SubMap(this,endKey);
266 Clazz.overrideMethod(c$,"keySet",
268 if(this.$keySet==null){
269 this.$keySet=((Clazz.isClassDefined("java.util.TreeMap$2")?0:java.util.TreeMap.$TreeMap$2$()),Clazz.innerTypeInstance(java.util.TreeMap$2,this,null));
270 }return this.$keySet;
272 Clazz.overrideMethod(c$,"lastKey",
275 return java.util.TreeMap.maximum(this.root).key;
276 }throw new java.util.NoSuchElementException();
278 Clazz.defineMethod(c$,"leftRotate",
288 if(x===x.parent.left){
294 },$fz.isPrivate=true,$fz),"java.util.TreeMap.Entry");
295 c$.maximum=Clazz.defineMethod(c$,"maximum",
297 while(x.right!=null){
301 },"java.util.TreeMap.Entry");
302 c$.minimum=Clazz.defineMethod(c$,"minimum",
308 },"java.util.TreeMap.Entry");
309 c$.predecessor=Clazz.defineMethod(c$,"predecessor",
312 return java.util.TreeMap.maximum(x.left);
314 while(y!=null&&x===y.left){
319 },"java.util.TreeMap.Entry");
320 Clazz.overrideMethod(c$,"put",
322 var entry=this.rbInsert(key);
323 var result=entry.value;
327 Clazz.defineMethod(c$,"rbDelete",
329 var y=z.left==null||z.right==null?z:java.util.TreeMap.successor(z);
330 var x=y.left!=null?y.left:y.right;
335 }else if(y===y.parent.left){
343 }if(!y.color&&this.root!=null){
345 this.fixup(y.parent);
349 },"java.util.TreeMap.Entry");
350 Clazz.defineMethod(c$,"rbInsert",
351 ($fz=function(object){
356 if(this.$comparator==null){
357 key=java.util.TreeMap.toComparable(object);
361 result=key!=null?key.compareTo(x.key):this.$comparator.compare(object,x.key);
364 }x=result<0?x.left:x.right;
368 var z=new java.util.TreeMap.Entry(object);
378 },$fz.isPrivate=true,$fz),"~O");
379 Clazz.overrideMethod(c$,"remove",
381 var node=this.find(key);
384 }var result=node.value;
388 Clazz.defineMethod(c$,"rightRotate",
398 if(x===x.parent.right){
404 },$fz.isPrivate=true,$fz),"java.util.TreeMap.Entry");
405 Clazz.overrideMethod(c$,"size",
409 Clazz.overrideMethod(c$,"subMap",
410 function(startKey,endKey){
411 if(this.$comparator==null){
412 if(java.util.TreeMap.toComparable(startKey).compareTo(endKey)<=0){
413 return new java.util.TreeMap.SubMap(startKey,this,endKey);
415 if(this.$comparator.compare(startKey,endKey)<=0){
416 return new java.util.TreeMap.SubMap(startKey,this,endKey);
417 }}throw new IllegalArgumentException();
419 c$.successor=Clazz.defineMethod(c$,"successor",
422 return java.util.TreeMap.minimum(x.right);
424 while(y!=null&&x===y.right){
429 },"java.util.TreeMap.Entry");
430 Clazz.overrideMethod(c$,"tailMap",
432 if(this.$comparator==null){
433 java.util.TreeMap.toComparable(startKey).compareTo(startKey);
435 this.$comparator.compare(startKey,startKey);
436 }return new java.util.TreeMap.SubMap(startKey,this);
438 Clazz.overrideMethod(c$,"values",
440 if(this.valuesCollection==null){
441 this.valuesCollection=((Clazz.isClassDefined("java.util.TreeMap$3")?0:java.util.TreeMap.$TreeMap$3$()),Clazz.innerTypeInstance(java.util.TreeMap$3,this,null));
442 }return this.valuesCollection;
444 c$.$TreeMap$1$=function(){
446 c$=Clazz.declareAnonymous(java.util,"TreeMap$1",java.util.AbstractSet);
447 Clazz.overrideMethod(c$,"size",
449 return this.b$["java.util.TreeMap"].$size;
451 Clazz.overrideMethod(c$,"clear",
453 this.b$["java.util.TreeMap"].clear();
455 Clazz.overrideMethod(c$,"contains",
457 if(Clazz.instanceOf(object,java.util.Map.Entry)){
459 var v1=this.b$["java.util.TreeMap"].get(entry.getKey());
460 var v2=entry.getValue();
461 return v1==null?v2==null:v1.equals(v2);
464 Clazz.defineMethod(c$,"iterator",
466 return new java.util.TreeMap.UnboundedEntryIterator(this.b$["java.util.TreeMap"]);
470 c$.$TreeMap$2$=function(){
472 c$=Clazz.declareAnonymous(java.util,"TreeMap$2",java.util.AbstractSet);
473 Clazz.overrideMethod(c$,"contains",
475 return this.b$["java.util.TreeMap"].containsKey(object);
477 Clazz.overrideMethod(c$,"size",
479 return this.b$["java.util.TreeMap"].$size;
481 Clazz.overrideMethod(c$,"clear",
483 this.b$["java.util.TreeMap"].clear();
485 Clazz.overrideMethod(c$,"iterator",
487 return new java.util.TreeMap.UnboundedKeyIterator(this.b$["java.util.TreeMap"]);
491 c$.$TreeMap$3$=function(){
493 c$=Clazz.declareAnonymous(java.util,"TreeMap$3",java.util.AbstractCollection);
494 Clazz.overrideMethod(c$,"contains",
496 return this.b$["java.util.TreeMap"].containsValue(object);
498 Clazz.overrideMethod(c$,"size",
500 return this.b$["java.util.TreeMap"].$size;
502 Clazz.overrideMethod(c$,"clear",
504 this.b$["java.util.TreeMap"].clear();
506 Clazz.overrideMethod(c$,"iterator",
508 return new java.util.TreeMap.UnboundedValueIterator(this.b$["java.util.TreeMap"]);
513 c$=Clazz.decorateAsClass(function(){
518 Clazz.instantialize(this,arguments);
519 },java.util.TreeMap,"Entry",java.util.MapEntry);
520 Clazz.defineMethod(c$,"clone",
522 var b=Clazz.superCall(this,java.util.TreeMap.Entry,"clone",[]);
525 b.left=this.left.clone(b);
526 }if(this.right!=null){
527 b.right=this.right.clone(b);
529 },"java.util.TreeMap.Entry");
532 c$=Clazz.decorateAsClass(function(){
533 this.backingMap=null;
534 this.expectedModCount=0;
537 Clazz.instantialize(this,arguments);
538 },java.util.TreeMap,"AbstractMapIterator");
539 Clazz.makeConstructor(c$,
542 this.expectedModCount=a.modCount;
544 },"java.util.TreeMap,java.util.TreeMap.Entry");
545 Clazz.defineMethod(c$,"hasNext",
547 return this.node!=null;
549 Clazz.defineMethod(c$,"remove",
551 if(this.expectedModCount==this.backingMap.modCount){
552 if(this.lastNode!=null){
553 this.backingMap.rbDelete(this.lastNode);
555 this.expectedModCount++;
557 throw new IllegalStateException();
559 throw new java.util.ConcurrentModificationException();
561 Clazz.defineMethod(c$,"makeNext",
563 if(this.expectedModCount!=this.backingMap.modCount){
564 throw new java.util.ConcurrentModificationException();
565 }else if(this.node==null){
566 throw new java.util.NoSuchElementException();
567 }this.lastNode=this.node;
568 this.node=java.util.TreeMap.successor(this.node);
572 c$=Clazz.declareType(java.util.TreeMap,"UnboundedEntryIterator",java.util.TreeMap.AbstractMapIterator,java.util.Iterator);
573 Clazz.makeConstructor(c$,
575 Clazz.superConstructor(this,java.util.TreeMap.UnboundedEntryIterator,[a,a.root==null?null:java.util.TreeMap.minimum(a.root)]);
576 },"java.util.TreeMap");
577 Clazz.overrideMethod(c$,"next",
580 return this.lastNode;
584 c$=Clazz.declareType(java.util.TreeMap,"UnboundedKeyIterator",java.util.TreeMap.AbstractMapIterator,java.util.Iterator);
585 Clazz.makeConstructor(c$,
587 Clazz.superConstructor(this,java.util.TreeMap.UnboundedKeyIterator,[a,a.root==null?null:java.util.TreeMap.minimum(a.root)]);
588 },"java.util.TreeMap");
589 Clazz.overrideMethod(c$,"next",
592 return this.lastNode.key;
596 c$=Clazz.declareType(java.util.TreeMap,"UnboundedValueIterator",java.util.TreeMap.AbstractMapIterator,java.util.Iterator);
597 Clazz.makeConstructor(c$,
599 Clazz.superConstructor(this,java.util.TreeMap.UnboundedValueIterator,[a,a.root==null?null:java.util.TreeMap.minimum(a.root)]);
600 },"java.util.TreeMap");
601 Clazz.overrideMethod(c$,"next",
604 return this.lastNode.value;
608 c$=Clazz.decorateAsClass(function(){
611 Clazz.instantialize(this,arguments);
612 },java.util.TreeMap,"ComparatorBoundedIterator",java.util.TreeMap.AbstractMapIterator);
613 Clazz.makeConstructor(c$,
615 Clazz.superConstructor(this,java.util.TreeMap.ComparatorBoundedIterator,[a,b]);
617 this.cmp=a.comparator();
618 },"java.util.TreeMap,java.util.TreeMap.Entry,~O");
619 Clazz.defineMethod(c$,"cleanNext",
621 if(this.node!=null&&this.cmp.compare(this.endKey,this.node.key)<=0){
624 Clazz.overrideMethod(c$,"hasNext",
626 return(this.node!=null&&this.endKey!=null)&&(this.cmp.compare(this.node.key,this.endKey)<0);
630 c$=Clazz.declareType(java.util.TreeMap,"ComparatorBoundedEntryIterator",java.util.TreeMap.ComparatorBoundedIterator,java.util.Iterator);
631 Clazz.overrideMethod(c$,"next",
635 return this.lastNode;
639 c$=Clazz.declareType(java.util.TreeMap,"ComparatorBoundedKeyIterator",java.util.TreeMap.ComparatorBoundedIterator,java.util.Iterator);
640 Clazz.overrideMethod(c$,"next",
644 return this.lastNode.key;
648 c$=Clazz.declareType(java.util.TreeMap,"ComparatorBoundedValueIterator",java.util.TreeMap.ComparatorBoundedIterator,java.util.Iterator);
649 Clazz.overrideMethod(c$,"next",
653 return this.lastNode.value;
657 c$=Clazz.decorateAsClass(function(){
659 Clazz.instantialize(this,arguments);
660 },java.util.TreeMap,"ComparableBoundedIterator",java.util.TreeMap.AbstractMapIterator);
661 Clazz.makeConstructor(c$,
663 Clazz.superConstructor(this,java.util.TreeMap.ComparableBoundedIterator,[a,b]);
665 },"java.util.TreeMap,java.util.TreeMap.Entry,Comparable");
666 Clazz.defineMethod(c$,"cleanNext",
668 if((this.node!=null)&&(this.endKey.compareTo(this.node.key)<=0)){
671 Clazz.overrideMethod(c$,"hasNext",
673 return(this.node!=null)&&(this.endKey.compareTo(this.node.key)>0);
677 c$=Clazz.declareType(java.util.TreeMap,"ComparableBoundedEntryIterator",java.util.TreeMap.ComparableBoundedIterator,java.util.Iterator);
678 Clazz.overrideMethod(c$,"next",
682 return this.lastNode;
686 c$=Clazz.declareType(java.util.TreeMap,"ComparableBoundedKeyIterator",java.util.TreeMap.ComparableBoundedIterator,java.util.Iterator);
687 Clazz.overrideMethod(c$,"next",
691 return this.lastNode.key;
695 c$=Clazz.declareType(java.util.TreeMap,"ComparableBoundedValueIterator",java.util.TreeMap.ComparableBoundedIterator,java.util.Iterator);
696 Clazz.overrideMethod(c$,"next",
700 return this.lastNode.value;
704 c$=Clazz.decorateAsClass(function(){
705 this.backingMap=null;
711 Clazz.instantialize(this,arguments);
712 },java.util.TreeMap,"SubMap",java.util.AbstractMap,[java.util.SortedMap,java.io.Serializable]);
713 Clazz.makeConstructor(c$,
715 Clazz.superConstructor(this,java.util.TreeMap.SubMap,[]);
719 },"~O,java.util.TreeMap");
720 Clazz.makeConstructor(c$,
722 Clazz.superConstructor(this,java.util.TreeMap.SubMap,[]);
724 this.hasStart=this.hasEnd=true;
727 },"~O,java.util.TreeMap,~O");
728 Clazz.makeConstructor(c$,
730 Clazz.superConstructor(this,java.util.TreeMap.SubMap,[]);
734 },"java.util.TreeMap,~O");
735 Clazz.overrideMethod(c$,"comparator",
737 return this.backingMap.comparator();
739 Clazz.overrideMethod(c$,"containsKey",
741 if(this.isInRange(a)){
742 return this.backingMap.containsKey(a);
745 Clazz.overrideMethod(c$,"entrySet",
747 if(this.$entrySet==null){
748 this.$entrySet=new java.util.TreeMap.SubMapEntrySet(this);
749 }return this.$entrySet;
751 Clazz.overrideMethod(c$,"firstKey",
753 var a=this.firstEntry();
756 }throw new java.util.NoSuchElementException();
758 Clazz.defineMethod(c$,"firstEntry",
761 var a=this.backingMap.root;
762 return(a==null)?null:java.util.TreeMap.minimum(this.backingMap.root);
763 }var a=this.backingMap.findAfter(this.startKey);
764 if(a!=null&&this.checkUpperBound(a.key)){
768 Clazz.overrideMethod(c$,"get",
770 if(this.isInRange(a)){
771 return this.backingMap.get(a);
774 Clazz.overrideMethod(c$,"headMap",
778 return new java.util.TreeMap.SubMap(this.startKey,this.backingMap,a);
779 }return new java.util.TreeMap.SubMap(this.backingMap,a);
781 Clazz.overrideMethod(c$,"isEmpty",
784 var a=this.backingMap.findAfter(this.startKey);
785 return a==null||!this.checkUpperBound(a.key);
786 }return this.backingMap.findBefore(this.endKey)==null;
788 Clazz.overrideMethod(c$,"keySet",
790 if(this.$keySet==null){
791 this.$keySet=new java.util.TreeMap.SubMapKeySet(this);
792 }return this.$keySet;
794 Clazz.overrideMethod(c$,"lastKey",
797 return this.backingMap.lastKey();
798 }var a=this.backingMap.findBefore(this.endKey);
799 if(a!=null&&this.checkLowerBound(a.key)){
801 }throw new java.util.NoSuchElementException();
803 Clazz.overrideMethod(c$,"put",
805 if(this.isInRange(a)){
806 return this.backingMap.put(a,b);
807 }throw new IllegalArgumentException();
809 Clazz.overrideMethod(c$,"remove",
811 if(this.isInRange(a)){
812 return this.backingMap.remove(a);
815 Clazz.overrideMethod(c$,"subMap",
819 var c=this.backingMap.comparator();
821 if(java.util.TreeMap.toComparable(a).compareTo(b)<=0){
822 return new java.util.TreeMap.SubMap(a,this.backingMap,b);
824 if(c.compare(a,b)<=0){
825 return new java.util.TreeMap.SubMap(a,this.backingMap,b);
826 }}throw new IllegalArgumentException();
828 Clazz.overrideMethod(c$,"tailMap",
832 return new java.util.TreeMap.SubMap(a,this.backingMap,this.endKey);
833 }return new java.util.TreeMap.SubMap(a,this.backingMap);
835 Clazz.overrideMethod(c$,"values",
837 if(this.valuesCollection==null){
838 this.valuesCollection=new java.util.TreeMap.SubMapValuesCollection(this);
839 }return this.valuesCollection;
843 c$=Clazz.decorateAsClass(function(){
845 Clazz.instantialize(this,arguments);
846 },java.util.TreeMap,"SubMapEntrySet",java.util.AbstractSet,java.util.Set);
847 Clazz.makeConstructor(c$,
849 Clazz.superConstructor(this,java.util.TreeMap.SubMapEntrySet,[]);
851 },"java.util.TreeMap.SubMap");
852 Clazz.overrideMethod(c$,"isEmpty",
854 return this.subMap.isEmpty();
856 Clazz.overrideMethod(c$,"iterator",
858 var a=this.subMap.firstEntry();
859 if(this.subMap.hasEnd){
860 var b=this.subMap.comparator();
862 return new java.util.TreeMap.ComparableBoundedEntryIterator(this.subMap.backingMap,a,java.util.TreeMap.toComparable(this.subMap.endKey));
863 }return new java.util.TreeMap.ComparatorBoundedEntryIterator(this.subMap.backingMap,a,this.subMap.endKey);
864 }return new java.util.TreeMap.UnboundedEntryIterator(this.subMap.backingMap,a);
866 Clazz.overrideMethod(c$,"size",
869 var b=this.iterator();
876 Clazz.overrideMethod(c$,"contains",
878 if(Clazz.instanceOf(a,java.util.Map.Entry)){
881 if(this.subMap.isInRange(c)){
882 var d=this.subMap.get(c);
884 return d==null?e==null:d.equals(e);
889 c$=Clazz.decorateAsClass(function(){
891 Clazz.instantialize(this,arguments);
892 },java.util.TreeMap,"SubMapKeySet",java.util.AbstractSet,java.util.Set);
893 Clazz.makeConstructor(c$,
895 Clazz.superConstructor(this,java.util.TreeMap.SubMapKeySet,[]);
897 },"java.util.TreeMap.SubMap");
898 Clazz.overrideMethod(c$,"contains",
900 return this.subMap.containsKey(a);
902 Clazz.overrideMethod(c$,"isEmpty",
904 return this.subMap.isEmpty();
906 Clazz.overrideMethod(c$,"size",
909 var b=this.iterator();
916 Clazz.overrideMethod(c$,"iterator",
918 var a=this.subMap.firstEntry();
919 if(this.subMap.hasEnd){
920 var b=this.subMap.comparator();
922 return new java.util.TreeMap.ComparableBoundedKeyIterator(this.subMap.backingMap,a,java.util.TreeMap.toComparable(this.subMap.endKey));
923 }return new java.util.TreeMap.ComparatorBoundedKeyIterator(this.subMap.backingMap,a,this.subMap.endKey);
924 }return new java.util.TreeMap.UnboundedKeyIterator(this.subMap.backingMap,a);
928 c$=Clazz.decorateAsClass(function(){
930 Clazz.instantialize(this,arguments);
931 },java.util.TreeMap,"SubMapValuesCollection",java.util.AbstractCollection);
932 Clazz.makeConstructor(c$,
934 Clazz.superConstructor(this,java.util.TreeMap.SubMapValuesCollection,[]);
936 },"java.util.TreeMap.SubMap");
937 Clazz.overrideMethod(c$,"isEmpty",
939 return this.subMap.isEmpty();
941 Clazz.overrideMethod(c$,"iterator",
943 var a=this.subMap.firstEntry();
944 if(this.subMap.hasEnd){
945 var b=this.subMap.comparator();
947 return new java.util.TreeMap.ComparableBoundedValueIterator(this.subMap.backingMap,a,java.util.TreeMap.toComparable(this.subMap.endKey));
948 }return new java.util.TreeMap.ComparatorBoundedValueIterator(this.subMap.backingMap,a,this.subMap.endKey);
949 }return new java.util.TreeMap.UnboundedValueIterator(this.subMap.backingMap,a);
951 Clazz.overrideMethod(c$,"size",
954 for(var b=this.iterator();b.hasNext();){