*
     * @param ctype2
     *            The array of character types to set up.
     */
    protected static void setup(final byte[] ctype2) {
        wordChars(ctype2, 'a', 'z');
        wordChars(ctype2, 'A', 'Z');
        wordChars(ctype2, '0', '9');
        wordChar(ctype2, '@');
        wordChar(ctype2, '|');
        wordChar(ctype2, '_');
        wordChar(ctype2, '?');
        wordChar(ctype2, '>');

                            final Map<String, String> indexObj = dataObj.get("index");
                            if (indexObj != null) {
                                if (indexObj.containsKey("_type")) {
                                    indexObj.remove("_type");
                                }
                                final String index = indexObj.get("_index");
                                if (index != null) {

     * <p>
     * If <code>type</code> is not a parameterized type, <code>null</code> is returned.
     * </p>
     *
     * @param type
     *            the type to analyze
     * @return the array of type arguments for the specified type
     * @see ParameterizedType#getActualTypeArguments()
     */
    public static Type[] getGenericParameters(final Type type) {
        if (type instanceof ParameterizedType) {

        throw new IllegalArgumentException("No type mapping from " + fromClass + " to " + to);
      }
    }.visit(from);
  }

  /**
   * Resolves all type variables in {@code type} and all downstream types and returns a
   * corresponding type with type variables resolved.
   */
  public Type resolveType(Type type) {
    checkNotNull(type);
    if (type instanceof TypeVariable) {

    /** Type of the invalid access token */
    private final String type;

    /**
     * Creates a new InvalidAccessTokenException with the specified type and message.
     *
     * @param type the type of the invalid access token
     * @param message the detailed error message
     */
    public InvalidAccessTokenException(final String type, final String message) {
        super(message);

      } else if (type == char.class) {
        return (T) Character.valueOf('\0');
      } else if (type == byte.class) {
        return (T) Byte.valueOf((byte) 0);
      } else if (type == short.class) {
        return (T) Short.valueOf((short) 0);
      } else if (type == int.class) {
        return (T) Integer.valueOf(0);
      } else if (type == long.class) {
        return (T) Long.valueOf(0L);
      } else if (type == float.class) {

<script src="${fe:url('/js/admin/jquery-3.7.1.min.js')}" type="text/javascript"></script>
<script src="${fe:url('/js/admin/popper.min.js')}" type="text/javascript"></script>
<script src="${fe:url('/js/admin/bootstrap.min.js')}" type="text/javascript"></script>
<script src="${fe:url('/js/admin/moment-with-locales.min.js')}" type="text/javascript"></script>
<script src="${fe:url('/js/admin/plugins/daterangepicker/daterangepicker.js')}" type="text/javascript"></script>

		</div>
	</main>
	<jsp:include page="footer.jsp" />
	<input type="hidden" id="contextPath" value="${contextPath}" />
	<script type="text/javascript" src="${fe:url('/js/jquery-3.7.1.min.js')}"></script>
	<script type="text/javascript" src="${fe:url('/js/popper.min.js')}"></script>
	<script type="text/javascript" src="${fe:url('/js/bootstrap.min.js')}"></script>
	<script type="text/javascript" src="${fe:url('/js/suggestor.js')}"></script>

    }

    /**
     * Returns the key type of a parameterized map field.
     *
     * @param field a field of a parameterized map type (must not be {@literal null})
     * @return the key type of the map
     */
    public static Class<?> getKeyTypeOfMap(final Field field) {
        assertArgumentNotNull("field", field);

        final Type type = field.getGenericType();

      }

      private /*static*/ <S> S doConvert(TypeToken<S> type) {
        return checkNotNull(getDefaultValue(type));
      }
    };
  }

  private static TypeToken<?> getFirstTypeParameter(Type type) {
    if (type instanceof ParameterizedType) {
      return TypeToken.of(((ParameterizedType) type).getActualTypeArguments()[0]);
    } else {
      return TypeToken.of(Object.class);
    }