import com.google.common.collect.Iterators;
import com.google.common.collect.Maps;
import com.google.common.collect.Maps.d;
import com.google.common.collect.Maps.f;
import com.google.common.collect.Maps.q;
import java.util.AbstractMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.SortedMap;
import javax.annotation.Nullable;

public abstract class mz<K, V>
  extends AbstractMap<K, V>
  implements NavigableMap<K, V>
{
  public abstract Iterator<Map.Entry<K, V>> a();
  
  public abstract Iterator<Map.Entry<K, V>> b();
  
  @Nullable
  public Map.Entry<K, V> ceilingEntry(K paramK)
  {
    return tailMap(paramK, true).firstEntry();
  }
  
  public K ceilingKey(K paramK)
  {
    return (K)Maps.b(ceilingEntry(paramK));
  }
  
  public NavigableSet<K> descendingKeySet()
  {
    return descendingMap().navigableKeySet();
  }
  
  public NavigableMap<K, V> descendingMap()
  {
    return new mz.a((byte)0);
  }
  
  public Set<Map.Entry<K, V>> entrySet()
  {
    new Maps.f()
    {
      final Map<K, V> a()
      {
        return mz.this;
      }
      
      public final Iterator<Map.Entry<K, V>> iterator()
      {
        return mz.this.a();
      }
    };
  }
  
  @Nullable
  public Map.Entry<K, V> firstEntry()
  {
    return (Map.Entry)Iterators.getNext(a(), null);
  }
  
  public K firstKey()
  {
    Map.Entry localEntry = firstEntry();
    if (localEntry == null) {
      throw new NoSuchElementException();
    }
    return (K)localEntry.getKey();
  }
  
  @Nullable
  public Map.Entry<K, V> floorEntry(K paramK)
  {
    return headMap(paramK, true).lastEntry();
  }
  
  public K floorKey(K paramK)
  {
    return (K)Maps.b(floorEntry(paramK));
  }
  
  public SortedMap<K, V> headMap(K paramK)
  {
    return headMap(paramK, false);
  }
  
  @Nullable
  public Map.Entry<K, V> higherEntry(K paramK)
  {
    return tailMap(paramK, false).firstEntry();
  }
  
  public K higherKey(K paramK)
  {
    return (K)Maps.b(higherEntry(paramK));
  }
  
  public Set<K> keySet()
  {
    return navigableKeySet();
  }
  
  @Nullable
  public Map.Entry<K, V> lastEntry()
  {
    return (Map.Entry)Iterators.getNext(b(), null);
  }
  
  public K lastKey()
  {
    Map.Entry localEntry = lastEntry();
    if (localEntry == null) {
      throw new NoSuchElementException();
    }
    return (K)localEntry.getKey();
  }
  
  @Nullable
  public Map.Entry<K, V> lowerEntry(K paramK)
  {
    return headMap(paramK, false).lastEntry();
  }
  
  public K lowerKey(K paramK)
  {
    return (K)Maps.b(lowerEntry(paramK));
  }
  
  public NavigableSet<K> navigableKeySet()
  {
    return new Maps.q(this);
  }
  
  @Nullable
  public Map.Entry<K, V> pollFirstEntry()
  {
    return (Map.Entry)Iterators.a(a());
  }
  
  @Nullable
  public Map.Entry<K, V> pollLastEntry()
  {
    return (Map.Entry)Iterators.a(b());
  }
  
  public SortedMap<K, V> subMap(K paramK1, K paramK2)
  {
    return subMap(paramK1, true, paramK2, false);
  }
  
  public SortedMap<K, V> tailMap(K paramK)
  {
    return tailMap(paramK, true);
  }
  
  final class a
    extends Maps.d<K, V>
  {
    private a() {}
    
    final NavigableMap<K, V> a()
    {
      return mz.this;
    }
    
    final Iterator<Map.Entry<K, V>> entryIterator()
    {
      return mz.this.b();
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/mz.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */