code: public MachineTime<U> plus(
          long amount,
          U unit
      ) {
  
          long s = this.seconds;
          int f = this.nanos;
  
          if (this.scale == POSIX) {
              TimeUnit u = TimeUnit.class.cast(unit);
  
              if (u.compareTo(TimeUnit.SECONDS) >= 0) {
                  s =
                      Math.addExact(
                          s,
                          Math.multiplyExact(
                              amount,
                              TimeUnit.SECONDS.convert(1, u))
                      );
              } else {
                  long total =
                      Math.addExact(
                          f,
                          Math.multiplyExact(
                              amount,
                              TimeUnit.NANOSECONDS.convert(1, u))
                      );
                  s = Math.addExact(s, Math.floorDiv(total, MRD));
                  f = (int) Math.floorMod(total, MRD);
              }
          } else {
              switch (SI.class.cast(unit)) {
                  case SECONDS:
                      s = Math.addExact(s, amount);
                      break;
                  case NANOSECONDS:
                      long total = Math.addExact(f, amount);
                      s = Math.addExact(s, Math.floorDiv(total, MRD));
                      f = (int) Math.floorMod(total, MRD);
                      break;
                  default:
                      throw new UnsupportedOperationException(unit.toString());
              }
          }
  
          return new MachineTime<>(s, f, this.scale);
  
      }
docs: /*[deutsch]
  <p>Addiert den angegebenen Zeitbetrag zu dieser maschinellen Dauer. </p>
  
  @param   amount  the amount to be added
  @param   unit    the related time unit
  @return  result of addition
  @throws  ArithmeticException in case of numerical overflow
  @since   2.0