(defvar system-type 'gnu/linux)

(defun set-advertised-calling-convention (&rest args) nil)
(defun add-hook (&rest args) nil)
(defun re-search-forward (&rest args) nil)
(defun re-search-backward (&rest args) nil)
(defun put (&rest args) nil)
(defun make-sparse-keymap (&rest args) nil)
(defun define-key (&rest args) nil)
(defun make-obsolete-variable (&rest args) nil)
(defun make-obsolete (&rest args) nil)
(defun make-variable-buffer-local (&rest args) nil)

(defun identity (arg)
  arg)

(defun delete (elt seq)
  ((guile-ref (srfi srfi-1) delete!) elt seq))

(defun atom (object)
  (not ((guile-ref (guile) pair?) object)))

(defun stringp (object)
  ((guile-ref (guile) string?) object))

(defun symbolp (object)
  ((guile-ref (guile) symbol?) object))

(defun make-symbol (name)
  ((guile-ref (guile) make-symbol) name))

(defun member (elt list)
  ((guile-ref (guile) member) elt list))

(defun hash-table-p (obj) nil)

(defun purecopy (x) x)

(defun defalias (a b &rest x)
  (if (and a b)
      (if (fboundp b)
          (fset a (symbol-function b)))))

(defun defvaralias (a b &rest x)
  (if (and a b)
      (if (boundp b)
          (set a (symbol-value b)))))

(defmacro declare (&rest x) nil)

(defvar features '())

(defun provide (feature)
  (if (not (member feature features))
      (setq features (cons feature features))))

(defun featurep (feature)
  (member feature features))

(defmacro defsubst (&rest args)
  `(defun ,@args))

(defmacro define-obsolete-function-alias (obs new &rest fnord)
  `(defalias ,obs ,new))

(defmacro define-obsolete-variable-alias (obs new &rest args)
  `(defvaralias ,obs ,new))

(defun default-boundp (symbol) (boundp symbol))

(defalias 'nreverse 'reverse)

(defun aref (array idx)
  (if (stringp array)
      ((guile-ref (guile) string-ref) array idx)
    ((guile-ref (guile) vector-ref) array idx)))

(defun arrayp (object)
  (or (stringp object)
      ((guile-ref (guile) vector?) object)))

(defun aset (array idx newelt)
  (if (stringp object)
      ((guile-ref (guile) string-set!) array idx newelt)
    ((guile-ref (guile) vector-set!) array idx newelt)))

(defun sin (arg)
  ((guile-ref (guile) sin) arg))

(defun cos (arg)
  ((guile-ref (guile) cos) arg))

(defun tan (arg)
  ((guile-ref (guile) tan) arg))

(defun asin (arg)
  ((guile-ref (guile) asin) arg))

(defun acos (arg)
  ((guile-ref (guile) acos) arg))

(defun atan (arg)
  ((guile-ref (guile) atan) arg))

(defun logior (&rest nums)
  ((guile-ref (guile) apply) (guile-ref (guile) logior) nums))

(defun lognot (number)
  ((guile-ref (guile) lognot) number))

(defun logxor (&rest nums)
  ((guile-ref (guile) apply) (guile-ref (guile) logxor) nums))

(defun logand (&rest nums)
  ((guile-ref (guile) apply) (guile-ref (guile) logand) nums))

(defun natnump (object)
  (and (integerp object) (>= object 0)))