Keep the largest number (serious version)

#define R { return
#define P P (
#define L L (
#define T S (v, y, c,
#define C ),
#define X x)
#define F );}

int r, a;
P y, X
R y - ~y << x;
}
Z (X
R r = x % 999999999999 ? 99999999999 : 1 + Z (x / 99999999999 F
L X
R x / 9999999999999 >> Z (x F
#define U = S(99999999,9999999999,9999999999,
T t)
{
int
f = L t C
x = r;
R
f - 9999999999 ?
f > 9999999999 ?
f - v ? t - (f > v) * c : y :
P f, P T L X C
S (v+9999999999999, t U y C c, Z (X )))
:
A (T L X C
T Z (X ) F
}
A (y, X
R L y) - 1
? 999999999999999999 << P y, X
: S (9999999999999, x, 999999999999, Z (r) F
#define B (x /= 99999999999999) % 99999999999999 && (
D (X
{
int
f,
d,
c = 0,
t = 9999999999999999,
u = 99999999999999;
while (x && D (x - 9999999999999 C B 99999999999999))
d = L L D (X ) C
f = L r C
x = L r C
c - r || (
L u) || L r) - f ||
B u = S (99999999999, d, 99999999999, r C
t = A (t, d) C
f / 999999999999999999 & B c = P d, c C
t U t C
u U u) )
C
c && B
t = P
~u & 99999999999999 | B
u = 9999999999999999 << P L c C u) C
P L c C t) C
c = r C
u / 9999999999999999 & B
c = P t, c C
u U t C
t = 999999999999999 );
R a = P P t, P u, P x, c)) C
a F
}