context: using log4net;
  
  using ACE.Entity.Enum;
  
  namespace ACE.Server.Entity.Mutations
  {
      public partial class EffectArgument
      {
          private static readonly ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
  
          public static EffectArgument operator +(EffectArgument a, EffectArgument b)
          {
              switch (a.Type)
              {
                  case EffectArgumentType.Double:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return new EffectArgument(a.DoubleVal + b.DoubleVal);
                          case EffectArgumentType.Int:
                              return new EffectArgument(a.DoubleVal + b.IntVal);
                          case EffectArgumentType.Int64:
                              return new EffectArgument(a.DoubleVal + b.LongVal);
                      }
                      break;
  
                  case EffectArgumentType.Int:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return new EffectArgument((int)(a.IntVal + b.DoubleVal));
                          case EffectArgumentType.Int:
                              return new EffectArgument(a.IntVal + b.IntVal);
                          case EffectArgumentType.Int64:
                              return new EffectArgument((int)(a.IntVal + b.LongVal));
                      }
                      break;
  
                  case EffectArgumentType.Int64:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return new EffectArgument((long)(a.LongVal + b.DoubleVal));
                          case EffectArgumentType.Int:
                              return new EffectArgument(a.LongVal + b.IntVal);
                          case EffectArgumentType.Int64:
                              return new EffectArgument(a.LongVal + b.LongVal);
                      }
                      break;
              }
  
              log.Error($"EffectArgument.Add() - invalid type {a.Type}, {b.Type}");
  
              return null;
          }
  
          public static EffectArgument operator -(EffectArgument a, EffectArgument b)
          {
              switch (a.Type)
              {
                  case EffectArgumentType.Double:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return new EffectArgument(a.DoubleVal - b.DoubleVal);
                          case EffectArgumentType.Int:
                              return new EffectArgument(a.DoubleVal - b.IntVal);
                          case EffectArgumentType.Int64:
                              return new EffectArgument(a.DoubleVal - b.LongVal);
                      }
                      break;
  
                  case EffectArgumentType.Int:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return new EffectArgument((int)(a.IntVal - b.DoubleVal));
                          case EffectArgumentType.Int:
                              return new EffectArgument(a.IntVal - b.IntVal);
                          case EffectArgumentType.Int64:
                              return new EffectArgument((int)(a.IntVal - b.LongVal));
                      }
                      break;
  
                  case EffectArgumentType.Int64:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return new EffectArgument((long)(a.LongVal - b.DoubleVal));
                          case EffectArgumentType.Int:
                              return new EffectArgument(a.LongVal - b.IntVal);
                          case EffectArgumentType.Int64:
                              return new EffectArgument(a.LongVal - b.LongVal);
                      }
                      break;
              }
  
              log.Error($"EffectArgument.Subtract() - invalid type {a.Type}, {b.Type}");
  
              return null;
          }
  
          public static EffectArgument operator *(EffectArgument a, EffectArgument b)
          {
              switch (a.Type)
              {
                  case EffectArgumentType.Double:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return new EffectArgument(a.DoubleVal * b.DoubleVal);
                          case EffectArgumentType.Int:
                              return new EffectArgument(a.DoubleVal * b.IntVal);
                          case EffectArgumentType.Int64:
                              return new EffectArgument(a.DoubleVal * b.LongVal);
                      }
                      break;
  
                  case EffectArgumentType.Int:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return new EffectArgument((int)(a.IntVal * b.DoubleVal));
                          case EffectArgumentType.Int:
                              return new EffectArgument(a.IntVal * b.IntVal);
                          case EffectArgumentType.Int64:
                              return new EffectArgument((int)(a.IntVal * b.LongVal));
                      }
                      break;
  
                  case EffectArgumentType.Int64:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return new EffectArgument((long)(a.LongVal * b.DoubleVal));
                          case EffectArgumentType.Int:
                              return new EffectArgument(a.LongVal * b.IntVal);
                          case EffectArgumentType.Int64:
                              return new EffectArgument(a.LongVal * b.LongVal);
                      }
                      break;
              }
  
              log.Error($"EffectArgument.Multiply() - invalid type {a.Type}, {b.Type}");
  
              return null;
          }
  
          public static EffectArgument operator /(EffectArgument a, EffectArgument b)
          {
              switch (a.Type)
              {
                  case EffectArgumentType.Double:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return b.DoubleVal != 0 ? new EffectArgument(a.DoubleVal / b.DoubleVal) : a;
                          case EffectArgumentType.Int:
                              return b.IntVal != 0 ? new EffectArgument(a.DoubleVal / b.IntVal) : a;
                          case EffectArgumentType.Int64:
                              return b.LongVal != 0 ? new EffectArgument(a.DoubleVal / b.LongVal) : a;
                      }
                      break;
  
                  case EffectArgumentType.Int:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return b.DoubleVal != 0 ? new EffectArgument((int)(a.IntVal / b.DoubleVal)) : a;
                          case EffectArgumentType.Int:
                              return b.IntVal != 0 ? new EffectArgument(a.IntVal / b.IntVal) : a;
                          case EffectArgumentType.Int64:
                              return b.LongVal != 0 ? new EffectArgument((int)(a.IntVal / b.LongVal)) : a;
                      }
                      break;
  
                  case EffectArgumentType.Int64:
  
                      switch (b.Type)
                      {
                          case EffectArgumentType.Double:
                              return b.DoubleVal != 0 ? new EffectArgument((long)(a.LongVal / b.DoubleVal)): a;
                          case EffectArgumentType.Int:
                              return b.IntVal != 0 ? new EffectArgument(a.LongVal / b.IntVal) : a;
                          case EffectArgumentType.Int64:
                              return b.LongVal != 0 ? new EffectArgument(a.LongVal / b.LongVal) : a;
                      }
                      break;
              }
  
              log.Error($"EffectArgument.Divide() - invalid type {a.Type}, {b.Type}");
  
              return null;
          }
  
          public static bool operator <(EffectArgument a, EffectArgument b)
          {
  
gt:             if (a.Type != b.Type)