/**
     * Safe integer addition with overflow check
     *
     * @param a first operand
     * @param b second operand
     * @return sum of a and b
     * @throws ArithmeticException if overflow occurs
     */
    public static int safeAdd(int a, int b) {
        validateIntegerAddition(a, b, "Addition");
        return a + b;
    }

    /**
     * Safe integer multiplication with overflow check

    }

    /**
     * Returns the raw byte representation of this message.
     *
     * @return A <code>byte[]</code> containing the raw message material.
     * @throws IOException if an error occurs during message serialization
     */
    public abstract byte[] toByteArray() throws IOException;

 * quickly, since the row key is provided. However, {@code column(columnKey).size()} takes longer,
 * since an iteration across all row keys occurs.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access this table
 * concurrently and one of the threads modifies the table, it must be synchronized externally.
 *

 * quickly, since the row key is provided. However, {@code column(columnKey).size()} takes longer,
 * since an iteration across all row keys occurs.
 *
 * <p>Note that this implementation is not synchronized. If multiple threads access this table
 * concurrently and one of the threads modifies the table, it must be synchronized externally.
 *

    val writer = DerWriter(buffer)
    toDer(writer, value)
    return buffer.readByteString()
  }

  /**
   * Returns an adapter that expects this value wrapped by another value. Typically this occurs
   * when a value has both a context or application tag and a universal tag.
   *
   * Use this for EXPLICIT tag types:
   *
   * ```
   * [5] EXPLICIT UTF8String
   * ```
   *

   * #loadExceptionCount}). Multiple concurrent misses for the same key will result in a single load
   * operation. This may be incremented not in conjunction with {@code missCount} if the load occurs
   * as a result of a refresh or if the cache loader returned more items than was requested. {@code
   * missCount} may also be incremented not in conjunction with this (nor {@link

     * value without re-executing the supplier.
     * <p>
     * The caching behavior is determined by the cache retention specified in the request's metadata.
     * If an error occurs during execution, it will be cached and re-thrown for subsequent identical requests.
     *
     * @param <REQ> The request type
     * @param <REP> The response type
     * @param req The request object used as the cache key

     *
     * @param material
     *            The raw Type-1 material used to construct this message.
     * @throws IOException
     *             If an error occurs while parsing the material.
     */
    public Type1Message(final byte[] material) throws IOException {
        parse(material);
    }

    /**
     * Returns the default flags for a generic Type-1 message in the

All we need to do is handle the request inside a `try`/`except` block:

{* ../../docs_src/custom_request_and_route/tutorial002.py hl[13,15] *}

If an exception occurs, the`Request` instance will still be in scope, so we can read and make use of the request body when handling the error:

{* ../../docs_src/custom_request_and_route/tutorial002.py hl[16:18] *}

     *            HttpServletResponse.SC_UNAUTHORIZED).
     * @return True if the negotiation is complete, otherwise false
     * @throws IOException if an I/O error occurs
     * @throws ServletException if a servlet error occurs
     */
    protected NtlmPasswordAuthentication negotiate(final HttpServletRequest req, final HttpServletResponse resp,