The [Sharkovsky's Theorem](https://en.wikipedia.org/wiki/Sharkovskii%27s_theorem) involves the following ordering of the natural numbers:
```math
3≺5≺7≺9≺ ...\\
≺2·3≺2·5≺2·7≺2·9≺...\\
≺2^n·3≺2^n·5≺2^n·7≺2^n·9≺...\\
≺2^{(n+1)}·3≺2^{(n+1)}·5≺2^{(n+1)}·7≺2^{(n+1)}·9≺...\\
≺2^n≺2^{(n-1)}≺...\\
≺4≺2≺1\\
```
 
Your task is to complete the function which returns `true` if `$a≺b$` according to this ordering, and `false` otherwise.
 
You may assume both `$a$` and `$b$` are non-zero positive integers.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

def _disabled_input(*args, **kwargs):
    raise RuntimeError("input() is disabled in callable mode")
builtins.input = _disabled_input

ns = {"__name__": "__judge__"}  # prevent if __name__ == "__main__" blocks
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'from math import log\n\ndef decompose(n):\n    """\n    Given integer n, finds the coefficient and exponent of 2 decomposition\n    (c, p) such that c * 2^p == n when c, p are both integers\n    """\n    for p in range(int(log(n, 2)), -1, -1):\n        c = n / (2 ** p)\n        if c == int(c):\n            c = int(c)\n            return c, p\n        \n\ndef sharkovsky(a, b):\n    """\n    Given a, b determine if a precedes b in a Sharkovsky sequence.\n    \n    Any natural number can be decomposed into a position in the table (k \\in \\mathbb{N}):\n    \n         3.2^0           5.2^0           7.2^0  ...  (2(k-1)+1).2^0  (2k+1).2^0    ...\n         3.2^1           5.2^1           7.2^1  ...  (2(k-1)+1).2^1  (2k+1).2^1    ...\n         3.2^2           5.2^2           7.2^2  ...  (2(k-1)+1).2^2  (2k+1).2^2    ...\n         3.2^3           5.2^3           7.2^3  ...  (2(k-1)+1).2^3  (2k+1).2^3    ...\n           ...             ...             ...  ...             ...         ...    ...\n    1.2^(2k+1)  1.2^(2(k-1)+1)  1.2^(2(k-2)+1)  ...           2.2^2       1.2^1  1.2^0\n    \n    Reading the table left to right, top to bottom gives the Sharkovsky sequence\n    """\n    coef_a, exp_a = decompose(a)\n    coef_b, exp_b = decompose(b)\n    if coef_a == 1 and coef_b == 1:\n        # Both on the final row\n        return exp_b < exp_a\n    if coef_a == 1 or coef_b == 1:\n        # One on the final row\n        return coef_b == 1\n    if exp_a != exp_b:\n        # On differing rows\n        return exp_a < exp_b\n    if exp_a == exp_b:\n        # On same row\n        return coef_a < coef_b\n    return False\n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'sharkovsky'
if _fn_name:
    if "Solution" in ns:
        try:
            _obj = ns["Solution"]()
            if hasattr(_obj, _fn_name):
                _target = getattr(_obj, _fn_name)
        except Exception:
            _target = None
    if _target is None and _fn_name in ns and callable(ns[_fn_name]):
        _target = ns[_fn_name]
# Fallback: if there's exactly one user-defined function, use it
if _target is None:
    _cands = [v for k, v in ns.items() if callable(v) and getattr(v, "__module__", "") in ("__judge__", "__main__")]
    _user_funcs = [c for c in _cands if getattr(c, "__name__", "").startswith("_") is False]
    if len(_user_funcs) == 1:
        _target = _user_funcs[0]
if _target is None:
    raise RuntimeError(f"Could not resolve callable '{_fn_name}'")

_raw = sys.stdin.read().strip()
if _raw:
    _parsed = json.loads(_raw)
    if isinstance(_parsed, dict):
        _kwargs = _parsed.get("kwargs", {})
        _args = _parsed.get("args", [])
    else:
        _args, _kwargs = _parsed, {}
else:
    _args, _kwargs = [], {}
if not isinstance(_args, (list, tuple)):
    _args = [_args]
_res = _target(*_args, **_kwargs)
try:
    sys.stdout.write(repr(_res) + "\n")
except Exception:
    pass

```

Measured memory_bytes: 5782