(defun nreconc (list tail)
  (if list
    (let ((next (cdr list)))
      (rplacd list tail)
      (nreconc next list))
    tail))

(defun nreconc (list tail)
  (prog (next)
    loop
    (unless list
      (return tail))
    (setq next (cdr list))
    (rplacd list tail)
    (setq tail list)
    (setq list next)
    (go loop)))

(defun nreconc-inefficient (list tail)
  (nconc (nreverse list) tail))

(define (nreconc list tail)
  (if (null? list)
    tail
    (let ((next (cdr list)))
      (set-cdr! list tail)
      (nreconc next list))))

void *nreconc(void *list, void *tail)
{
    void *next;

    while (! null(list)) {
        next = cdr(list);
        rplacd(list, tail);
        tail = list;
        list = next;
    }

    return tail;
}

void *nreconc(void *list, void *tail)
{
    void *next;

    if (null(list))
        return tail;
    next = cdr(list);
    rplacd(list, tail);

    return nreconc(next, list);
}

(deftest nreconc.1
  (nreconc nil nil)
  nil)

(deftest nreconc.2
  (nreconc nil 10)
  10)

(deftest nreconc.3
  (nreconc (list 10 20 30) 999)
  (30 20 10 . 999))

(deftest nreconc.4
  (nreconc (list 'c 'b 'a) (list 'd 'e 'f))
  (a b c d e f))

(deftest nreconc.5
  (let ((x (list 1 2 3))
        (y (list 'a 'b 'c)))
    (values
      (nreconc x y)
      (equal x '(1 2 3))
      (equal y '(a b c))))
  (3 2 1 a b c) nil t)

(deftest nreconc.7
  (nreconc (list 1 2 3) ())
  (3 2 1))

(deftest nreconc.8
  (nreconc (list 1 2 3) (cons 'a 'b))
  (3 2 1 a . b))

(deftest nreconc.9
  (nreconc () (list 'a 'b 'c))
  (a b c))

(deftest nreconc.10
  (nreconc (list 1 2 3) 'a)
  (3 2 1 . a))

(deftest nreconc.11
  (nreconc () 'a)
  a)

(deftest-error nreconc-error.1
  (eval '(nreconc 10 20)))

(deftest-error nreconc-error.2
  (eval '(nreconc nil)))

(deftest-error nreconc-error.3
  (eval '(nreconc nil nil nil)))

(deftest-error nreconc-error.4
  (nreconc (list* 'x 'y 'z 'w) 10))