save

+import android.view.ViewGroup;
+
+public class a
+{
+  public void a(ViewGroup paramViewGroup) {}
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/a.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+public final class aa
+{
+  public static final int[] a = { 16842755, 16843041, 16843093, 16843097, 16843551, 16843754, 16843771, 16843778, 16843779 };
+  public static final int[] b = { 16842755, 16843189, 16843190, 16843556, 16843557, 16843558, 16843866, 16843867 };
+  public static final int[] c = { 16842755, 16843780, 16843781, 16843782, 16843783, 16843784, 16843785, 16843786, 16843787, 16843788, 16843789, 16843979, 16843980 };
+  public static final int[] d = { 16842755, 16843781 };
+  public static final int[] e = { 16843161 };
+  public static final int[] f = { 16842755, 16843213 };
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/aa.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.content.res.TypedArray;
+import org.xmlpull.v1.XmlPullParser;
+
+public final class ab
+{
+  public static float a(TypedArray paramTypedArray, XmlPullParser paramXmlPullParser, String paramString, int paramInt, float paramFloat)
+  {
+    if (!a(paramXmlPullParser, paramString)) {
+      return paramFloat;
+    }
+    return paramTypedArray.getFloat(paramInt, paramFloat);
+  }
+  
+  public static int a(TypedArray paramTypedArray, XmlPullParser paramXmlPullParser, String paramString, int paramInt)
+  {
+    if (!a(paramXmlPullParser, paramString)) {
+      return -1;
+    }
+    return paramTypedArray.getInt(paramInt, -1);
+  }
+  
+  public static int a(TypedArray paramTypedArray, XmlPullParser paramXmlPullParser, String paramString, int paramInt1, int paramInt2)
+  {
+    if (!a(paramXmlPullParser, paramString)) {
+      return paramInt2;
+    }
+    return paramTypedArray.getColor(paramInt1, paramInt2);
+  }
+  
+  public static boolean a(XmlPullParser paramXmlPullParser, String paramString)
+  {
+    return paramXmlPullParser.getAttributeValue("http://schemas.android.com/apk/res/android", paramString) != null;
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/ab.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.content.res.Resources;
+import android.content.res.Resources.Theme;
+import android.content.res.TypedArray;
+import android.graphics.ColorFilter;
+import android.graphics.PorterDuff.Mode;
+import android.graphics.Rect;
+import android.graphics.Region;
+import android.graphics.drawable.Drawable;
+import android.support.v4.graphics.drawable.DrawableCompat;
+import android.support.v4.graphics.drawable.TintAwareDrawable;
+import android.util.AttributeSet;
+
+public abstract class ac
+  extends Drawable
+  implements TintAwareDrawable
+{
+  public Drawable c;
+  
+  public static TypedArray obtainAttributes(Resources paramResources, Resources.Theme paramTheme, AttributeSet paramAttributeSet, int[] paramArrayOfInt)
+  {
+    if (paramTheme == null) {
+      return paramResources.obtainAttributes(paramAttributeSet, paramArrayOfInt);
+    }
+    return paramTheme.obtainStyledAttributes(paramAttributeSet, paramArrayOfInt, 0, 0);
+  }
+  
+  public void applyTheme(Resources.Theme paramTheme)
+  {
+    if (this.c != null) {
+      DrawableCompat.applyTheme(this.c, paramTheme);
+    }
+  }
+  
+  public void clearColorFilter()
+  {
+    if (this.c != null)
+    {
+      this.c.clearColorFilter();
+      return;
+    }
+    super.clearColorFilter();
+  }
+  
+  public ColorFilter getColorFilter()
+  {
+    if (this.c != null) {
+      return DrawableCompat.getColorFilter(this.c);
+    }
+    return null;
+  }
+  
+  public Drawable getCurrent()
+  {
+    if (this.c != null) {
+      return this.c.getCurrent();
+    }
+    return super.getCurrent();
+  }
+  
+  public int getMinimumHeight()
+  {
+    if (this.c != null) {
+      return this.c.getMinimumHeight();
+    }
+    return super.getMinimumHeight();
+  }
+  
+  public int getMinimumWidth()
+  {
+    if (this.c != null) {
+      return this.c.getMinimumWidth();
+    }
+    return super.getMinimumWidth();
+  }
+  
+  public boolean getPadding(Rect paramRect)
+  {
+    if (this.c != null) {
+      return this.c.getPadding(paramRect);
+    }
+    return super.getPadding(paramRect);
+  }
+  
+  public int[] getState()
+  {
+    if (this.c != null) {
+      return this.c.getState();
+    }
+    return super.getState();
+  }
+  
+  public Region getTransparentRegion()
+  {
+    if (this.c != null) {
+      return this.c.getTransparentRegion();
+    }
+    return super.getTransparentRegion();
+  }
+  
+  public void jumpToCurrentState()
+  {
+    if (this.c != null) {
+      DrawableCompat.jumpToCurrentState(this.c);
+    }
+  }
+  
+  public void onBoundsChange(Rect paramRect)
+  {
+    if (this.c != null)
+    {
+      this.c.setBounds(paramRect);
+      return;
+    }
+    super.onBoundsChange(paramRect);
+  }
+  
+  public boolean onLevelChange(int paramInt)
+  {
+    if (this.c != null) {
+      return this.c.setLevel(paramInt);
+    }
+    return super.onLevelChange(paramInt);
+  }
+  
+  public void setChangingConfigurations(int paramInt)
+  {
+    if (this.c != null)
+    {
+      this.c.setChangingConfigurations(paramInt);
+      return;
+    }
+    super.setChangingConfigurations(paramInt);
+  }
+  
+  public void setColorFilter(int paramInt, PorterDuff.Mode paramMode)
+  {
+    if (this.c != null)
+    {
+      this.c.setColorFilter(paramInt, paramMode);
+      return;
+    }
+    super.setColorFilter(paramInt, paramMode);
+  }
+  
+  public void setFilterBitmap(boolean paramBoolean)
+  {
+    if (this.c != null) {
+      this.c.setFilterBitmap(paramBoolean);
+    }
+  }
+  
+  public void setHotspot(float paramFloat1, float paramFloat2)
+  {
+    if (this.c != null) {
+      DrawableCompat.setHotspot(this.c, paramFloat1, paramFloat2);
+    }
+  }
+  
+  public void setHotspotBounds(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
+  {
+    if (this.c != null) {
+      DrawableCompat.setHotspotBounds(this.c, paramInt1, paramInt2, paramInt3, paramInt4);
+    }
+  }
+  
+  public boolean setState(int[] paramArrayOfInt)
+  {
+    if (this.c != null) {
+      return this.c.setState(paramArrayOfInt);
+    }
+    return super.setState(paramArrayOfInt);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/ac.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import java.io.File;
+import java.io.FileFilter;
+
+final class ad$1
+  implements FileFilter
+{
+  ad$1(String paramString) {}
+  
+  public final boolean accept(File paramFile)
+  {
+    return !paramFile.getName().startsWith(this.a);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/ad$1.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+final class ae$a
+{
+  long a;
+  long b;
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/ae$a.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.util.zip.CRC32;
+import java.util.zip.ZipException;
+
+final class ae
+{
+  static long a(File paramFile)
+    throws IOException
+  {
+    paramFile = new RandomAccessFile(paramFile, "r");
+    try
+    {
+      long l = a(paramFile, a(paramFile));
+      return l;
+    }
+    finally
+    {
+      paramFile.close();
+    }
+  }
+  
+  private static long a(RandomAccessFile paramRandomAccessFile, ae.a parama)
+    throws IOException
+  {
+    CRC32 localCRC32 = new CRC32();
+    long l = parama.b;
+    paramRandomAccessFile.seek(parama.a);
+    int i = (int)Math.min(16384L, l);
+    parama = new byte['䀀'];
+    for (i = paramRandomAccessFile.read(parama, 0, i); i != -1; i = paramRandomAccessFile.read(parama, 0, (int)Math.min(16384L, l)))
+    {
+      localCRC32.update(parama, 0, i);
+      l -= i;
+      if (l == 0L) {
+        break;
+      }
+    }
+    return localCRC32.getValue();
+  }
+  
+  private static ae.a a(RandomAccessFile paramRandomAccessFile)
+    throws IOException, ZipException
+  {
+    long l1 = 0L;
+    long l2 = paramRandomAccessFile.length() - 22L;
+    if (l2 < 0L) {
+      throw new ZipException("File too short to be a zip file: " + paramRandomAccessFile.length());
+    }
+    long l3 = l2 - 65536L;
+    if (l3 < 0L) {}
+    for (;;)
+    {
+      int i = Integer.reverseBytes(101010256);
+      do
+      {
+        paramRandomAccessFile.seek(l2);
+        if (paramRandomAccessFile.readInt() == i) {
+          break;
+        }
+        l3 = l2 - 1L;
+        l2 = l3;
+      } while (l3 >= l1);
+      throw new ZipException("End Of Central Directory signature not found");
+      paramRandomAccessFile.skipBytes(2);
+      paramRandomAccessFile.skipBytes(2);
+      paramRandomAccessFile.skipBytes(2);
+      paramRandomAccessFile.skipBytes(2);
+      ae.a locala = new ae.a();
+      locala.b = (Integer.reverseBytes(paramRandomAccessFile.readInt()) & 0xFFFFFFFF);
+      locala.a = (Integer.reverseBytes(paramRandomAccessFile.readInt()) & 0xFFFFFFFF);
+      return locala;
+      l1 = l3;
+    }
+  }
+  
+  static final class a
+  {
+    long a;
+    long b;
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/ae.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.annotation.TargetApi;
+import android.support.annotation.RequiresApi;
+
+@TargetApi(14)
+@RequiresApi(14)
+final class af
+  extends bo
+{
+  public af()
+  {
+    c(1);
+    a(new am(2)).a(new aj()).a(new am(1));
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/af.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.annotation.TargetApi;
+import android.support.annotation.RequiresApi;
+
+@TargetApi(14)
+@RequiresApi(14)
+public final class ag
+  extends az
+  implements ah
+{
+  public ag(bb parambb)
+  {
+    a(parambb, new aj());
+  }
+  
+  public final void a(boolean paramBoolean)
+  {
+    ((aj)this.a).b = paramBoolean;
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/ag.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+public abstract interface ah
+{
+  public abstract void a(boolean paramBoolean);
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/ah.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.annotation.TargetApi;
+import android.support.annotation.RequiresApi;
+import android.transition.ChangeBounds;
+
+@TargetApi(19)
+@RequiresApi(19)
+public final class ai
+  extends bd
+  implements ah
+{
+  public ai(bb parambb)
+  {
+    a(parambb, new ChangeBounds());
+  }
+  
+  public final void a(boolean paramBoolean)
+  {
+    ((ChangeBounds)this.a).setResizeClip(paramBoolean);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/ai.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.support.transition.TransitionPort;
+import android.support.transition.TransitionPort.TransitionListenerAdapter;
+
+final class aj$1
+  extends TransitionPort.TransitionListenerAdapter
+{
+  boolean a = false;
+  
+  aj$1(aj paramaj) {}
+  
+  public final void onTransitionCancel(TransitionPort paramTransitionPort)
+  {
+    this.a = true;
+  }
+  
+  public final void onTransitionEnd(TransitionPort paramTransitionPort) {}
+  
+  public final void onTransitionPause(TransitionPort paramTransitionPort) {}
+  
+  public final void onTransitionResume(TransitionPort paramTransitionPort) {}
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/aj$1.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.support.transition.TransitionPort;
+import android.support.transition.TransitionPort.TransitionListenerAdapter;
+
+final class aj$2
+  extends TransitionPort.TransitionListenerAdapter
+{
+  boolean a = false;
+  
+  aj$2(aj paramaj) {}
+  
+  public final void onTransitionCancel(TransitionPort paramTransitionPort)
+  {
+    this.a = true;
+  }
+  
+  public final void onTransitionEnd(TransitionPort paramTransitionPort) {}
+  
+  public final void onTransitionPause(TransitionPort paramTransitionPort) {}
+  
+  public final void onTransitionResume(TransitionPort paramTransitionPort) {}
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/aj$2.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+
+final class aj$3
+  extends AnimatorListenerAdapter
+{
+  aj$3(aj paramaj) {}
+  
+  public final void onAnimationEnd(Animator paramAnimator) {}
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/aj$3.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.graphics.drawable.BitmapDrawable;
+import android.view.View;
+import android.view.ViewGroup;
+
+final class aj$4
+  extends AnimatorListenerAdapter
+{
+  aj$4(aj paramaj, ViewGroup paramViewGroup, BitmapDrawable paramBitmapDrawable, View paramView) {}
+  
+  public final void onAnimationEnd(Animator paramAnimator)
+  {
+    br.c(this.a).b(this.b);
+    this.c.setVisibility(0);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/aj$4.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.animation.Animator;
+import android.annotation.TargetApi;
+import android.support.annotation.RequiresApi;
+import android.support.transition.TransitionValues;
+import android.view.ViewGroup;
+
+@TargetApi(14)
+@RequiresApi(14)
+public final class ak
+  extends az
+  implements bt
+{
+  public ak(bb parambb)
+  {
+    a(parambb, new am());
+  }
+  
+  public ak(bb parambb, int paramInt)
+  {
+    a(parambb, new am(paramInt));
+  }
+  
+  public final Animator a(ViewGroup paramViewGroup, TransitionValues paramTransitionValues1, int paramInt1, TransitionValues paramTransitionValues2, int paramInt2)
+  {
+    return ((am)this.a).a(paramViewGroup, paramTransitionValues1, paramInt1, paramTransitionValues2, paramInt2);
+  }
+  
+  public final boolean a(TransitionValues paramTransitionValues)
+  {
+    return ((am)this.a).c(paramTransitionValues);
+  }
+  
+  public final Animator b(ViewGroup paramViewGroup, TransitionValues paramTransitionValues1, int paramInt1, TransitionValues paramTransitionValues2, int paramInt2)
+  {
+    return ((am)this.a).b(paramViewGroup, paramTransitionValues1, paramInt1, paramTransitionValues1, paramInt1);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/ak.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.animation.Animator;
+import android.annotation.TargetApi;
+import android.support.annotation.RequiresApi;
+import android.support.transition.TransitionValues;
+import android.transition.Fade;
+import android.view.ViewGroup;
+
+@TargetApi(19)
+@RequiresApi(19)
+public final class al
+  extends bd
+  implements bt
+{
+  public al(bb parambb)
+  {
+    a(parambb, new Fade());
+  }
+  
+  public al(bb parambb, int paramInt)
+  {
+    a(parambb, new Fade(paramInt));
+  }
+  
+  public final Animator a(ViewGroup paramViewGroup, TransitionValues paramTransitionValues1, int paramInt1, TransitionValues paramTransitionValues2, int paramInt2)
+  {
+    return ((Fade)this.a).onAppear(paramViewGroup, d(paramTransitionValues1), paramInt1, d(paramTransitionValues2), paramInt2);
+  }
+  
+  public final boolean a(TransitionValues paramTransitionValues)
+  {
+    return ((Fade)this.a).isVisible(d(paramTransitionValues));
+  }
+  
+  public final Animator b(ViewGroup paramViewGroup, TransitionValues paramTransitionValues1, int paramInt1, TransitionValues paramTransitionValues2, int paramInt2)
+  {
+    return ((Fade)this.a).onDisappear(paramViewGroup, d(paramTransitionValues1), paramInt1, d(paramTransitionValues2), paramInt2);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/al.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.support.transition.TransitionPort;
+import android.support.transition.TransitionPort.TransitionListenerAdapter;
+import android.view.View;
+
+final class am$1
+  extends TransitionPort.TransitionListenerAdapter
+{
+  boolean a = false;
+  float b;
+  
+  am$1(am paramam, View paramView) {}
+  
+  public final void onTransitionCancel(TransitionPort paramTransitionPort)
+  {
+    this.c.setAlpha(1.0F);
+    this.a = true;
+  }
+  
+  public final void onTransitionEnd(TransitionPort paramTransitionPort)
+  {
+    if (!this.a) {
+      this.c.setAlpha(1.0F);
+    }
+  }
+  
+  public final void onTransitionPause(TransitionPort paramTransitionPort)
+  {
+    this.b = this.c.getAlpha();
+    this.c.setAlpha(1.0F);
+  }
+  
+  public final void onTransitionResume(TransitionPort paramTransitionPort)
+  {
+    this.c.setAlpha(this.b);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/am$1.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.view.View;
+import android.view.ViewGroup;
+
+final class am$2
+  extends AnimatorListenerAdapter
+{
+  am$2(am paramam, View paramView1, View paramView2, int paramInt, View paramView3, ViewGroup paramViewGroup) {}
+  
+  public final void onAnimationEnd(Animator paramAnimator)
+  {
+    this.a.setAlpha(1.0F);
+    if (this.b != null) {
+      this.b.setVisibility(this.c);
+    }
+    if (this.d != null) {
+      ((bq)br.c(this.e)).b(this.d);
+    }
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/am$2.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.view.View;
+import android.view.ViewGroup;
+
+final class am$3
+  extends AnimatorListenerAdapter
+{
+  boolean a = false;
+  float b = -1.0F;
+  
+  am$3(am paramam, View paramView1, View paramView2, int paramInt, View paramView3, ViewGroup paramViewGroup) {}
+  
+  public final void onAnimationCancel(Animator paramAnimator)
+  {
+    this.a = true;
+    if (this.b >= 0.0F) {
+      this.c.setAlpha(this.b);
+    }
+  }
+  
+  public final void onAnimationEnd(Animator paramAnimator)
+  {
+    if (!this.a) {
+      this.c.setAlpha(1.0F);
+    }
+    if ((this.d != null) && (!this.a)) {
+      this.d.setVisibility(this.e);
+    }
+    if (this.f != null) {
+      ((bq)br.c(this.g)).a(this.f);
+    }
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/am$3.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.annotation.TargetApi;
+import android.support.annotation.RequiresApi;
+import android.support.transition.TransitionPort;
+import android.support.transition.TransitionPort.TransitionListenerAdapter;
+import android.support.transition.TransitionValues;
+import android.support.v4.view.ViewCompat;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import java.util.Map;
+
+@TargetApi(14)
+@RequiresApi(14)
+final class am
+  extends bw
+{
+  private static boolean a = false;
+  private int b;
+  
+  public am()
+  {
+    this(3);
+  }
+  
+  public am(int paramInt)
+  {
+    this.b = paramInt;
+  }
+  
+  private static Animator a(View paramView, float paramFloat1, float paramFloat2, AnimatorListenerAdapter paramAnimatorListenerAdapter)
+  {
+    ObjectAnimator localObjectAnimator = null;
+    if (paramFloat1 == paramFloat2)
+    {
+      paramView = localObjectAnimator;
+      if (paramAnimatorListenerAdapter != null)
+      {
+        paramAnimatorListenerAdapter.onAnimationEnd(null);
+        paramView = localObjectAnimator;
+      }
+    }
+    do
+    {
+      return paramView;
+      localObjectAnimator = ObjectAnimator.ofFloat(paramView, "alpha", new float[] { paramFloat1, paramFloat2 });
+      if (a) {
+        new StringBuilder("Created animator ").append(localObjectAnimator);
+      }
+      paramView = localObjectAnimator;
+    } while (paramAnimatorListenerAdapter == null);
+    localObjectAnimator.addListener(paramAnimatorListenerAdapter);
+    return localObjectAnimator;
+  }
+  
+  public final Animator a(ViewGroup paramViewGroup, TransitionValues paramTransitionValues1, int paramInt1, final TransitionValues paramTransitionValues2, int paramInt2)
+  {
+    if (((this.b & 0x1) != 1) || (paramTransitionValues2 == null)) {
+      return null;
+    }
+    paramTransitionValues2 = paramTransitionValues2.view;
+    if (a) {
+      if (paramTransitionValues1 == null) {
+        break label112;
+      }
+    }
+    label112:
+    for (paramViewGroup = paramTransitionValues1.view;; paramViewGroup = null)
+    {
+      new StringBuilder("Fade.onAppear: startView, startVis, endView, endVis = ").append(paramViewGroup).append(", ").append(paramInt1).append(", ").append(paramTransitionValues2).append(", ").append(paramInt2);
+      paramTransitionValues2.setAlpha(0.0F);
+      a(new TransitionPort.TransitionListenerAdapter()
+      {
+        boolean a = false;
+        float b;
+        
+        public final void onTransitionCancel(TransitionPort paramAnonymousTransitionPort)
+        {
+          paramTransitionValues2.setAlpha(1.0F);
+          this.a = true;
+        }
+        
+        public final void onTransitionEnd(TransitionPort paramAnonymousTransitionPort)
+        {
+          if (!this.a) {
+            paramTransitionValues2.setAlpha(1.0F);
+          }
+        }
+        
+        public final void onTransitionPause(TransitionPort paramAnonymousTransitionPort)
+        {
+          this.b = paramTransitionValues2.getAlpha();
+          paramTransitionValues2.setAlpha(1.0F);
+        }
+        
+        public final void onTransitionResume(TransitionPort paramAnonymousTransitionPort)
+        {
+          paramTransitionValues2.setAlpha(this.b);
+        }
+      });
+      return a(paramTransitionValues2, 0.0F, 1.0F, null);
+    }
+  }
+  
+  public final void a(TransitionValues paramTransitionValues)
+  {
+    super.a(paramTransitionValues);
+    int[] arrayOfInt = new int[2];
+    paramTransitionValues.view.getLocationOnScreen(arrayOfInt);
+    paramTransitionValues.values.put("android:fade:screenX", Integer.valueOf(arrayOfInt[0]));
+    paramTransitionValues.values.put("android:fade:screenY", Integer.valueOf(arrayOfInt[1]));
+  }
+  
+  public final Animator b(final ViewGroup paramViewGroup, TransitionValues paramTransitionValues1, int paramInt1, final TransitionValues paramTransitionValues2, final int paramInt2)
+  {
+    if ((this.b & 0x2) != 2) {
+      return null;
+    }
+    final Object localObject1;
+    label22:
+    label34:
+    Object localObject3;
+    final Object localObject2;
+    if (paramTransitionValues1 != null)
+    {
+      localObject1 = paramTransitionValues1.view;
+      if (paramTransitionValues2 == null) {
+        break label244;
+      }
+      paramTransitionValues2 = paramTransitionValues2.view;
+      if (a) {
+        new StringBuilder("Fade.onDisappear: startView, startVis, endView, endVis = ").append(localObject1).append(", ").append(paramInt1).append(", ").append(paramTransitionValues2).append(", ").append(paramInt2);
+      }
+      if ((paramTransitionValues2 != null) && (paramTransitionValues2.getParent() != null)) {
+        break label355;
+      }
+      if (paramTransitionValues2 == null) {
+        break label250;
+      }
+      localObject3 = null;
+      localObject2 = paramTransitionValues2;
+      localObject1 = paramTransitionValues2;
+      paramTransitionValues2 = (TransitionValues)localObject3;
+    }
+    for (;;)
+    {
+      label117:
+      if (localObject1 != null)
+      {
+        paramInt1 = ((Integer)paramTransitionValues1.values.get("android:fade:screenX")).intValue();
+        int i = ((Integer)paramTransitionValues1.values.get("android:fade:screenY")).intValue();
+        paramTransitionValues1 = new int[2];
+        paramViewGroup.getLocationOnScreen(paramTransitionValues1);
+        ViewCompat.offsetLeftAndRight((View)localObject1, paramInt1 - paramTransitionValues1[0] - ((View)localObject1).getLeft());
+        ViewCompat.offsetTopAndBottom((View)localObject1, i - paramTransitionValues1[1] - ((View)localObject1).getTop());
+        ((bq)br.c(paramViewGroup)).a((View)localObject1);
+        a((View)localObject2, 1.0F, 0.0F, new AnimatorListenerAdapter()
+        {
+          public final void onAnimationEnd(Animator paramAnonymousAnimator)
+          {
+            localObject2.setAlpha(1.0F);
+            if (paramTransitionValues2 != null) {
+              paramTransitionValues2.setVisibility(paramInt2);
+            }
+            if (localObject1 != null) {
+              ((bq)br.c(paramViewGroup)).b(localObject1);
+            }
+          }
+        });
+        localObject1 = null;
+        break label22;
+        label244:
+        paramTransitionValues2 = null;
+        break label34;
+        label250:
+        if (localObject1 == null) {
+          break label475;
+        }
+        if (((View)localObject1).getParent() == null)
+        {
+          paramTransitionValues2 = null;
+          localObject3 = localObject1;
+          localObject2 = localObject1;
+          localObject1 = localObject3;
+          continue;
+        }
+        if ((!(((View)localObject1).getParent() instanceof View)) || (((View)localObject1).getParent().getParent() != null)) {
+          break label475;
+        }
+        paramInt1 = ((View)((View)localObject1).getParent()).getId();
+        if ((paramInt1 == -1) || (paramViewGroup.findViewById(paramInt1) == null) || (!this.q)) {
+          break label466;
+        }
+        paramTransitionValues2 = (TransitionValues)localObject1;
+      }
+      for (;;)
+      {
+        localObject3 = null;
+        localObject2 = paramTransitionValues2;
+        paramTransitionValues2 = (TransitionValues)localObject3;
+        break label117;
+        label355:
+        if (paramInt2 == 4)
+        {
+          localObject1 = paramTransitionValues2;
+          localObject3 = null;
+          localObject2 = paramTransitionValues2;
+          paramTransitionValues2 = (TransitionValues)localObject1;
+          localObject1 = localObject3;
+          break label117;
+        }
+        if (localObject1 == paramTransitionValues2)
+        {
+          localObject1 = paramTransitionValues2;
+          localObject3 = null;
+          localObject2 = paramTransitionValues2;
+          paramTransitionValues2 = (TransitionValues)localObject1;
+          localObject1 = localObject3;
+          break label117;
+        }
+        paramTransitionValues2 = null;
+        localObject3 = localObject1;
+        localObject2 = localObject1;
+        localObject1 = localObject3;
+        break label117;
+        if (paramTransitionValues2 == null) {
+          break;
+        }
+        paramTransitionValues2.setVisibility(0);
+        a((View)localObject2, 1.0F, 0.0F, new AnimatorListenerAdapter()
+        {
+          boolean a = false;
+          float b = -1.0F;
+          
+          public final void onAnimationCancel(Animator paramAnonymousAnimator)
+          {
+            this.a = true;
+            if (this.b >= 0.0F) {
+              localObject2.setAlpha(this.b);
+            }
+          }
+          
+          public final void onAnimationEnd(Animator paramAnonymousAnimator)
+          {
+            if (!this.a) {
+              localObject2.setAlpha(1.0F);
+            }
+            if ((paramTransitionValues2 != null) && (!this.a)) {
+              paramTransitionValues2.setVisibility(paramInt2);
+            }
+            if (localObject1 != null) {
+              ((bq)br.c(paramViewGroup)).a(localObject1);
+            }
+          }
+        });
+        label466:
+        paramTransitionValues2 = null;
+        localObject1 = null;
+      }
+      label475:
+      paramTransitionValues2 = null;
+      localObject2 = null;
+      localObject1 = null;
+    }
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/am.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+import android.animation.TypeEvaluator;
+import android.annotation.TargetApi;
+import android.graphics.Rect;
+import android.support.annotation.RequiresApi;
+
+@TargetApi(14)
+@RequiresApi(14)
+final class an
+  implements TypeEvaluator<Rect>
+{
+  private Rect a;
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/an.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface AnimRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/AnimRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface AnimatorRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/AnimatorRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface AnyRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/AnyRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.TYPE})
+public @interface AnyThread {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/AnyThread.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface ArrayRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/ArrayRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface AttrRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/AttrRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.TYPE})
+public @interface BinderThread {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/BinderThread.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface BoolRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/BoolRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD})
+public @interface CallSuper {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/CallSuper.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD})
+public @interface CheckResult
+{
+  String suggest() default "";
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/CheckResult.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.LOCAL_VARIABLE, java.lang.annotation.ElementType.FIELD})
+public @interface ColorInt {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/ColorInt.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface ColorRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/ColorRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface DimenRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/DimenRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE, java.lang.annotation.ElementType.ANNOTATION_TYPE})
+public @interface Dimension
+{
+  public static final int DP = 0;
+  public static final int PX = 1;
+  public static final int SP = 2;
+  
+  int unit() default 1;
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/Dimension.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface DrawableRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/DrawableRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE, java.lang.annotation.ElementType.ANNOTATION_TYPE})
+public @interface FloatRange
+{
+  double from() default Double.NEGATIVE_INFINITY;
+  
+  boolean fromInclusive() default true;
+  
+  double to() default Double.POSITIVE_INFINITY;
+  
+  boolean toInclusive() default true;
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/FloatRange.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface FractionRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/FractionRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface IdRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/IdRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.SOURCE)
+@Target({java.lang.annotation.ElementType.ANNOTATION_TYPE})
+public @interface IntDef
+{
+  boolean flag() default false;
+  
+  long[] value() default {};
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/IntDef.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE, java.lang.annotation.ElementType.ANNOTATION_TYPE})
+public @interface IntRange
+{
+  long from() default Long.MIN_VALUE;
+  
+  long to() default Long.MAX_VALUE;
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/IntRange.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface IntegerRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/IntegerRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface InterpolatorRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/InterpolatorRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.PACKAGE, java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.ANNOTATION_TYPE, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.FIELD})
+public @interface Keep {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/Keep.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface LayoutRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/LayoutRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.TYPE})
+public @interface MainThread {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/MainThread.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface MenuRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/MenuRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.ANNOTATION_TYPE, java.lang.annotation.ElementType.PACKAGE})
+public @interface NonNull {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/NonNull.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.ANNOTATION_TYPE, java.lang.annotation.ElementType.PACKAGE})
+public @interface Nullable {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/Nullable.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface PluralsRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/PluralsRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+@Dimension(unit=1)
+public @interface Px {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/Px.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface RawRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/RawRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.FIELD})
+public @interface RequiresApi
+{
+  @IntRange(from=1L)
+  int api() default 1;
+  
+  @IntRange(from=1L)
+  int value() default 1;
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/RequiresApi.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.ANNOTATION_TYPE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.PARAMETER})
+public @interface RequiresPermission
+{
+  String[] allOf() default {};
+  
+  String[] anyOf() default {};
+  
+  boolean conditional() default false;
+  
+  String value() default "";
+  
+  @Target({java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER})
+  public static @interface Read
+  {
+    RequiresPermission value() default @RequiresPermission;
+  }
+  
+  @Target({java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER})
+  public static @interface Write
+  {
+    RequiresPermission value() default @RequiresPermission;
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/RequiresPermission.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.ANNOTATION_TYPE, java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.PACKAGE})
+public @interface RestrictTo
+{
+  Scope[] value();
+  
+  public static enum Scope
+  {
+    static
+    {
+      GROUP_ID = new Scope("GROUP_ID", 2);
+      TESTS = new Scope("TESTS", 3);
+    }
+    
+    private Scope() {}
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/RestrictTo.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.LOCAL_VARIABLE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.ANNOTATION_TYPE})
+public @interface Size
+{
+  long max() default Long.MAX_VALUE;
+  
+  long min() default Long.MIN_VALUE;
+  
+  long multiple() default 1L;
+  
+  long value() default -1L;
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/Size.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.SOURCE)
+@Target({java.lang.annotation.ElementType.ANNOTATION_TYPE})
+public @interface StringDef
+{
+  String[] value() default {};
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/StringDef.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface StringRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/StringRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface StyleRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/StyleRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface StyleableRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/StyleableRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.SOURCE)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD})
+public @interface TransitionRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/TransitionRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.TYPE})
+public @interface UiThread {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/UiThread.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.CLASS)
+public @interface VisibleForTesting
+{
+  public static final int NONE = 5;
+  public static final int PACKAGE_PRIVATE = 3;
+  public static final int PRIVATE = 2;
+  public static final int PROTECTED = 4;
+  
+  int otherwise() default 2;
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/VisibleForTesting.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.TYPE})
+public @interface WorkerThread {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/WorkerThread.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.LOCAL_VARIABLE})
+public @interface XmlRes {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/annotation/XmlRes.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.compat;
+
+public final class BuildConfig
+{
+  public static final String APPLICATION_ID = "android.support.compat";
+  public static final String BUILD_TYPE = "release";
+  public static final boolean DEBUG = false;
+  public static final String FLAVOR = "";
+  public static final int VERSION_CODE = -1;
+  public static final String VERSION_NAME = "";
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/compat/BuildConfig.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.compat;
+
+public final class R {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/compat/R.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.coreui;
+
+public final class BuildConfig
+{
+  public static final String APPLICATION_ID = "android.support.coreui";
+  public static final String BUILD_TYPE = "release";
+  public static final boolean DEBUG = false;
+  public static final String FLAVOR = "";
+  public static final int VERSION_CODE = -1;
+  public static final String VERSION_NAME = "";
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/coreui/BuildConfig.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.coreui;
+
+public final class R {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/coreui/R.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.coreutils;
+
+public final class BuildConfig
+{
+  public static final String APPLICATION_ID = "android.support.coreutils";
+  public static final String BUILD_TYPE = "release";
+  public static final boolean DEBUG = false;
+  public static final String FLAVOR = "";
+  public static final int VERSION_CODE = -1;
+  public static final String VERSION_NAME = "";
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/coreutils/BuildConfig.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.coreutils;
+
+public final class R {}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/coreutils/R.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design;
+
+public final class BuildConfig
+{
+  public static final String APPLICATION_ID = "android.support.design";
+  public static final String BUILD_TYPE = "release";
+  public static final boolean DEBUG = false;
+  public static final String FLAVOR = "";
+  public static final int VERSION_CODE = -1;
+  public static final String VERSION_NAME = "";
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/BuildConfig.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.content.Context;
+import android.support.v4.view.ViewCompat;
+import android.support.v7.widget.ViewUtils;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+
+public class BaselineLayout
+  extends ViewGroup
+{
+  private int a = -1;
+  
+  public BaselineLayout(Context paramContext)
+  {
+    super(paramContext, null, 0);
+  }
+  
+  public BaselineLayout(Context paramContext, AttributeSet paramAttributeSet)
+  {
+    super(paramContext, paramAttributeSet, 0);
+  }
+  
+  public BaselineLayout(Context paramContext, AttributeSet paramAttributeSet, int paramInt)
+  {
+    super(paramContext, paramAttributeSet, paramInt);
+  }
+  
+  public int getBaseline()
+  {
+    return this.a;
+  }
+  
+  protected void onLayout(boolean paramBoolean, int paramInt1, int paramInt2, int paramInt3, int paramInt4)
+  {
+    int j = getChildCount();
+    int k = getPaddingLeft();
+    int m = getPaddingRight();
+    int i = getPaddingTop();
+    paramInt2 = 0;
+    if (paramInt2 < j)
+    {
+      View localView = getChildAt(paramInt2);
+      int n;
+      int i1;
+      int i2;
+      if (localView.getVisibility() != 8)
+      {
+        n = localView.getMeasuredWidth();
+        i1 = localView.getMeasuredHeight();
+        i2 = k + (paramInt3 - paramInt1 - m - k - n) / 2;
+        if ((this.a == -1) || (localView.getBaseline() == -1)) {
+          break label141;
+        }
+      }
+      label141:
+      for (paramInt4 = this.a + i - localView.getBaseline();; paramInt4 = i)
+      {
+        localView.layout(i2, paramInt4, n + i2, i1 + paramInt4);
+        paramInt2 += 1;
+        break;
+      }
+    }
+  }
+  
+  protected void onMeasure(int paramInt1, int paramInt2)
+  {
+    int i4 = getChildCount();
+    int i2 = 0;
+    int m = 0;
+    int j = -1;
+    int k = 0;
+    int i3 = 0;
+    int i = -1;
+    int n;
+    if (i2 < i4)
+    {
+      View localView = getChildAt(i2);
+      if (localView.getVisibility() == 8) {
+        break label235;
+      }
+      measureChild(localView, paramInt1, paramInt2);
+      int i5 = localView.getBaseline();
+      n = i;
+      int i1 = j;
+      if (i5 != -1)
+      {
+        i1 = Math.max(j, i5);
+        n = Math.max(i, localView.getMeasuredHeight() - i5);
+      }
+      i3 = Math.max(i3, localView.getMeasuredWidth());
+      k = Math.max(k, localView.getMeasuredHeight());
+      i = ViewUtils.combineMeasuredStates(m, ViewCompat.getMeasuredState(localView));
+      j = i1;
+    }
+    for (m = n;; m = n)
+    {
+      i2 += 1;
+      n = i;
+      i = m;
+      m = n;
+      break;
+      n = k;
+      if (j != -1)
+      {
+        n = Math.max(k, Math.max(i, getPaddingBottom()) + j);
+        this.a = j;
+      }
+      i = Math.max(n, getSuggestedMinimumHeight());
+      setMeasuredDimension(ViewCompat.resolveSizeAndState(Math.max(i3, getSuggestedMinimumWidth()), paramInt1, m), ViewCompat.resolveSizeAndState(i, paramInt2, m << 16));
+      return;
+      label235:
+      n = i;
+      i = m;
+    }
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/BaselineLayout.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.Drawable.ConstantState;
+import android.support.annotation.NonNull;
+import android.support.annotation.RestrictTo;
+import android.support.design.R.dimen;
+import android.support.design.R.drawable;
+import android.support.design.R.id;
+import android.support.design.R.layout;
+import android.support.v4.content.ContextCompat;
+import android.support.v4.graphics.drawable.DrawableCompat;
+import android.support.v4.view.PointerIconCompat;
+import android.support.v4.view.ViewCompat;
+import android.support.v7.view.menu.MenuItemImpl;
+import android.support.v7.view.menu.MenuView.ItemView;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.widget.FrameLayout;
+import android.widget.FrameLayout.LayoutParams;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class BottomNavigationItemView
+  extends FrameLayout
+  implements MenuView.ItemView
+{
+  public static final int INVALID_ITEM_POSITION = -1;
+  private static final int[] a = { 16842912 };
+  private final int b;
+  private final int c;
+  private final float d;
+  private final float e;
+  private boolean f;
+  private ImageView g;
+  private final TextView h;
+  private final TextView i;
+  private int j = -1;
+  private MenuItemImpl k;
+  private ColorStateList l;
+  
+  public BottomNavigationItemView(@NonNull Context paramContext)
+  {
+    this(paramContext, null);
+  }
+  
+  public BottomNavigationItemView(@NonNull Context paramContext, AttributeSet paramAttributeSet)
+  {
+    this(paramContext, paramAttributeSet, 0);
+  }
+  
+  public BottomNavigationItemView(Context paramContext, AttributeSet paramAttributeSet, int paramInt)
+  {
+    super(paramContext, paramAttributeSet, paramInt);
+    paramAttributeSet = getResources();
+    paramInt = paramAttributeSet.getDimensionPixelSize(R.dimen.design_bottom_navigation_text_size);
+    int m = paramAttributeSet.getDimensionPixelSize(R.dimen.design_bottom_navigation_active_text_size);
+    this.b = paramAttributeSet.getDimensionPixelSize(R.dimen.design_bottom_navigation_margin);
+    this.c = (paramInt - m);
+    this.d = (m * 1.0F / paramInt);
+    this.e = (paramInt * 1.0F / m);
+    LayoutInflater.from(paramContext).inflate(R.layout.design_bottom_navigation_item, this, true);
+    setBackgroundResource(R.drawable.design_bottom_navigation_item_background);
+    this.g = ((ImageView)findViewById(R.id.icon));
+    this.h = ((TextView)findViewById(R.id.smallLabel));
+    this.i = ((TextView)findViewById(R.id.largeLabel));
+  }
+  
+  public MenuItemImpl getItemData()
+  {
+    return this.k;
+  }
+  
+  public int getItemPosition()
+  {
+    return this.j;
+  }
+  
+  public void initialize(MenuItemImpl paramMenuItemImpl, int paramInt)
+  {
+    this.k = paramMenuItemImpl;
+    setCheckable(paramMenuItemImpl.isCheckable());
+    setChecked(paramMenuItemImpl.isChecked());
+    setEnabled(paramMenuItemImpl.isEnabled());
+    setIcon(paramMenuItemImpl.getIcon());
+    setTitle(paramMenuItemImpl.getTitle());
+    setId(paramMenuItemImpl.getItemId());
+  }
+  
+  public int[] onCreateDrawableState(int paramInt)
+  {
+    int[] arrayOfInt = super.onCreateDrawableState(paramInt + 1);
+    if ((this.k != null) && (this.k.isCheckable()) && (this.k.isChecked())) {
+      mergeDrawableStates(arrayOfInt, a);
+    }
+    return arrayOfInt;
+  }
+  
+  public boolean prefersCondensedTitle()
+  {
+    return false;
+  }
+  
+  public void setCheckable(boolean paramBoolean)
+  {
+    refreshDrawableState();
+  }
+  
+  public void setChecked(boolean paramBoolean)
+  {
+    ViewCompat.setPivotX(this.i, this.i.getWidth() / 2);
+    ViewCompat.setPivotY(this.i, this.i.getBaseline());
+    ViewCompat.setPivotX(this.h, this.h.getWidth() / 2);
+    ViewCompat.setPivotY(this.h, this.h.getBaseline());
+    FrameLayout.LayoutParams localLayoutParams;
+    if (this.f) {
+      if (paramBoolean)
+      {
+        localLayoutParams = (FrameLayout.LayoutParams)this.g.getLayoutParams();
+        localLayoutParams.gravity = 49;
+        localLayoutParams.topMargin = this.b;
+        this.g.setLayoutParams(localLayoutParams);
+        this.i.setVisibility(0);
+        ViewCompat.setScaleX(this.i, 1.0F);
+        ViewCompat.setScaleY(this.i, 1.0F);
+        this.h.setVisibility(4);
+      }
+    }
+    for (;;)
+    {
+      refreshDrawableState();
+      return;
+      localLayoutParams = (FrameLayout.LayoutParams)this.g.getLayoutParams();
+      localLayoutParams.gravity = 17;
+      localLayoutParams.topMargin = this.b;
+      this.g.setLayoutParams(localLayoutParams);
+      this.i.setVisibility(4);
+      ViewCompat.setScaleX(this.i, 0.5F);
+      ViewCompat.setScaleY(this.i, 0.5F);
+      break;
+      if (paramBoolean)
+      {
+        localLayoutParams = (FrameLayout.LayoutParams)this.g.getLayoutParams();
+        localLayoutParams.gravity = 49;
+        localLayoutParams.topMargin = (this.b + this.c);
+        this.g.setLayoutParams(localLayoutParams);
+        this.i.setVisibility(0);
+        this.h.setVisibility(4);
+        ViewCompat.setScaleX(this.i, 1.0F);
+        ViewCompat.setScaleY(this.i, 1.0F);
+        ViewCompat.setScaleX(this.h, this.d);
+        ViewCompat.setScaleY(this.h, this.d);
+      }
+      else
+      {
+        localLayoutParams = (FrameLayout.LayoutParams)this.g.getLayoutParams();
+        localLayoutParams.gravity = 49;
+        localLayoutParams.topMargin = this.b;
+        this.g.setLayoutParams(localLayoutParams);
+        this.i.setVisibility(4);
+        this.h.setVisibility(0);
+        ViewCompat.setScaleX(this.i, this.e);
+        ViewCompat.setScaleY(this.i, this.e);
+        ViewCompat.setScaleX(this.h, 1.0F);
+        ViewCompat.setScaleY(this.h, 1.0F);
+      }
+    }
+  }
+  
+  public void setEnabled(boolean paramBoolean)
+  {
+    super.setEnabled(paramBoolean);
+    this.h.setEnabled(paramBoolean);
+    this.i.setEnabled(paramBoolean);
+    this.g.setEnabled(paramBoolean);
+    if (paramBoolean)
+    {
+      ViewCompat.setPointerIcon(this, PointerIconCompat.getSystemIcon(getContext(), 1002));
+      return;
+    }
+    ViewCompat.setPointerIcon(this, null);
+  }
+  
+  public void setIcon(Drawable paramDrawable)
+  {
+    Object localObject = paramDrawable;
+    if (paramDrawable != null)
+    {
+      localObject = paramDrawable.getConstantState();
+      if (localObject != null) {
+        break label40;
+      }
+    }
+    for (;;)
+    {
+      localObject = DrawableCompat.wrap(paramDrawable).mutate();
+      DrawableCompat.setTintList((Drawable)localObject, this.l);
+      this.g.setImageDrawable((Drawable)localObject);
+      return;
+      label40:
+      paramDrawable = ((Drawable.ConstantState)localObject).newDrawable();
+    }
+  }
+  
+  public void setIconTintList(ColorStateList paramColorStateList)
+  {
+    this.l = paramColorStateList;
+    if (this.k != null) {
+      setIcon(this.k.getIcon());
+    }
+  }
+  
+  public void setItemBackground(int paramInt)
+  {
+    if (paramInt == 0) {}
+    for (Drawable localDrawable = null;; localDrawable = ContextCompat.getDrawable(getContext(), paramInt))
+    {
+      ViewCompat.setBackground(this, localDrawable);
+      return;
+    }
+  }
+  
+  public void setItemPosition(int paramInt)
+  {
+    this.j = paramInt;
+  }
+  
+  public void setShiftingMode(boolean paramBoolean)
+  {
+    this.f = paramBoolean;
+  }
+  
+  public void setShortcut(boolean paramBoolean, char paramChar) {}
+  
+  public void setTextColor(ColorStateList paramColorStateList)
+  {
+    this.h.setTextColor(paramColorStateList);
+    this.i.setTextColor(paramColorStateList);
+  }
+  
+  public void setTitle(CharSequence paramCharSequence)
+  {
+    this.h.setText(paramCharSequence);
+    this.i.setText(paramCharSequence);
+  }
+  
+  public boolean showsIcon()
+  {
+    return true;
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/BottomNavigationItemView.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.content.Context;
+import android.support.annotation.RestrictTo;
+import android.support.v7.view.menu.MenuBuilder;
+import android.support.v7.view.menu.MenuItemImpl;
+import android.view.MenuItem;
+import android.view.SubMenu;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public final class BottomNavigationMenu
+  extends MenuBuilder
+{
+  public static final int MAX_ITEM_COUNT = 5;
+  
+  public BottomNavigationMenu(Context paramContext)
+  {
+    super(paramContext);
+  }
+  
+  protected final MenuItem addInternal(int paramInt1, int paramInt2, int paramInt3, CharSequence paramCharSequence)
+  {
+    if (size() + 1 > 5) {
+      throw new IllegalArgumentException("Maximum number of items supported by BottomNavigationView is 5. Limit can be checked with BottomNavigationView#getMaxItemCount()");
+    }
+    stopDispatchingItemsChanged();
+    paramCharSequence = super.addInternal(paramInt1, paramInt2, paramInt3, paramCharSequence);
+    if ((paramCharSequence instanceof MenuItemImpl)) {
+      ((MenuItemImpl)paramCharSequence).setExclusiveCheckable(true);
+    }
+    startDispatchingItemsChanged();
+    return paramCharSequence;
+  }
+  
+  public final SubMenu addSubMenu(int paramInt1, int paramInt2, int paramInt3, CharSequence paramCharSequence)
+  {
+    throw new UnsupportedOperationException("BottomNavigationView does not support submenus");
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/BottomNavigationMenu.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.content.Context;
+import android.os.Parcelable;
+import android.support.annotation.RestrictTo;
+import android.support.v7.view.menu.MenuBuilder;
+import android.support.v7.view.menu.MenuItemImpl;
+import android.support.v7.view.menu.MenuPresenter;
+import android.support.v7.view.menu.MenuPresenter.Callback;
+import android.support.v7.view.menu.MenuView;
+import android.support.v7.view.menu.SubMenuBuilder;
+import android.view.ViewGroup;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class BottomNavigationPresenter
+  implements MenuPresenter
+{
+  private MenuBuilder a;
+  private BottomNavigationMenuView b;
+  private boolean c = false;
+  
+  public boolean collapseItemActionView(MenuBuilder paramMenuBuilder, MenuItemImpl paramMenuItemImpl)
+  {
+    return false;
+  }
+  
+  public boolean expandItemActionView(MenuBuilder paramMenuBuilder, MenuItemImpl paramMenuItemImpl)
+  {
+    return false;
+  }
+  
+  public boolean flagActionItems()
+  {
+    return false;
+  }
+  
+  public int getId()
+  {
+    return -1;
+  }
+  
+  public MenuView getMenuView(ViewGroup paramViewGroup)
+  {
+    return this.b;
+  }
+  
+  public void initForMenu(Context paramContext, MenuBuilder paramMenuBuilder)
+  {
+    this.b.initialize(this.a);
+    this.a = paramMenuBuilder;
+  }
+  
+  public void onCloseMenu(MenuBuilder paramMenuBuilder, boolean paramBoolean) {}
+  
+  public void onRestoreInstanceState(Parcelable paramParcelable) {}
+  
+  public Parcelable onSaveInstanceState()
+  {
+    return null;
+  }
+  
+  public boolean onSubMenuSelected(SubMenuBuilder paramSubMenuBuilder)
+  {
+    return false;
+  }
+  
+  public void setBottomNavigationMenuView(BottomNavigationMenuView paramBottomNavigationMenuView)
+  {
+    this.b = paramBottomNavigationMenuView;
+  }
+  
+  public void setCallback(MenuPresenter.Callback paramCallback) {}
+  
+  public void setUpdateSuspended(boolean paramBoolean)
+  {
+    this.c = paramBoolean;
+  }
+  
+  public void updateMenuView(boolean paramBoolean)
+  {
+    if (this.c) {
+      return;
+    }
+    if (paramBoolean)
+    {
+      this.b.buildMenuView();
+      return;
+    }
+    this.b.updateMenuView();
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/BottomNavigationPresenter.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.NonNull;
+import android.support.annotation.RequiresApi;
+import android.support.annotation.RestrictTo;
+import android.support.design.R.styleable;
+import android.support.v7.widget.LinearLayoutCompat;
+import android.util.AttributeSet;
+import android.view.Gravity;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class ForegroundLinearLayout
+  extends LinearLayoutCompat
+{
+  boolean a = false;
+  private Drawable b;
+  private final Rect c = new Rect();
+  private final Rect d = new Rect();
+  private int e = 119;
+  protected boolean mForegroundInPadding = true;
+  
+  public ForegroundLinearLayout(Context paramContext)
+  {
+    this(paramContext, null);
+  }
+  
+  public ForegroundLinearLayout(Context paramContext, AttributeSet paramAttributeSet)
+  {
+    this(paramContext, paramAttributeSet, 0);
+  }
+  
+  public ForegroundLinearLayout(Context paramContext, AttributeSet paramAttributeSet, int paramInt)
+  {
+    super(paramContext, paramAttributeSet, paramInt);
+    paramContext = paramContext.obtainStyledAttributes(paramAttributeSet, R.styleable.ForegroundLinearLayout, paramInt, 0);
+    this.e = paramContext.getInt(R.styleable.ForegroundLinearLayout_android_foregroundGravity, this.e);
+    paramAttributeSet = paramContext.getDrawable(R.styleable.ForegroundLinearLayout_android_foreground);
+    if (paramAttributeSet != null) {
+      setForeground(paramAttributeSet);
+    }
+    this.mForegroundInPadding = paramContext.getBoolean(R.styleable.ForegroundLinearLayout_foregroundInsidePadding, true);
+    paramContext.recycle();
+  }
+  
+  public void draw(@NonNull Canvas paramCanvas)
+  {
+    super.draw(paramCanvas);
+    Drawable localDrawable;
+    Rect localRect1;
+    Rect localRect2;
+    int i;
+    int j;
+    if (this.b != null)
+    {
+      localDrawable = this.b;
+      if (this.a)
+      {
+        this.a = false;
+        localRect1 = this.c;
+        localRect2 = this.d;
+        i = getRight() - getLeft();
+        j = getBottom() - getTop();
+        if (!this.mForegroundInPadding) {
+          break label113;
+        }
+        localRect1.set(0, 0, i, j);
+      }
+    }
+    for (;;)
+    {
+      Gravity.apply(this.e, localDrawable.getIntrinsicWidth(), localDrawable.getIntrinsicHeight(), localRect1, localRect2);
+      localDrawable.setBounds(localRect2);
+      localDrawable.draw(paramCanvas);
+      return;
+      label113:
+      localRect1.set(getPaddingLeft(), getPaddingTop(), i - getPaddingRight(), j - getPaddingBottom());
+    }
+  }
+  
+  @TargetApi(21)
+  @RequiresApi(21)
+  public void drawableHotspotChanged(float paramFloat1, float paramFloat2)
+  {
+    super.drawableHotspotChanged(paramFloat1, paramFloat2);
+    if (this.b != null) {
+      this.b.setHotspot(paramFloat1, paramFloat2);
+    }
+  }
+  
+  protected void drawableStateChanged()
+  {
+    super.drawableStateChanged();
+    if ((this.b != null) && (this.b.isStateful())) {
+      this.b.setState(getDrawableState());
+    }
+  }
+  
+  public Drawable getForeground()
+  {
+    return this.b;
+  }
+  
+  public int getForegroundGravity()
+  {
+    return this.e;
+  }
+  
+  @TargetApi(11)
+  @RequiresApi(11)
+  public void jumpDrawablesToCurrentState()
+  {
+    super.jumpDrawablesToCurrentState();
+    if (this.b != null) {
+      this.b.jumpToCurrentState();
+    }
+  }
+  
+  protected void onLayout(boolean paramBoolean, int paramInt1, int paramInt2, int paramInt3, int paramInt4)
+  {
+    super.onLayout(paramBoolean, paramInt1, paramInt2, paramInt3, paramInt4);
+    this.a |= paramBoolean;
+  }
+  
+  protected void onSizeChanged(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
+  {
+    super.onSizeChanged(paramInt1, paramInt2, paramInt3, paramInt4);
+    this.a = true;
+  }
+  
+  public void setForeground(Drawable paramDrawable)
+  {
+    if (this.b != paramDrawable)
+    {
+      if (this.b != null)
+      {
+        this.b.setCallback(null);
+        unscheduleDrawable(this.b);
+      }
+      this.b = paramDrawable;
+      if (paramDrawable == null) {
+        break label96;
+      }
+      setWillNotDraw(false);
+      paramDrawable.setCallback(this);
+      if (paramDrawable.isStateful()) {
+        paramDrawable.setState(getDrawableState());
+      }
+      if (this.e == 119) {
+        paramDrawable.getPadding(new Rect());
+      }
+    }
+    for (;;)
+    {
+      requestLayout();
+      invalidate();
+      return;
+      label96:
+      setWillNotDraw(true);
+    }
+  }
+  
+  public void setForegroundGravity(int paramInt)
+  {
+    if (this.e != paramInt)
+    {
+      if ((0x800007 & paramInt) != 0) {
+        break label77;
+      }
+      paramInt = 0x800003 | paramInt;
+    }
+    label77:
+    for (;;)
+    {
+      int i = paramInt;
+      if ((paramInt & 0x70) == 0) {
+        i = paramInt | 0x30;
+      }
+      this.e = i;
+      if ((this.e == 119) && (this.b != null))
+      {
+        Rect localRect = new Rect();
+        this.b.getPadding(localRect);
+      }
+      requestLayout();
+      return;
+    }
+  }
+  
+  protected boolean verifyDrawable(Drawable paramDrawable)
+  {
+    return (super.verifyDrawable(paramDrawable)) || (paramDrawable == this.b);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/ForegroundLinearLayout.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.content.Context;
+import android.support.annotation.RestrictTo;
+import android.support.v7.view.menu.MenuBuilder;
+import android.support.v7.view.menu.MenuItemImpl;
+import android.view.SubMenu;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class NavigationMenu
+  extends MenuBuilder
+{
+  public NavigationMenu(Context paramContext)
+  {
+    super(paramContext);
+  }
+  
+  public SubMenu addSubMenu(int paramInt1, int paramInt2, int paramInt3, CharSequence paramCharSequence)
+  {
+    paramCharSequence = (MenuItemImpl)addInternal(paramInt1, paramInt2, paramInt3, paramCharSequence);
+    NavigationSubMenu localNavigationSubMenu = new NavigationSubMenu(getContext(), this, paramCharSequence);
+    paramCharSequence.setSubMenu(localNavigationSubMenu);
+    return localNavigationSubMenu;
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/NavigationMenu.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.content.res.Resources.Theme;
+import android.graphics.drawable.ColorDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.Drawable.ConstantState;
+import android.graphics.drawable.StateListDrawable;
+import android.support.annotation.RestrictTo;
+import android.support.design.R.dimen;
+import android.support.design.R.drawable;
+import android.support.design.R.id;
+import android.support.design.R.layout;
+import android.support.v4.content.res.ResourcesCompat;
+import android.support.v4.graphics.drawable.DrawableCompat;
+import android.support.v4.view.AccessibilityDelegateCompat;
+import android.support.v4.view.ViewCompat;
+import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
+import android.support.v4.widget.TextViewCompat;
+import android.support.v7.appcompat.R.attr;
+import android.support.v7.view.menu.MenuItemImpl;
+import android.support.v7.view.menu.MenuView.ItemView;
+import android.support.v7.widget.LinearLayoutCompat.LayoutParams;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewStub;
+import android.widget.CheckedTextView;
+import android.widget.FrameLayout;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class NavigationMenuItemView
+  extends ForegroundLinearLayout
+  implements MenuView.ItemView
+{
+  private static final int[] c = { 16842912 };
+  boolean b;
+  private final int d;
+  private boolean e;
+  private final CheckedTextView f;
+  private FrameLayout g;
+  private MenuItemImpl h;
+  private ColorStateList i;
+  private boolean j;
+  private Drawable k;
+  private final AccessibilityDelegateCompat l = new AccessibilityDelegateCompat()
+  {
+    public final void onInitializeAccessibilityNodeInfo(View paramAnonymousView, AccessibilityNodeInfoCompat paramAnonymousAccessibilityNodeInfoCompat)
+    {
+      super.onInitializeAccessibilityNodeInfo(paramAnonymousView, paramAnonymousAccessibilityNodeInfoCompat);
+      paramAnonymousAccessibilityNodeInfoCompat.setCheckable(NavigationMenuItemView.this.b);
+    }
+  };
+  
+  public NavigationMenuItemView(Context paramContext)
+  {
+    this(paramContext, null);
+  }
+  
+  public NavigationMenuItemView(Context paramContext, AttributeSet paramAttributeSet)
+  {
+    this(paramContext, paramAttributeSet, 0);
+  }
+  
+  public NavigationMenuItemView(Context paramContext, AttributeSet paramAttributeSet, int paramInt)
+  {
+    super(paramContext, paramAttributeSet, paramInt);
+    setOrientation(0);
+    LayoutInflater.from(paramContext).inflate(R.layout.design_navigation_menu_item, this, true);
+    this.d = paramContext.getResources().getDimensionPixelSize(R.dimen.design_navigation_icon_size);
+    this.f = ((CheckedTextView)findViewById(R.id.design_menu_item_text));
+    this.f.setDuplicateParentStateEnabled(true);
+    ViewCompat.setAccessibilityDelegate(this.f, this.l);
+  }
+  
+  private void setActionView(View paramView)
+  {
+    if (paramView != null)
+    {
+      if (this.g == null) {
+        this.g = ((FrameLayout)((ViewStub)findViewById(R.id.design_menu_item_action_area_stub)).inflate());
+      }
+      this.g.removeAllViews();
+      this.g.addView(paramView);
+    }
+  }
+  
+  public MenuItemImpl getItemData()
+  {
+    return this.h;
+  }
+  
+  public void initialize(MenuItemImpl paramMenuItemImpl, int paramInt)
+  {
+    this.h = paramMenuItemImpl;
+    StateListDrawable localStateListDrawable;
+    if (paramMenuItemImpl.isVisible())
+    {
+      paramInt = 0;
+      setVisibility(paramInt);
+      if (getBackground() == null)
+      {
+        TypedValue localTypedValue = new TypedValue();
+        if (!getContext().getTheme().resolveAttribute(R.attr.colorControlHighlight, localTypedValue, true)) {
+          break label232;
+        }
+        localStateListDrawable = new StateListDrawable();
+        localStateListDrawable.addState(c, new ColorDrawable(localTypedValue.data));
+        localStateListDrawable.addState(EMPTY_STATE_SET, new ColorDrawable(0));
+        label96:
+        ViewCompat.setBackground(this, localStateListDrawable);
+      }
+      setCheckable(paramMenuItemImpl.isCheckable());
+      setChecked(paramMenuItemImpl.isChecked());
+      setEnabled(paramMenuItemImpl.isEnabled());
+      setTitle(paramMenuItemImpl.getTitle());
+      setIcon(paramMenuItemImpl.getIcon());
+      setActionView(paramMenuItemImpl.getActionView());
+      if ((this.h.getTitle() != null) || (this.h.getIcon() != null) || (this.h.getActionView() == null)) {
+        break label237;
+      }
+      paramInt = 1;
+      label181:
+      if (paramInt == 0) {
+        break label242;
+      }
+      this.f.setVisibility(8);
+      if (this.g != null)
+      {
+        paramMenuItemImpl = (LinearLayoutCompat.LayoutParams)this.g.getLayoutParams();
+        paramMenuItemImpl.width = -1;
+        this.g.setLayoutParams(paramMenuItemImpl);
+      }
+    }
+    label232:
+    label237:
+    label242:
+    do
+    {
+      return;
+      paramInt = 8;
+      break;
+      localStateListDrawable = null;
+      break label96;
+      paramInt = 0;
+      break label181;
+      this.f.setVisibility(0);
+    } while (this.g == null);
+    paramMenuItemImpl = (LinearLayoutCompat.LayoutParams)this.g.getLayoutParams();
+    paramMenuItemImpl.width = -2;
+    this.g.setLayoutParams(paramMenuItemImpl);
+  }
+  
+  protected int[] onCreateDrawableState(int paramInt)
+  {
+    int[] arrayOfInt = super.onCreateDrawableState(paramInt + 1);
+    if ((this.h != null) && (this.h.isCheckable()) && (this.h.isChecked())) {
+      mergeDrawableStates(arrayOfInt, c);
+    }
+    return arrayOfInt;
+  }
+  
+  public boolean prefersCondensedTitle()
+  {
+    return false;
+  }
+  
+  public void recycle()
+  {
+    if (this.g != null) {
+      this.g.removeAllViews();
+    }
+    this.f.setCompoundDrawables(null, null, null, null);
+  }
+  
+  public void setCheckable(boolean paramBoolean)
+  {
+    refreshDrawableState();
+    if (this.b != paramBoolean)
+    {
+      this.b = paramBoolean;
+      this.l.sendAccessibilityEvent(this.f, 2048);
+    }
+  }
+  
+  public void setChecked(boolean paramBoolean)
+  {
+    refreshDrawableState();
+    this.f.setChecked(paramBoolean);
+  }
+  
+  public void setIcon(Drawable paramDrawable)
+  {
+    Object localObject;
+    if (paramDrawable != null)
+    {
+      localObject = paramDrawable;
+      if (this.j)
+      {
+        localObject = paramDrawable.getConstantState();
+        if (localObject == null)
+        {
+          localObject = DrawableCompat.wrap(paramDrawable).mutate();
+          DrawableCompat.setTintList((Drawable)localObject, this.i);
+        }
+      }
+      else
+      {
+        ((Drawable)localObject).setBounds(0, 0, this.d, this.d);
+        paramDrawable = (Drawable)localObject;
+      }
+    }
+    for (;;)
+    {
+      TextViewCompat.setCompoundDrawablesRelative(this.f, paramDrawable, null, null, null);
+      return;
+      paramDrawable = ((Drawable.ConstantState)localObject).newDrawable();
+      break;
+      if (this.e)
+      {
+        if (this.k == null)
+        {
+          this.k = ResourcesCompat.getDrawable(getResources(), R.drawable.navigation_empty_icon, getContext().getTheme());
+          if (this.k != null) {
+            this.k.setBounds(0, 0, this.d, this.d);
+          }
+        }
+        paramDrawable = this.k;
+      }
+    }
+  }
+  
+  void setIconTintList(ColorStateList paramColorStateList)
+  {
+    this.i = paramColorStateList;
+    if (this.i != null) {}
+    for (boolean bool = true;; bool = false)
+    {
+      this.j = bool;
+      if (this.h != null) {
+        setIcon(this.h.getIcon());
+      }
+      return;
+    }
+  }
+  
+  public void setNeedsEmptyIcon(boolean paramBoolean)
+  {
+    this.e = paramBoolean;
+  }
+  
+  public void setShortcut(boolean paramBoolean, char paramChar) {}
+  
+  public void setTextAppearance(int paramInt)
+  {
+    TextViewCompat.setTextAppearance(this.f, paramInt);
+  }
+  
+  public void setTextColor(ColorStateList paramColorStateList)
+  {
+    this.f.setTextColor(paramColorStateList);
+  }
+  
+  public void setTitle(CharSequence paramCharSequence)
+  {
+    this.f.setText(paramCharSequence);
+  }
+  
+  public boolean showsIcon()
+  {
+    return true;
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/NavigationMenuItemView.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.content.Context;
+import android.support.annotation.RestrictTo;
+import android.support.v7.view.menu.MenuBuilder;
+import android.support.v7.view.menu.MenuView;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.util.AttributeSet;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class NavigationMenuView
+  extends RecyclerView
+  implements MenuView
+{
+  public NavigationMenuView(Context paramContext)
+  {
+    this(paramContext, null);
+  }
+  
+  public NavigationMenuView(Context paramContext, AttributeSet paramAttributeSet)
+  {
+    this(paramContext, paramAttributeSet, 0);
+  }
+  
+  public NavigationMenuView(Context paramContext, AttributeSet paramAttributeSet, int paramInt)
+  {
+    super(paramContext, paramAttributeSet, paramInt);
+    setLayoutManager(new LinearLayoutManager(paramContext, 1, false));
+  }
+  
+  public int getWindowAnimations()
+  {
+    return 0;
+  }
+  
+  public void initialize(MenuBuilder paramMenuBuilder) {}
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/NavigationMenuView.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.content.Context;
+import android.support.annotation.RestrictTo;
+import android.support.v7.view.menu.MenuBuilder;
+import android.support.v7.view.menu.MenuItemImpl;
+import android.support.v7.view.menu.SubMenuBuilder;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class NavigationSubMenu
+  extends SubMenuBuilder
+{
+  public NavigationSubMenu(Context paramContext, NavigationMenu paramNavigationMenu, MenuItemImpl paramMenuItemImpl)
+  {
+    super(paramContext, paramNavigationMenu, paramMenuItemImpl);
+  }
+  
+  public void onItemsChanged(boolean paramBoolean)
+  {
+    super.onItemsChanged(paramBoolean);
+    ((MenuBuilder)getParentMenu()).onItemsChanged(paramBoolean);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/NavigationSubMenu.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.os.Parcelable.Creator;
+import android.support.annotation.RestrictTo;
+import android.support.v4.os.ParcelableCompat;
+import android.support.v4.os.ParcelableCompatCreatorCallbacks;
+import android.util.SparseArray;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class ParcelableSparseArray
+  extends SparseArray<Parcelable>
+  implements Parcelable
+{
+  public static final Parcelable.Creator<ParcelableSparseArray> CREATOR = ParcelableCompat.newCreator(new ParcelableCompatCreatorCallbacks() {});
+  
+  public ParcelableSparseArray() {}
+  
+  public ParcelableSparseArray(Parcel paramParcel, ClassLoader paramClassLoader)
+  {
+    int j = paramParcel.readInt();
+    int[] arrayOfInt = new int[j];
+    paramParcel.readIntArray(arrayOfInt);
+    paramParcel = paramParcel.readParcelableArray(paramClassLoader);
+    int i = 0;
+    while (i < j)
+    {
+      put(arrayOfInt[i], paramParcel[i]);
+      i += 1;
+    }
+  }
+  
+  public int describeContents()
+  {
+    return 0;
+  }
+  
+  public void writeToParcel(Parcel paramParcel, int paramInt)
+  {
+    int j = size();
+    int[] arrayOfInt = new int[j];
+    Parcelable[] arrayOfParcelable = new Parcelable[j];
+    int i = 0;
+    while (i < j)
+    {
+      arrayOfInt[i] = keyAt(i);
+      arrayOfParcelable[i] = ((Parcelable)valueAt(i));
+      i += 1;
+    }
+    paramParcel.writeInt(j);
+    paramParcel.writeIntArray(arrayOfInt);
+    paramParcel.writeParcelableArray(arrayOfParcelable, paramInt);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/ParcelableSparseArray.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.NonNull;
+import android.support.annotation.RestrictTo;
+import android.support.design.R.style;
+import android.support.design.R.styleable;
+import android.support.v4.view.OnApplyWindowInsetsListener;
+import android.support.v4.view.ViewCompat;
+import android.support.v4.view.WindowInsetsCompat;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.FrameLayout;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class ScrimInsetsFrameLayout
+  extends FrameLayout
+{
+  Drawable a;
+  Rect b;
+  private Rect c = new Rect();
+  
+  public ScrimInsetsFrameLayout(Context paramContext)
+  {
+    this(paramContext, null);
+  }
+  
+  public ScrimInsetsFrameLayout(Context paramContext, AttributeSet paramAttributeSet)
+  {
+    this(paramContext, paramAttributeSet, 0);
+  }
+  
+  public ScrimInsetsFrameLayout(Context paramContext, AttributeSet paramAttributeSet, int paramInt)
+  {
+    super(paramContext, paramAttributeSet, paramInt);
+    paramContext = paramContext.obtainStyledAttributes(paramAttributeSet, R.styleable.ScrimInsetsFrameLayout, paramInt, R.style.Widget_Design_ScrimInsetsFrameLayout);
+    this.a = paramContext.getDrawable(R.styleable.ScrimInsetsFrameLayout_insetForeground);
+    paramContext.recycle();
+    setWillNotDraw(true);
+    ViewCompat.setOnApplyWindowInsetsListener(this, new OnApplyWindowInsetsListener()
+    {
+      public final WindowInsetsCompat onApplyWindowInsets(View paramAnonymousView, WindowInsetsCompat paramAnonymousWindowInsetsCompat)
+      {
+        if (ScrimInsetsFrameLayout.this.b == null) {
+          ScrimInsetsFrameLayout.this.b = new Rect();
+        }
+        ScrimInsetsFrameLayout.this.b.set(paramAnonymousWindowInsetsCompat.getSystemWindowInsetLeft(), paramAnonymousWindowInsetsCompat.getSystemWindowInsetTop(), paramAnonymousWindowInsetsCompat.getSystemWindowInsetRight(), paramAnonymousWindowInsetsCompat.getSystemWindowInsetBottom());
+        ScrimInsetsFrameLayout.this.onInsetsChanged(paramAnonymousWindowInsetsCompat);
+        paramAnonymousView = ScrimInsetsFrameLayout.this;
+        if ((!paramAnonymousWindowInsetsCompat.hasSystemWindowInsets()) || (ScrimInsetsFrameLayout.this.a == null)) {}
+        for (boolean bool = true;; bool = false)
+        {
+          paramAnonymousView.setWillNotDraw(bool);
+          ViewCompat.postInvalidateOnAnimation(ScrimInsetsFrameLayout.this);
+          return paramAnonymousWindowInsetsCompat.consumeSystemWindowInsets();
+        }
+      }
+    });
+  }
+  
+  public void draw(@NonNull Canvas paramCanvas)
+  {
+    super.draw(paramCanvas);
+    int i = getWidth();
+    int j = getHeight();
+    if ((this.b != null) && (this.a != null))
+    {
+      int k = paramCanvas.save();
+      paramCanvas.translate(getScrollX(), getScrollY());
+      this.c.set(0, 0, i, this.b.top);
+      this.a.setBounds(this.c);
+      this.a.draw(paramCanvas);
+      this.c.set(0, j - this.b.bottom, i, j);
+      this.a.setBounds(this.c);
+      this.a.draw(paramCanvas);
+      this.c.set(0, this.b.top, this.b.left, j - this.b.bottom);
+      this.a.setBounds(this.c);
+      this.a.draw(paramCanvas);
+      this.c.set(i - this.b.right, this.b.top, i, j - this.b.bottom);
+      this.a.setBounds(this.c);
+      this.a.draw(paramCanvas);
+      paramCanvas.restoreToCount(k);
+    }
+  }
+  
+  protected void onAttachedToWindow()
+  {
+    super.onAttachedToWindow();
+    if (this.a != null) {
+      this.a.setCallback(this);
+    }
+  }
+  
+  protected void onDetachedFromWindow()
+  {
+    super.onDetachedFromWindow();
+    if (this.a != null) {
+      this.a.setCallback(null);
+    }
+  }
+  
+  public void onInsetsChanged(WindowInsetsCompat paramWindowInsetsCompat) {}
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/ScrimInsetsFrameLayout.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.support.annotation.RestrictTo;
+import android.support.design.R.dimen;
+import android.support.design.R.id;
+import android.support.design.R.styleable;
+import android.support.design.widget.BaseTransientBottomBar.ContentViewCallback;
+import android.support.v4.view.ViewCompat;
+import android.support.v4.view.ViewPropertyAnimatorCompat;
+import android.text.Layout;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.View.MeasureSpec;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class SnackbarContentLayout
+  extends LinearLayout
+  implements BaseTransientBottomBar.ContentViewCallback
+{
+  private TextView a;
+  private Button b;
+  private int c;
+  private int d;
+  
+  public SnackbarContentLayout(Context paramContext)
+  {
+    this(paramContext, null);
+  }
+  
+  public SnackbarContentLayout(Context paramContext, AttributeSet paramAttributeSet)
+  {
+    super(paramContext, paramAttributeSet);
+    paramContext = paramContext.obtainStyledAttributes(paramAttributeSet, R.styleable.SnackbarLayout);
+    this.c = paramContext.getDimensionPixelSize(R.styleable.SnackbarLayout_android_maxWidth, -1);
+    this.d = paramContext.getDimensionPixelSize(R.styleable.SnackbarLayout_maxActionInlineWidth, -1);
+    paramContext.recycle();
+  }
+  
+  private boolean a(int paramInt1, int paramInt2, int paramInt3)
+  {
+    boolean bool = false;
+    if (paramInt1 != getOrientation())
+    {
+      setOrientation(paramInt1);
+      bool = true;
+    }
+    TextView localTextView;
+    if ((this.a.getPaddingTop() != paramInt2) || (this.a.getPaddingBottom() != paramInt3))
+    {
+      localTextView = this.a;
+      if (!ViewCompat.isPaddingRelative(localTextView)) {
+        break label78;
+      }
+      ViewCompat.setPaddingRelative(localTextView, ViewCompat.getPaddingStart(localTextView), paramInt2, ViewCompat.getPaddingEnd(localTextView), paramInt3);
+    }
+    for (;;)
+    {
+      bool = true;
+      return bool;
+      label78:
+      localTextView.setPadding(localTextView.getPaddingLeft(), paramInt2, localTextView.getPaddingRight(), paramInt3);
+    }
+  }
+  
+  public void animateContentIn(int paramInt1, int paramInt2)
+  {
+    ViewCompat.setAlpha(this.a, 0.0F);
+    ViewCompat.animate(this.a).alpha(1.0F).setDuration(paramInt2).setStartDelay(paramInt1).start();
+    if (this.b.getVisibility() == 0)
+    {
+      ViewCompat.setAlpha(this.b, 0.0F);
+      ViewCompat.animate(this.b).alpha(1.0F).setDuration(paramInt2).setStartDelay(paramInt1).start();
+    }
+  }
+  
+  public void animateContentOut(int paramInt1, int paramInt2)
+  {
+    ViewCompat.setAlpha(this.a, 1.0F);
+    ViewCompat.animate(this.a).alpha(0.0F).setDuration(paramInt2).setStartDelay(paramInt1).start();
+    if (this.b.getVisibility() == 0)
+    {
+      ViewCompat.setAlpha(this.b, 1.0F);
+      ViewCompat.animate(this.b).alpha(0.0F).setDuration(paramInt2).setStartDelay(paramInt1).start();
+    }
+  }
+  
+  public Button getActionView()
+  {
+    return this.b;
+  }
+  
+  public TextView getMessageView()
+  {
+    return this.a;
+  }
+  
+  protected void onFinishInflate()
+  {
+    super.onFinishInflate();
+    this.a = ((TextView)findViewById(R.id.snackbar_text));
+    this.b = ((Button)findViewById(R.id.snackbar_action));
+  }
+  
+  protected void onMeasure(int paramInt1, int paramInt2)
+  {
+    super.onMeasure(paramInt1, paramInt2);
+    int i = paramInt1;
+    if (this.c > 0)
+    {
+      i = paramInt1;
+      if (getMeasuredWidth() > this.c)
+      {
+        i = View.MeasureSpec.makeMeasureSpec(this.c, 1073741824);
+        super.onMeasure(i, paramInt2);
+      }
+    }
+    int j = getResources().getDimensionPixelSize(R.dimen.design_snackbar_padding_vertical_2lines);
+    int k = getResources().getDimensionPixelSize(R.dimen.design_snackbar_padding_vertical);
+    if (this.a.getLayout().getLineCount() > 1)
+    {
+      paramInt1 = 1;
+      if ((paramInt1 == 0) || (this.d <= 0) || (this.b.getMeasuredWidth() <= this.d)) {
+        break label142;
+      }
+      if (!a(1, j, j - k)) {
+        break label170;
+      }
+      paramInt1 = 1;
+    }
+    for (;;)
+    {
+      if (paramInt1 != 0) {
+        super.onMeasure(i, paramInt2);
+      }
+      return;
+      paramInt1 = 0;
+      break;
+      label142:
+      if (paramInt1 != 0) {}
+      for (paramInt1 = j;; paramInt1 = k)
+      {
+        if (!a(0, paramInt1, paramInt1)) {
+          break label170;
+        }
+        paramInt1 = 1;
+        break;
+      }
+      label170:
+      paramInt1 = 0;
+    }
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/SnackbarContentLayout.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.internal;
+
+import android.animation.Animator;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.annotation.TargetApi;
+import android.support.annotation.RequiresApi;
+import android.support.transition.Transition;
+import android.support.transition.TransitionValues;
+import android.view.ViewGroup;
+import android.widget.TextView;
+import java.util.Map;
+
+@TargetApi(14)
+@RequiresApi(14)
+public class TextScale
+  extends Transition
+{
+  private static void a(TransitionValues paramTransitionValues)
+  {
+    if ((paramTransitionValues.view instanceof TextView))
+    {
+      TextView localTextView = (TextView)paramTransitionValues.view;
+      paramTransitionValues.values.put("android:textscale:scale", Float.valueOf(localTextView.getScaleX()));
+    }
+  }
+  
+  public void captureEndValues(TransitionValues paramTransitionValues)
+  {
+    a(paramTransitionValues);
+  }
+  
+  public void captureStartValues(TransitionValues paramTransitionValues)
+  {
+    a(paramTransitionValues);
+  }
+  
+  public Animator createAnimator(final ViewGroup paramViewGroup, TransitionValues paramTransitionValues1, TransitionValues paramTransitionValues2)
+  {
+    float f2 = 1.0F;
+    if ((paramTransitionValues1 == null) || (paramTransitionValues2 == null) || (!(paramTransitionValues1.view instanceof TextView)) || (!(paramTransitionValues2.view instanceof TextView))) {
+      return null;
+    }
+    paramViewGroup = (TextView)paramTransitionValues2.view;
+    paramTransitionValues1 = paramTransitionValues1.values;
+    paramTransitionValues2 = paramTransitionValues2.values;
+    if (paramTransitionValues1.get("android:textscale:scale") != null) {}
+    for (float f1 = ((Float)paramTransitionValues1.get("android:textscale:scale")).floatValue();; f1 = 1.0F)
+    {
+      if (paramTransitionValues2.get("android:textscale:scale") != null) {
+        f2 = ((Float)paramTransitionValues2.get("android:textscale:scale")).floatValue();
+      }
+      if (f1 != f2) {
+        break;
+      }
+      return null;
+    }
+    paramTransitionValues1 = ValueAnimator.ofFloat(new float[] { f1, f2 });
+    paramTransitionValues1.addUpdateListener(new ValueAnimator.AnimatorUpdateListener()
+    {
+      public final void onAnimationUpdate(ValueAnimator paramAnonymousValueAnimator)
+      {
+        float f = ((Float)paramAnonymousValueAnimator.getAnimatedValue()).floatValue();
+        paramViewGroup.setScaleX(f);
+        paramViewGroup.setScaleY(f);
+      }
+    });
+    return paramTransitionValues1;
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/internal/TextScale.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.widget;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.content.res.Resources.Theme;
+import android.os.Build.VERSION;
+import android.support.annotation.DrawableRes;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.design.R.color;
+import android.support.design.R.dimen;
+import android.support.design.R.style;
+import android.support.design.R.styleable;
+import android.support.design.internal.BottomNavigationMenu;
+import android.support.design.internal.BottomNavigationMenuView;
+import android.support.design.internal.BottomNavigationPresenter;
+import android.support.v4.content.ContextCompat;
+import android.support.v4.view.ViewCompat;
+import android.support.v7.appcompat.R.attr;
+import android.support.v7.content.res.AppCompatResources;
+import android.support.v7.view.SupportMenuInflater;
+import android.support.v7.view.menu.MenuBuilder;
+import android.support.v7.view.menu.MenuBuilder.Callback;
+import android.support.v7.widget.TintTypedArray;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.FrameLayout.LayoutParams;
+import r;
+
+public class BottomNavigationView
+  extends FrameLayout
+{
+  private static final int[] a = { 16842912 };
+  private static final int[] b = { -16842910 };
+  private final MenuBuilder c;
+  private final BottomNavigationMenuView d;
+  private final BottomNavigationPresenter e = new BottomNavigationPresenter();
+  private MenuInflater f;
+  private OnNavigationItemSelectedListener g;
+  
+  public BottomNavigationView(Context paramContext)
+  {
+    this(paramContext, null);
+  }
+  
+  public BottomNavigationView(Context paramContext, AttributeSet paramAttributeSet)
+  {
+    this(paramContext, paramAttributeSet, 0);
+  }
+  
+  public BottomNavigationView(Context paramContext, AttributeSet paramAttributeSet, int paramInt)
+  {
+    super(paramContext, paramAttributeSet, paramInt);
+    r.a(paramContext);
+    this.c = new BottomNavigationMenu(paramContext);
+    this.d = new BottomNavigationMenuView(paramContext);
+    FrameLayout.LayoutParams localLayoutParams = new FrameLayout.LayoutParams(-2, -2);
+    localLayoutParams.gravity = 17;
+    this.d.setLayoutParams(localLayoutParams);
+    this.e.setBottomNavigationMenuView(this.d);
+    this.d.setPresenter(this.e);
+    this.c.addMenuPresenter(this.e);
+    this.e.initForMenu(getContext(), this.c);
+    paramAttributeSet = TintTypedArray.obtainStyledAttributes(paramContext, paramAttributeSet, R.styleable.BottomNavigationView, paramInt, R.style.Widget_Design_BottomNavigationView);
+    if (paramAttributeSet.hasValue(R.styleable.BottomNavigationView_itemIconTint))
+    {
+      this.d.setIconTintList(paramAttributeSet.getColorStateList(R.styleable.BottomNavigationView_itemIconTint));
+      if (!paramAttributeSet.hasValue(R.styleable.BottomNavigationView_itemTextColor)) {
+        break label345;
+      }
+      this.d.setItemTextColor(paramAttributeSet.getColorStateList(R.styleable.BottomNavigationView_itemTextColor));
+    }
+    for (;;)
+    {
+      if (paramAttributeSet.hasValue(R.styleable.BottomNavigationView_elevation)) {
+        ViewCompat.setElevation(this, paramAttributeSet.getDimensionPixelSize(R.styleable.BottomNavigationView_elevation, 0));
+      }
+      paramInt = paramAttributeSet.getResourceId(R.styleable.BottomNavigationView_itemBackground, 0);
+      this.d.setItemBackgroundRes(paramInt);
+      if (paramAttributeSet.hasValue(R.styleable.BottomNavigationView_menu)) {
+        inflateMenu(paramAttributeSet.getResourceId(R.styleable.BottomNavigationView_menu, 0));
+      }
+      paramAttributeSet.recycle();
+      addView(this.d, localLayoutParams);
+      if (Build.VERSION.SDK_INT < 21)
+      {
+        paramAttributeSet = new View(paramContext);
+        paramAttributeSet.setBackgroundColor(ContextCompat.getColor(paramContext, R.color.design_bottom_navigation_shadow_color));
+        paramAttributeSet.setLayoutParams(new FrameLayout.LayoutParams(-1, getResources().getDimensionPixelSize(R.dimen.design_bottom_navigation_shadow_height)));
+        addView(paramAttributeSet);
+      }
+      this.c.setCallback(new MenuBuilder.Callback()
+      {
+        public final boolean onMenuItemSelected(MenuBuilder paramAnonymousMenuBuilder, MenuItem paramAnonymousMenuItem)
+        {
+          return (BottomNavigationView.a(BottomNavigationView.this) != null) && (!BottomNavigationView.a(BottomNavigationView.this).onNavigationItemSelected(paramAnonymousMenuItem));
+        }
+        
+        public final void onMenuModeChange(MenuBuilder paramAnonymousMenuBuilder) {}
+      });
+      return;
+      this.d.setIconTintList(a());
+      break;
+      label345:
+      this.d.setItemTextColor(a());
+    }
+  }
+  
+  private ColorStateList a()
+  {
+    Object localObject = new TypedValue();
+    if (!getContext().getTheme().resolveAttribute(16842808, (TypedValue)localObject, true)) {}
+    ColorStateList localColorStateList;
+    do
+    {
+      return null;
+      localColorStateList = AppCompatResources.getColorStateList(getContext(), ((TypedValue)localObject).resourceId);
+    } while (!getContext().getTheme().resolveAttribute(R.attr.colorPrimary, (TypedValue)localObject, true));
+    int i = ((TypedValue)localObject).data;
+    int j = localColorStateList.getDefaultColor();
+    localObject = b;
+    int[] arrayOfInt1 = a;
+    int[] arrayOfInt2 = EMPTY_STATE_SET;
+    int k = localColorStateList.getColorForState(b, j);
+    return new ColorStateList(new int[][] { localObject, arrayOfInt1, arrayOfInt2 }, new int[] { k, i, j });
+  }
+  
+  private MenuInflater getMenuInflater()
+  {
+    if (this.f == null) {
+      this.f = new SupportMenuInflater(getContext());
+    }
+    return this.f;
+  }
+  
+  @DrawableRes
+  public int getItemBackgroundResource()
+  {
+    return this.d.getItemBackgroundRes();
+  }
+  
+  @Nullable
+  public ColorStateList getItemIconTintList()
+  {
+    return this.d.getIconTintList();
+  }
+  
+  @Nullable
+  public ColorStateList getItemTextColor()
+  {
+    return this.d.getItemTextColor();
+  }
+  
+  public int getMaxItemCount()
+  {
+    return 5;
+  }
+  
+  @NonNull
+  public Menu getMenu()
+  {
+    return this.c;
+  }
+  
+  public void inflateMenu(int paramInt)
+  {
+    this.e.setUpdateSuspended(true);
+    getMenuInflater().inflate(paramInt, this.c);
+    this.e.setUpdateSuspended(false);
+    this.e.updateMenuView(true);
+  }
+  
+  public void setItemBackgroundResource(@DrawableRes int paramInt)
+  {
+    this.d.setItemBackgroundRes(paramInt);
+  }
+  
+  public void setItemIconTintList(@Nullable ColorStateList paramColorStateList)
+  {
+    this.d.setIconTintList(paramColorStateList);
+  }
+  
+  public void setItemTextColor(@Nullable ColorStateList paramColorStateList)
+  {
+    this.d.setItemTextColor(paramColorStateList);
+  }
+  
+  public void setOnNavigationItemSelectedListener(@Nullable OnNavigationItemSelectedListener paramOnNavigationItemSelectedListener)
+  {
+    this.g = paramOnNavigationItemSelectedListener;
+  }
+  
+  public static abstract interface OnNavigationItemSelectedListener
+  {
+    public abstract boolean onNavigationItemSelected(@NonNull MenuItem paramMenuItem);
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/widget/BottomNavigationView.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.widget;
+
+import android.content.Context;
+import android.content.DialogInterface.OnCancelListener;
+import android.content.res.TypedArray;
+import android.os.Build.VERSION;
+import android.os.Bundle;
+import android.support.annotation.LayoutRes;
+import android.support.annotation.NonNull;
+import android.support.annotation.StyleRes;
+import android.support.design.R.id;
+import android.support.design.R.layout;
+import android.support.v4.view.AccessibilityDelegateCompat;
+import android.support.v4.view.ViewCompat;
+import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
+import android.support.v7.app.AppCompatDialog;
+import android.util.TypedValue;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup.LayoutParams;
+import android.view.Window;
+import android.widget.FrameLayout;
+
+public class BottomSheetDialog
+  extends AppCompatDialog
+{
+  boolean a = true;
+  boolean b = true;
+  boolean c;
+  private BottomSheetBehavior<FrameLayout> d;
+  private BottomSheetBehavior.BottomSheetCallback e = new BottomSheetBehavior.BottomSheetCallback()
+  {
+    public final void onSlide(@NonNull View paramAnonymousView, float paramAnonymousFloat) {}
+    
+    public final void onStateChanged(@NonNull View paramAnonymousView, int paramAnonymousInt)
+    {
+      if (paramAnonymousInt == 5) {
+        BottomSheetDialog.this.cancel();
+      }
+    }
+  };
+  
+  public BottomSheetDialog(@NonNull Context paramContext)
+  {
+    this(paramContext, 0);
+  }
+  
+  public BottomSheetDialog(@NonNull Context paramContext, @StyleRes int paramInt) {}
+  
+  protected BottomSheetDialog(@NonNull Context paramContext, boolean paramBoolean, DialogInterface.OnCancelListener paramOnCancelListener)
+  {
+    super(paramContext, paramBoolean, paramOnCancelListener);
+    supportRequestWindowFeature(1);
+    this.a = paramBoolean;
+  }
+  
+  private View a(int paramInt, View paramView, ViewGroup.LayoutParams paramLayoutParams)
+  {
+    CoordinatorLayout localCoordinatorLayout = (CoordinatorLayout)View.inflate(getContext(), R.layout.design_bottom_sheet_dialog, null);
+    View localView = paramView;
+    if (paramInt != 0)
+    {
+      localView = paramView;
+      if (paramView == null) {
+        localView = getLayoutInflater().inflate(paramInt, localCoordinatorLayout, false);
+      }
+    }
+    paramView = (FrameLayout)localCoordinatorLayout.findViewById(R.id.design_bottom_sheet);
+    this.d = BottomSheetBehavior.from(paramView);
+    this.d.setBottomSheetCallback(this.e);
+    this.d.setHideable(this.a);
+    if (paramLayoutParams == null) {
+      paramView.addView(localView);
+    }
+    for (;;)
+    {
+      localCoordinatorLayout.findViewById(R.id.touch_outside).setOnClickListener(new View.OnClickListener()
+      {
+        public final void onClick(View paramAnonymousView)
+        {
+          if ((BottomSheetDialog.this.a) && (BottomSheetDialog.this.isShowing()))
+          {
+            paramAnonymousView = BottomSheetDialog.this;
+            if (!paramAnonymousView.c)
+            {
+              if (Build.VERSION.SDK_INT >= 11) {
+                break label65;
+              }
+              paramAnonymousView.b = true;
+            }
+          }
+          for (;;)
+          {
+            paramAnonymousView.c = true;
+            if (paramAnonymousView.b) {
+              BottomSheetDialog.this.cancel();
+            }
+            return;
+            label65:
+            TypedArray localTypedArray = paramAnonymousView.getContext().obtainStyledAttributes(new int[] { 16843611 });
+            paramAnonymousView.b = localTypedArray.getBoolean(0, true);
+            localTypedArray.recycle();
+          }
+        }
+      });
+      ViewCompat.setAccessibilityDelegate(paramView, new AccessibilityDelegateCompat()
+      {
+        public final void onInitializeAccessibilityNodeInfo(View paramAnonymousView, AccessibilityNodeInfoCompat paramAnonymousAccessibilityNodeInfoCompat)
+        {
+          super.onInitializeAccessibilityNodeInfo(paramAnonymousView, paramAnonymousAccessibilityNodeInfoCompat);
+          if (BottomSheetDialog.this.a)
+          {
+            paramAnonymousAccessibilityNodeInfoCompat.addAction(1048576);
+            paramAnonymousAccessibilityNodeInfoCompat.setDismissable(true);
+            return;
+          }
+          paramAnonymousAccessibilityNodeInfoCompat.setDismissable(false);
+        }
+        
+        public final boolean performAccessibilityAction(View paramAnonymousView, int paramAnonymousInt, Bundle paramAnonymousBundle)
+        {
+          if ((paramAnonymousInt == 1048576) && (BottomSheetDialog.this.a))
+          {
+            BottomSheetDialog.this.cancel();
+            return true;
+          }
+          return super.performAccessibilityAction(paramAnonymousView, paramAnonymousInt, paramAnonymousBundle);
+        }
+      });
+      return localCoordinatorLayout;
+      paramView.addView(localView, paramLayoutParams);
+    }
+  }
+  
+  protected void onCreate(Bundle paramBundle)
+  {
+    super.onCreate(paramBundle);
+    getWindow().setLayout(-1, -1);
+  }
+  
+  public void setCancelable(boolean paramBoolean)
+  {
+    super.setCancelable(paramBoolean);
+    if (this.a != paramBoolean)
+    {
+      this.a = paramBoolean;
+      if (this.d != null) {
+        this.d.setHideable(paramBoolean);
+      }
+    }
+  }
+  
+  public void setCanceledOnTouchOutside(boolean paramBoolean)
+  {
+    super.setCanceledOnTouchOutside(paramBoolean);
+    if ((paramBoolean) && (!this.a)) {
+      this.a = true;
+    }
+    this.b = paramBoolean;
+    this.c = true;
+  }
+  
+  public void setContentView(@LayoutRes int paramInt)
+  {
+    super.setContentView(a(paramInt, null, null));
+  }
+  
+  public void setContentView(View paramView)
+  {
+    super.setContentView(a(0, paramView, null));
+  }
+  
+  public void setContentView(View paramView, ViewGroup.LayoutParams paramLayoutParams)
+  {
+    super.setContentView(a(0, paramView, paramLayoutParams));
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/widget/BottomSheetDialog.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.widget;
+
+import android.app.Dialog;
+import android.os.Bundle;
+import android.support.v7.app.AppCompatDialogFragment;
+
+public class BottomSheetDialogFragment
+  extends AppCompatDialogFragment
+{
+  public Dialog onCreateDialog(Bundle paramBundle)
+  {
+    return new BottomSheetDialog(getContext(), getTheme());
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/widget/BottomSheetDialogFragment.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file

+package android.support.design.widget;
+
+import android.content.Context;
+import android.support.annotation.RestrictTo;
+import android.support.v4.view.AccessibilityDelegateCompat;
+import android.support.v4.view.ViewCompat;
+import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
+import android.support.v7.appcompat.R.attr;
+import android.support.v7.widget.AppCompatImageButton;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.accessibility.AccessibilityEvent;
+import android.widget.Checkable;
+
+@RestrictTo({android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP})
+public class CheckableImageButton
+  extends AppCompatImageButton
+  implements Checkable
+{
+  private static final int[] a = { 16842912 };
+  private boolean b;
+  
+  public CheckableImageButton(Context paramContext)
+  {
+    this(paramContext, null);
+  }
+  
+  public CheckableImageButton(Context paramContext, AttributeSet paramAttributeSet)
+  {
+    this(paramContext, paramAttributeSet, R.attr.imageButtonStyle);
+  }
+  
+  public CheckableImageButton(Context paramContext, AttributeSet paramAttributeSet, int paramInt)
+  {
+    super(paramContext, paramAttributeSet, paramInt);
+    ViewCompat.setAccessibilityDelegate(this, new AccessibilityDelegateCompat()
+    {
+      public final void onInitializeAccessibilityEvent(View paramAnonymousView, AccessibilityEvent paramAnonymousAccessibilityEvent)
+      {
+        super.onInitializeAccessibilityEvent(paramAnonymousView, paramAnonymousAccessibilityEvent);
+        paramAnonymousAccessibilityEvent.setChecked(CheckableImageButton.this.isChecked());
+      }
+      
+      public final void onInitializeAccessibilityNodeInfo(View paramAnonymousView, AccessibilityNodeInfoCompat paramAnonymousAccessibilityNodeInfoCompat)
+      {
+        super.onInitializeAccessibilityNodeInfo(paramAnonymousView, paramAnonymousAccessibilityNodeInfoCompat);
+        paramAnonymousAccessibilityNodeInfoCompat.setCheckable(true);
+        paramAnonymousAccessibilityNodeInfoCompat.setChecked(CheckableImageButton.this.isChecked());
+      }
+    });
+  }
+  
+  public boolean isChecked()
+  {
+    return this.b;
+  }
+  
+  public int[] onCreateDrawableState(int paramInt)
+  {
+    if (this.b) {
+      return mergeDrawableStates(super.onCreateDrawableState(a.length + paramInt), a);
+    }
+    return super.onCreateDrawableState(paramInt);
+  }
+  
+  public void setChecked(boolean paramBoolean)
+  {
+    if (this.b != paramBoolean)
+    {
+      this.b = paramBoolean;
+      refreshDrawableState();
+      sendAccessibilityEvent(2048);
+    }
+  }
+  
+  public void toggle()
+  {
+    if (!this.b) {}
+    for (boolean bool = true;; bool = false)
+    {
+      setChecked(bool);
+      return;
+    }
+  }
+}
+
+
+/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/design/widget/CheckableImageButton.class
+ * Java compiler version: 6 (50.0)
+ * JD-Core Version:       0.7.1
+ */
\ No newline at end of file