_DoChannelList:


  word_10F64++
  byte_10F78 = 0
  ax = 0
  bx = 0xFFFF
  set all channelMap to 0xFFFF
  set all unknownArray2/3/4 to 0
  set all unknownArray1 to 0xFFFF
  _SampleList = 0
  if (!PlayList) {
    dx = 0xFFFF;
    set all channelMap to 0xFFFF (again)
    jmp loc_12470
  }

loc_11C86
  cl = playList[0].bReverb ??
  if (cl == 0x7F)
    cl = bReverb
  _driver->Reverb(cl?)
  availVoices = snd_nVoices

  for (entrynum = 0; entrynum != 0x10; ++entrynum) {

loc_11CA7
    entry = _PlayList[entrynum]
    if (!entry)
      break

loc_11CB5
    if (entry->field_164 != 0)
      continue

loc_11CC0
    if (entry->bLock != 0) {
      if (_sampleList == 0)
        _sampleList = entry

      continue
    }

loc_11CED:
    backup unknownArray1,2,3,4, availVoices

    for (chanindex = 0; chanindex != 0x10; ++chanindex) {

loc_11DF5:

      channum = entry->bChanNumber[chanindex]
      if (channum is 0xFF or is 0xFE or is 0x0F)
        continue

loc_11E12
      if (entry->bNoRemap[channum] & 2)
        continue
      if (entry->bMuteCntFlags[channum] & 0xFF)
        continue

loc_11E31
      dl = 0x10*entrynum + channum
      reqVoices = entry->bPolyphony[channum] & 0x0F
      ch = entry->bPolyphony[channum] >> 4
      if (ch) {
        ch = 0x10 - ch + 0x10*entrynum
      }

loc_11E67
      if (entry->bNoRemap[channum] & 1) || (unknownArray1[channum] == 0xFF) {
        availChan = channum

      } else {

loc_11E8C
        availChan = 0xFF

        for (j = 0; j != 0x10; ++j) {
          if unknownArray1[j] == 0xFF
            if j >= word_10F71 || j <= word_10F73
              availChan = j
            continue
    
          if unknownArray1[j] == dl
            jmp loc_12092 (continue chanindex loop)
        }

        if (availChan == 0xFF) {
          if (ch) // (inverted???)
            jmp loc_121A6 (continue entry loop)

loc_11ED0:

          availChan = 0xFF
          max = 0
          for (j = 0; j != 0x10; ++j) {
            if (max < unknownArray2[j])
              max = unknownArray2[j]
              availChan = j
          }

          if (availChan != 0xFF) {
            availVoices += unknownArray4[availChan]
            unknownArray1[availChan] = 0xFF
            unknownArray4[availChan] = 0
            unknownArray2[availChan] = 0
            unknownArray3[availChan] = 0

          } else {
loc_11F1A
            restore backup of unknownArray1,2,3,4, availVoices
            break
          }

        }

      }

      if (reqVoices > availVoices) {    // not enough free polyphony?

        if (ch) // (inverted???)
          continue

        do {

          for (j = 0; j != 0x10; ++j) {
            if (max < unknownArray2[j])
              max = unknownArray2[j]
              availChan = j
          }

          if (availChan != 0xFF) {
            availVoices += unknownArray4[availChan]
            unknownArray1[availChan] = 0xFF
            unknownArray4[availChan] = 0
            unknownArray2[availChan] = 0
            unknownArray3[availChan] = 0
          }

          if (availChan == 0xFF) { // failure
            restore backup of unknownArray1,2,3,4, availVoices
            break out of chanindex loop
          }

        } while (reqVoices > availVoices)

      }

loc_11F8A

      unknownArray1[availChan] = dl
      unknownArray4[availChan] = reqVoices
      availVoices -= reqVoices
      unknownArray2[availChan] = ch
      if !(entry->bNoRemap[channum] & 1)
        unknownArray3[availChan] = 0
        continue
      unknownArray3[availChan] = 1
      if (availChan == channum)
        continue

loc_11FCE
      push si
      si = channum
      if unknownArray3[channum] == 0
        swap unknownArray1 entries channum, availChan
        swap unknownArray2 entries channum, availChan
        swap unknownArray4 entries channum, availChan
        swap unknownArray3 entries channum, availChan
        continue

      if ch != 0 // (inverted???)
        unknownArray1[availChan] = 0xFF
        unknownArray2[availChan] = 0
        unknownArray4[availChan] = 0
        unknownArray3[availChan] = 0
        availVoices += reqVoices
        continue

      if unknownArray2[channum] == 0 {  // failure
        restore backup of unknownArray1,2,3,4, availVoices
        break
      }

      availVoices += unknownArray4[channum]
      unknownArray1[availChan] = 0xFF
      unknownArray4[availChan] = 0
      unknownArray2[availChan] = 0
      unknownArray3[availChan] = 0
      unknownArray1[channum] = dl
      unknownArray2[channum] = ch
      unknownArray4[channum] = reqVoices
      availVoices -= reqVoices

loc_12092:

    } // end chanindex loop --------

  } // end entry loop

loc_121B4


  for (si = 0; si != 0x10; ++si) {

loc_121B6

    if unknownArray1[si] == 0xFF
      continue

    if unknownArray3[si] != 0 {

      ax = unknownArray1[si]
      unknownArray1[si] = 0xFF
      channelMap[si] = ax
      di = (ax & 0xF0) >> 4
      es:bx = _PlayList[di]
      al &= 0x0F
      if ticker[si] != al || channelMapSong[si] != _PlayList[di] {
loc_1220F
        // control changes...
      }
   
      continue
    }

loc_122DA
    ax = unknownArray1[si] & 0x0F
    cx = (unknownArray1[si] & 0xF0) >> 4

    for (di = word_10F71; di <= word_10F73; ++di) {

      if (_PlayList[cx] == channelMapSong[di] && ticker[di] == al) {

        if (unknownArray3[di] == 0) {
          channelMap[word_10F71] = unknownArray1[si]
          unknownArray1[si] = 0xFF
        }

        break

    }

  }

loc_1235E

  di = word_10F73 + 1
  ax = 0

  for (si = 0; si != 0x10; ++si) {
    if (unknownArray1[si] == 0xFF)
      continue (jmp loc_12467)

    do {
      di--
    } while (channelMap[di] == 0xFF)

    bx = ax = channelMap[di] = unknownArray1[si]
    ax &= 0x0F
    bl = (bl & 0xF0) >> 4
    es:bx = _PlayList[bl]

    // control changes...

  }

loc_12470

  for (si = 0x0F; si >= 0; --si) {
    if (channelMap[si] == 0xFF) {
      // control changes...
    }
  }

  for (int i = 0; i < 0x10; ++i)
    channelMapChan[i] = channelMap[i] & 0x0F

  for (si = 0; si != 0x10; ++si) {
    if (channelMap[si] == 0xFF)
      channelMapSong[si] = 0
    else
      channelMapSong[si] = _PlayList[(channelMap[si] & 0xF0) >> 4]
  }

  word_10F64--