docs: function(){
  
              var isX
                  ,hash
                  ,tr1
                  ,tr2
                  ,bound
                  ,list
                  ,len
                  ,i
                  ,j
                  ,c
                  // determine which axis is the last we need to check
                  ,collisionFlag = 1 << (dof.z + 1) << (dof.y + 1) << (dof.x + 1)
                  ,encounters = this.encounters
                  ,enclen = 0
                  ,candidates = this.candidates
                  ;
  
              Physics.util.clearArray( encounters );
              Physics.util.clearArray( candidates );
  
              for ( var xyz = 0; xyz < maxDof; ++xyz ){
  
                  // is the x coord
                  isX = (xyz === 0);
                  // get the interval list for this axis
                  list = this.intervalLists[ xyz ];
  
                  // for each interval bound
                  for ( i = 0, len = list.length; i < len; i++ ){
  
                      bound = list[ i ];
                      tr1 = bound.tracker;
  
                      if ( bound.type ){
  
                          // is a max
  
                          j = enclen;
  
                          for ( j = enclen - 1; j >= 0; j-- ){
  
                              tr2 = encounters[ j ];
  
                              // if they are the same tracked interval
                              if ( tr2 === tr1 ){
  
                                  // remove the interval from the encounters list
                                  // faster than .splice()
                                  if ( j < enclen - 1 ) {
  
                                      encounters[ j ] = encounters.pop();
  
                                  } else {
  
                                      // encountered a max right after a min... no overlap
                                      encounters.pop();
                                  }
  
                                  enclen--;
  
                              } else {
  
                                  // check if we have flagged this pair before
                                  // if it's the x axis, create a pair
                                  c = this.getPair( tr1, tr2, isX );
  
                                  if ( c && c.flag < collisionFlag ){
  
                                      // if it's greater than the axis index, set the flag
                                      // to = 0.
                                      // if not, increment the flag by one.
                                      c.flag = c.flag << (xyz + 1);
  
                                      // c.flag will equal collisionFlag
                                      // if we've incremented the flag
                                      // enough that all axes are overlapping
                                      if ( c.flag === collisionFlag ){
  
                                          // overlaps on all axes.
                                          // add it to possible collision
                                          // candidates list for narrow phase
  
                                          candidates.push( c );
                                      }
                                  }
                              }
                          }
  
                      } else {
  
                          // is a min
                          // just add this minimum to the encounters list
                          enclen = encounters.push( tr1 );
                      }
                  }
              }
  
              return candidates;
          }