k:   int64(k),
		m:   m,
		a:   a,
		max: max,
	}
}

func sdivisible8(c int8) sdivisibleData   { return sdivisible(8, int64(c)) }
func sdivisible16(c int16) sdivisibleData { return sdivisible(16, int64(c)) }
func sdivisible32(c int32) sdivisibleData { return sdivisible(32, int64(c)) }

 => (Leq8U
			(RotateLeft8 <typ.UInt8>
				(Add8 <typ.UInt8>
					(Mul8 <typ.UInt8>
						(Const8 <typ.UInt8> [int8(sdivisible8(c).m)])
						x)
					(Const8 <typ.UInt8> [int8(sdivisible8(c).a)])
				)
				(Const8 <typ.UInt8> [int8(8-sdivisible8(c).k)])
			)
			(Const8 <typ.UInt8> [int8(sdivisible8(c).max)])
		)

(Eq16 x (Mul16 (Const16 [c])
  (Sub16
    (Rsh32x64
      mul:(Mul32

	// ppc64x:"ANDCC",-"RLDICL",-"SRAD",-"CMP"
	a := n1%64 == 0 // signed divisible

	// 386:"TESTL\t[$]63",-"DIVL",-"SHRL"
	// amd64:"TESTQ\t[$]63",-"DIVQ",-"SHRQ"
	// arm:"AND\t[$]63",-".*udiv",-"SRA"
	// arm64:"TST\t[$]63",-"UDIV",-"ASR",-"AND"
	// ppc64x:"ANDCC",-"RLDICL",-"SRAD",-"CMP"
	b := n2%64 != 0 // signed indivisible

	return a, b
}

// Check that constant modulo divs get turned into MULs

        when:
        renderer.onOutput(userInputRequestEvent)

        then:
        1 * console.getBuildProgressArea() >> buildProgressArea
        1 * buildProgressArea.setVisible(false)
        1 * console.flush()

        and:
        0 * console._
        0 * listener.onOutput(_)
        0 * prompt._
        0 * textArea._
        0 * userInput._
        renderer.eventQueue.empty

        toggleBuildProgressAreaVisibility(true);
        flushConsole();
    }

    private void toggleBuildProgressAreaVisibility(boolean visible) {
        console.getBuildProgressArea().setVisible(visible);
    }

    private void flushConsole() {
        console.flush();
    }

            calculatedValueContainerFactory,
            defaultConfigurationFactory,
            taskDependencyFactory,
            ConfigurationRoles.DEPENDENCY_SCOPE,
            true
        );

        setVisible(false);
    }

        jvmPluginServices.configureAsRuntimeClasspath(plugins);

        Configuration zinc = project.getConfigurations().resolvableDependencyScopeUnlocked(ZINC_CONFIGURATION_NAME);
        zinc.setVisible(false);
        zinc.setDescription("The Zinc incremental compiler to be used for this Scala project.");

        zinc.getResolutionStrategy().eachDependency(rule -> {

        Configuration apiElements = maybeCreateElementsConfiguration(configName, configurations, useMigrationRoleForElementsConfigurations);

        apiElements.setVisible(false);
        jvmLanguageUtilities.useDefaultTargetPlatformInference(apiElements, compileJava);
        jvmPluginServices.configureAsApiElements(apiElements);

            calculatedValueContainerFactory,
            defaultConfigurationFactory,
            taskDependencyFactory,
            ConfigurationRoles.RESOLVABLE,
            true
        );

        setVisible(false);
    }

	pageSize := strings.TrimPrefix(string(name), v1.ResourceHugePagesPrefix)
	return resource.ParseQuantity(pageSize)
}

// HugePageUnitSizeFromByteSize returns hugepage size has the format.
// `size` must be guaranteed to divisible into the largest units that can be expressed.
// <size><unit-prefix>B (1024 = "1KB", 1048576 = "1MB", etc).
func HugePageUnitSizeFromByteSize(size int64) (string, error) {