package defpackage;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

final class ans {
   private static final int HEADER_SIZE = 8;
   private static final int LARGE_HEADER_SIZE = 16;
   private static final int LARGE_SIZE_MARKER = 1;
   private static final int FULL_BOX_HEADER = 4;
   private static final int MAX_INIT_BOX = 4194304;
   private static final int MAX_FRAGMENT_BOX = 8388608;
   private static final int MAX_SAMPLE = 4194304;
   private static final long MILLIS_PER_SECOND = 1000L;
   private static final int VISUAL_ENTRY_FIELDS = 78;
   private static final int AUDIO_ENTRY_FIELDS = 28;
   private static final int TAG_ES = 3;
   private static final int TAG_DECODER_CONFIG = 4;
   private static final int TAG_DECODER_SPECIFIC = 5;
   private static final int DECODER_CONFIG_FIELDS = 13;
   private static final int ES_FLAG_DEPENDENCE = 128;
   private static final int ES_FLAG_URL = 64;
   private static final int ES_FLAG_OCR = 32;
   private static final int DESCRIPTOR_LENGTH_BYTES = 4;
   private static final int DESCRIPTOR_CONTINUE = 128;
   private static final int DESCRIPTOR_VALUE = 127;
   private static final int DESCRIPTOR_SHIFT = 7;
   private static final int REFERENCE_SIZE_MASK = Integer.MAX_VALUE;
   private static final int TFHD_BASE_OFFSET = 1;
   private static final int TFHD_DESCRIPTION_INDEX = 2;
   private static final int TFHD_DEFAULT_DURATION = 8;
   private static final int TFHD_DEFAULT_SIZE = 16;
   private static final int TFHD_DEFAULT_FLAGS = 32;
   private static final int TRUN_DATA_OFFSET = 1;
   private static final int TRUN_FIRST_FLAGS = 4;
   private static final int TRUN_DURATION = 256;
   private static final int TRUN_SIZE = 512;
   private static final int TRUN_FLAGS = 1024;
   private static final int TRUN_COMPOSITION = 2048;
   private static final int NON_SYNC_FLAG = 65536;
   private static final int FLAGS_MASK = 16777215;
   private static final int VERSION_SHIFT = 24;
   private static final String MOOV = "moov";
   private static final String SIDX = "sidx";
   private static final String MOOF = "moof";
   private static final String TRAK = "trak";
   private static final String MDIA = "mdia";
   private static final String MDHD = "mdhd";
   private static final String MINF = "minf";
   private static final String STBL = "stbl";
   private static final String STSD = "stsd";
   private static final String MVEX = "mvex";
   private static final String TREX = "trex";
   private static final String TRAF = "traf";
   private static final String TFHD = "tfhd";
   private static final String TFDT = "tfdt";
   private static final String TRUN = "trun";
   private static final String AVC1 = "avc1";
   private static final String AVC3 = "avc3";
   private static final String MP4A = "mp4a";
   private static final String AVCC = "avcC";
   private static final String ESDS = "esds";
   private static final String NO_INDEX = "stream has no segment index";
   private static final String NO_CODEC = "stream has no supported codec";
   private static final String BAD_BOX = "malformed mp4 box ";
   private final ant channel;
   private final List<anr> segments = new ArrayList<>();
   private int timescale;
   private boolean video;
   private byte[] codecConfig;
   private anp trackDefaults = new anp(
      0,
      0,
      (-989610675 ^ 989610675) + ((-989610675 & 989610675) << 1)
   );
   private String headerType;
   private String lastType;

   private ans(ant var1) {
      this.channel = var1;
   }

   static ans open(ant var0) throws IOException {
      ans var1 = new ans(var0);
      var1.readInit();
      return var1;
   }

   boolean isVideo() {
      return this.video;
   }

   byte[] codecConfig() {
      return this.codecConfig;
   }

   int segmentCount() {
      return this.segments.size();
   }

   int segmentAt(long var1) {
      int var3 = 0;
      int var4 = 0;
      int var5 = 0;
      int var6 = 0;
      int var7 = -1375977729;

      while (true) {
         switch (var7) {
            case -1434743073:
               var7 = 886457760;
               break;
            case -1384642667:
               var6 = var3 + var4 >>> 1;
               if (this.segments.get(var6).startMs() <= var1) {
                  var7 = -256902951;
               } else {
                  var7 = -455469975;
               }
               break;
            case -1375977729:
            default:
               var3 = 0;
               var4 = this.segments.size() - (1);
               var5 = 0;
               var7 = 886457760;
               break;
            case -564277243:
               return var5;
            case -455469975:
               var4 = var6 - (1);
               var7 = -1434743073;
               break;
            case -256902951:
               var5 = var6;
               var3 = var6 + 1;
               var7 = -1434743073;
               break;
            case 886457760:
               if (var3 <= var4) {
                  var7 = -1384642667;
               } else {
                  var7 = -564277243;
               }
         }
      }
   }

   List<anq> readSegment(int var1) throws IOException {
      anr var2 = null;
      ByteBuffer var3 = null;
      ArrayList var4 = null;
      ByteBuffer var5 = null;
      int var6 = -1556286043;

      while (true) {
         switch (var6) {
            case -1687150231:
               this.parseTraf(var5, var2.offset(), var4);
               var6 = 142604501;
               break;
            case -1556286043:
            default:
               var2 = this.segments.get(var1);
               var3 = this.readBox(
                  var2.offset(),
                  "moof",
                  (-1748646828 ^ 1757035436) + ((-1748646828 & 1757035436) << 1)
               );
               var4 = new ArrayList();
               var6 = 429576451;
               break;
            case -117190557:
               var4.sort((var0, var1x) -> Long.compare(var0.offset(), var1x.offset()));
               return var4;
            case 142604501:
               var6 = 429576451;
               break;
            case 429576451:
               if (var3.hasRemaining()) {
                  var6 = 790007517;
               } else {
                  var6 = -117190557;
               }
               break;
            case 790007517:
               var5 = this.nextChild(var3);
               if ("traf".equals(this.lastType)) {
                  var6 = -1687150231;
               } else {
                  var6 = 142604501;
               }
         }
      }
   }

   ByteBuffer read(anq var1, ByteBuffer var2) throws IOException {
      if (var1.size() > 0 && var1.size() <= (703881152 ^ -699686848) + ((703881152 & -699686848) << 1)) {
         ByteBuffer var3 = var2 != null && var2.capacity() >= var1.size()
            ? var2.clear()
            : ByteBuffer.allocate(
               Math.max(
                  var1.size(),
                  var2 == null
                     ? 0: var2.capacity() * ((-1041923229 | 1041923231) + (-1041923229 & 1041923231))
               )
            );
         var3.limit(var1.size());
         this.channel.setPosition(var1.offset());
         this.readFully(var3);
         var3.flip();
         return var3;
      } else {
         throw new IOException("malformed mp4 box trun");
      }
   }

   private void readInit() throws IOException {
      long var1 = (7411397759284608797L ^ -7411397759284608797L) + ((7411397759284608797L & -7411397759284608797L) << 1);
      ByteBuffer var3 = null;
      long var4 = (3805654444444626470L | -3805654444444626470L) + (3805654444444626470L & -3805654444444626470L);
      long var6 = (9141068795157752576L | -9141068795157752576L) + (9141068795157752576L & -9141068795157752576L);
      Object var8 = null;
      long var9 = (-7573062104143992540L ^ 7573062104143992540L) + ((-7573062104143992540L & 7573062104143992540L) << 1);
      int var11 = 0;
      String var12 = null;
      int var13 = 440056696;

      while (true) {
         switch (var13) {
            case -2139693340:
               this.parseSidx(var3, var4);
               return;
            case -1634972743:
               if ("sidx".equals(var12)) {
                  var13 = 54234298;
               } else {
                  var13 = 172949529;
               }
               break;
            case -1462951968:
               if (var1 < var6) {
                  var13 = -465831660;
               } else {
                  var13 = 1798056365;
               }
               break;
            case -1457415919:
               var13 = 1798056365;
               break;
            case -1171543993:
               if (this.timescale <= 0) {
                  var13 = 2072484515;
               } else {
                  var13 = 945788598;
               }
               break;
            case -672257516:
               var1 += var9;
               var13 = -1462951968;
               break;
            case -465831660:
               if (var3 == null) {
                  var13 = -67413064;
               } else {
                  var13 = 1798056365;
               }
               break;
            case -259764133:
               this.parseMoov(this.readBody(var1 + var11, var9 - var11));
               var13 = -672257516;
               break;
            case -67413064:
               var8 = this.readHeader(var1);
               var9 = (long)((Object[])var8)[0];
               var11 = (int)((Object[])var8)[1];
               var12 = this.headerType;
               if (var9 >= var11) {
                  var13 = 1760847170;
               } else {
                  var13 = 756152629;
               }
               break;
            case 54234298:
               var3 = this.readBody(var1 + var11, var9 - var11);
               var4 = var1 + var9;
               var13 = -672257516;
               break;
            case 172949529:
               if ("moof".equals(var12)) {
                  var13 = -1457415919;
               } else {
                  var13 = -672257516;
               }
               break;
            case 440056696:
            default:
               var1 = (2552891194613996489L ^ -2552891194613996489L) + ((2552891194613996489L & -2552891194613996489L) << 1);
               var3 = null;
               var4 = (940066504459481028L ^ -940066504459481028L) + ((940066504459481028L & -940066504459481028L) << 1);
               var6 = this.channel.size();
               var13 = -1462951968;
               break;
            case 452914626:
               if ("moov".equals(var12)) {
                  var13 = -259764133;
               } else {
                  var13 = -1634972743;
               }
               break;
            case 594968410:
               throw new IOException("stream has no segment index");
            case 756152629:
               throw new IOException("malformed mp4 box " + var12);
            case 945788598:
               if (var3 == null) {
                  var13 = 594968410;
               } else {
                  var13 = -2139693340;
               }
               break;
            case 1760847170:
               if (var9 > var6 - var1 + var11) {
                  var13 = 756152629;
               } else {
                  var13 = 452914626;
               }
               break;
            case 1798056365:
               if (this.codecConfig != null) {
                  var13 = -1171543993;
               } else {
                  var13 = 2072484515;
               }
               break;
            case 2072484515:
               throw new IOException(
                  "stream has no supported codec"
               );
         }
      }
   }

   private void parseMoov(ByteBuffer var1) throws IOException {
      ByteBuffer var2 = null;
      String var3 = null;
      ByteBuffer var4 = null;
      int var5 = -301528956;

      while (true) {
         switch (var5) {
            case -2104894051:
               var4 = this.nextChild(var2);
               if ("trex".equals(this.lastType)) {
                  var5 = -1451465374;
               } else {
                  var5 = -1884663492;
               }
               break;
            case -1884663492:
               var5 = 2059330867;
               break;
            case -1451465374:
               var4.getInt();
               var4.getInt();
               var4.getInt();
               this.trackDefaults = new anp(var4.getInt(), var4.getInt(), var4.getInt());
               var5 = -1884663492;
               break;
            case -422340387:
               if ("mvex".equals(var3)) {
                  var5 = 2059330867;
               } else {
                  var5 = 692881069;
               }
               break;
            case -301528956:
            default:
               if (var1.hasRemaining()) {
                  var5 = 323594408;
               } else {
                  var5 = 166103649;
               }
               break;
            case 166103649:
               return;
            case 323594408:
               var2 = this.nextChild(var1);
               var3 = this.lastType;
               if ("trak".equals(var3)) {
                  var5 = 1727192512;
               } else {
                  var5 = -422340387;
               }
               break;
            case 692881069:
               var5 = -301528956;
               break;
            case 717544781:
               this.parseTrak(var2);
               var5 = 692881069;
               break;
            case 1727192512:
               if (this.codecConfig == null) {
                  var5 = 717544781;
               } else {
                  var5 = -422340387;
               }
               break;
            case 2059330867:
               if (var2.hasRemaining()) {
                  var5 = -2104894051;
               } else {
                  var5 = 692881069;
               }
         }
      }
   }

   private void parseTrak(ByteBuffer var1) throws IOException {
      ByteBuffer var2 = this.findChild(var1, "mdia");
      if (var2 != null) {
         ByteBuffer var3 = this.findChild(var2.duplicate(), "mdhd");
         ByteBuffer var4 = this.findChild(var2.duplicate(), "minf");
         ByteBuffer var5 = var4 == null ? null : this.findChild(var4, "stbl");
         ByteBuffer var6 = var5 == null ? null : this.findChild(var5, "stsd");
         if (var3 != null && var6 != null) {
            int var7 = var3.get() & 255;
            var3.position(
               var3.position()
                  + (-685824852 | 685824856)
                  + (-685824852 & 685824856)
                  - ((-1401865506 ^ 1401865507) + ((-1401865506 & 1401865507) << 1))
                  + (
                     var7 == 1? 16: (693468506 ^ -693468498) + ((693468506 & -693468498) << 1)
                  )
            );
            this.timescale = var3.getInt();
            var6.position(var6.position() + (876033248 | -876033244) + (876033248 & -876033244) + (865572086 | -865572082) + (865572086 & -865572082));
            ByteBuffer var8 = this.nextChild(var6);
            String var9 = this.lastType;
            if (!"avc1".equals(var9)
               && !"avc3".equals(var9)) {
               if ("mp4a".equals(var9)) {
                  var8.position(var8.position() + (-1695756714 | 1695756742) + (-1695756714 & 1695756742));
                  ByteBuffer var11 = this.findChild(var8, "esds");
                  if (var11 != null) {
                     var11.position(var11.position() + (-1674133520 ^ 1674133524) + ((-1674133520 & 1674133524) << 1));
                     this.codecConfig = audioSpecificConfig(var11);
                     this.video = (boolean)(((0)) != 0);
                  }
               }
            } else {
               var8.position(var8.position() + (-566438694 ^ 566438772) + ((-566438694 & 566438772) << 1));
               ByteBuffer var10 = this.findChild(var8, "avcC");
               if (var10 != null) {
                  this.video = (boolean)(((1)) != 0);
                  this.codecConfig = bytes(var10);
               }
            }
         }
      }
   }

   private static byte[] audioSpecificConfig(ByteBuffer var0) throws IOException {
      int var1 = 0;
      int var2 = 0;
      B var3 = null;
      int var4 = -1096445122;

      while (true) {
         switch (var4) {
            case -1997685852:
               if (var2 > var0.remaining()) {
                  var4 = -1764616459;
               } else {
                  var4 = -1968286316;
               }
               break;
            case -1968286316:
               var3 = new byte[var2];
               var0.get((byte[])var3);
               return (byte[])var3;
            case -1764616459:
               throw new IOException(
                  "malformed mp4 box esds"
               );
            case -1305548382:
               var2 = descriptorLength(var0);
               if (var2 > 0) {
                  var4 = -1997685852;
               } else {
                  var4 = -1764616459;
               }
               break;
            case -1204162978:
               throw new IOException("malformed mp4 box esds");
            case -1119606006:
               if ((var1 & (-1309597121 | 1309597185) + (-1309597121 & 1309597185)) != 0) {
                  var4 = 1774782979;
               } else {
                  var4 = 832155241;
               }
               break;
            case -1096445122:
            default:
               if ((var0.get() & (1483213758 ^ -1483213503) + ((1483213758 & -1483213503) << 1)) != (988814225 ^ -988814222) + ((988814225 & -988814222) << 1)) {
                  var4 = -1204162978;
               } else {
                  var4 = 1190173442;
               }
               break;
            case -749808190:
               throw new IOException(
                  "malformed mp4 box esds"
               );
            case -269512334:
               var0.getShort();
               var4 = -195629486;
               break;
            case -195629486:
               if ((var0.get() & (229069346 | -229069091) + (229069346 & -229069091)) != (-125974441 ^ 125974445) + ((-125974441 & 125974445) << 1)) {
                  var4 = 1409742169;
               } else {
                  var4 = 587537308;
               }
               break;
            case 431210569:
               var0.getShort();
               var4 = -1119606006;
               break;
            case 587537308:
               descriptorLength(var0);
               var0.position(var0.position() + (213567955 ^ -213567942) + ((213567955 & -213567942) << 1));
               if ((var0.get() & (-1603401203 | 1603401458) + (-1603401203 & 1603401458)) != (1561493147 ^ -1561493142) + ((1561493147 & -1561493142) << 1)) {
                  var4 = -749808190;
               } else {
                  var4 = -1305548382;
               }
               break;
            case 832155241:
               if ((var1 & (-41635529 ^ 41635561) + ((-41635529 & 41635561) << 1)) != 0) {
                  var4 = -269512334;
               } else {
                  var4 = -195629486;
               }
               break;
            case 1190173442:
               descriptorLength(var0);
               var0.getShort();
               var1 = var0.get() & 255;
               if ((var1 & (-1389192563 | 1389192691) + (-1389192563 & 1389192691)) != 0) {
                  var4 = 431210569;
               } else {
                  var4 = -1119606006;
               }
               break;
            case 1409742169:
               throw new IOException(
                  "malformed mp4 box esds"
               );
            case 1774782979:
               var0.position(var0.position() + (var0.get() & (-489906828 | 489907083) + (-489906828 & 489907083)));
               var4 = 832155241;
         }
      }
   }

   private static int descriptorLength(ByteBuffer var0) {
      int var1 = 0;
      int var2 = 0;
      int var3 = 0;
      int var4 = 2036729414;

      while (true) {
         switch (var4) {
            case -1873015505:
               var2++;
               var4 = 1237330076;
               break;
            case -1441293489:
               return var1;
            case -1044781650:
               var4 = -1441293489;
               break;
            case -346707391:
               var3 = var0.get() & 255;
               var1 = var1 << (2061741280 | -2061741273) + (2061741280 & -2061741273) | var3 & 127;
               if ((var3 & (635745314 ^ -635745186) + ((635745314 & -635745186) << 1)) == 0) {
                  var4 = -1044781650;
               } else {
                  var4 = -1873015505;
               }
               break;
            case 1237330076:
               if (var2 < (1194279294 | -1194279290) + (1194279294 & -1194279290)) {
                  var4 = -346707391;
               } else {
                  var4 = -1441293489;
               }
               break;
            case 2036729414:
            default:
               var1 = 0;
               var2 = 0;
               var4 = 1237330076;
         }
      }
   }

   private void parseSidx(ByteBuffer var1, long var2) throws IOException {
      int var4 = 0;
      long var5 = (3831471514619511095L | -3831471514619511095L) + (3831471514619511095L & -3831471514619511095L);
      long var7 = (1821138891753438902L | -1821138891753438902L) + (1821138891753438902L & -1821138891753438902L);
      long var9 = (-1061455935572584451L | 1061455935572584451L) + (-1061455935572584451L & 1061455935572584451L);
      int var11 = 0;
      long var12 = (4171997177025757527L | -4171997177025757527L) + (4171997177025757527L & -4171997177025757527L);
      long var14 = (-2460661822976514631L | 2460661822976514631L) + (-2460661822976514631L & 2460661822976514631L);
      int var16 = 0;
      long var17 = (-3780586801239854412L ^ 3780586801239854412L) + ((-3780586801239854412L & 3780586801239854412L) << 1);
      long var19 = (3456051884729680349L | -3456051884729680349L) + (3456051884729680349L & -3456051884729680349L);
      long var22 = (3128965157428713979L ^ -3128965157428713979L) + ((3128965157428713979L & -3128965157428713979L) << 1);
      long var24 = (-8517966229240719283L | 8517966229240719283L) + (-8517966229240719283L & 8517966229240719283L);
      int var21 = 1929521438;

      while (true) {
         switch (var21) {
            case -2138543696:
               var22 = Integer.toUnsignedLong(var1.getInt());
               var21 = -2078374584;
               break;
            case -2078374584:
               var7 = var22;
               if (var4 == 0) {
                  var21 = 611360565;
               } else {
                  var21 = 825211583;
               }
               break;
            case -1968474426:
               return;
            case -1836119336:
               throw new IOException(
                  "stream has no segment index"
               );
            case -1737082648:
               var12 = var2 + var9;
               var14 = var7;
               var16 = 0;
               var21 = -824854579;
               break;
            case -1439015422:
               var9 = var24;
               var1.getShort();
               var11 = var1.getShort() & 65535;
               if (var5 > (8413449736749540036L ^ -8413449736749540036L) + ((8413449736749540036L & -8413449736749540036L) << 1)) {
                  var21 = 344581089;
               } else {
                  var21 = -1836119336;
               }
               break;
            case -824854579:
               if (var16 < var11) {
                  var21 = 101280181;
               } else {
                  var21 = -1968474426;
               }
               break;
            case -290906332:
               var22 = var1.getLong();
               var21 = -2078374584;
               break;
            case 101280181:
               var17 = var1.getInt() & 2147483647;
               var19 = Integer.toUnsignedLong(var1.getInt());
               var1.getInt();
               this.segments
                  .add(new anr(var12, var14 * ((5500300374376334535L | -5500300374376333535L) + (5500300374376334535L & -5500300374376333535L)) / var5));
               var12 += var17;
               var14 += var19;
               var16++;
               var21 = -824854579;
               break;
            case 344581089:
               if (var11 == 0) {
                  var21 = -1836119336;
               } else {
                  var21 = -1737082648;
               }
               break;
            case 611360565:
               var24 = Integer.toUnsignedLong(var1.getInt());
               var21 = -1439015422;
               break;
            case 825211583:
               var24 = var1.getLong();
               var21 = -1439015422;
               break;
            case 1929521438:
            default:
               var4 = var1.get() & 255;
               var1.position(
                  var1.position() + (-1280611948 | 1280611952) + (-1280611948 & 1280611952) - ((980245715 ^ -980245714) + ((980245715 & -980245714) << 1))
               );
               var1.getInt();
               var5 = Integer.toUnsignedLong(var1.getInt());
               if (var4 == 0) {
                  var21 = -2138543696;
               } else {
                  var21 = -290906332;
               }
         }
      }
   }

   private void parseTraf(ByteBuffer var1, long var2, List<anq> var4) throws IOException {
      long var5 = var2;
      long var7 = (-4904487195750384624L | 4904487195750384624L) + (-4904487195750384624L & 4904487195750384624L);
      int var9 = this.trackDefaults.duration();
      int var10 = this.trackDefaults.size();
      int var11 = this.trackDefaults.flags();
      ArrayList var12 = new ArrayList();

      while (var1.hasRemaining()) {
         ByteBuffer var13 = this.nextChild(var1);
         String var14 = this.lastType;
         if ("tfhd".equals(var14)) {
            int var15 = var13.getInt() & 16777215;
            var13.getInt();
            if ((var15 & (-2116886066 ^ 2116886067) + ((-2116886066 & 2116886067) << 1)) != 0) {
               var5 = var13.getLong();
            }

            if ((var15 & (568500500 ^ -568500498) + ((568500500 & -568500498) << 1)) != 0) {
               var13.getInt();
            }

            if ((var15 & (1768970636 | -1768970628) + (1768970636 & -1768970628)) != 0) {
               var9 = var13.getInt();
            }

            if ((var15 & (728567715 ^ -728567699) + ((728567715 & -728567699) << 1)) != 0) {
               var10 = var13.getInt();
            }

            if ((var15 & (1214956429 | -1214956397) + (1214956429 & -1214956397)) != 0) {
               var11 = var13.getInt();
            }
         } else if ("tfdt".equals(var14)) {
            int var30 = var13.getInt() >>> 24;
            var7 = var30 == 1? var13.getLong() : Integer.toUnsignedLong(var13.getInt());
         } else if ("trun".equals(var14)) {
            var12.add(var13);
         }
      }

      for (ByteBuffer var29 : (Iterable<ByteBuffer>)var12) {
         int var31 = var29.getInt();
         int var16 = var31 & 16777215;
         int var17 = var29.getInt();
         long var18 = var5;
         if ((var16 & (-130552350 | 130552351) + (-130552350 & 130552351)) != 0) {
            var18 = var5 + var29.getInt();
         }

         int var20 = (var16 & (800770923 ^ -800770919) + ((800770923 & -800770919) << 1)) != 0
            ? var29.getInt()
            : -1;

         for (int var21 = 0; var21 < var17; var21++) {
            int var22 = (var16 & (-1770260101 | 1770260357) + (-1770260101 & 1770260357)) != 0 ? var29.getInt() : var9;
            int var23 = (var16 & (890095412 | -890094900) + (890095412 & -890094900)) != 0 ? var29.getInt() : var10;
            int var24 = (var16 & (-37984295 ^ 37985319) + ((-37984295 & 37985319) << 1)) != 0 ? var29.getInt() : (var21 == 0 && var20 >= 0 ? var20 : var11);
            int var25 = (var16 & (-1137172152 | 1137174200) + (-1137172152 & 1137174200)) != 0
               ? var29.getInt()
               : 0;
            long var26 = (var7 + var25)
               * ((8324970555036979122L ^ -8324970555036978122L) + ((8324970555036979122L & -8324970555036978122L) << 1))
               / this.timescale;
            var4.add(
               new anq(
                  var26,
                  var18,
                  var23,
                  (boolean)((((var24 & (-171303705 | 171369241) + (-171303705 & 171369241)) == 0
                     ? 1: (2018186926 | -2018186926) + (2018186926 & -2018186926))
               ) != 0))
            );
            var18 += Integer.toUnsignedLong(var23);
            var7 += Integer.toUnsignedLong(var22);
         }
      }
   }

   private long[] readHeader(long var1) throws IOException {
      ByteBuffer var3 = null;
      long var4 = (3231648927111230452L ^ -3231648927111230452L) + ((3231648927111230452L & -3231648927111230452L) << 1);
      int var6 = -423888311;

      while (true) {
         switch (var6) {
            case -805875744:
               long[] var7 = new long[2];
               var7[0] = var4;
               var7[1] = (7320995526534565662L | -7320995526534565654L)
                  + (7320995526534565662L & -7320995526534565654L);
               return var7;
            case -423888311:
            default:
               var3 = ByteBuffer.allocate((2143588260 | -2143588244) + (2143588260 & -2143588244));
               var3.limit((1540542962 | -1540542954) + (1540542962 & -1540542954));
               this.channel.setPosition(var1);
               this.readFully(var3);
               var3.flip();
               var4 = Integer.toUnsignedLong(var3.getInt());
               this.headerType = fourcc(var3);
               if (var4 == (-6814894446849728777L ^ 6814894446849728778L) + ((-6814894446849728777L & 6814894446849728778L) << 1)) {
                  var6 = 804506090;
               } else {
                  var6 = -805875744;
               }
               break;
            case 804506090:
               var3.clear();
               var3.limit((-877307175 ^ 877307183) + ((-877307175 & 877307183) << 1));
               this.readFully(var3);
               var3.flip();
               long[] var10000 = new long[2];
               var10000[0] = var3.getLong();
               var10000[1] = (2434810948995596201L ^ -2434810948995596185L)
                  + ((2434810948995596201L & -2434810948995596185L) << 1);
               return var10000;
         }
      }
   }

   private ByteBuffer readBox(long var1, String var3, int var4) throws IOException {
      long[] var5 = null;
      int var6 = -1621090942;

      while (true) {
         switch (var6) {
            case -1621090942:
            default:
               var5 = this.readHeader(var1);
               if (var3.equals(this.headerType)) {
                  var6 = -906418742;
               } else {
                  var6 = 1007665017;
               }
               break;
            case -1219065191:
               return this.readBody(
                  var1 + var5[1],
                  var5[0] - var5[1]
               );
            case -906418742:
               if (var5[0] >= var5[1]) {
                  var6 = 1048125538;
               } else {
                  var6 = 1007665017;
               }
               break;
            case 1007665017:
               throw new IOException("malformed mp4 box " + this.headerType);
            case 1048125538:
               if (var5[0] > var4) {
                  var6 = 1007665017;
               } else {
                  var6 = -1219065191;
               }
         }
      }
   }

   private ByteBuffer readBody(long var1, long var3) throws IOException {
      ByteBuffer var5 = null;
      int var6 = 1236545215;

      while (true) {
         switch (var6) {
            case -814841221:
               var5 = ByteBuffer.allocate((int)var3);
               this.channel.setPosition(var1);
               this.readFully(var5);
               var5.flip();
               return var5;
            case 861717400:
               throw new IOException("malformed mp4 box " + this.headerType);
            case 1236545215:
         }

         if (var3 > (7571846619419810277L ^ -7571846619411421669L) + ((7571846619419810277L & -7571846619411421669L) << 1)) {
            var6 = 861717400;
         } else {
            var6 = -814841221;
         }
      }
   }

   private void readFully(ByteBuffer var1) throws IOException {
      int var2 = 653934146;

      while (true) {
         switch (var2) {
            case -1123486463:
               if (this.channel.read(var1) < 0) {
                  var2 = 1565434703;
               } else {
                  var2 = 653934146;
               }
               break;
            case -835982463:
               return;
            case 653934146:
            default:
               if (var1.hasRemaining()) {
                  var2 = -1123486463;
               } else {
                  var2 = -835982463;
               }
               break;
            case 1565434703:
               throw new IOException("malformed mp4 box " + this.headerType);
         }
      }
   }

   private ByteBuffer nextChild(ByteBuffer var1) throws IOException {
      long var2 = (-2503122657854808208L ^ 2503122657854808208L) + ((-2503122657854808208L & 2503122657854808208L) << 1);
      int var4 = 0;
      long var5 = (-236149922448909385L | 236149922448909385L) + (-236149922448909385L & 236149922448909385L);
      ByteBuffer var7 = null;
      int var8 = -1972605173;

      while (true) {
         switch (var8) {
            case -1993588768:
               var5 = var2 - var4;
               if (var5 >= (165396616700685102L ^ -165396616700685102L) + ((165396616700685102L & -165396616700685102L) << 1)) {
                  var8 = 1518288467;
               } else {
                  var8 = 808143016;
               }
               break;
            case -1972605173:
            default:
               if (var1.remaining() < (-1877086113 ^ 1877086121) + ((-1877086113 & 1877086121) << 1)) {
                  var8 = -255762832;
               } else {
                  var8 = -1081115078;
               }
               break;
            case -1764455227:
               var7 = var1.slice(var1.position(), (int)var5);
               var1.position(var1.position() + (int)var5);
               return var7;
            case -1081115078:
               var2 = Integer.toUnsignedLong(var1.getInt());
               this.lastType = fourcc(var1);
               var4 = 8;
               if (var2 == (1720352128774993448L ^ -1720352128774993447L) + ((1720352128774993448L & -1720352128774993447L) << 1)) {
                  var8 = 962253841;
               } else {
                  var8 = 383432441;
               }
               break;
            case -255762832:
               this.lastType = "";
               var1.position(var1.limit());
               return ByteBuffer.allocate((-2019184955 ^ 2019184955) + ((-2019184955 & 2019184955) << 1));
            case 383432441:
               if (var2 == (-3879194029498667517L ^ 3879194029498667517L) + ((-3879194029498667517L & 3879194029498667517L) << 1)) {
                  var8 = 1066781826;
               } else {
                  var8 = -1993588768;
               }
               break;
            case 808143016:
               throw new IOException("malformed mp4 box " + this.lastType);
            case 962253841:
               var2 = var1.getLong();
               var4 = 16;
               var8 = -1993588768;
               break;
            case 1066781826:
               var2 = (long)var1.remaining() + var4;
               var8 = -1993588768;
               break;
            case 1518288467:
               if (var5 > var1.remaining()) {
                  var8 = 808143016;
               } else {
                  var8 = -1764455227;
               }
         }
      }
   }

   private ByteBuffer findChild(ByteBuffer var1, String var2) throws IOException {
      ByteBuffer var3 = null;
      int var4 = -1123289809;

      while (true) {
         switch (var4) {
            case -1774680113:
               return null;
            case -1123289809:
            default:
               if (var1.hasRemaining()) {
                  var4 = 71772650;
               } else {
                  var4 = -1774680113;
               }
               break;
            case 71772650:
               var3 = this.nextChild(var1);
               if (var2.equals(this.lastType)) {
                  var4 = 1134754558;
               } else {
                  var4 = 1713597196;
               }
               break;
            case 1134754558:
               return var3;
            case 1713597196:
               var4 = -1123289809;
         }
      }
   }

   private static String fourcc(ByteBuffer var0) {
      char[] var1 = null;
      int var2 = 0;
      int var3 = 1310070610;

      while (true) {
         switch (var3) {
            case 899162500:
               var1[var2] = (char)(var0.get() & (-1682982377 | 1682982632) + (-1682982377 & 1682982632));
               var2++;
               var3 = 1477720923;
               break;
            case 1310070610:
            default:
               var1 = new char[4];
               var2 = 0;
               var3 = 1477720923;
               break;
            case 1344566532:
               return new String(var1);
            case 1477720923:
               if (var2 < var1.length) {
                  var3 = 899162500;
               } else {
                  var3 = 1344566532;
               }
         }
      }
   }

   private static byte[] bytes(ByteBuffer var0) {
      byte[] var1 = new byte[var0.remaining()];
      var0.get(var1);
      return var1;
   }
}