//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package java.lang;

import java.io.ObjectStreamField;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Formatter;
import java.util.Iterator;
import java.util.Locale;
import java.util.Objects;
import java.util.StringJoiner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public final class String implements Serializable, Comparable<String>, CharSequence {
  private final char[] value;
  private int hash;
  private static final long serialVersionUID = -6849794470754667710L;
  private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];
  public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator();

  public String() {
    this.value = "".value;
  }

  public String(String var1) {
    this.value = var1.value;
    this.hash = var1.hash;
  }

  public String(char[] var1) {
    this.value = Arrays.copyOf(var1, var1.length);
  }

  public String(char[] var1, int var2, int var3) {
    if (var2 < 0) {
      throw new StringIndexOutOfBoundsException(var2);
    } else {
      if (var3 <= 0) {
        if (var3 < 0) {
          throw new StringIndexOutOfBoundsException(var3);
        }

        if (var2 <= var1.length) {
          this.value = "".value;
          return;
        }
      }

      if (var2 > var1.length - var3) {
        throw new StringIndexOutOfBoundsException(var2 + var3);
      } else {
        this.value = Arrays.copyOfRange(var1, var2, var2 + var3);
      }
    }
  }

  public String(int[] var1, int var2, int var3) {
    if (var2 < 0) {
      throw new StringIndexOutOfBoundsException(var2);
    } else {
      if (var3 <= 0) {
        if (var3 < 0) {
          throw new StringIndexOutOfBoundsException(var3);
        }

        if (var2 <= var1.length) {
          this.value = "".value;
          return;
        }
      }

      if (var2 > var1.length - var3) {
        throw new StringIndexOutOfBoundsException(var2 + var3);
      } else {
        int var4 = var2 + var3;
        int var5 = var3;

        int var7;
        for(int var6 = var2; var6 < var4; ++var6) {
          var7 = var1[var6];
          if (!Character.isBmpCodePoint(var7)) {
            if (!Character.isValidCodePoint(var7)) {
              throw new IllegalArgumentException(Integer.toString(var7));
            }

            ++var5;
          }
        }

        char[] var10 = new char[var5];
        var7 = var2;

        for(int var8 = 0; var7 < var4; ++var8) {
          int var9 = var1[var7];
          if (Character.isBmpCodePoint(var9)) {
            var10[var8] = (char)var9;
          } else {
            Character.toSurrogates(var9, var10, var8++);
          }

          ++var7;
        }

        this.value = var10;
      }
    }
  }

  /** @deprecated */
  @Deprecated
  public String(byte[] var1, int var2, int var3, int var4) {
    checkBounds(var1, var3, var4);
    char[] var5 = new char[var4];
    int var6;
    if (var2 == 0) {
      for(var6 = var4; var6-- > 0; var5[var6] = (char)(var1[var6 + var3] & 255)) {
      }
    } else {
      var2 <<= 8;

      for(var6 = var4; var6-- > 0; var5[var6] = (char)(var2 | var1[var6 + var3] & 255)) {
      }
    }

    this.value = var5;
  }

  /** @deprecated */
  @Deprecated
  public String(byte[] var1, int var2) {
    this(var1, var2, 0, var1.length);
  }

  private static void checkBounds(byte[] var0, int var1, int var2) {
    if (var2 < 0) {
      throw new StringIndexOutOfBoundsException(var2);
    } else if (var1 < 0) {
      throw new StringIndexOutOfBoundsException(var1);
    } else if (var1 > var0.length - var2) {
      throw new StringIndexOutOfBoundsException(var1 + var2);
    }
  }

  public String(byte[] var1, int var2, int var3, String var4) throws UnsupportedEncodingException {
    if (var4 == null) {
      throw new NullPointerException("charsetName");
    } else {
      checkBounds(var1, var2, var3);
      this.value = StringCoding.decode(var4, var1, var2, var3);
    }
  }

  public String(byte[] var1, int var2, int var3, Charset var4) {
    if (var4 == null) {
      throw new NullPointerException("charset");
    } else {
      checkBounds(var1, var2, var3);
      this.value = StringCoding.decode(var4, var1, var2, var3);
    }
  }

  public String(byte[] var1, String var2) throws UnsupportedEncodingException {
    this(var1, 0, var1.length, (String)var2);
  }

  public String(byte[] var1, Charset var2) {
    this(var1, 0, var1.length, (Charset)var2);
  }

  public String(byte[] var1, int var2, int var3) {
    checkBounds(var1, var2, var3);
    this.value = StringCoding.decode(var1, var2, var3);
  }

  public String(byte[] var1) {
    this((byte[])var1, 0, var1.length);
  }

  public String(StringBuffer var1) {
    synchronized(var1) {
      this.value = Arrays.copyOf(var1.getValue(), var1.length());
    }
  }

  public String(StringBuilder var1) {
    this.value = Arrays.copyOf(var1.getValue(), var1.length());
  }

  String(char[] var1, boolean var2) {
    this.value = var1;
  }

  public int length() {
    return this.value.length;
  }

  public boolean isEmpty() {
    return this.value.length == 0;
  }

  public char charAt(int var1) {
    if (var1 >= 0 && var1 < this.value.length) {
      return this.value[var1];
    } else {
      throw new StringIndexOutOfBoundsException(var1);
    }
  }

  public int codePointAt(int var1) {
    if (var1 >= 0 && var1 < this.value.length) {
      return Character.codePointAtImpl(this.value, var1, this.value.length);
    } else {
      throw new StringIndexOutOfBoundsException(var1);
    }
  }

  public int codePointBefore(int var1) {
    int var2 = var1 - 1;
    if (var2 >= 0 && var2 < this.value.length) {
      return Character.codePointBeforeImpl(this.value, var1, 0);
    } else {
      throw new StringIndexOutOfBoundsException(var1);
    }
  }

  public int codePointCount(int var1, int var2) {
    if (var1 >= 0 && var2 <= this.value.length && var1 <= var2) {
      return Character.codePointCountImpl(this.value, var1, var2 - var1);
    } else {
      throw new IndexOutOfBoundsException();
    }
  }

  public int offsetByCodePoints(int var1, int var2) {
    if (var1 >= 0 && var1 <= this.value.length) {
      return Character.offsetByCodePointsImpl(this.value, 0, this.value.length, var1, var2);
    } else {
      throw new IndexOutOfBoundsException();
    }
  }

  void getChars(char[] var1, int var2) {
    System.arraycopy(this.value, 0, var1, var2, this.value.length);
  }

  public void getChars(int var1, int var2, char[] var3, int var4) {
    if (var1 < 0) {
      throw new StringIndexOutOfBoundsException(var1);
    } else if (var2 > this.value.length) {
      throw new StringIndexOutOfBoundsException(var2);
    } else if (var1 > var2) {
      throw new StringIndexOutOfBoundsException(var2 - var1);
    } else {
      System.arraycopy(this.value, var1, var3, var4, var2 - var1);
    }
  }

  /** @deprecated */
  @Deprecated
  public void getBytes(int var1, int var2, byte[] var3, int var4) {
    if (var1 < 0) {
      throw new StringIndexOutOfBoundsException(var1);
    } else if (var2 > this.value.length) {
      throw new StringIndexOutOfBoundsException(var2);
    } else if (var1 > var2) {
      throw new StringIndexOutOfBoundsException(var2 - var1);
    } else {
      Objects.requireNonNull(var3);
      int var5 = var4;
      int var6 = var2;
      int var7 = var1;

      for(char[] var8 = this.value; var7 < var6; var3[var5++] = (byte)var8[var7++]) {
      }

    }
  }

  public byte[] getBytes(String var1) throws UnsupportedEncodingException {
    if (var1 == null) {
      throw new NullPointerException();
    } else {
      return StringCoding.encode(var1, this.value, 0, this.value.length);
    }
  }

  public byte[] getBytes(Charset var1) {
    if (var1 == null) {
      throw new NullPointerException();
    } else {
      return StringCoding.encode(var1, this.value, 0, this.value.length);
    }
  }

  public byte[] getBytes() {
    return StringCoding.encode(this.value, 0, this.value.length);
  }

  public boolean equals(Object var1) {
    if (this == var1) {
      return true;
    } else {
      if (var1 instanceof String) {
        String var2 = (String)var1;
        int var3 = this.value.length;
        if (var3 == var2.value.length) {
          char[] var4 = this.value;
          char[] var5 = var2.value;

          for(int var6 = 0; var3-- != 0; ++var6) {
            if (var4[var6] != var5[var6]) {
              return false;
            }
          }

          return true;
        }
      }

      return false;
    }
  }

  public boolean contentEquals(StringBuffer var1) {
    return this.contentEquals((CharSequence)var1);
  }

  private boolean nonSyncContentEquals(AbstractStringBuilder var1) {
    char[] var2 = this.value;
    char[] var3 = var1.getValue();
    int var4 = var2.length;
    if (var4 != var1.length()) {
      return false;
    } else {
      for(int var5 = 0; var5 < var4; ++var5) {
        if (var2[var5] != var3[var5]) {
          return false;
        }
      }

      return true;
    }
  }

  public boolean contentEquals(CharSequence var1) {
    if (var1 instanceof AbstractStringBuilder) {
      if (var1 instanceof StringBuffer) {
        synchronized(var1) {
          return this.nonSyncContentEquals((AbstractStringBuilder)var1);
        }
      } else {
        return this.nonSyncContentEquals((AbstractStringBuilder)var1);
      }
    } else if (var1 instanceof String) {
      return this.equals(var1);
    } else {
      char[] var2 = this.value;
      int var3 = var2.length;
      if (var3 != var1.length()) {
        return false;
      } else {
        for(int var4 = 0; var4 < var3; ++var4) {
          if (var2[var4] != var1.charAt(var4)) {
            return false;
          }
        }

        return true;
      }
    }
  }

  public boolean equalsIgnoreCase(String var1) {
    return this == var1 ? true : var1 != null && var1.value.length == this.value.length && this.regionMatches(true, 0, var1, 0, this.value.length);
  }

  public int compareTo(String var1) {
    int var2 = this.value.length;
    int var3 = var1.value.length;
    int var4 = Math.min(var2, var3);
    char[] var5 = this.value;
    char[] var6 = var1.value;

    for(int var7 = 0; var7 < var4; ++var7) {
      char var8 = var5[var7];
      char var9 = var6[var7];
      if (var8 != var9) {
        return var8 - var9;
      }
    }

    return var2 - var3;
  }

  public int compareToIgnoreCase(String var1) {
    return CASE_INSENSITIVE_ORDER.compare(this, var1);
  }

  public boolean regionMatches(int var1, String var2, int var3, int var4) {
    char[] var5 = this.value;
    int var6 = var1;
    char[] var7 = var2.value;
    int var8 = var3;
    if (var3 >= 0 && var1 >= 0 && (long)var1 <= (long)this.value.length - (long)var4 && (long)var3 <= (long)var2.value.length - (long)var4) {
      do {
        if (var4-- <= 0) {
          return true;
        }
      } while(var5[var6++] == var7[var8++]);

      return false;
    } else {
      return false;
    }
  }

  public boolean regionMatches(boolean var1, int var2, String var3, int var4, int var5) {
    char[] var6 = this.value;
    int var7 = var2;
    char[] var8 = var3.value;
    int var9 = var4;
    if (var4 >= 0 && var2 >= 0 && (long)var2 <= (long)this.value.length - (long)var5 && (long)var4 <= (long)var3.value.length - (long)var5) {
      char var12;
      char var13;
      do {
        char var10;
        char var11;
        do {
          if (var5-- <= 0) {
            return true;
          }

          var10 = var6[var7++];
          var11 = var8[var9++];
        } while(var10 == var11);

        if (!var1) {
          break;
        }

        var12 = Character.toUpperCase(var10);
        var13 = Character.toUpperCase(var11);
      } while(var12 == var13 || Character.toLowerCase(var12) == Character.toLowerCase(var13));

      return false;
    } else {
      return false;
    }
  }

  public boolean startsWith(String var1, int var2) {
    char[] var3 = this.value;
    int var4 = var2;
    char[] var5 = var1.value;
    int var6 = 0;
    int var7 = var1.value.length;
    if (var2 >= 0 && var2 <= this.value.length - var7) {
      do {
        --var7;
        if (var7 < 0) {
          return true;
        }
      } while(var3[var4++] == var5[var6++]);

      return false;
    } else {
      return false;
    }
  }

  public boolean startsWith(String var1) {
    return this.startsWith(var1, 0);
  }

  public boolean endsWith(String var1) {
    return this.startsWith(var1, this.value.length - var1.value.length);
  }

  public int hashCode() {
    int var1 = this.hash;
    if (var1 == 0 && this.value.length > 0) {
      char[] var2 = this.value;

      for(int var3 = 0; var3 < this.value.length; ++var3) {
        var1 = 31 * var1 + var2[var3];
      }

      this.hash = var1;
    }

    return var1;
  }

  public int indexOf(int var1) {
    return this.indexOf(var1, 0);
  }

  public int indexOf(int var1, int var2) {
    int var3 = this.value.length;
    if (var2 < 0) {
      var2 = 0;
    } else if (var2 >= var3) {
      return -1;
    }

    if (var1 < 65536) {
      char[] var4 = this.value;

      for(int var5 = var2; var5 < var3; ++var5) {
        if (var4[var5] == var1) {
          return var5;
        }
      }

      return -1;
    } else {
      return this.indexOfSupplementary(var1, var2);
    }
  }

  private int indexOfSupplementary(int var1, int var2) {
    if (Character.isValidCodePoint(var1)) {
      char[] var3 = this.value;
      char var4 = Character.highSurrogate(var1);
      char var5 = Character.lowSurrogate(var1);
      int var6 = var3.length - 1;

      for(int var7 = var2; var7 < var6; ++var7) {
        if (var3[var7] == var4 && var3[var7 + 1] == var5) {
          return var7;
        }
      }
    }

    return -1;
  }

  public int lastIndexOf(int var1) {
    return this.lastIndexOf(var1, this.value.length - 1);
  }

  public int lastIndexOf(int var1, int var2) {
    if (var1 < 65536) {
      char[] var3 = this.value;

      for(int var4 = Math.min(var2, var3.length - 1); var4 >= 0; --var4) {
        if (var3[var4] == var1) {
          return var4;
        }
      }

      return -1;
    } else {
      return this.lastIndexOfSupplementary(var1, var2);
    }
  }

  private int lastIndexOfSupplementary(int var1, int var2) {
    if (Character.isValidCodePoint(var1)) {
      char[] var3 = this.value;
      char var4 = Character.highSurrogate(var1);
      char var5 = Character.lowSurrogate(var1);

      for(int var6 = Math.min(var2, var3.length - 2); var6 >= 0; --var6) {
        if (var3[var6] == var4 && var3[var6 + 1] == var5) {
          return var6;
        }
      }
    }

    return -1;
  }

  public int indexOf(String var1) {
    return this.indexOf(var1, 0);
  }

  public int indexOf(String var1, int var2) {
    return indexOf(this.value, 0, this.value.length, var1.value, 0, var1.value.length, var2);
  }

  static int indexOf(char[] var0, int var1, int var2, String var3, int var4) {
    return indexOf(var0, var1, var2, var3.value, 0, var3.value.length, var4);
  }

  static int indexOf(char[] var0, int var1, int var2, char[] var3, int var4, int var5, int var6) {
    if (var6 >= var2) {
      return var5 == 0 ? var2 : -1;
    } else {
      if (var6 < 0) {
        var6 = 0;
      }

      if (var5 == 0) {
        return var6;
      } else {
        char var7 = var3[var4];
        int var8 = var1 + (var2 - var5);

        for(int var9 = var1 + var6; var9 <= var8; ++var9) {
          if (var0[var9] != var7) {
            do {
              ++var9;
            } while(var9 <= var8 && var0[var9] != var7);
          }

          if (var9 <= var8) {
            int var10 = var9 + 1;
            int var11 = var10 + var5 - 1;

            for(int var12 = var4 + 1; var10 < var11 && var0[var10] == var3[var12]; ++var12) {
              ++var10;
            }

            if (var10 == var11) {
              return var9 - var1;
            }
          }
        }

        return -1;
      }
    }
  }

  public int lastIndexOf(String var1) {
    return this.lastIndexOf(var1, this.value.length);
  }

  public int lastIndexOf(String var1, int var2) {
    return lastIndexOf(this.value, 0, this.value.length, var1.value, 0, var1.value.length, var2);
  }

  static int lastIndexOf(char[] var0, int var1, int var2, String var3, int var4) {
    return lastIndexOf(var0, var1, var2, var3.value, 0, var3.value.length, var4);
  }

  static int lastIndexOf(char[] var0, int var1, int var2, char[] var3, int var4, int var5, int var6) {
    int var7 = var2 - var5;
    if (var6 < 0) {
      return -1;
    } else {
      if (var6 > var7) {
        var6 = var7;
      }

      if (var5 == 0) {
        return var6;
      } else {
        int var8 = var4 + var5 - 1;
        char var9 = var3[var8];
        int var10 = var1 + var5 - 1;
        int var11 = var10 + var6;

        while(true) {
          while(var11 < var10 || var0[var11] == var9) {
            if (var11 < var10) {
              return -1;
            }

            int var12 = var11 - 1;
            int var13 = var12 - (var5 - 1);
            int var14 = var8 - 1;

            do {
              if (var12 <= var13) {
                return var13 - var1 + 1;
              }
            } while(var0[var12--] == var3[var14--]);

            --var11;
          }

          --var11;
        }
      }
    }
  }

  public String substring(int var1) {
    if (var1 < 0) {
      throw new StringIndexOutOfBoundsException(var1);
    } else {
      int var2 = this.value.length - var1;
      if (var2 < 0) {
        throw new StringIndexOutOfBoundsException(var2);
      } else {
        return var1 == 0 ? this : new String(this.value, var1, var2);
      }
    }
  }

  public String substring(int var1, int var2) {
    if (var1 < 0) {
      throw new StringIndexOutOfBoundsException(var1);
    } else if (var2 > this.value.length) {
      throw new StringIndexOutOfBoundsException(var2);
    } else {
      int var3 = var2 - var1;
      if (var3 < 0) {
        throw new StringIndexOutOfBoundsException(var3);
      } else {
        return var1 == 0 && var2 == this.value.length ? this : new String(this.value, var1, var3);
      }
    }
  }

  public CharSequence subSequence(int var1, int var2) {
    return this.substring(var1, var2);
  }

  public String concat(String var1) {
    if (var1.isEmpty()) {
      return this;
    } else {
      int var2 = this.value.length;
      int var3 = var1.length();
      char[] var4 = Arrays.copyOf(this.value, var2 + var3);
      var1.getChars(var4, var2);
      return new String(var4, true);
    }
  }

  public String replace(char var1, char var2) {
    if (var1 != var2) {
      int var3 = this.value.length;
      int var4 = -1;
      char[] var5 = this.value;

      do {
        ++var4;
      } while(var4 < var3 && var5[var4] != var1);

      if (var4 < var3) {
        char[] var6 = new char[var3];

        for(int var7 = 0; var7 < var4; ++var7) {
          var6[var7] = var5[var7];
        }

        while(var4 < var3) {
          char var8 = var5[var4];
          var6[var4] = var8 == var1 ? var2 : var8;
          ++var4;
        }

        return new String(var6, true);
      }
    }

    return this;
  }

  public boolean matches(String var1) {
    return Pattern.matches(var1, this);
  }

  public boolean contains(CharSequence var1) {
    return this.indexOf(var1.toString()) > -1;
  }

  public String replaceFirst(String var1, String var2) {
    return Pattern.compile(var1).matcher(this).replaceFirst(var2);
  }

  public String replaceAll(String var1, String var2) {
    return Pattern.compile(var1).matcher(this).replaceAll(var2);
  }

  public String replace(CharSequence var1, CharSequence var2) {
    return Pattern.compile(var1.toString(), 16).matcher(this).replaceAll(Matcher.quoteReplacement(var2.toString()));
  }

  public String[] split(String var1, int var2) {
    char var3 = 0;
    if ((var1.value.length != 1 || ".$|()[{^?*+\\".indexOf(var3 = var1.charAt(0)) != -1) && (var1.length() != 2 || var1.charAt(0) != '\\' || ((var3 = var1.charAt(1)) - 48 | 57 - var3) >= 0 || (var3 - 97 | 122 - var3) >= 0 || (var3 - 65 | 90 - var3) >= 0) || var3 >= '\ud800' && var3 <= '\udfff') {
      return Pattern.compile(var1).split(this, var2);
    } else {
      int var4 = 0;
      boolean var5 = false;
      boolean var6 = var2 > 0;

      ArrayList var7;
      int var10;
      for(var7 = new ArrayList(); (var10 = this.indexOf(var3, var4)) != -1; var4 = var10 + 1) {
        if (var6 && var7.size() >= var2 - 1) {
          var7.add(this.substring(var4, this.value.length));
          var4 = this.value.length;
          break;
        }

        var7.add(this.substring(var4, var10));
      }

      if (var4 == 0) {
        return new String[]{this};
      } else {
        if (!var6 || var7.size() < var2) {
          var7.add(this.substring(var4, this.value.length));
        }

        int var8 = var7.size();
        if (var2 == 0) {
          while(var8 > 0 && ((String)var7.get(var8 - 1)).isEmpty()) {
            --var8;
          }
        }

        String[] var9 = new String[var8];
        return (String[])var7.subList(0, var8).toArray(var9);
      }
    }
  }

  public String[] split(String var1) {
    return this.split(var1, 0);
  }

  public static String join(CharSequence var0, CharSequence... var1) {
    Objects.requireNonNull(var0);
    Objects.requireNonNull(var1);
    StringJoiner var2 = new StringJoiner(var0);
    CharSequence[] var3 = var1;
    int var4 = var1.length;

    for(int var5 = 0; var5 < var4; ++var5) {
      CharSequence var6 = var3[var5];
      var2.add(var6);
    }

    return var2.toString();
  }

  public static String join(CharSequence var0, Iterable<? extends CharSequence> var1) {
    Objects.requireNonNull(var0);
    Objects.requireNonNull(var1);
    StringJoiner var2 = new StringJoiner(var0);
    Iterator var3 = var1.iterator();

    while(var3.hasNext()) {
      CharSequence var4 = (CharSequence)var3.next();
      var2.add(var4);
    }

    return var2.toString();
  }

  public String toLowerCase(Locale var1) {
    if (var1 == null) {
      throw new NullPointerException();
    } else {
      int var3 = this.value.length;
      int var2 = 0;

      int var5;
      while(true) {
        if (var2 >= var3) {
          return this;
        }

        char var4 = this.value[var2];
        if (var4 >= '\ud800' && var4 <= '\udbff') {
          var5 = this.codePointAt(var2);
          if (var5 != Character.toLowerCase(var5)) {
            break;
          }

          var2 += Character.charCount(var5);
        } else {
          if (var4 != Character.toLowerCase(var4)) {
            break;
          }

          ++var2;
        }
      }

      char[] var15 = new char[var3];
      var5 = 0;
      System.arraycopy(this.value, 0, var15, 0, var2);
      String var6 = var1.getLanguage();
      boolean var7 = var6 == "tr" || var6 == "az" || var6 == "lt";

      int var11;
      for(int var12 = var2; var12 < var3; var12 += var11) {
        int var10 = this.value[var12];
        if ((char)var10 >= '\ud800' && (char)var10 <= '\udbff') {
          var10 = this.codePointAt(var12);
          var11 = Character.charCount(var10);
        } else {
          var11 = 1;
        }

        int var9;
        if (!var7 && var10 != 931 && var10 != 304) {
          var9 = Character.toLowerCase(var10);
        } else {
          var9 = ConditionalSpecialCasing.toLowerCaseEx(this, var12, var1);
        }

        if (var9 != -1 && var9 < 65536) {
          var15[var12 + var5] = (char)var9;
        } else {
          char[] var8;
          if (var9 == -1) {
            var8 = ConditionalSpecialCasing.toLowerCaseCharArray(this, var12, var1);
          } else {
            if (var11 == 2) {
              var5 += Character.toChars(var9, var15, var12 + var5) - var11;
              continue;
            }

            var8 = Character.toChars(var9);
          }

          int var13 = var8.length;
          if (var13 > var11) {
            char[] var14 = new char[var15.length + var13 - var11];
            System.arraycopy(var15, 0, var14, 0, var12 + var5);
            var15 = var14;
          }

          for(int var16 = 0; var16 < var13; ++var16) {
            var15[var12 + var5 + var16] = var8[var16];
          }

          var5 += var13 - var11;
        }
      }

      return new String(var15, 0, var3 + var5);
    }
  }

  public String toLowerCase() {
    return this.toLowerCase(Locale.getDefault());
  }

  public String toUpperCase(Locale var1) {
    if (var1 == null) {
      throw new NullPointerException();
    } else {
      int var3 = this.value.length;

      int var5;
      for(int var2 = 0; var2 < var3; var2 += var5) {
        int var4 = this.value[var2];
        if (var4 >= 55296 && var4 <= 56319) {
          var4 = this.codePointAt(var2);
          var5 = Character.charCount(var4);
        } else {
          var5 = 1;
        }

        int var6 = Character.toUpperCaseEx(var4);
        if (var6 == -1 || var4 != var6) {
          var4 = 0;
          char[] var15 = new char[var3];
          System.arraycopy(this.value, 0, var15, 0, var2);
          String var16 = var1.getLanguage();
          boolean var7 = var16 == "tr" || var16 == "az" || var16 == "lt";

          int var11;
          for(int var12 = var2; var12 < var3; var12 += var11) {
            int var10 = this.value[var12];
            if ((char)var10 >= '\ud800' && (char)var10 <= '\udbff') {
              var10 = this.codePointAt(var12);
              var11 = Character.charCount(var10);
            } else {
              var11 = 1;
            }

            int var9;
            if (var7) {
              var9 = ConditionalSpecialCasing.toUpperCaseEx(this, var12, var1);
            } else {
              var9 = Character.toUpperCaseEx(var10);
            }

            if (var9 != -1 && var9 < 65536) {
              var15[var12 + var4] = (char)var9;
            } else {
              char[] var8;
              if (var9 == -1) {
                if (var7) {
                  var8 = ConditionalSpecialCasing.toUpperCaseCharArray(this, var12, var1);
                } else {
                  var8 = Character.toUpperCaseCharArray(var10);
                }
              } else {
                if (var11 == 2) {
                  var4 += Character.toChars(var9, var15, var12 + var4) - var11;
                  continue;
                }

                var8 = Character.toChars(var9);
              }

              int var13 = var8.length;
              if (var13 > var11) {
                char[] var14 = new char[var15.length + var13 - var11];
                System.arraycopy(var15, 0, var14, 0, var12 + var4);
                var15 = var14;
              }

              for(int var17 = 0; var17 < var13; ++var17) {
                var15[var12 + var4 + var17] = var8[var17];
              }

              var4 += var13 - var11;
            }
          }

          return new String(var15, 0, var3 + var4);
        }
      }

      return this;
    }
  }

  public String toUpperCase() {
    return this.toUpperCase(Locale.getDefault());
  }

  public String trim() {
    int var1 = this.value.length;
    int var2 = 0;

    char[] var3;
    for(var3 = this.value; var2 < var1 && var3[var2] <= ' '; ++var2) {
    }

    while(var2 < var1 && var3[var1 - 1] <= ' ') {
      --var1;
    }

    return var2 <= 0 && var1 >= this.value.length ? this : this.substring(var2, var1);
  }

  public String toString() {
    return this;
  }

  public char[] toCharArray() {
    char[] var1 = new char[this.value.length];
    System.arraycopy(this.value, 0, var1, 0, this.value.length);
    return var1;
  }

  public static String format(String var0, Object... var1) {
    return (new Formatter()).format(var0, var1).toString();
  }

  public static String format(Locale var0, String var1, Object... var2) {
    return (new Formatter(var0)).format(var1, var2).toString();
  }

  public static String valueOf(Object var0) {
    return var0 == null ? "null" : var0.toString();
  }

  public static String valueOf(char[] var0) {
    return new String(var0);
  }

  public static String valueOf(char[] var0, int var1, int var2) {
    return new String(var0, var1, var2);
  }

  public static String copyValueOf(char[] var0, int var1, int var2) {
    return new String(var0, var1, var2);
  }

  public static String copyValueOf(char[] var0) {
    return new String(var0);
  }

  public static String valueOf(boolean var0) {
    return var0 ? "true" : "false";
  }

  public static String valueOf(char var0) {
    char[] var1 = new char[]{var0};
    return new String(var1, true);
  }

  public static String valueOf(int var0) {
    return Integer.toString(var0);
  }

  public static String valueOf(long var0) {
    return Long.toString(var0);
  }

  public static String valueOf(float var0) {
    return Float.toString(var0);
  }

  public static String valueOf(double var0) {
    return Double.toString(var0);
  }

  public native String intern();

  private static class CaseInsensitiveComparator implements Comparator<String>, Serializable {
    private static final long serialVersionUID = 8575799808933029326L;

    private CaseInsensitiveComparator() {
    }

    public int compare(String var1, String var2) {
      int var3 = var1.length();
      int var4 = var2.length();
      int var5 = Math.min(var3, var4);

      for(int var6 = 0; var6 < var5; ++var6) {
        char var7 = var1.charAt(var6);
        char var8 = var2.charAt(var6);
        if (var7 != var8) {
          var7 = Character.toUpperCase(var7);
          var8 = Character.toUpperCase(var8);
          if (var7 != var8) {
            var7 = Character.toLowerCase(var7);
            var8 = Character.toLowerCase(var8);
            if (var7 != var8) {
              return var7 - var8;
            }
          }
        }
      }

      return var3 - var4;
    }

    private Object readResolve() {
      return String.CASE_INSENSITIVE_ORDER;
    }
  }
}