@REM Licensed to the Apache Software Foundation (ASF) under one
@REM or more contributor license agreements.  See the NOTICE file
@REM distributed with this work for additional information
@REM regarding copyright ownership.  The ASF licenses this file
@REM to you under the Apache License, Version 2.0 (the
@REM "License"); you may not use this file except in compliance
@REM with the License.  You may obtain a copy of the License at
@REM

     * @return the aligned size
     */
    protected static final int size8(final int size, final int align) {

        int rem = size % 8 - align;
        if (rem == 0) {
            return size;
        }
        if (rem < 0) {
            rem = 8 + rem;
        }
        return size + 8 - rem;
    }

    /**
     * Calculates padding needed to align to 8-byte boundary from header start.
     *

     * that floor(floor(x)/i) == floor(x/i) for any real x and integer i != 0. The proof is not
     * quite trivial.
     */
    long quotient = ((dividend >>> 1) / divisor) << 1;
    long rem = dividend - quotient * divisor;
    return rem - (compare(rem, divisor) >= 0 ? divisor : 0);
  }

  /**
   * Returns the unsigned {@code long} value represented by the given decimal string.
   *

    checkNotNull(mode);
    if (q == 0) {
      throw new ArithmeticException("/ by zero"); // for GWT
    }
    int div = p / q;
    int rem = p - q * div; // equal to p % q

    if (rem == 0) {
      return div;
    }

    /*
     * Normal Java division rounds towards 0, consistently with RoundingMode.DOWN. We just have to

            // size8(10, 2): rem = 10%8 - 2 = 2 - 2 = 0, returns 10
            assertEquals(10, ServerMessageBlock2.size8(10, 2));
            // size8(18, 2): rem = 18%8 - 2 = 2 - 2 = 0, returns 18
            assertEquals(18, ServerMessageBlock2.size8(18, 2));
            // size8(17, 2): rem = 17%8 - 2 = 1 - 2 = -1, rem = 8 + (-1) = 7, returns 17 + 8 - 7 = 18

  @SuppressWarnings("fallthrough")
  public static long divide(long p, long q, RoundingMode mode) {
    checkNotNull(mode);
    long div = p / q; // throws if q == 0
    long rem = p - q * div; // equals p % q

    if (rem == 0) {
      return div;
    }

    /*
     * Normal Java division rounds towards 0, consistently with RoundingMode.DOWN. We just have to

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;

public class FessMimeTypeHelperTest extends UnitFessTestCase {

    private static final String SQL_REM_CONTENT = "rem utldtree.sql\nrem\nCREATE TABLE test (id NUMBER);\n";

    private FessMimeTypeHelper mimeTypeHelper;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);

//	}
	DIV	R18, R22	// 02d2001a
	DIVU	R14, R9		// 012e001b
	DIVV	R8, R13		// 01a8001e
	DIVVU	R16, R19	// 0270001f

//	LREM rreg ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	REM	R18, R22	// 02d2001a
	REMU	R14, R9		// 012e001b
	REMV	R8, R13		// 01a8001e
	REMVU	R16, R19	// 0270001f

//	LSHW rreg ',' sreg ',' rreg
//	{
//		outcode(int($1), &$2, int($4), &$6);
//	}

	MOVHU	y+8(FP), R4		// 6440402a
	MOVHU	1(R5), R4		// a404402a
	MULH	R4, R5	   		// a5901c00
	MULH	R4, R5, R6	   	// a6901c00
	MULHU	R4, R5			// a5101d00
	MULHU	R4, R5, R6		// a6101d00
	REM	R4, R5	  		// a5902000
	REM	R4, R5, R6	  	// a6902000
	REMW	R4, R5	  		// a5902000
	REMW	R4, R5, R6	  	// a6902000
	REMU	R4, R5	   		// a5902100
	REMU	R4, R5, R6	   	// a6902100
	REMWU	R4, R5	   		// a5902100