import com.ibm.icu.text.NFRuleSet;
import com.ibm.icu.text.NFSubstitution;
import com.ibm.icu.text.RuleBasedNumberFormat;
import java.text.ParsePosition;
class NumeratorSubstitution extends NFSubstitution {
   double denominator;
   boolean withZeros;
   NumeratorSubstitution(int pos, double denominator, NFRuleSet ruleSet, RuleBasedNumberFormat formatter, String description) {
      super(pos, ruleSet, formatter, fixdesc(description));
      this.denominator = denominator;
      this.withZeros = description.endsWith("<<");
   }
   static String fixdesc(String description) {
      return description.endsWith("<<")?description.substring(0, description.length() - 1):description;
   }
   public boolean equals(Object that) {
      if(super.equals(that)) {
         NumeratorSubstitution that2 = (NumeratorSubstitution)that;
         return this.denominator == that2.denominator;
      } else {
         return false;
      }
   }
   public int hashCode() {
      assert false : "hashCode not designed";
      return 42;
   }
   public void doSubstitution(double number, StringBuffer toInsertInto, int position) {
      double numberToFormat = this.transformNumber(number);
      if(this.withZeros && this.ruleSet != null) {
         long nf = (long)numberToFormat;
         int len = toInsertInto.length();
         while((double)(nf *= 10L) < this.denominator) {
            toInsertInto.insert(position + this.pos, ' ');
            this.ruleSet.format(0L, toInsertInto, position + this.pos);
         }
         position += toInsertInto.length() - len;
      }
      if(numberToFormat == Math.floor(numberToFormat) && this.ruleSet != null) {
         this.ruleSet.format((long)numberToFormat, toInsertInto, position + this.pos);
      } else if(this.ruleSet != null) {
         this.ruleSet.format(numberToFormat, toInsertInto, position + this.pos);
      } else {
         toInsertInto.insert(position + this.pos, this.numberFormat.format(numberToFormat));
      }
   }
   public long transformNumber(long number) {
      return Math.round((double)number * this.denominator);
   }
   public double transformNumber(double number) {
      return (double)Math.round(number * this.denominator);
   }
   public Number doParse(String text, ParsePosition parsePosition, double baseValue, double upperBound, boolean lenientParse) {
      int zeroCount = 0;
      if(this.withZeros) {
         String workText = text;
         ParsePosition workPos = new ParsePosition(1);
         while(workText.length() > 0 && workPos.getIndex() != 0) {
            workPos.setIndex(0);
            this.ruleSet.parse(workText, workPos, 1.0D).intValue();
            if(workPos.getIndex() == 0) {
               break;
            }
            ++zeroCount;
            parsePosition.setIndex(parsePosition.getIndex() + workPos.getIndex());
            workText = workText.substring(workPos.getIndex());
            while(workText.length() > 0 && workText.charAt(0) == 32) {
               workText = workText.substring(1);
               parsePosition.setIndex(parsePosition.getIndex() + 1);
            }
         }
         text = text.substring(parsePosition.getIndex());
         parsePosition.setIndex(0);
      }
      Number result = super.doParse(text, parsePosition, this.withZeros?1.0D:baseValue, upperBound, false);
      if(this.withZeros) {
         long n = result.longValue();
         long d;
         for(d = 1L; d <= n; d *= 10L) {
            ;
         }
         while(zeroCount > 0) {
            d *= 10L;
            --zeroCount;
         }
         result = new Double((double)n / (double)d);
      }
      return result;
   }
   public double composeRuleValue(double newRuleValue, double oldRuleValue) {
      return newRuleValue / oldRuleValue;
   }
   public double calcUpperBound(double oldUpperBound) {
      return this.denominator;
   }
   char tokenChar() {
      return '<';
   }
}
package com.ibm.icu.text;
import com.ibm.icu.impl.Utility;
import com.ibm.icu.text.MessagePattern;
import com.ibm.icu.text.NumberFormat;
import com.ibm.icu.text.PluralRules;
import com.ibm.icu.text.UFormat;
import com.ibm.icu.util.ULocale;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.text.FieldPosition;
import java.text.ParsePosition;
import java.util.Map;
public class PluralFormat extends UFormat {
   private static final long serialVersionUID = 1L;
   private ULocale ulocale = null;
   private PluralRules pluralRules = null;
   private String pattern = null;
//监督判别投影的高维网络数据特征选择管理
            JsonPrimitive primitive = keyElement.getAsJsonPrimitive();
            if(primitive.isNumber()) {
               return String.valueOf(primitive.getAsNumber());
            } else if(primitive.isBoolean()) {
               return Boolean.toString(primitive.getAsBoolean());
            } else if(primitive.isString()) {
               return primitive.getAsString();
            } else {
               throw new AssertionError();
            }
         } else if(keyElement.isJsonNull()) {
            return "null";
         } else {
            throw new AssertionError();
         }
      }
   }
}
package com.google.gson.internal.bind;
import com.google.gson.Gson;
import com.google.gson.TypeAdapter;
import com.google.gson.TypeAdapterFactory;
import com.google.gson.internal.LinkedTreeMap;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public final class ObjectTypeAdapter extends TypeAdapter {
   public static final TypeAdapterFactory FACTORY = new TypeAdapterFactory() {
      public TypeAdapter create(Gson gson, TypeToken type) {
         return type.getRawType() == Object.class?new ObjectTypeAdapter(gson):null;
      }
   };
   private final Gson gson;
   private ObjectTypeAdapter(Gson gson) {
      this.gson = gson;
   }
   public Object read(JsonReader in) throws IOException {
      JsonToken token = in.peek();
      switch(token) {
      case BEGIN_ARRAY:
         List<Object> list = new ArrayList();
         in.beginArray();
         while(in.hasNext()) {
            list.add(this.read(in));
         }
         in.endArray();
         return list;
      case BEGIN_OBJECT:
         Map<String, Object> map = new LinkedTreeMap();
         in.beginObject();
         while(in.hasNext()) {
            map.put(in.nextName(), this.read(in));
         }
         in.endObject();
         return map;
      case STRING:
         return in.nextString();
      case NUMBER:
         return Double.valueOf(in.nextDouble());
      case BOOLEAN:
         return Boolean.valueOf(in.nextBoolean());
      case NULL:
         in.nextNull();
         return null;
      default:
         throw new IllegalStateException();
      }
   }
   public void write(JsonWriter out, Object value) throws IOException {
      if(value == null) {
         out.nullValue();
      } else {
         TypeAdapter<Object> typeAdapter = this.gson.getAdapter(value.getClass());
         if(typeAdapter instanceof ObjectTypeAdapter) {
            out.beginObject();
            out.endObject();
         } else {
            typeAdapter.write(out, value);
         }
      }
   }
}
package com.google.gson.internal.bind;
import com.google.gson.FieldNamingStrategy;
import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import com.google.gson.TypeAdapter;
import com.google.gson.TypeAdapterFactory;
import com.google.gson.annotations.SerializedName;
import com.google.gson.internal.$Gson$Types;
import com.google.gson.internal.ConstructorConstructor;
import com.google.gson.internal.Excluder;
import com.google.gson.internal.ObjectConstructor;
import com.google.gson.internal.Primitives;
import com.google.gson.internal.bind.TypeAdapterRuntimeTypeWrapper;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.LinkedHashMap;
import java.util.Map;
public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
   private final ConstructorConstructor constructorConstructor;
   private final FieldNamingStrategy fieldNamingPolicy;
   private final Excluder excluder;
   public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor, FieldNamingStrategy fieldNamingPolicy, Excluder excluder) {
      this.constructorConstructor = constructorConstructor;
      this.fieldNamingPolicy = fieldNamingPolicy;
//
      MapMakerInternalMap.ReferenceEntry nextExpirable = MapMakerInternalMap.nullEntry();
      @GuardedBy("Segment.this")
      MapMakerInternalMap.ReferenceEntry previousExpirable = MapMakerInternalMap.nullEntry();
      @GuardedBy("Segment.this")
      MapMakerInternalMap.ReferenceEntry nextEvictable = MapMakerInternalMap.nullEntry();
      @GuardedBy("Segment.this")
      MapMakerInternalMap.ReferenceEntry previousEvictable = MapMakerInternalMap.nullEntry();
      StrongExpirableEvictableEntry(Object key, int hash, @Nullable MapMakerInternalMap.ReferenceEntry next) {
         super(key, hash, next);
      }
      public long getExpirationTime() {
         return this.time;
      }
      public void setExpirationTime(long time) {
         this.time = time;
      }
      public MapMakerInternalMap.ReferenceEntry getNextExpirable() {
         return this.nextExpirable;
      }
      public void setNextExpirable(MapMakerInternalMap.ReferenceEntry next) {
         this.nextExpirable = next;
      }
      public MapMakerInternalMap.ReferenceEntry getPreviousExpirable() {
         return this.previousExpirable;
      }
      public void setPreviousExpirable(MapMakerInternalMap.ReferenceEntry previous) {
         this.previousExpirable = previous;
      }
      public MapMakerInternalMap.ReferenceEntry getNextEvictable() {
         return this.nextEvictable;
      }
      public void setNextEvictable(MapMakerInternalMap.ReferenceEntry next) {
         this.nextEvictable = next;
      }
      public MapMakerInternalMap.ReferenceEntry getPreviousEvictable() {
         return this.previousEvictable;
      }
      public void setPreviousEvictable(MapMakerInternalMap.ReferenceEntry previous) {
         this.previousEvictable = previous;
      }
   }
   static final class StrongValueReference implements MapMakerInternalMap.ValueReference {
      final Object referent;
      StrongValueReference(Object referent) {
         this.referent = referent;
      }
      public Object get() {
         return this.referent;
      }
      public MapMakerInternalMap.ReferenceEntry getEntry() {
         return null;
      }
      public MapMakerInternalMap.ValueReference copyFor(ReferenceQueue queue, Object value, MapMakerInternalMap.ReferenceEntry entry) {
         return this;
      }
      public boolean isComputingReference() {
         return false;
      }
      public Object waitForValue() {
         return this.get();
      }
      public void clear(MapMakerInternalMap.ValueReference newValue) {
      }
   }
   final class ValueIterator extends MapMakerInternalMap.HashIterator {
      ValueIterator() {
         super();
      }
      public Object next() {
         return this.nextEntry().getValue();
      }
   }
   interface ValueReference {
      Object get();
      Object waitForValue() throws ExecutionException;
      MapMakerInternalMap.ReferenceEntry getEntry();
      MapMakerInternalMap.ValueReference copyFor(ReferenceQueue var1, @Nullable Object var2, MapMakerInternalMap.ReferenceEntry var3);
      void clear(@Nullable MapMakerInternalMap.ValueReference var1);
      boolean isComputingReference();
   }
   final class Values extends AbstractCollection {
      public Iterator iterator() {
         return MapMakerInternalMap.this.new ValueIterator();
      }
      public int size() {
         return MapMakerInternalMap.this.size();
      }
      public boolean isEmpty() {
         return MapMakerInternalMap.this.isEmpty();
      }
      public boolean contains(Object o) {
         return MapMakerInternalMap.this.containsValue(o);
      }
      public void clear() {
         MapMakerInternalMap.this.clear();
      }
   }
   static class WeakEntry extends WeakReference implements MapMakerInternalMap.ReferenceEntry {
      final int hash;
      final MapMakerInternalMap.ReferenceEntry next;
      volatile MapMakerInternalMap.ValueReference valueReference = MapMakerInternalMap.UNSET;
      WeakEntry(ReferenceQueue queue, Object key, int hash, @Nullable MapMakerInternalMap.ReferenceEntry next) {
         super(key, queue);
         this.hash = hash;
         this.next = next;
      }
      public Object getKey() {
         return this.get();
      }
      public long getExpirationTime() {
         throw new UnsupportedOperationException();
      }
      public void setExpirationTime(long time) {
         throw new UnsupportedOperationException();
      }
//
   private Object readResolve() {
      return INSTANCE;
   }
}
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.ImmutableSortedMap;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Ordering;
import java.util.Comparator;
import javax.annotation.Nullable;
@GwtCompatible(
   emulated = true
)
final class EmptyImmutableSortedMap extends ImmutableSortedMap {
   private final transient ImmutableSortedSet keySet;
   EmptyImmutableSortedMap(Comparator comparator) {
      this.keySet = ImmutableSortedSet.emptySet(comparator);
   }
   EmptyImmutableSortedMap(Comparator comparator, ImmutableSortedMap descendingMap) {
      super(descendingMap);
      this.keySet = ImmutableSortedSet.emptySet(comparator);
   }
   public Object get(@Nullable Object key) {
      return null;
   }
   public ImmutableSortedSet keySet() {
      return this.keySet;
   }
   public int size() {
      return 0;
   }
   public boolean isEmpty() {
      return true;
   }
   public ImmutableCollection values() {
      return ImmutableList.of();
   }
   public String toString() {
      return "{}";
   }
   boolean isPartialView() {
      return false;
   }
   public ImmutableSet entrySet() {
      return ImmutableSet.of();
   }
   ImmutableSet createEntrySet() {
      throw new AssertionError("should never be called");
   }
   public ImmutableSetMultimap asMultimap() {
      return ImmutableSetMultimap.of();
   }
   public ImmutableSortedMap headMap(Object toKey, boolean inclusive) {
      Preconditions.checkNotNull(toKey);
      return this;
   }
   public ImmutableSortedMap tailMap(Object fromKey, boolean inclusive) {
      Preconditions.checkNotNull(fromKey);
      return this;
   }
   ImmutableSortedMap createDescendingMap() {
      return new EmptyImmutableSortedMap(Ordering.from(this.comparator()).reverse(), this);
   }
}
package com.google.common.collect;
import com.google.common.base.Preconditions;
import com.google.common.collect.BoundType;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSortedMultiset;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Iterators;
import com.google.common.collect.Multiset;
import com.google.common.collect.UnmodifiableIterator;
import java.util.Collection;
import java.util.Comparator;
import javax.annotation.Nullable;
final class EmptyImmutableSortedMultiset extends ImmutableSortedMultiset {
   private final ImmutableSortedSet elementSet;
   EmptyImmutableSortedMultiset(Comparator comparator) {
      this.elementSet = ImmutableSortedSet.emptySet(comparator);
   }
   public Multiset.Entry firstEntry() {
      return null;
   }
   public Multiset.Entry lastEntry() {
      return null;
   }
   public int count(@Nullable Object element) {
      return 0;
   }
   public boolean containsAll(Collection targets) {
      return targets.isEmpty();
   }
   public int size() {
      return 0;
   }
   public ImmutableSortedSet elementSet() {
      return this.elementSet;
   }
   Multiset.Entry getEntry(int index) {
      throw new AssertionError("should never be called");
   }
   public ImmutableSortedMultiset headMultiset(Object upperBound, BoundType boundType) {
      Preconditions.checkNotNull(upperBound);
      Preconditions.checkNotNull(boundType);
      return this;
   }
   public ImmutableSortedMultiset tailMultiset(Object lowerBound, BoundType boundType) {
      Preconditions.checkNotNull(lowerBound);
      Preconditions.checkNotNull(boundType);
      return this;
//
      }
   }
   private static class ImmediateSuccessfulFuture extends Futures.ImmediateFuture {
      @Nullable
      private final Object value;
      ImmediateSuccessfulFuture(@Nullable Object value) {
         super(null);
         this.value = value;
      }
      public Object get() {
         return this.value;
      }
   }
   private static class MappingCheckedFuture extends AbstractCheckedFuture {
      final Function mapper;
      MappingCheckedFuture(ListenableFuture delegate, Function mapper) {
         super(delegate);
         this.mapper = (Function)Preconditions.checkNotNull(mapper);
      }
      protected Exception mapException(Exception e) {
         return (Exception)this.mapper.apply(e);
      }
   }
   private static class NonCancellationPropagatingFuture extends AbstractFuture {
      NonCancellationPropagatingFuture(final ListenableFuture delegate) {
         Preconditions.checkNotNull(delegate);
         Futures.addCallback(delegate, new FutureCallback() {
            public void onSuccess(Object result) {
               NonCancellationPropagatingFuture.this.set(result);
            }
            public void onFailure(Throwable t) {
               if(delegate.isCancelled()) {
                  NonCancellationPropagatingFuture.this.cancel(false);
               } else {
                  NonCancellationPropagatingFuture.this.setException(t);
               }
            }
         }, MoreExecutors.sameThreadExecutor());
      }
   }
}
package com.google.common.util.concurrent;
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.ExecutionList;
import com.google.common.util.concurrent.ForwardingFuture;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.google.common.util.concurrent.Uninterruptibles;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicBoolean;
@Beta
public final class JdkFutureAdapters {
   public static ListenableFuture listenInPoolThread(Future future) {
      return (ListenableFuture)(future instanceof ListenableFuture?(ListenableFuture)future:new JdkFutureAdapters.ListenableFutureAdapter(future));
   }
   public static ListenableFuture listenInPoolThread(Future future, Executor executor) {
      Preconditions.checkNotNull(executor);
      return (ListenableFuture)(future instanceof ListenableFuture?(ListenableFuture)future:new JdkFutureAdapters.ListenableFutureAdapter(future, executor));
   }
   private static class ListenableFutureAdapter extends ForwardingFuture implements ListenableFuture {
      private static final ThreadFactory threadFactory = (new ThreadFactoryBuilder()).setDaemon(true).setNameFormat("ListenableFutureAdapter-thread-%d").build();
      private static final Executor defaultAdapterExecutor = Executors.newCachedThreadPool(threadFactory);
      private final Executor adapterExecutor;
      private final ExecutionList executionList;
      private final AtomicBoolean hasListeners;
      private final Future delegate;
      ListenableFutureAdapter(Future delegate) {
         this(delegate, defaultAdapterExecutor);
      }
      ListenableFutureAdapter(Future delegate, Executor adapterExecutor) {
         this.executionList = new ExecutionList();
         this.hasListeners = new AtomicBoolean(false);
         this.delegate = (Future)Preconditions.checkNotNull(delegate);
         this.adapterExecutor = (Executor)Preconditions.checkNotNull(adapterExecutor);
      }
      protected Future delegate() {
         return this.delegate;
      }
      public void addListener(Runnable listener, Executor exec) {
         this.executionList.add(listener, exec);
         if(this.hasListeners.compareAndSet(false, true)) {
            if(this.delegate.isDone()) {
               this.executionList.execute();
               return;
            }
            this.adapterExecutor.execute(new Runnable() {
               public void run() {
                  try {
                     Uninterruptibles.getUninterruptibly(ListenableFutureAdapter.this.delegate);
                  } catch (Error var2) {
                     throw var2;
                  } catch (Throwable var3) {
                     ;
                  }
                  ListenableFutureAdapter.this.executionList.execute();
               }
            });
         }
      }
   }
}
package com.google.common.util.concurrent;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
public interface ListenableFuture extends Future {
   void addListener(Runnable var1, Executor var2);
}
package com.google.common.util.concurrent;
import com.google.common.util.concurrent.ExecutionList;
//监督判别投影的高维网络数据特征选择运行报告 this.isNumber()?this.getAsNumber().toString():(this.isBoolean()?this.getAsBooleanWrapper().toString():(String)this.value);
   }
   public double getAsDouble() {
      return this.isNumber()?this.getAsNumber().doubleValue():Double.parseDouble(this.getAsString());
   }
   public BigDecimal getAsBigDecimal() {
      return this.value instanceof BigDecimal?(BigDecimal)this.value:new BigDecimal(this.value.toString());
   }
   public BigInteger getAsBigInteger() {
      return this.value instanceof BigInteger?(BigInteger)this.value:new BigInteger(this.value.toString());
   }
   public float getAsFloat() {
      return this.isNumber()?this.getAsNumber().floatValue():Float.parseFloat(this.getAsString());
   }
   public long getAsLong() {
      return this.isNumber()?this.getAsNumber().longValue():Long.parseLong(this.getAsString());
   }
   public short getAsShort() {
      return this.isNumber()?this.getAsNumber().shortValue():Short.parseShort(this.getAsString());
   }
   public int getAsInt() {
      return this.isNumber()?this.getAsNumber().intValue():Integer.parseInt(this.getAsString());
   }
   public byte getAsByte() {
      return this.isNumber()?this.getAsNumber().byteValue():Byte.parseByte(this.getAsString());
   }
   public char getAsCharacter() {
      return this.getAsString().charAt(0);
   }
   private static boolean isPrimitiveOrString(Object target) {
      if(target instanceof String) {
         return true;
      } else {
         Class<?> classOfPrimitive = target.getClass();
         for(Class<?> standardPrimitive : PRIMITIVE_TYPES) {
            if(standardPrimitive.isAssignableFrom(classOfPrimitive)) {
               return true;
            }
         }
         return false;
      }
   }
   public int hashCode() {
      if(this.value == null) {
         return 31;
      } else if(isIntegral(this)) {
         long value = this.getAsNumber().longValue();
         return (int)(value ^ value >>> 32);
      } else if(this.value instanceof Number) {
         long value = Double.doubleToLongBits(this.getAsNumber().doubleValue());
         return (int)(value ^ value >>> 32);
      } else {
         return this.value.hashCode();
      }
   }
   public boolean equals(Object obj) {
      if(this == obj) {
         return true;
      } else if(obj != null && this.getClass() == obj.getClass()) {
         JsonPrimitive other = (JsonPrimitive)obj;
         if(this.value == null) {
            return other.value == null;
         } else if(isIntegral(this) && isIntegral(other)) {
            return this.getAsNumber().longValue() == other.getAsNumber().longValue();
         } else if(this.value instanceof Number && other.value instanceof Number) {
            double a = this.getAsNumber().doubleValue();
            double b = other.getAsNumber().doubleValue();
            return a == b || Double.isNaN(a) && Double.isNaN(b);
         } else {
            return this.value.equals(other.value);
         }
      } else {
         return false;
      }
   }
   private static boolean isIntegral(JsonPrimitive primitive) {
      if(!(primitive.value instanceof Number)) {
         return false;
      } else {
         Number number = (Number)primitive.value;
         return number instanceof BigInteger || number instanceof Long || number instanceof Integer || number instanceof Short || number instanceof Byte;
      }
   }
}
package com.google.gson;
import com.google.gson.JsonElement;
import java.lang.reflect.Type;
public interface JsonSerializationContext {
   JsonElement serialize(Object var1);
   JsonElement serialize(Object var1, Type var2);
}
package com.google.gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonSerializationContext;
import java.lang.reflect.Type;
public interface JsonSerializer {
   JsonElement serialize(Object var1, Type var2, JsonSerializationContext var3);
}
package com.google.gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonIOException;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSyntaxException;
import com.google.gson.internal.Streams;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.MalformedJsonException;
import java.io.EOFException;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.Iterator;
import java.util.NoSuchElementException;
public final class JsonStreamParser implements Iterator {
   private final JsonReader parser;
//
   }
   private static boolean isTashkeelCharFE(char ch) {
      return ch != '\ufe75' && ch >= 'ﹰ' && ch <= 'ﹿ';
   }
   private static int isTashkeelOnTatweelChar(char ch) {
      return ch >= 'ﹰ' && ch <= 'ﹿ' && ch != 'ﹳ' && ch != '\ufe75' && ch != 'ﹽ'?tashkeelMedial[ch - 'ﹰ']:((ch < 'ﳲ' || ch > 'ﳴ') && ch != 'ﹽ'?0:2);
   }
   private static int isIsolatedTashkeelChar(char ch) {
      return ch >= 'ﹰ' && ch <= 'ﹿ' && ch != 'ﹳ' && ch != '\ufe75'?1 - tashkeelMedial[ch - 'ﹰ']:(ch >= 'ﱞ' && ch <= 'ﱣ'?1:0);
   }
   private static boolean isAlefChar(char ch) {
      return ch == 1570 || ch == 1571 || ch == 1573 || ch == 1575;
   }
   private static boolean isLamAlefChar(char ch) {
      return ch >= 'ﻵ' && ch <= 'ﻼ';
   }
   private static boolean isNormalizedLamAlefChar(char ch) {
      return ch >= 1628 && ch <= 1631;
   }
   private int calculateSize(char[] source, int sourceStart, int sourceLength) {
      int destSize = sourceLength;
      switch(this.options & 24) {
      case 8:
      case 24:
         if(this.isLogical) {
            int i = sourceStart;
            for(int e = sourceStart + sourceLength - 1; i < e; ++i) {
               if(source[i] == 1604 && isAlefChar(source[i + 1]) || isTashkeelCharFE(source[i])) {
                  --destSize;
               }
            }
            return destSize;
         } else {
            int i = sourceStart + 1;
            for(int e = sourceStart + sourceLength; i < e; ++i) {
               if(source[i] == 1604 && isAlefChar(source[i - 1]) || isTashkeelCharFE(source[i])) {
                  --destSize;
               }
            }
            return destSize;
         }
      case 16:
         int i = sourceStart;
         for(int e = sourceStart + sourceLength; i < e; ++i) {
            if(isLamAlefChar(source[i])) {
               ++destSize;
            }
         }
      }
      return destSize;
   }
   private static int countSpaceSub(char[] dest, int length, char subChar) {
      int i = 0;
      int count;
      for(count = 0; i < length; ++i) {
         if(dest[i] == subChar) {
            ++count;
         }
      }
      return count;
   }
   private static void shiftArray(char[] dest, int start, int e, char subChar) {
      int w = e;
      int r = e;
      while(true) {
         --r;
         if(r < start) {
            return;
         }
         char ch = dest[r];
         if(ch != subChar) {
            --w;
            if(w != r) {
               dest[w] = ch;
            }
         }
      }
   }
   private static int flipArray(char[] dest, int start, int e, int w) {
      if(w > start) {
         int r = w;
         for(w = start; r < e; dest[w++] = dest[r++]) {
            ;
         }
      } else {
         w = e;
      }
      return w;
   }
   private static int handleTashkeelWithTatweel(char[] dest, int sourceLength) {
      for(int i = 0; i < sourceLength; ++i) {
         if(isTashkeelOnTatweelChar(dest[i]) == 1) {
            dest[i] = 1600;
         } else if(isTashkeelOnTatweelChar(dest[i]) == 2) {
            dest[i] = 'ﹽ';
         } else if(isIsolatedTashkeelChar(dest[i]) == 1 && dest[i] != 'ﹼ') {
            dest[i] = 32;
         }
      }
      return sourceLength;
   }
   private int handleGeneratedSpaces(char[] dest, int start, int length) {
      int lenOptionsLamAlef = this.options & 65539;
      int lenOptionsTashkeel = this.options & 917504;
      boolean lamAlefOn = false;
      boolean tashkeelOn = false;
      if(!this.isLogical & !this.spacesRelativeToTextBeginEnd) {
         switch(lenOptionsLamAlef) {
         case 2:
            lenOptionsLamAlef = 3;
            break;
         case 3:
            lenOptionsLamAlef = 2;
         }
         switch(lenOptionsTashkeel) {
         case 262144:
//
   }
   @GwtIncompatible("java.io.ObjectInputStream")
   private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
      stream.defaultReadObject();
      int size = Serialization.readCount(stream);
      this.init(size);
      Serialization.populateMap(this, stream, size);
   }
   private static final class BiEntry extends ImmutableEntry {
      final int keyHash;
      final int valueHash;
      @Nullable
      HashBiMap.BiEntry nextInKToVBucket;
      @Nullable
      HashBiMap.BiEntry nextInVToKBucket;
      BiEntry(Object key, int keyHash, Object value, int valueHash) {
         super(key, value);
         this.keyHash = keyHash;
         this.valueHash = valueHash;
      }
   }
   private final class EntrySet extends Maps.EntrySet {
      private EntrySet() {
      }
      Map map() {
         return HashBiMap.this;
      }
      public Iterator iterator() {
         return new HashBiMap.Itr() {
            Entry output(HashBiMap.BiEntry entry) {
               return new null.MapEntry(entry);
            }
            class MapEntry extends AbstractMapEntry {
               HashBiMap.BiEntry delegate;
               MapEntry(HashBiMap.BiEntry entry) {
                  this.delegate = entry;
               }
               public Object getKey() {
                  return this.delegate.key;
               }
               public Object getValue() {
                  return this.delegate.value;
               }
               public Object setValue(Object value) {
                  V oldValue = this.delegate.value;
                  int valueHash = HashBiMap.hash(value);
                  if(valueHash == this.delegate.valueHash && Objects.equal(value, oldValue)) {
                     return value;
                  } else {
                     Preconditions.checkArgument(HashBiMap.this.seekByValue(value, valueHash) == null, "value already present: %s", new Object[]{value});
                     HashBiMap.this.delete(this.delegate);
                     HashBiMap.BiEntry<K, V> newEntry = new HashBiMap.BiEntry(this.delegate.key, this.delegate.keyHash, value, valueHash);
                     HashBiMap.this.insert(newEntry);
                     expectedModCount = HashBiMap.this.modCount;
                     if(toRemove == this.delegate) {
                        toRemove = newEntry;
                     }
                     this.delegate = newEntry;
                     return oldValue;
                  }
               }
            }
         };
      }
   }
   private final class Inverse extends AbstractMap implements BiMap, Serializable {
      private Inverse() {
      }
      BiMap forward() {
         return HashBiMap.this;
      }
      public int size() {
         return HashBiMap.this.size;
      }
      public void clear() {
         this.forward().clear();
      }
      public boolean containsKey(@Nullable Object value) {
         return this.forward().containsValue(value);
      }
      public Object get(@Nullable Object value) {
         HashBiMap.BiEntry<K, V> entry = HashBiMap.this.seekByValue(value, HashBiMap.hash(value));
         return entry == null?null:entry.key;
      }
      public Object put(@Nullable Object value, @Nullable Object key) {
         return HashBiMap.this.putInverse(value, key, false);
      }
      public Object forcePut(@Nullable Object value, @Nullable Object key) {
         return HashBiMap.this.putInverse(value, key, true);
      }
      public Object remove(@Nullable Object value) {
         HashBiMap.BiEntry<K, V> entry = HashBiMap.this.seekByValue(value, HashBiMap.hash(value));
         if(entry == null) {
            return null;
         } else {
            HashBiMap.this.delete(entry);
            return entry.key;
         }
      }
      public BiMap inverse() {
         return this.forward();
      }
      public Set keySet() {
         return new HashBiMap.Inverse.InverseKeySet();
      }
      public Set values() {
         return this.forward().keySet();
      }
      public Set entrySet() {
         return new Maps.EntrySet() {
            Map map() {
               return Inverse.this;
            }
            public Iterator iterator() {
               return new HashBiMap.Itr() {
//
         return this;
      }
      public ImmutableSortedMultiset.Builder add(Object... elements) {
         super.add(elements);
         return this;
      }
      public ImmutableSortedMultiset.Builder addAll(Iterable elements) {
         super.addAll(elements);
         return this;
      }
      public ImmutableSortedMultiset.Builder addAll(Iterator elements) {
         super.addAll(elements);
         return this;
      }
      public ImmutableSortedMultiset build() {
         return ImmutableSortedMultiset.copyOfSorted((SortedMultiset)this.contents);
      }
   }
   private static final class SerializedForm implements Serializable {
      Comparator comparator;
      Object[] elements;
      int[] counts;
      SerializedForm(SortedMultiset multiset) {
         this.comparator = multiset.comparator();
         int n = multiset.entrySet().size();
         this.elements = (Object[])(new Object[n]);
         this.counts = new int[n];
         int i = 0;
         for(Multiset.Entry<E> entry : multiset.entrySet()) {
            this.elements[i] = entry.getElement();
            this.counts[i] = entry.getCount();
            ++i;
         }
      }
      Object readResolve() {
         int n = this.elements.length;
         ImmutableSortedMultiset.Builder<E> builder = new ImmutableSortedMultiset.Builder(this.comparator);
         for(int i = 0; i < n; ++i) {
            builder.addCopies(this.elements[i], this.counts[i]);
         }
         return builder.build();
      }
   }
}
package com.google.common.collect;
import com.google.common.collect.ImmutableMultiset;
import com.google.common.collect.ImmutableSortedMultiset;
abstract class ImmutableSortedMultisetFauxverideShim extends ImmutableMultiset {
   /** @deprecated */
   @Deprecated
   public static ImmutableSortedMultiset.Builder builder() {
      throw new UnsupportedOperationException();
   }
   /** @deprecated */
   @Deprecated
   public static ImmutableSortedMultiset of(Object element) {
      throw new UnsupportedOperationException();
   }
   /** @deprecated */
   @Deprecated
   public static ImmutableSortedMultiset of(Object e1, Object e2) {
      throw new UnsupportedOperationException();
   }
   /** @deprecated */
   @Deprecated
   public static ImmutableSortedMultiset of(Object e1, Object e2, Object e3) {
      throw new UnsupportedOperationException();
   }
   /** @deprecated */
   @Deprecated
   public static ImmutableSortedMultiset of(Object e1, Object e2, Object e3, Object e4) {
      throw new UnsupportedOperationException();
   }
   /** @deprecated */
   @Deprecated
   public static ImmutableSortedMultiset of(Object e1, Object e2, Object e3, Object e4, Object e5) {
      throw new UnsupportedOperationException();
   }
   /** @deprecated */
   @Deprecated
   public static ImmutableSortedMultiset of(Object e1, Object e2, Object e3, Object e4, Object e5, Object e6, Object... remaining) {
      throw new UnsupportedOperationException();
   }
   /** @deprecated */
   @Deprecated
   public static ImmutableSortedMultiset copyOf(Object[] elements) {
      throw new UnsupportedOperationException();
   }
}
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Preconditions;
import com.google.common.collect.DescendingImmutableSortedSet;
import com.google.common.collect.EmptyImmutableSortedSet;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedSetFauxverideShim;
import com.google.common.collect.Iterables;
import com.google.common.collect.Iterators;
import com.google.common.collect.ObjectArrays;
import com.google.common.collect.Ordering;
import com.google.common.collect.RegularImmutableSortedSet;
import com.google.common.collect.SortedIterable;
import com.google.common.collect.SortedIterables;
import com.google.common.collect.UnmodifiableIterator;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NavigableSet;
import java.util.SortedSet;
import javax.annotation.Nullable;
//监督判别投影的高维网络数据特征选择许可管理
   private final class PostOrderIterator extends UnmodifiableIterator {
      private final Deque stack = new ArrayDeque();
      private final BitSet hasExpanded;
      PostOrderIterator(Object root) {
         this.stack.addLast(root);
         this.hasExpanded = new BitSet();
      }
      public boolean hasNext() {
         return !this.stack.isEmpty();
      }
      public Object next() {
         while(true) {
            T node = this.stack.getLast();
            boolean expandedNode = this.hasExpanded.get(this.stack.size() - 1);
            if(expandedNode) {
               this.stack.removeLast();
               this.hasExpanded.clear(this.stack.size());
               return node;
            }
            this.hasExpanded.set(this.stack.size() - 1);
            BinaryTreeTraverser.pushIfPresent(this.stack, BinaryTreeTraverser.this.rightChild(node));
            BinaryTreeTraverser.pushIfPresent(this.stack, BinaryTreeTraverser.this.leftChild(node));
         }
      }
   }
   private final class PreOrderIterator extends UnmodifiableIterator implements PeekingIterator {
      private final Deque stack = new ArrayDeque();
      PreOrderIterator(Object root) {
         this.stack.addLast(root);
      }
      public boolean hasNext() {
         return !this.stack.isEmpty();
      }
      public Object next() {
         T result = this.stack.removeLast();
         BinaryTreeTraverser.pushIfPresent(this.stack, BinaryTreeTraverser.this.rightChild(result));
         BinaryTreeTraverser.pushIfPresent(this.stack, BinaryTreeTraverser.this.leftChild(result));
         return result;
      }
      public Object peek() {
         return this.stack.getLast();
      }
   }
}
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
@GwtCompatible
public enum BoundType {
   OPEN {
      BoundType flip() {
         return CLOSED;
      }
   },
   CLOSED {
      BoundType flip() {
         return OPEN;
      }
   };
   private BoundType() {
   }
   static BoundType forBoolean(boolean inclusive) {
      return inclusive?CLOSED:OPEN;
   }
   abstract BoundType flip();
}
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Function;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import com.google.common.collect.Ordering;
import java.io.Serializable;
import javax.annotation.Nullable;
@GwtCompatible(
   serializable = true
)
final class ByFunctionOrdering extends Ordering implements Serializable {
   final Function function;
   final Ordering ordering;
   private static final long serialVersionUID = 0L;
   ByFunctionOrdering(Function function, Ordering ordering) {
      this.function = (Function)Preconditions.checkNotNull(function);
      this.ordering = (Ordering)Preconditions.checkNotNull(ordering);
   }
   public int compare(Object left, Object right) {
      return this.ordering.compare(this.function.apply(left), this.function.apply(right));
   }
   public boolean equals(@Nullable Object object) {
      if(object == this) {
         return true;
      } else if(!(object instanceof ByFunctionOrdering)) {
         return false;
      } else {
         ByFunctionOrdering<?, ?> that = (ByFunctionOrdering)object;
         return this.function.equals(that.function) && this.ordering.equals(that.ordering);
      }
   }
   public int hashCode() {
      return Objects.hashCode(new Object[]{this.function, this.ordering});
   }
   public String toString() {
      return this.ordering + ".onResultOf(" + this.function + ")";
   }
}
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.math.IntMath;
import java.util.AbstractList;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import java.util.RandomAccess;
import javax.annotation.Nullable;
@GwtCompatible
final class CartesianList extends AbstractList implements RandomAccess {
//
            ImmutableCollection delegateCollection() {
               return CellSet.this;
            }
         };
      }
      public boolean contains(@Nullable Object object) {
         if(!(object instanceof Table.Cell)) {
            return false;
         } else {
            Table.Cell<?, ?, ?> cell = (Table.Cell)object;
            Object value = RegularImmutableTable.this.get(cell.getRowKey(), cell.getColumnKey());
            return value != null && value.equals(cell.getValue());
         }
      }
      boolean isPartialView() {
         return false;
      }
   }
   private final class Values extends ImmutableList {
      private Values() {
      }
      public int size() {
         return RegularImmutableTable.this.size();
      }
      public Object get(int index) {
         return RegularImmutableTable.this.getValue(index);
      }
      boolean isPartialView() {
         return true;
      }
   }
}
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import com.google.common.collect.NaturalOrdering;
import com.google.common.collect.Ordering;
import java.io.Serializable;
import java.util.Iterator;
@GwtCompatible(
   serializable = true
)
final class ReverseNaturalOrdering extends Ordering implements Serializable {
   static final ReverseNaturalOrdering INSTANCE = new ReverseNaturalOrdering();
   private static final long serialVersionUID = 0L;
   public int compare(Comparable left, Comparable right) {
      Preconditions.checkNotNull(left);
      return left == right?0:right.compareTo(left);
   }
   public Ordering reverse() {
      return Ordering.natural();
   }
   public Comparable min(Comparable a, Comparable b) {
      return (Comparable)NaturalOrdering.INSTANCE.max(a, b);
   }
   public Comparable min(Comparable a, Comparable b, Comparable c, Comparable... rest) {
      return (Comparable)NaturalOrdering.INSTANCE.max(a, b, c, rest);
   }
   public Comparable min(Iterator iterator) {
      return (Comparable)NaturalOrdering.INSTANCE.max(iterator);
   }
   public Comparable min(Iterable iterable) {
      return (Comparable)NaturalOrdering.INSTANCE.max(iterable);
   }
   public Comparable max(Comparable a, Comparable b) {
      return (Comparable)NaturalOrdering.INSTANCE.min(a, b);
   }
   public Comparable max(Comparable a, Comparable b, Comparable c, Comparable... rest) {
      return (Comparable)NaturalOrdering.INSTANCE.min(a, b, c, rest);
   }
   public Comparable max(Iterator iterator) {
      return (Comparable)NaturalOrdering.INSTANCE.min(iterator);
   }
   public Comparable max(Iterable iterable) {
      return (Comparable)NaturalOrdering.INSTANCE.min(iterable);
   }
   private Object readResolve() {
      return INSTANCE;
   }
   public String toString() {
      return "Ordering.natural().reverse()";
   }
}
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Preconditions;
import com.google.common.collect.Ordering;
import java.io.Serializable;
import java.util.Iterator;
import javax.annotation.Nullable;
@GwtCompatible(
   serializable = true
)
final class ReverseOrdering extends Ordering implements Serializable {
   final Ordering forwardOrder;
   private static final long serialVersionUID = 0L;
   ReverseOrdering(Ordering forwardOrder) {
      this.forwardOrder = (Ordering)Preconditions.checkNotNull(forwardOrder);
   }
   public int compare(Object a, Object b) {
      return this.forwardOrder.compare(b, a);
   }
   public Ordering reverse() {
      return this.forwardOrder;
   }
   public Object min(Object a, Object b) {
      return this.forwardOrder.max(a, b);
   }
   public Object min(Object a, Object b, Object c, Object... rest) {
      return this.forwardOrder.max(a, b, c, rest);
   }
   public Object min(Iterator iterator) {
      return this.forwardOrder.max(iterator);
   }
   public Object min(Iterable iterable) {
      return this.forwardOrder.max(iterable);
   }
//
      return this.forwardOrder.min(a, b);
   }
   public Object max(Object a, Object b, Object c, Object... rest) {
      return this.forwardOrder.min(a, b, c, rest);
   }
   public Object max(Iterator iterator) {
      return this.forwardOrder.min(iterator);
   }
   public Object max(Iterable iterable) {
      return this.forwardOrder.min(iterable);
   }
   public int hashCode() {
      return -this.forwardOrder.hashCode();
   }
   public boolean equals(@Nullable Object object) {
      if(object == this) {
         return true;
      } else if(object instanceof ReverseOrdering) {
         ReverseOrdering<?> that = (ReverseOrdering)object;
         return this.forwardOrder.equals(that.forwardOrder);
      } else {
         return false;
      }
   }
   public String toString() {
      return this.forwardOrder + ".reverse()";
   }
}
package com.google.common.collect;
import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.Table;
import java.util.SortedMap;
import java.util.SortedSet;
@GwtCompatible
@Beta
public interface RowSortedTable extends Table {
   SortedSet rowKeySet();
   SortedMap rowMap();
}
package com.google.common.collect;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multiset;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
final class Serialization {
   static int readCount(ObjectInputStream stream) throws IOException {
      return stream.readInt();
   }
   static void writeMap(Map map, ObjectOutputStream stream) throws IOException {
      stream.writeInt(map.size());
      for(Entry<K, V> entry : map.entrySet()) {
         stream.writeObject(entry.getKey());
         stream.writeObject(entry.getValue());
      }
   }
   static void populateMap(Map map, ObjectInputStream stream) throws IOException, ClassNotFoundException {
      int size = stream.readInt();
      populateMap(map, stream, size);
   }
   static void populateMap(Map map, ObjectInputStream stream, int size) throws IOException, ClassNotFoundException {
      for(int i = 0; i < size; ++i) {
         K key = stream.readObject();
         V value = stream.readObject();
         map.put(key, value);
      }
   }
   static void writeMultiset(Multiset multiset, ObjectOutputStream stream) throws IOException {
      int entryCount = multiset.entrySet().size();
      stream.writeInt(entryCount);
      for(Multiset.Entry<E> entry : multiset.entrySet()) {
         stream.writeObject(entry.getElement());
         stream.writeInt(entry.getCount());
      }
   }
   static void populateMultiset(Multiset multiset, ObjectInputStream stream) throws IOException, ClassNotFoundException {
      int distinctElements = stream.readInt();
      populateMultiset(multiset, stream, distinctElements);
   }
   static void populateMultiset(Multiset multiset, ObjectInputStream stream, int distinctElements) throws IOException, ClassNotFoundException {
      for(int i = 0; i < distinctElements; ++i) {
         E element = stream.readObject();
         int count = stream.readInt();
         multiset.add(element, count);
      }
   }
   static void writeMultimap(Multimap multimap, ObjectOutputStream stream) throws IOException {
      stream.writeInt(multimap.asMap().size());
      for(Entry<K, Collection<V>> entry : multimap.asMap().entrySet()) {
         stream.writeObject(entry.getKey());
         stream.writeInt(((Collection)entry.getValue()).size());
         for(V value : (Collection)entry.getValue()) {
            stream.writeObject(value);
         }
      }
   }
   static void populateMultimap(Multimap multimap, ObjectInputStream stream) throws IOException, ClassNotFoundException {
      int distinctKeys = stream.readInt();
      populateMultimap(multimap, stream, distinctKeys);
   }
   static void populateMultimap(Multimap multimap, ObjectInputStream stream, int distinctKeys) throws IOException, ClassNotFoundException {
      for(int i = 0; i < distinctKeys; ++i) {
         K key = stream.readObject();
         Collection<V> values = multimap.get(key);
         int valueCount = stream.readInt();
         for(int j = 0; j < valueCount; ++j) {
            V value = stream.readObject();
//
                  if(!Bidi.IsBidiControlChar(uchar)) {
                     indexMap[k++] = m;
                  }
               }
            }
            ++i;
         }
      }
      if(allocLength == bidi.resultLength) {
         return indexMap;
      } else {
         int[] newMap = new int[bidi.resultLength];
         System.arraycopy(indexMap, 0, newMap, 0, bidi.resultLength);
         return newMap;
      }
   }
   static int[] invertMap(int[] srcMap) {
      int srcLength = srcMap.length;
      int destLength = -1;
      int count = 0;
      for(int i = 0; i < srcLength; ++i) {
         int srcEntry = srcMap[i];
         if(srcEntry > destLength) {
            destLength = srcEntry;
         }
         if(srcEntry >= 0) {
            ++count;
         }
      }
      ++destLength;
      int[] destMap = new int[destLength];
      if(count < destLength) {
         Arrays.fill(destMap, -1);
      }
      for(int var8 = 0; var8 < srcLength; ++var8) {
         int srcEntry = srcMap[var8];
         if(srcEntry >= 0) {
            destMap[srcEntry] = var8;
         }
      }
      return destMap;
   }
}
package com.ibm.icu.text;
public class BidiRun {
   int start;
   int limit;
   int insertRemove;
   byte level;
   BidiRun() {
      this(0, 0, (byte)0);
   }
   BidiRun(int start, int limit, byte embeddingLevel) {
      this.start = start;
      this.limit = limit;
      this.level = embeddingLevel;
   }
   void copyFrom(BidiRun run) {
      this.start = run.start;
      this.limit = run.limit;
      this.level = run.level;
      this.insertRemove = run.insertRemove;
   }
   public int getStart() {
      return this.start;
   }
   public int getLimit() {
      return this.limit;
   }
   public int getLength() {
      return this.limit - this.start;
   }
   public byte getEmbeddingLevel() {
      return this.level;
   }
   public boolean isOddRun() {
      return (this.level & 1) == 1;
   }
   public boolean isEvenRun() {
      return (this.level & 1) == 0;
   }
   public byte getDirection() {
      return (byte)(this.level & 1);
   }
   public String toString() {
      return "BidiRun " + this.start + " - " + this.limit + " @ " + this.level;
   }
}
package com.ibm.icu.text;
import com.ibm.icu.lang.UCharacter;
import com.ibm.icu.text.Bidi;
import com.ibm.icu.text.BidiRun;
import com.ibm.icu.text.UTF16;
final class BidiWriter {
   static final char LRM_CHAR = '\u200e';
   static final char RLM_CHAR = '\u200f';
   static final int MASK_R_AL = 8194;
   private static boolean IsCombining(int type) {
      return (1 << type & 448) != 0;
   }
   private static String doWriteForward(String src, int options) {
      switch(options & 10) {
      case 0:
         return src;
      case 2:
         StringBuffer dest = new StringBuffer(src.length());
         int i = 0;
         while(true) {
            int c = UTF16.charAt(src, i);
            i += UTF16.getCharCount(c);
            UTF16.append(dest, UCharacter.getMirror(c));
            if(i >= src.length()) {
               break;
            }
         }
         return dest.toString();
      case 8:
//监督判别投影的高维网络数据特征选择分类管理
      return valueOf(lint, 0);
   }
   public static BigDecimal valueOf(long lint, int scale) {
      BigDecimal res = null;
      if(lint == 0L) {
         res = ZERO;
      } else if(lint == 1L) {
         res = ONE;
      } else if(lint == 10L) {
         res = TEN;
      } else {
         res = new BigDecimal(lint);
      }
      if(scale == 0) {
         return res;
      } else if(scale < 0) {
         throw new NumberFormatException("Negative scale: " + scale);
      } else {
         res = clone(res);
         res.exp = -scale;
         return res;
      }
   }
   private char[] layout() {
      int i = 0;
      StringBuilder sb = null;
      int euse = 0;
      int sig = 0;
      char csign = '\u0000';
      char[] rec = null;
      int len = 0;
      char[] cmant = new char[this.mant.length];
      int $18 = this.mant.length;
      for(i = 0; $18 > 0; ++i) {
         cmant[i] = (char)(this.mant[i] + 48);
         --$18;
      }
      if(this.form != 0) {
         sb = new StringBuilder(cmant.length + 15);
         if(this.ind == -1) {
            sb.append('-');
         }
         euse = this.exp + cmant.length - 1;
         if(this.form == 1) {
            sb.append(cmant[0]);
            if(cmant.length > 1) {
               sb.append('.').append(cmant, 1, cmant.length - 1);
            }
         } else {
            sig = euse % 3;
            if(sig < 0) {
               sig += 3;
            }
            euse -= sig;
            ++sig;
            if(sig >= cmant.length) {
               sb.append(cmant, 0, cmant.length);
               for($18 = sig - cmant.length; $18 > 0; --$18) {
                  sb.append('0');
               }
            } else {
               sb.append(cmant, 0, sig).append('.').append(cmant, sig, cmant.length - sig);
            }
         }
         if(euse != 0) {
            if(euse < 0) {
               csign = '-';
               euse = -euse;
            } else {
               csign = '+';
            }
            sb.append('E').append(csign).append(euse);
         }
         rec = new char[sb.length()];
         $18 = sb.length();
         if(0 != $18) {
            sb.getChars(0, $18, rec, 0);
         }
         return rec;
      } else if(this.exp == 0) {
         if(this.ind >= 0) {
            return cmant;
         } else {
            rec = new char[cmant.length + 1];
            rec[0] = 45;
            System.arraycopy(cmant, 0, rec, 1, cmant.length);
            return rec;
         }
      } else {
         int needsign = this.ind == -1?1:0;
         int mag = this.exp + cmant.length;
         if(mag < 1) {
            len = needsign + 2 - this.exp;
            rec = new char[len];
            if(needsign != 0) {
               rec[0] = 45;
            }
            rec[needsign] = 48;
            rec[needsign + 1] = 46;
            $18 = -mag;
            for(i = needsign + 2; $18 > 0; ++i) {
               rec[i] = 48;
               --$18;
            }
            System.arraycopy(cmant, 0, rec, needsign + 2 - mag, cmant.length);
            return rec;
         } else if(mag <= cmant.length) {
            len = needsign + 1 + cmant.length;
            rec = new char[len];
            if(needsign != 0) {
               rec[0] = 45;
            }
            System.arraycopy(cmant, 0, rec, needsign, mag);
            rec[needsign + mag] = 46;
            System.arraycopy(cmant, mag, rec, needsign + mag + 1, cmant.length - mag);
            return rec;
         } else {
//
            output.addAll(collection);
            AbstractMapBasedMultimap.this.totalSize = collection.size();
            collection.clear();
            return output;
         }
      }
      public boolean equals(@Nullable Object object) {
         return this == object || this.submap.equals(object);
      }
      public int hashCode() {
         return this.submap.hashCode();
      }
      public String toString() {
         return this.submap.toString();
      }
      public void clear() {
         if(this.submap == AbstractMapBasedMultimap.this.map) {
            AbstractMapBasedMultimap.this.clear();
         } else {
            Iterators.clear(new AbstractMapBasedMultimap.AsMap.AsMapIterator());
         }
      }
      Entry wrapEntry(Entry entry) {
         K key = entry.getKey();
         return Maps.immutableEntry(key, AbstractMapBasedMultimap.this.wrapCollection(key, (Collection)entry.getValue()));
      }
      class AsMapEntries extends Maps.EntrySet {
         Map map() {
            return AsMap.this;
         }
         public Iterator iterator() {
            return AsMap.this.new AsMapIterator();
         }
         public boolean contains(Object o) {
            return Collections2.safeContains(AsMap.this.submap.entrySet(), o);
         }
         public boolean remove(Object o) {
            if(!this.contains(o)) {
               return false;
            } else {
               Entry<?, ?> entry = (Entry)o;
               AbstractMapBasedMultimap.this.removeValuesForKey(entry.getKey());
               return true;
            }
         }
      }
      class AsMapIterator implements Iterator {
         final Iterator delegateIterator;
         Collection collection;
         AsMapIterator() {
            this.delegateIterator = AsMap.this.submap.entrySet().iterator();
         }
         public boolean hasNext() {
            return this.delegateIterator.hasNext();
         }
         public Entry next() {
            Entry<K, Collection<V>> entry = (Entry)this.delegateIterator.next();
            this.collection = (Collection)entry.getValue();
            return AsMap.this.wrapEntry(entry);
         }
         public void remove() {
            this.delegateIterator.remove();
            AbstractMapBasedMultimap.this.totalSize = this.collection.size();
            this.collection.clear();
         }
      }
   }
   private abstract class Itr implements Iterator {
      final Iterator keyIterator;
      Object key;
      Collection collection;
      Iterator valueIterator;
      Itr() {
         this.keyIterator = AbstractMapBasedMultimap.this.map.entrySet().iterator();
         this.key = null;
         this.collection = null;
         this.valueIterator = Iterators.emptyModifiableIterator();
      }
      abstract Object output(Object var1, Object var2);
      public boolean hasNext() {
         return this.keyIterator.hasNext() || this.valueIterator.hasNext();
      }
      public Object next() {
         if(!this.valueIterator.hasNext()) {
            Entry<K, Collection<V>> mapEntry = (Entry)this.keyIterator.next();
            this.key = mapEntry.getKey();
            this.collection = (Collection)mapEntry.getValue();
            this.valueIterator = this.collection.iterator();
         }
         return this.output(this.key, this.valueIterator.next());
      }
      public void remove() {
         this.valueIterator.remove();
         if(this.collection.isEmpty()) {
            this.keyIterator.remove();
         }
         AbstractMapBasedMultimap.this.totalSize--;
      }
   }
   private class KeySet extends Maps.KeySet {
      KeySet(Map subMap) {
         super(subMap);
      }
      public Iterator iterator() {
         final Iterator<Entry<K, Collection<V>>> entryIterator = this.map().entrySet().iterator();
         return new Iterator() {
            Entry entry;
            public boolean hasNext() {
               return entryIterator.hasNext();
            }
            public Object next() {
               this.entry = (Entry)entryIterator.next();
               return this.entry.getKey();
            }
            public void remove() {
               CollectPreconditions.checkRemove(this.entry != null);
//
      public Object poll() {
         return null;
      }
      public int size() {
         return 0;
      }
      public Iterator iterator() {
         return Iterators.emptyIterator();
      }
   };
   transient Set keySet;
   transient Collection values;
   transient Set entrySet;
   private static final long serialVersionUID = 5L;
   MapMakerInternalMap(MapMaker builder) {
      this.concurrencyLevel = Math.min(builder.getConcurrencyLevel(), 65536);
      this.keyStrength = builder.getKeyStrength();
      this.valueStrength = builder.getValueStrength();
      this.keyEquivalence = builder.getKeyEquivalence();
      this.valueEquivalence = this.valueStrength.defaultEquivalence();
      this.maximumSize = builder.maximumSize;
      this.expireAfterAccessNanos = builder.getExpireAfterAccessNanos();
      this.expireAfterWriteNanos = builder.getExpireAfterWriteNanos();
      this.entryFactory = MapMakerInternalMap.EntryFactory.getFactory(this.keyStrength, this.expires(), this.evictsBySize());
      this.ticker = builder.getTicker();
      this.removalListener = builder.getRemovalListener();
      this.removalNotificationQueue = (Queue)(this.removalListener == GenericMapMaker.NullListener.INSTANCE?discardingQueue():new ConcurrentLinkedQueue());
      int initialCapacity = Math.min(builder.getInitialCapacity(), 1073741824);
      if(this.evictsBySize()) {
         initialCapacity = Math.min(initialCapacity, this.maximumSize);
      }
      int segmentShift = 0;
      int segmentCount;
      for(segmentCount = 1; segmentCount < this.concurrencyLevel && (!this.evictsBySize() || segmentCount * 2 <= this.maximumSize); segmentCount <<= 1) {
         ++segmentShift;
      }
      this.segmentShift = 32 - segmentShift;
      this.segmentMask = segmentCount - 1;
      this.segments = this.newSegmentArray(segmentCount);
      int segmentCapacity = initialCapacity / segmentCount;
      if(segmentCapacity * segmentCount < initialCapacity) {
         ++segmentCapacity;
      }
      int segmentSize;
      for(segmentSize = 1; segmentSize < segmentCapacity; segmentSize <<= 1) {
         ;
      }
      if(this.evictsBySize()) {
         int maximumSegmentSize = this.maximumSize / segmentCount + 1;
         int remainder = this.maximumSize % segmentCount;
         for(int i = 0; i < this.segments.length; ++i) {
            if(i == remainder) {
               --maximumSegmentSize;
            }
            this.segments[i] = this.createSegment(segmentSize, maximumSegmentSize);
         }
      } else {
         for(int i = 0; i < this.segments.length; ++i) {
            this.segments[i] = this.createSegment(segmentSize, -1);
         }
      }
   }
   boolean evictsBySize() {
      return this.maximumSize != -1;
   }
   boolean expires() {
      return this.expiresAfterWrite() || this.expiresAfterAccess();
   }
   boolean expiresAfterWrite() {
      return this.expireAfterWriteNanos > 0L;
   }
   boolean expiresAfterAccess() {
      return this.expireAfterAccessNanos > 0L;
   }
   boolean usesKeyReferences() {
      return this.keyStrength != MapMakerInternalMap.Strength.STRONG;
   }
   boolean usesValueReferences() {
      return this.valueStrength != MapMakerInternalMap.Strength.STRONG;
   }
   static MapMakerInternalMap.ValueReference unset() {
      return UNSET;
   }
   static MapMakerInternalMap.ReferenceEntry nullEntry() {
      return MapMakerInternalMap.NullEntry.INSTANCE;
   }
   static Queue discardingQueue() {
      return DISCARDING_QUEUE;
   }
   static int rehash(int h) {
      h = h + (h << 15 ^ -12931);
      h = h ^ h >>> 10;
      h = h + (h << 3);
      h = h ^ h >>> 6;
      h = h + (h << 2) + (h << 14);
      return h ^ h >>> 16;
   }
   @GuardedBy("Segment.this")
   @VisibleForTesting
   MapMakerInternalMap.ReferenceEntry newEntry(Object key, int hash, @Nullable MapMakerInternalMap.ReferenceEntry next) {
      return this.segmentFor(hash).newEntry(key, hash, next);
   }
   @GuardedBy("Segment.this")
   @VisibleForTesting
   MapMakerInternalMap.ReferenceEntry copyEntry(MapMakerInternalMap.ReferenceEntry original, MapMakerInternalMap.ReferenceEntry newNext) {
      int hash = original.getHash();
      return this.segmentFor(hash).copyEntry(original, newNext);
   }
   @GuardedBy("Segment.this")
   @VisibleForTesting
   MapMakerInternalMap.ValueReference newValueReference(MapMakerInternalMap.ReferenceEntry entry, Object value) {
//
   public boolean containsValue(@Nullable Object value) {
      return this.seekByValue(value, hash(value)) != null;
   }
   @Nullable
   public Object get(@Nullable Object key) {
      HashBiMap.BiEntry<K, V> entry = this.seekByKey(key, hash(key));
      return entry == null?null:entry.value;
   }
   public Object put(@Nullable Object key, @Nullable Object value) {
      return this.put(key, value, false);
   }
   public Object forcePut(@Nullable Object key, @Nullable Object value) {
      return this.put(key, value, true);
   }
   private Object put(@Nullable Object key, @Nullable Object value, boolean force) {
      int keyHash = hash(key);
      int valueHash = hash(value);
      HashBiMap.BiEntry<K, V> oldEntryForKey = this.seekByKey(key, keyHash);
      if(oldEntryForKey != null && valueHash == oldEntryForKey.valueHash && Objects.equal(value, oldEntryForKey.value)) {
         return value;
      } else {
         HashBiMap.BiEntry<K, V> oldEntryForValue = this.seekByValue(value, valueHash);
         if(oldEntryForValue != null) {
            if(!force) {
               throw new IllegalArgumentException("value already present: " + value);
            }
            this.delete(oldEntryForValue);
         }
         if(oldEntryForKey != null) {
            this.delete(oldEntryForKey);
         }
         HashBiMap.BiEntry<K, V> newEntry = new HashBiMap.BiEntry(key, keyHash, value, valueHash);
         this.insert(newEntry);
         this.rehashIfNecessary();
         return oldEntryForKey == null?null:oldEntryForKey.value;
      }
   }
   @Nullable
   private Object putInverse(@Nullable Object value, @Nullable Object key, boolean force) {
      int valueHash = hash(value);
      int keyHash = hash(key);
      HashBiMap.BiEntry<K, V> oldEntryForValue = this.seekByValue(value, valueHash);
      if(oldEntryForValue != null && keyHash == oldEntryForValue.keyHash && Objects.equal(key, oldEntryForValue.key)) {
         return key;
      } else {
         HashBiMap.BiEntry<K, V> oldEntryForKey = this.seekByKey(key, keyHash);
         if(oldEntryForKey != null) {
            if(!force) {
               throw new IllegalArgumentException("value already present: " + key);
            }
            this.delete(oldEntryForKey);
         }
         if(oldEntryForValue != null) {
            this.delete(oldEntryForValue);
         }
         HashBiMap.BiEntry<K, V> newEntry = new HashBiMap.BiEntry(key, keyHash, value, valueHash);
         this.insert(newEntry);
         this.rehashIfNecessary();
         return oldEntryForValue == null?null:oldEntryForValue.key;
      }
   }
   private void rehashIfNecessary() {
      HashBiMap.BiEntry<K, V>[] oldKToV = this.hashTableKToV;
      if(Hashing.needsResizing(this.size, oldKToV.length, 1.0D)) {
         int newTableSize = oldKToV.length * 2;
         this.hashTableKToV = this.createTable(newTableSize);
         this.hashTableVToK = this.createTable(newTableSize);
         this.mask = newTableSize - 1;
         this.size = 0;
         HashBiMap.BiEntry<K, V> nextEntry;
         for(int bucket = 0; bucket < oldKToV.length; ++bucket) {
            for(HashBiMap.BiEntry<K, V> entry = oldKToV[bucket]; entry != null; entry = nextEntry) {
               nextEntry = entry.nextInKToVBucket;
               this.insert(entry);
            }
         }
         ++this.modCount;
      }
   }
   private HashBiMap.BiEntry[] createTable(int length) {
      return new HashBiMap.BiEntry[length];
   }
   public Object remove(@Nullable Object key) {
      HashBiMap.BiEntry<K, V> entry = this.seekByKey(key, hash(key));
      if(entry == null) {
         return null;
      } else {
         this.delete(entry);
         return entry.value;
      }
   }
   public void clear() {
      this.size = 0;
      Arrays.fill(this.hashTableKToV, (Object)null);
      Arrays.fill(this.hashTableVToK, (Object)null);
      ++this.modCount;
   }
   public int size() {
      return this.size;
   }
   public Set keySet() {
      return new HashBiMap.KeySet();
   }
   public Set values() {
      return this.inverse().keySet();
   }
   public Set entrySet() {
      return new HashBiMap.EntrySet();
   }
   public BiMap inverse() {
      return this.inverse == null?(this.inverse = new HashBiMap.Inverse()):this.inverse;
   }
   @GwtIncompatible("java.io.ObjectOutputStream")
   private void writeObject(ObjectOutputStream stream) throws IOException {
      stream.defaultWriteObject();
//监督判别投影的高维网络数据特征选择设计流程管理
   static final double moonT0 = 0.009042550854582622D;
   static final double moonPi = 0.016592845198710092D;
   public static final CalendarAstronomer.MoonAge NEW_MOON = new CalendarAstronomer.MoonAge(0.0D);
   public static final CalendarAstronomer.MoonAge FIRST_QUARTER = new CalendarAstronomer.MoonAge(1.5707963267948966D);
   public static final CalendarAstronomer.MoonAge FULL_MOON = new CalendarAstronomer.MoonAge(3.141592653589793D);
   public static final CalendarAstronomer.MoonAge LAST_QUARTER = new CalendarAstronomer.MoonAge(4.71238898038469D);
   private long time;
   private double fLongitude;
   private double fLatitude;
   private long fGmtOffset;
   private static final double INVALID = Double.MIN_VALUE;
   private transient double julianDay;
   private transient double julianCentury;
   private transient double sunLongitude;
   private transient double meanAnomalySun;
   private transient double moonLongitude;
   private transient double moonEclipLong;
   private transient double eclipObliquity;
   private transient double siderealT0;
   private transient double siderealTime;
   private transient CalendarAstronomer.Equatorial moonPosition;
   public CalendarAstronomer() {
      this(System.currentTimeMillis());
   }
   public CalendarAstronomer(Date d) {
      this(d.getTime());
   }
   public CalendarAstronomer(long aTime) {
      this.fLongitude = 0.0D;
      this.fLatitude = 0.0D;
      this.fGmtOffset = 0L;
      this.julianDay = Double.MIN_VALUE;
      this.julianCentury = Double.MIN_VALUE;
      this.sunLongitude = Double.MIN_VALUE;
      this.meanAnomalySun = Double.MIN_VALUE;
      this.moonLongitude = Double.MIN_VALUE;
      this.moonEclipLong = Double.MIN_VALUE;
      this.eclipObliquity = Double.MIN_VALUE;
      this.siderealT0 = Double.MIN_VALUE;
      this.siderealTime = Double.MIN_VALUE;
      this.moonPosition = null;
      this.time = aTime;
   }
   public CalendarAstronomer(double longitude, double latitude) {
      this();
      this.fLongitude = normPI(longitude * 0.017453292519943295D);
      this.fLatitude = normPI(latitude * 0.017453292519943295D);
      this.fGmtOffset = (long)(this.fLongitude * 24.0D * 3600000.0D / 6.283185307179586D);
   }
   public void setTime(long aTime) {
      this.time = aTime;
      this.clearCache();
   }
   public void setDate(Date date) {
      this.setTime(date.getTime());
   }
   public void setJulianDay(double jdn) {
      this.time = (long)(jdn * 8.64E7D) + -210866760000000L;
      this.clearCache();
      this.julianDay = jdn;
   }
   public long getTime() {
      return this.time;
   }
   public Date getDate() {
      return new Date(this.time);
   }
   public double getJulianDay() {
      if(this.julianDay == Double.MIN_VALUE) {
         this.julianDay = (double)(this.time - -210866760000000L) / 8.64E7D;
      }
      return this.julianDay;
   }
   public double getJulianCentury() {
      if(this.julianCentury == Double.MIN_VALUE) {
         this.julianCentury = (this.getJulianDay() - 2415020.0D) / 36525.0D;
      }
      return this.julianCentury;
   }
   public double getGreenwichSidereal() {
      if(this.siderealTime == Double.MIN_VALUE) {
         double UT = normalize((double)this.time / 3600000.0D, 24.0D);
         this.siderealTime = normalize(this.getSiderealOffset() + UT * 1.002737909D, 24.0D);
      }
      return this.siderealTime;
   }
   private double getSiderealOffset() {
      if(this.siderealT0 == Double.MIN_VALUE) {
         double JD = Math.floor(this.getJulianDay() - 0.5D) + 0.5D;
         double S = JD - 2451545.0D;
         double T = S / 36525.0D;
         this.siderealT0 = normalize(6.697374558D + 2400.051336D * T + 2.5862E-5D * T * T, 24.0D);
      }
      return this.siderealT0;
   }
   public double getLocalSidereal() {
      return normalize(this.getGreenwichSidereal() + (double)this.fGmtOffset / 3600000.0D, 24.0D);
   }
   private long lstToUT(double lst) {
      double lt = normalize((lst - this.getSiderealOffset()) * 0.9972695663D, 24.0D);
      long base = 86400000L * ((this.time + this.fGmtOffset) / 86400000L) - this.fGmtOffset;
      return base + (long)(lt * 3600000.0D);
   }
   public final CalendarAstronomer.Equatorial eclipticToEquatorial(CalendarAstronomer.Ecliptic ecliptic) {
      return this.eclipticToEquatorial(ecliptic.longitude, ecliptic.latitude);
   }
   public final CalendarAstronomer.Equatorial eclipticToEquatorial(double eclipLong, double eclipLat) {
      double obliq = this.eclipticObliquity();
      double sinE = Math.sin(obliq);
      double cosE = Math.cos(obliq);
      double sinL = Math.sin(eclipLong);
      double cosL = Math.cos(eclipLong);
      double sinB = Math.sin(eclipLat);
      double cosB = Math.cos(eclipLat);
//
errorMessageArgs) {
      if(!expression) {
         throw new VerifyException(Preconditions.format(errorMessageTemplate, errorMessageArgs));
      }
   }
   public static Object verifyNotNull(@Nullable Object reference) {
      return verifyNotNull(reference, "expected a non-null reference", new Object[0]);
   }
   public static Object verifyNotNull(@Nullable Object reference, @Nullable String errorMessageTemplate, @Nullable Object... errorMessageArgs) {
      verify(reference != null, errorMessageTemplate, errorMessageArgs);
      return reference;
   }
}
package com.google.common.base;
import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import javax.annotation.Nullable;
@Beta
@GwtCompatible
public class VerifyException extends RuntimeException {
   public VerifyException() {
   }
   public VerifyException(@Nullable String message) {
      super(message);
   }
}
package com.google.common.base.internal;
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Finalizer implements Runnable {
   private static final Logger logger = Logger.getLogger(Finalizer.class.getName());
   private static final String FINALIZABLE_REFERENCE = "com.google.common.base.FinalizableReference";
   private final WeakReference finalizableReferenceClassReference;
   private final PhantomReference frqReference;
   private final ReferenceQueue queue;
   private static final Field inheritableThreadLocals = getInheritableThreadLocalsField();
   public static void startFinalizer(Class finalizableReferenceClass, ReferenceQueue queue, PhantomReference frqReference) {
      if(!finalizableReferenceClass.getName().equals("com.google.common.base.FinalizableReference")) {
         throw new IllegalArgumentException("Expected com.google.common.base.FinalizableReference.");
      } else {
         Finalizer finalizer = new Finalizer(finalizableReferenceClass, queue, frqReference);
         Thread thread = new Thread(finalizer);
         thread.setName(Finalizer.class.getName());
         thread.setDaemon(true);
         try {
            if(inheritableThreadLocals != null) {
               inheritableThreadLocals.set(thread, (Object)null);
            }
         } catch (Throwable var6) {
            logger.log(Level.INFO, "Failed to clear thread local values inherited by reference finalizer thread.", var6);
         }
         thread.start();
      }
   }
   private Finalizer(Class finalizableReferenceClass, ReferenceQueue queue, PhantomReference frqReference) {
      this.queue = queue;
      this.finalizableReferenceClassReference = new WeakReference(finalizableReferenceClass);
      this.frqReference = frqReference;
   }
   public void run() {
      while(true) {
         try {
            if(!this.cleanUp(this.queue.remove())) {
               return;
            }
         } catch (InterruptedException var2) {
            ;
         }
      }
   }
   private boolean cleanUp(Reference reference) {
      Method finalizeReferentMethod = this.getFinalizeReferentMethod();
      if(finalizeReferentMethod == null) {
         return false;
      } else {
         while(true) {
            reference.clear();
            if(reference == this.frqReference) {
               return false;
            }
            try {
               finalizeReferentMethod.invoke(reference, new Object[0]);
            } catch (Throwable var4) {
               logger.log(Level.SEVERE, "Error cleaning up after reference.", var4);
            }
            if((reference = this.queue.poll()) == null) {
               break;
            }
         }
         return true;
      }
   }
   private Method getFinalizeReferentMethod() {
      Class<?> finalizableReferenceClass = (Class)this.finalizableReferenceClassReference.get();
      if(finalizableReferenceClass == null) {
         return null;
      } else {
         try {
            return finalizableReferenceClass.getMethod("finalizeReferent", new Class[0]);
         } catch (NoSuchMethodException var3) {
            throw new AssertionError(var3);
         }
      }
   }
   public static Field getInheritableThreadLocalsField() {
      try {
         Field inheritableThreadLocals = Thread.class.getDeclaredField("inheritableThreadLocals");
         inheritableThreadLocals.setAccessible(true);
         return inheritableThreadLocals;
//
         }
      } else if(bidi.controlCount > 0) {
         int controlFound = 0;
         int visualStart = 0;
         int i = 0;
         while(true) {
            int length = runs[i].limit - visualStart;
            int insertRemove = runs[i].insertRemove;
            if(visualIndex < runs[i].limit - controlFound + insertRemove) {
               if(insertRemove == 0) {
                  visualIndex += controlFound;
               } else {
                  int logicalStart = runs[i].start;
                  boolean evenRun = runs[i].isEvenRun();
                  int logicalEnd = logicalStart + length - 1;
                  for(int j = 0; j < length; ++j) {
                     int k = evenRun?logicalStart + j:logicalEnd - j;
                     char uchar = bidi.text[k];
                     if(Bidi.IsBidiControlChar(uchar)) {
                        ++controlFound;
                     }
                     if(visualIndex + controlFound == visualStart + j) {
                        break;
                     }
                  }
                  visualIndex += controlFound;
               }
               break;
            }
            controlFound -= insertRemove;
            ++i;
            visualStart += length;
         }
      }
      int i;
      if(runCount <= 10) {
         for(i = 0; visualIndex >= runs[i].limit; ++i) {
            ;
         }
      } else {
         int begin = 0;
         int limit = runCount;
         while(true) {
            i = begin + limit >>> 1;
            if(visualIndex >= runs[i].limit) {
               begin = i + 1;
            } else {
               if(i == 0 || visualIndex >= runs[i - 1].limit) {
                  break;
               }
               limit = i;
            }
         }
      }
      int start = runs[i].start;
      if(runs[i].isEvenRun()) {
         if(i > 0) {
            visualIndex -= runs[i - 1].limit;
         }
         return start + visualIndex;
      } else {
         return start + runs[i].limit - visualIndex - 1;
      }
   }
   static int[] getLogicalMap(Bidi bidi) {
      BidiRun[] runs = bidi.runs;
      int[] indexMap = new int[bidi.length];
      if(bidi.length > bidi.resultLength) {
         Arrays.fill(indexMap, -1);
      }
      int visualStart = 0;
      for(int j = 0; j < bidi.runCount; ++j) {
         int logicalStart = runs[j].start;
         int visualLimit = runs[j].limit;
         if(runs[j].isEvenRun()) {
            while(true) {
               indexMap[logicalStart++] = visualStart++;
               if(visualStart >= visualLimit) {
                  break;
               }
            }
         } else {
            logicalStart = logicalStart + (visualLimit - visualStart);
            while(true) {
               --logicalStart;
               indexMap[logicalStart] = visualStart++;
               if(visualStart >= visualLimit) {
                  break;
               }
            }
         }
      }
      if(bidi.insertPoints.size > 0) {
         int markFound = 0;
         int runCount = bidi.runCount;
         runs = bidi.runs;
         visualStart = 0;
         int length;
         for(int i = 0; i < runCount; visualStart += length) {
            length = runs[i].limit - visualStart;
            int insertRemove = runs[i].insertRemove;
            if((insertRemove & 5) > 0) {
               ++markFound;
            }
            if(markFound > 0) {
               int logicalStart = runs[i].start;
               int logicalLimit = logicalStart + length;
               for(int j = logicalStart; j < logicalLimit; ++j) {
                  indexMap[j] += markFound;
               }
            }
            if((insertRemove & 10) > 0) {
               ++markFound;
            }
            ++i;
         }
      } else if(bidi.controlCount > 0) {
//
      if(token != JsonToken.NUMBER && token != JsonToken.STRING) {
         throw new IllegalStateException("Expected " + JsonToken.NUMBER + " but was " + token);
      } else {
         double result = ((JsonPrimitive)this.peekStack()).getAsDouble();
         if(this.isLenient() || !Double.isNaN(result) && !Double.isInfinite(result)) {
            this.popStack();
            return result;
         } else {
            throw new NumberFormatException("JSON forbids NaN and infinities: " + result);
         }
      }
   }
   public long nextLong() throws IOException {
      JsonToken token = this.peek();
      if(token != JsonToken.NUMBER && token != JsonToken.STRING) {
         throw new IllegalStateException("Expected " + JsonToken.NUMBER + " but was " + token);
      } else {
         long result = ((JsonPrimitive)this.peekStack()).getAsLong();
         this.popStack();
         return result;
      }
   }
   public int nextInt() throws IOException {
      JsonToken token = this.peek();
      if(token != JsonToken.NUMBER && token != JsonToken.STRING) {
         throw new IllegalStateException("Expected " + JsonToken.NUMBER + " but was " + token);
      } else {
         int result = ((JsonPrimitive)this.peekStack()).getAsInt();
         this.popStack();
         return result;
      }
   }
   public void close() throws IOException {
      this.stack.clear();
      this.stack.add(SENTINEL_CLOSED);
   }
   public void skipValue() throws IOException {
      if(this.peek() == JsonToken.NAME) {
         this.nextName();
      } else {
         this.popStack();
      }
   }
   public String toString() {
      return this.getClass().getSimpleName();
   }
   public void promoteNameToValue() throws IOException {
      this.expect(JsonToken.NAME);
      Iterator<?> i = (Iterator)this.peekStack();
      Entry<?, ?> entry = (Entry)i.next();
      this.stack.add(entry.getValue());
      this.stack.add(new JsonPrimitive((String)entry.getKey()));
   }
}
package com.google.gson.internal.bind;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonNull;
import com.google.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.List;
public final class JsonTreeWriter extends JsonWriter {
   private static final Writer UNWRITABLE_WRITER = new Writer() {
      public void write(char[] buffer, int offset, int counter) {
         throw new AssertionError();
      }
      public void flush() throws IOException {
         throw new AssertionError();
      }
      public void close() throws IOException {
         throw new AssertionError();
      }
   };
   private static final JsonPrimitive SENTINEL_CLOSED = new JsonPrimitive("closed");
   private final List stack = new ArrayList();
   private String pendingName;
   private JsonElement product = JsonNull.INSTANCE;
   public JsonTreeWriter() {
      super(UNWRITABLE_WRITER);
   }
   public JsonElement get() {
      if(!this.stack.isEmpty()) {
         throw new IllegalStateException("Expected one JSON element but was " + this.stack);
      } else {
         return this.product;
      }
   }
   private JsonElement peek() {
      return (JsonElement)this.stack.get(this.stack.size() - 1);
   }
   private void put(JsonElement value) {
      if(this.pendingName != null) {
         if(!value.isJsonNull() || this.getSerializeNulls()) {
            JsonObject object = (JsonObject)this.peek();
            object.add(this.pendingName, value);
         }
         this.pendingName = null;
      } else if(this.stack.isEmpty()) {
         this.product = value;
      } else {
         JsonElement element = this.peek();
         if(!(element instanceof JsonArray)) {
            throw new IllegalStateException();
         }
         ((JsonArray)element).add(value);
      }
   }
   public JsonWriter beginArray() throws IOException {
      JsonArray array = new JsonArray();
      this.put(array);
      this.stack.add(array);
      return this;
   }
//监督判别投影的高维网络数据特征选择数据分析
                  MapMakerInternalMap.ValueReference<K, V> v = e.getValueReference();
                  if(v != valueReference) {
                     boolean var18 = false;
                     return var18;
                  }
                  ++this.modCount;
                  this.enqueueNotification(key, hash, valueReference.get(), MapMaker.RemovalCause.COLLECTED);
                  MapMakerInternalMap.ReferenceEntry<K, V> newFirst = this.removeFromChain(first, e);
                  newCount = this.count - 1;
                  table.set(index, newFirst);
                  this.count = newCount;
                  boolean var12 = true;
                  return var12;
               }
            }
            boolean var17 = false;
            return var17;
         } finally {
            this.unlock();
            if(!this.isHeldByCurrentThread()) {
               this.postWriteCleanup();
            }
         }
      }
      boolean clearValue(Object key, int hash, MapMakerInternalMap.ValueReference valueReference) {
         this.lock();
         try {
            AtomicReferenceArray<MapMakerInternalMap.ReferenceEntry<K, V>> table = this.table;
            int index = hash & table.length() - 1;
            MapMakerInternalMap.ReferenceEntry<K, V> first = (MapMakerInternalMap.ReferenceEntry)table.get(index);
            for(MapMakerInternalMap.ReferenceEntry<K, V> e = first; e != null; e = e.getNext()) {
               K entryKey = e.getKey();
               if(e.getHash() == hash && entryKey != null && this.map.keyEquivalence.equivalent(key, entryKey)) {
                  MapMakerInternalMap.ValueReference<K, V> v = e.getValueReference();
                  if(v != valueReference) {
                     boolean var16 = false;
                     return var16;
                  }
                  MapMakerInternalMap.ReferenceEntry<K, V> newFirst = this.removeFromChain(first, e);
                  table.set(index, newFirst);
                  boolean var11 = true;
                  return var11;
               }
            }
            boolean var15 = false;
            return var15;
         } finally {
            this.unlock();
            this.postWriteCleanup();
         }
      }
      @GuardedBy("Segment.this")
      boolean removeEntry(MapMakerInternalMap.ReferenceEntry entry, int hash, MapMaker.RemovalCause cause) {
         int newCount = this.count - 1;
         AtomicReferenceArray<MapMakerInternalMap.ReferenceEntry<K, V>> table = this.table;
         int index = hash & table.length() - 1;
         MapMakerInternalMap.ReferenceEntry<K, V> first = (MapMakerInternalMap.ReferenceEntry)table.get(index);
         for(MapMakerInternalMap.ReferenceEntry<K, V> e = first; e != null; e = e.getNext()) {
            if(e == entry) {
               ++this.modCount;
               this.enqueueNotification(e.getKey(), hash, e.getValueReference().get(), cause);
               MapMakerInternalMap.ReferenceEntry<K, V> newFirst = this.removeFromChain(first, e);
               newCount = this.count - 1;
               table.set(index, newFirst);
               this.count = newCount;
               return true;
            }
         }
         return false;
      }
      boolean isCollected(MapMakerInternalMap.ValueReference valueReference) {
         return valueReference.isComputingReference()?false:valueReference.get() == null;
      }
      Object getLiveValue(MapMakerInternalMap.ReferenceEntry entry) {
         if(entry.getKey() == null) {
            this.tryDrainReferenceQueues();
            return null;
         } else {
            V value = entry.getValueReference().get();
            if(value == null) {
               this.tryDrainReferenceQueues();
               return null;
            } else if(this.map.expires() && this.map.isExpired(entry)) {
               this.tryExpireEntries();
               return null;
            } else {
               return value;
            }
         }
      }
      void postReadCleanup() {
         if((this.readCount.incrementAndGet() & 63) == 0) {
            this.runCleanup();
         }
      }
      @GuardedBy("Segment.this")
      void preWriteCleanup() {
         this.runLockedCleanup();
      }
      void postWriteCleanup() {
         this.runUnlockedCleanup();
      }
      void runCleanup() {
         this.runLockedCleanup();
         this.runUnlockedCleanup();
      }
      void runLockedCleanup() {
         if(this.tryLock()) {
            try {
               this.drainReferenceQueues();
               this.expireEntries();
               this.readCount.set(0);
            } finally {
               this.unlock();
            }
         }
      }
//
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public final class Excluder implements TypeAdapterFactory, Cloneable {
   private static final double IGNORE_VERSIONS = -1.0D;
   public static final Excluder DEFAULT = new Excluder();
   private double version = -1.0D;
   private int modifiers = 136;
   private boolean serializeInnerClasses = true;
   private boolean requireExpose;
   private List serializationStrategies = Collections.emptyList();
   private List deserializationStrategies = Collections.emptyList();
   protected Excluder clone() {
      try {
         return (Excluder)super.clone();
      } catch (CloneNotSupportedException var2) {
         throw new AssertionError();
      }
   }
   public Excluder withVersion(double ignoreVersionsAfter) {
      Excluder result = this.clone();
      result.version = ignoreVersionsAfter;
      return result;
   }
   public Excluder withModifiers(int... modifiers) {
      Excluder result = this.clone();
      result.modifiers = 0;
      for(int modifier : modifiers) {
         result.modifiers |= modifier;
      }
      return result;
   }
   public Excluder disableInnerClassSerialization() {
      Excluder result = this.clone();
      result.serializeInnerClasses = false;
      return result;
   }
   public Excluder excludeFieldsWithoutExposeAnnotation() {
      Excluder result = this.clone();
      result.requireExpose = true;
      return result;
   }
   public Excluder withExclusionStrategy(ExclusionStrategy exclusionStrategy, boolean serialization, boolean deserialization) {
      Excluder result = this.clone();
      if(serialization) {
         result.serializationStrategies = new ArrayList(this.serializationStrategies);
         result.serializationStrategies.add(exclusionStrategy);
      }
      if(deserialization) {
         result.deserializationStrategies = new ArrayList(this.deserializationStrategies);
         result.deserializationStrategies.add(exclusionStrategy);
      }
      return result;
   }
   public TypeAdapter create(final Gson gson, final TypeToken type) {
      Class<?> rawType = type.getRawType();
      final boolean skipSerialize = this.excludeClass(rawType, true);
      final boolean skipDeserialize = this.excludeClass(rawType, false);
      return !skipSerialize && !skipDeserialize?null:new TypeAdapter() {
         private TypeAdapter delegate;
         public Object read(JsonReader in) throws IOException {
            if(skipDeserialize) {
               in.skipValue();
               return null;
            } else {
               return this.delegate().read(in);
            }
         }
         public void write(JsonWriter out, Object value) throws IOException {
            if(skipSerialize) {
               out.nullValue();
            } else {
               this.delegate().write(out, value);
            }
         }
         private TypeAdapter delegate() {
            TypeAdapter<T> d = this.delegate;
            return d != null?d:(this.delegate = gson.getDelegateAdapter(Excluder.this, type));
         }
      };
   }
   public boolean excludeField(Field field, boolean serialize) {
      if((this.modifiers & field.getModifiers()) != 0) {
         return true;
      } else if(this.version != -1.0D && !this.isValidVersion((Since)field.getAnnotation(Since.class), (Until)field.getAnnotation(Until.class))) {
         return true;
      } else if(field.isSynthetic()) {
         return true;
      } else {
         if(this.requireExpose) {
            Expose annotation = (Expose)field.getAnnotation(Expose.class);
            if(annotation == null) {
               return true;
            }
            if(serialize) {
               if(!annotation.serialize()) {
                  return true;
               }
            } else if(!annotation.deserialize()) {
               return true;
            }
         }
         if(!this.serializeInnerClasses && this.isInnerClass(field.getType())) {
            return true;
         } else if(this.isAnonymousOrLocal(field.getType())) {
            return true;
         } else {
            List<ExclusionStrategy> list = serialize?this.serializationStrategies:this.deserializationStrategies;
            if(!list.isEmpty()) {
               FieldAttributes fieldAttributes = new FieldAttributes(field);
               for(ExclusionStrategy exclusionStrategy : list) {
                  if(exclusionStrategy.shouldSkipField(fieldAttributes)) {
                     return true;
//
   }
   public final Equivalence.Wrapper wrap(@Nullable Object reference) {
      return new Equivalence.Wrapper(this, reference);
   }
   @GwtCompatible(
      serializable = true
   )
   public final Equivalence pairwise() {
      return new PairwiseEquivalence(this);
   }
   @Beta
   public final Predicate equivalentTo(@Nullable Object target) {
      return new Equivalence.EquivalentToPredicate(this, target);
   }
   public static Equivalence equals() {
      return Equivalence.Equals.INSTANCE;
   }
   public static Equivalence identity() {
      return Equivalence.Identity.INSTANCE;
   }
   static final class Equals extends Equivalence implements Serializable {
      static final Equivalence.Equals INSTANCE = new Equivalence.Equals();
      private static final long serialVersionUID = 1L;
      protected boolean doEquivalent(Object a, Object b) {
         return a.equals(b);
      }
      public int doHash(Object o) {
         return o.hashCode();
      }
      private Object readResolve() {
         return INSTANCE;
      }
   }
   private static final class EquivalentToPredicate implements Predicate, Serializable {
      private final Equivalence equivalence;
      @Nullable
      private final Object target;
      private static final long serialVersionUID = 0L;
      EquivalentToPredicate(Equivalence equivalence, @Nullable Object target) {
         this.equivalence = (Equivalence)Preconditions.checkNotNull(equivalence);
         this.target = target;
      }
      public boolean apply(@Nullable Object input) {
         return this.equivalence.equivalent(input, this.target);
      }
      public boolean equals(@Nullable Object obj) {
         if(this == obj) {
            return true;
         } else if(!(obj instanceof Equivalence.EquivalentToPredicate)) {
            return false;
         } else {
            Equivalence.EquivalentToPredicate<?> that = (Equivalence.EquivalentToPredicate)obj;
            return this.equivalence.equals(that.equivalence) && Objects.equal(this.target, that.target);
         }
      }
      public int hashCode() {
         return Objects.hashCode(new Object[]{this.equivalence, this.target});
      }
      public String toString() {
         return this.equivalence + ".equivalentTo(" + this.target + ")";
      }
   }
   static final class Identity extends Equivalence implements Serializable {
      static final Equivalence.Identity INSTANCE = new Equivalence.Identity();
      private static final long serialVersionUID = 1L;
      protected boolean doEquivalent(Object a, Object b) {
         return false;
      }
      protected int doHash(Object o) {
         return System.identityHashCode(o);
      }
      private Object readResolve() {
         return INSTANCE;
      }
   }
   public static final class Wrapper implements Serializable {
      private final Equivalence equivalence;
      @Nullable
      private final Object reference;
      private static final long serialVersionUID = 0L;
      private Wrapper(Equivalence equivalence, @Nullable Object reference) {
         this.equivalence = (Equivalence)Preconditions.checkNotNull(equivalence);
         this.reference = reference;
      }
      @Nullable
      public Object get() {
         return this.reference;
      }
      public boolean equals(@Nullable Object obj) {
         if(obj == this) {
            return true;
         } else {
            if(obj instanceof Equivalence.Wrapper) {
               Equivalence.Wrapper<?> that = (Equivalence.Wrapper)obj;
               if(this.equivalence.equals(that.equivalence)) {
                  Equivalence<Object> equivalence = this.equivalence;
                  return equivalence.equivalent(this.reference, that.reference);
               }
            }
            return false;
         }
      }
      public int hashCode() {
         return this.equivalence.hash(this.reference);
      }
      public String toString() {
         return this.equivalence + ".wrap(" + this.reference + ")";
      }
   }
}
package com.google.common.base;
import com.google.common.base.FinalizableReference;
import com.google.common.base.FinalizableReferenceQueue;
import java.lang.ref.PhantomReference;
public abstract class FinalizablePhantomReference extends PhantomReference implements FinalizableReference {
   protected FinalizablePhantomReference(Object referent, FinalizableReferenceQueue queue) {
      super(referent, queue.queue);
//
      this.checkFrozen();
      this.appendItemNames[field] = value;
   }
   public String getAppendItemName(int field) {
      return this.appendItemNames[field];
   }
   /** @deprecated */
   public static boolean isSingleField(String skeleton) {
      char first = skeleton.charAt(0);
      for(int i = 1; i < skeleton.length(); ++i) {
         if(skeleton.charAt(i) != first) {
            return false;
         }
      }
      return true;
   }
   private void setAvailableFormat(String key) {
      this.checkFrozen();
      this.cldrAvailableFormatKeys.add(key);
   }
   private boolean isAvailableFormatSet(String key) {
      return this.cldrAvailableFormatKeys.contains(key);
   }
   public boolean isFrozen() {
      return this.frozen;
   }
   public DateTimePatternGenerator freeze() {
      this.frozen = true;
      return this;
   }
   public DateTimePatternGenerator cloneAsThawed() {
      DateTimePatternGenerator result = (DateTimePatternGenerator)((DateTimePatternGenerator)this.clone());
      this.frozen = false;
      return result;
   }
   public Object clone() {
      try {
         DateTimePatternGenerator result = (DateTimePatternGenerator)((DateTimePatternGenerator)super.clone());
         result.skeleton2pattern = (TreeMap)this.skeleton2pattern.clone();
         result.basePattern_pattern = (TreeMap)this.basePattern_pattern.clone();
         result.appendItemFormats = (String[])this.appendItemFormats.clone();
         result.appendItemNames = (String[])this.appendItemNames.clone();
         result.current = new DateTimePatternGenerator.DateTimeMatcher();
         result.fp = new DateTimePatternGenerator.FormatParser();
         result._distanceInfo = new DateTimePatternGenerator.DistanceInfo();
         result.frozen = false;
         return result;
      } catch (CloneNotSupportedException var2) {
         throw new IllegalArgumentException("Internal Error");
      }
   }
   /** @deprecated */
   public boolean skeletonsAreSimilar(String id, String skeleton) {
      if(id.equals(skeleton)) {
         return true;
      } else {
         TreeSet<String> parser1 = this.getSet(id);
         TreeSet<String> parser2 = this.getSet(skeleton);
         if(parser1.size() != parser2.size()) {
            return false;
         } else {
            Iterator<String> it2 = parser2.iterator();
            for(String item : parser1) {
               int index1 = getCanonicalIndex(item, false);
               String item2 = (String)it2.next();
               int index2 = getCanonicalIndex(item2, false);
               if(types[index1][1] != types[index2][1]) {
                  return false;
               }
            }
            return true;
         }
      }
   }
   private TreeSet getSet(String id) {
      List<Object> items = this.fp.set(id).getItems();
      TreeSet<String> result = new TreeSet();
      for(Object obj : items) {
         String item = obj.toString();
         if(!item.startsWith("G") && !item.startsWith("a")) {
            result.add(item);
         }
      }
      return result;
   }
   private void checkFrozen() {
      if(this.isFrozen()) {
         throw new UnsupportedOperationException("Attempt to modify frozen object");
      }
   }
   private String getBestAppending(DateTimePatternGenerator.DateTimeMatcher source, int missingFields, DateTimePatternGenerator.DistanceInfo distInfo, DateTimePatternGenerator.DateTimeMatcher skipMatcher, int options) {
      String resultPattern = null;
      if(missingFields != 0) {
         DateTimePatternGenerator.PatternWithMatcher resultPatternWithMatcher = this.getBestRaw(source, missingFields, distInfo, skipMatcher);
         resultPattern = this.adjustFieldTypes(resultPatternWithMatcher, source, false, options);
         while(distInfo.missingFieldMask != 0) {
            if((distInfo.missingFieldMask & 24576) == 16384 && (missingFields & 24576) == 24576) {
               resultPatternWithMatcher.pattern = resultPattern;
               resultPattern = this.adjustFieldTypes(resultPatternWithMatcher, source, true, options);
               distInfo.missingFieldMask &= -16385;
            } else {
               int startingMask = distInfo.missingFieldMask;
               DateTimePatternGenerator.PatternWithMatcher tempWithMatcher = this.getBestRaw(source, distInfo.missingFieldMask, distInfo, skipMatcher);
               String temp = this.adjustFieldTypes(tempWithMatcher, source, false, options);
               int foundMask = startingMask & ~distInfo.missingFieldMask;
               int topField = this.getTopBitNumber(foundMask);
               resultPattern = MessageFormat.format(this.getAppendFormat(topField), new Object[]{resultPattern, temp, this.getAppendName(topField)});
            }
         }
      }
      return resultPattern;
   }