ComputeSeparatingPlane

/* ComputeSeparatingPlane(matrix3x4_t const&, matrix3x4_t const&, Vector const&, Vector const&,
   float, cplane_t*) */

undefined4 __regparm3
ComputeSeparatingPlane
          (matrix3x4_t *param_1,matrix3x4_t *param_2,Vector *param_3,Vector *param_4,float param_5,
          cplane_t *param_6)

{
  float fVar1;
  float fVar2;
  float fVar3;
  float fVar4;
  float fVar5;
  float fVar6;
  float fVar7;
  float fVar8;
  float fVar9;
  float fVar10;
  float fVar11;
  float fVar12;
  float fVar13;
  float fVar14;
  float fVar15;
  float in_XMM0_Da;
  int iVar16;
  float local_64;
  float local_60;
  float local_5c;
  Vector local_58 [12];
  float local_4c;
  float local_48;
  float local_44;
  float local_3c;
  float local_38;
  float local_34;
  float local_2c;
  float local_28;
  float local_24;
  
  ConcatTransforms(param_1,param_2,(matrix3x4_t *)&local_4c);
  MatrixGetColumn((matrix3x4_t *)&local_4c,3,(Vector *)&local_64);
  fVar1 = *(float *)param_4;
  fVar2 = *(float *)(param_4 + 4);
  fVar3 = *(float *)(param_4 + 8);
  fVar7 = ABS(local_4c);
  fVar8 = ABS(local_48);
  fVar9 = ABS(local_44);
  fVar4 = *(float *)param_3;
  if ((uint)(fVar1 * fVar7 + fVar2 * fVar8 + fVar4 + fVar9 * fVar3) <
      (uint)(ABS(local_64) + in_XMM0_Da)) {
    *(undefined4 *)param_5 = *(undefined4 *)param_1;
    *(undefined4 *)((int)param_5 + 4) = *(undefined4 *)(param_1 + 4);
    *(undefined4 *)((int)param_5 + 8) = *(undefined4 *)(param_1 + 8);
    return 1;
  }
  fVar5 = *(float *)(param_3 + 4);
  fVar10 = ABS(local_3c);
  fVar11 = ABS(local_38);
  fVar12 = ABS(local_34);
  if ((uint)(fVar10 * fVar1 + fVar11 * fVar2 + fVar5 + fVar12 * fVar3) <
      (uint)(ABS(local_60) + in_XMM0_Da)) {
    *(undefined4 *)param_5 = *(undefined4 *)(param_1 + 0x10);
    *(undefined4 *)((int)param_5 + 4) = *(undefined4 *)(param_1 + 0x14);
    *(undefined4 *)((int)param_5 + 8) = *(undefined4 *)(param_1 + 0x18);
  }
  else {
    fVar6 = *(float *)(param_3 + 8);
    fVar13 = ABS(local_2c);
    fVar14 = ABS(local_28);
    fVar15 = ABS(local_24);
    if ((uint)(fVar13 * fVar1 + fVar14 * fVar2 + fVar6 + fVar15 * fVar3) <
        (uint)(ABS(local_5c) + in_XMM0_Da)) {
      *(undefined4 *)param_5 = *(undefined4 *)(param_1 + 0x20);
      *(undefined4 *)((int)param_5 + 4) = *(undefined4 *)(param_1 + 0x24);
      *(undefined4 *)((int)param_5 + 8) = *(undefined4 *)(param_1 + 0x28);
      return 1;
    }
    if ((uint)(fVar10 * fVar5 + fVar7 * fVar4 + fVar13 * fVar6 + fVar1) <
        (uint)(ABS(local_3c * local_60 + local_4c * local_64 + local_5c * local_2c) + in_XMM0_Da)) {
      MatrixGetColumn(param_2,0,(Vector *)param_5);
    }
    else if ((uint)(fVar11 * fVar5 + fVar8 * fVar4 + fVar14 * fVar6 + fVar2) <
             (uint)(ABS(local_38 * local_60 + local_48 * local_64 + local_5c * local_28) +
                   in_XMM0_Da)) {
      MatrixGetColumn(param_2,1,(Vector *)param_5);
    }
    else if ((uint)(fVar12 * fVar5 + fVar9 * fVar4 + fVar15 * fVar6 + fVar3) <
             (uint)(ABS(local_34 * local_60 + local_44 * local_64 + local_5c * local_24) +
                   in_XMM0_Da)) {
      MatrixGetColumn(param_2,2,(Vector *)param_5);
    }
    else {
      if ((0.999 <= fVar7) ||
         ((uint)(ABS(local_5c * local_3c - local_60 * local_2c) + in_XMM0_Da) <=
          (uint)(fVar10 * fVar6 + fVar13 * fVar5 + fVar9 * fVar2 + fVar8 * fVar3))) {
        if ((0.999 <= fVar8) ||
           ((uint)(ABS(local_5c * local_38 - local_60 * local_28) + in_XMM0_Da) <=
            (uint)(fVar11 * fVar6 + fVar14 * fVar5 + fVar9 * fVar1 + fVar7 * fVar3))) {
          if ((0.999 <= fVar9) ||
             ((uint)(ABS(local_5c * local_34 - local_60 * local_24) + in_XMM0_Da) <=
              (uint)(fVar12 * fVar6 + fVar15 * fVar5 + fVar8 * fVar1 + fVar7 * fVar2))) {
            if ((0.999 <= fVar10) ||
               ((uint)(ABS(local_2c * local_64 - local_5c * local_4c) + in_XMM0_Da) <=
                (uint)(fVar6 * fVar7 + fVar13 * fVar4 + fVar12 * fVar2 + fVar11 * fVar3))) {
              if ((0.999 <= fVar11) ||
                 ((uint)(ABS(local_28 * local_64 - local_48 * local_5c) + in_XMM0_Da) <=
                  (uint)(fVar6 * fVar8 + fVar14 * fVar4 + fVar12 * fVar1 + fVar10 * fVar3))) {
                if ((0.999 <= fVar12) ||
                   ((uint)(ABS(local_24 * local_64 - local_5c * local_44) + in_XMM0_Da) <=
                    (uint)(fVar6 * fVar9 + fVar15 * fVar4 + fVar11 * fVar1 + fVar10 * fVar2))) {
                  if ((0.999 <= fVar13) ||
                     ((uint)(ABS(local_4c * local_60 - local_3c * local_64) + in_XMM0_Da) <=
                      (uint)(fVar7 * fVar5 + fVar10 * fVar4 + fVar15 * fVar2 + fVar14 * fVar3))) {
                    if ((0.999 <= fVar14) ||
                       ((uint)(ABS(local_48 * local_60 - local_38 * local_64) + in_XMM0_Da) <=
                        (uint)(fVar8 * fVar5 + fVar11 * fVar4 + fVar15 * fVar1 + fVar3 * fVar13))) {
                      if (0.999 <= fVar15) {
                        return 0;
                      }
                      if ((uint)(ABS(local_44 * local_60 - local_64 * local_34) + in_XMM0_Da) <=
                          (uint)(fVar9 * fVar5 + fVar4 * fVar12 + fVar1 * fVar14 + fVar2 * fVar13))
                      {
                        return 0;
                      }
                      iVar16 = 2;
                    }
                    else {
                      iVar16 = 1;
                    }
                  }
                  else {
                    iVar16 = 0;
                  }
                  MatrixGetColumn(param_2,iVar16,local_58);
                  CrossProduct((float *)(param_1 + 0x20),(float *)local_58,(float *)param_5);
                  return 1;
                }
                iVar16 = 2;
              }
              else {
                iVar16 = 1;
              }
            }
            else {
              iVar16 = 0;
            }
            MatrixGetColumn(param_2,iVar16,local_58);
            CrossProduct((float *)(param_1 + 0x10),(float *)local_58,(float *)param_5);
            return 1;
          }
          iVar16 = 2;
        }
        else {
          iVar16 = 1;
        }
      }
      else {
        iVar16 = 0;
      }
      MatrixGetColumn(param_2,iVar16,local_58);
      CrossProduct((float *)param_1,(float *)local_58,(float *)param_5);
    }
  }
  return 1;
}