Problem:
Score : 500 points

Problem Statement

For integers b (b \geq 2) and n (n \geq 1), let the function f(b,n) be defined as follows:

f(b,n) = n, when n < b

f(b,n) = f(b,\,{\rm floor}(n / b)) + (n \ {\rm mod} \ b), when n \geq b

Here, {\rm floor}(n / b) denotes the largest integer not exceeding n / b,
and n \ {\rm mod} \ b denotes the remainder of n divided by b.

Less formally, f(b,n) is equal to the sum of the digits of n written in base b.
For example, the following hold:

f(10,\,87654)=8+7+6+5+4=30

f(100,\,87654)=8+76+54=138

You are given integers n and s.
Determine if there exists an integer b (b \geq 2) such that f(b,n)=s.
If the answer is positive, also find the smallest such b.

Constraints

1 \leq n \leq 10^{11}

1 \leq s \leq 10^{11}

n,\,s are integers.

Input

The input is given from Standard Input in the following format:

n
s

Output

If there exists an integer b (b \geq 2) such that f(b,n)=s, print the smallest such b.
If such b does not exist, print -1 instead.

Sample Input 1

87654
30

Sample Output 1

10

Sample Input 2

87654
138

Sample Output 2

100

Sample Input 3

87654
45678

Sample Output 3

-1

Sample Input 4

31415926535
1

Sample Output 4

31415926535

Sample Input 5

1
31415926535

Sample Output 5

-1

Solution in Common Lisp (SBCL 1.1.14) (judge verdict: Accepted)

;; -*- coding: utf-8 -*-
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defparameter OPT
    #+swank '(optimize (speed 3) (safety 2))
    #-swank '(optimize (speed 3) (safety 0) (debug 0)))
  #+swank (ql:quickload '(:cl-debug-print :fiveam))
  #-swank (set-dispatch-macro-character #\# #\> (lambda (s c p) (declare (ignore c p)) (read s nil (values) t))))
#+swank (cl-syntax:use-syntax cl-debug-print:debug-print-syntax)
#-swank (disable-debugger) ; for CS Academy

;; BEGIN_INSERTED_CONTENTS
;; Below is the variant that returns a sorted list.
(defun enum-divisors (n)
  "Returns the increasing list of all the divisors of N."
  (declare #.OPT
           ((integer 1 #.most-positive-fixnum) n))
  (if (= n 1)
      (list 1)
      (let* ((sqrt (isqrt n))
             (result (list 1)))
        (labels ((%enum (i first-half second-half)
                   (declare ((integer 1 #.most-positive-fixnum) i))
                   (cond ((or (< i sqrt)
                              (and (= i sqrt) (/= (* sqrt sqrt) n)))
                          (multiple-value-bind (quot rem) (floor n i)
                            (if (zerop rem)
                                (progn
                                  (setf (cdr first-half) (list i))
                                  (setf second-half (cons quot second-half))
                                  (%enum (1+ i) (cdr first-half) second-half))
                                (%enum (1+ i) first-half second-half))))
                         ((= i sqrt) ; N is a square number here
                          (setf (cdr first-half) (cons i second-half)))
                         (t ; (> i sqrt)
                          (setf (cdr first-half) second-half)))))
          (%enum 2 result (list n))
          result))))

(defmacro dbg (&rest forms)
  #+swank
  (if (= (length forms) 1)
      `(format *error-output* "~A => ~A~%" ',(car forms) ,(car forms))
      `(format *error-output* "~A => ~A~%" ',forms `(,,@forms)))
  #-swank (declare (ignore forms)))

(defmacro define-int-types (&rest bits)
  `(progn
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "UINT~A" b)) () '(unsigned-byte ,b))) bits)
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "INT~A" b)) () '(signed-byte ,b))) bits)))
(define-int-types 2 4 7 8 15 16 31 32 62 63 64)

(declaim (inline println))
(defun println (obj &optional (stream *standard-output*))
  (let ((*read-default-float-format* 'double-float))
    (prog1 (princ obj stream) (terpri stream))))

(defconstant +mod+ 1000000007)

;; Body

(declaim (ftype (function * (values uint62 &optional)) calc))
(defun calc (b n)
  (declare #.OPT
           (uint62 b n)
           (values uint62))
  (if (< n b)
      n
      (multiple-value-bind (quot rem) (floor n b)
        (+ rem (calc b quot)))))

(defun main ()
  (declare #.OPT)
  (let* ((n (read))
         (s (read))
         (sqrt (+ 1 (isqrt (- n 1)))))
    (declare (uint62 n s sqrt))
    (println
     (cond ((> s n) -1)
           ((= s n) (+ n 1))
           (t (loop for b from 2 to sqrt
                    when (= s (calc b n))
                    do (return b))
              (let ((divisors (enum-divisors (- n s))))
                (dolist (div divisors -1)
                  (let ((b (+ div 1)))
                    (when (= s (calc b n))
                      (return b))))))))))

#-swank (main)