gcd() {
    local _n=$1 _m=$2
    if (( _n % _m == 0 )); then
        echo "$_m"
        return
    fi
    gcd "$_m" $(( _n % _m ))
}

chocolates_by_numbers() {
    local _n=$1 _m=$2
    local _g
    _g=$(gcd "$_n" "$_m")
    echo $(( (_n * _m / _g) / _m ))
}

long long chocolatesGcd(long long n, long long m)
{
    if (n % m == 0) {
        return m;
    }

    return chocolatesGcd(m, n % m);
}

long long chocolatesByNumbers(long long n, long long m)
{
    long long g = chocolatesGcd(n, m);

    return ((n * m) / g) / m;
}

static long ChocolatesByNumbers(long n, long m)
{
    long Gcd(long x, long y) => x % y == 0 ? y : Gcd(y, x % y);

    return (n * m) / Gcd(n, m) / m;
}

defmodule ChocolatesByNumbers do
  def chocolates_by_numbers(n, m) do
    g = gcd(n, m)
    n * m |> div(g) |> div(m)
  end

  defp gcd(n, m) when rem(n, m) == 0, do: m
  defp gcd(n, m), do: gcd(m, rem(n, m))
end

-module(chocolates_by_numbers).
-export([chocolates_by_numbers/2]).

chocolates_by_numbers(N, M) ->
    G = gcd(N, M),
    (N * M) div G div M.

gcd(N, M) when N rem M =:= 0 -> M;
gcd(N, M) -> gcd(M, N rem M).

func chocolatesByNumbers(n, m int) int {
	var gcd func(n, m int) int
	gcd = func(n, m int) int {
		if n%m == 0 {
			return m
		}

		return gcd(m, n%m)
	}

	return n / gcd(n, m)
}

chocolatesByNumbers :: Int -> Int -> Int
chocolatesByNumbers n m = (n * m) `div` gcd n m `div` m

public class Solution {
    public static int chocolatesByNumbers(int n, int m) {
        long gcd = gcd(n, m);
        long result = ((long) n * m / gcd) / m;

        return (int) result;
    }

    private static long gcd(long n, long m) {
        if (n % m == 0) {
            return m;
        }

        return gcd(m, n % m);
    }
}

(defun choc-gcd (n m)
  (if (zerop (mod n m))
      m
      (choc-gcd m (mod n m))))

(defun chocolates-by-numbers (n m)
  (/ (/ (* n m) (choc-gcd n m)) m))

function chocolatesByNumbers(int $n, int $m): int
{
    $gcd = static function (int $n, int $m) use (&$gcd) {
        if ($n % $m === 0) {
            return $m;
        }

        return $gcd($m, $n % $m);
    };

    return (($n * $m) / $gcd($n, $m)) / $m;
}