((pred (car lis))
                     (list (nreverse first-lis) lis))
                    (true (spla pred
                                (cdr lis)
                                (cons (car lis) first-lis)))))))

                   ((null lis)
                    (list (nreverse first-lis) lis))
                   ((pred (car lis))
                    ;; throw away the separator
                    (list (nreverse first-lis) (cdr lis)))
                   (true (spla pred
                               (cdr lis)
                               (cons (car lis) first-lis)))))))

(defun authorized-keys (user)
  (sprintf "/home/%s/.ssh/authorized_keys" user))
(defun add-jjl ()
  (let ((me "jjl")
        (my-ak (authorized-keys me)))
    (local-user-exists me "wheel")
    (file-exists-with-entire-contents
     my-ak "0644" me me
     "hardware keys"
     ssh-authorized-keys-contents)))
(defun doas-for-wheel ()
  (package-installed "doas")
  (file-exists-with-entire-contents
   "/usr/local/etc/doas.conf" "0644" "root" "wheel"
   "permit nopass :wheel"
   "permit nopass :wheel"))
(defun FreeBSD-boot-fibs (n)
  (let ((directive (sprintf "net.fibs=%d" n)))
    (file-exists-with-entire-contents
     "/boot/loader.conf.d/fibs.conf" "0644" "root" "wheel"
     directive directive)))
(defun FreeBSD-boot-load-modules (purpose-identifier module-names)
  (let* ((loads (mapcar
                 (lambda (na) (sprintf "%s_load=\"YES\"" na))
                 module-names))
         (file-contents (string-join "\n" loads)))
    (file-exists-with-entire-contents
     (sprintf "/boot/loader.conf.d/%s.conf" purpose-identifier)
     "0644" "root" "wheel"
     (sprintf "load modules: %s" (string-join " " module-names))
     file-contents)))
(defun FreeBSD-devfs-firewall-jail-rules ()
  (file-exists-with-entire-contents
   "/etc/devfs.rules" "0600" "root" "wheel"
   "devfs ruleset with bpf, pf, login"
   "\
[devfsrules_firewall_jail_vnet=10]
add include $devfsrules_hide_all
add include $devfsrules_unhide_basic
add include $devfsrules_unhide_login
add path bpf* unhide
add path pf unhide
"))
   

(defun get-ogm (source-path)

(defun get-mog (source-path)

    (list user group mode)))

    (list mode user group)))

(defun set-ogm (dest-path user group mode)

(defun set-mog (dest-path mode user group)

(defun copy-ogm (source-path dest-path)
  (apply set-ogm dest-path (get-ogm source-path)))

(defun copy-mog (source-path dest-path)
  (apply set-mog dest-path (get-mog source-path)))

    (let* ((grep-command (if detect-regex
                             (list "grep" detect-regex fp)
                           (list "grep" "-xF" line fp)))
           (output (apply probe-output grep-command))
           (script (sprintf "$a\\\n%s\n" line)))

    (let* (grep-command (if detect-regex
                            (list "grep" detect-regex fp)
                          (list "grep" "-xF" line fp)))
      (output (apply probe-output grep-command))
      (script (sprintf "$a\\\n%s\n" line))

(defun file-exists (file-path owner group mode)
  (with-log-rule ("file-exists: %s, owned by %d:%d, mode %s"
                  file-path owner group mode)

(defun file-exists (file-path mode owner group)
  (with-log-rule ("file-exists: %s, mode %s, owned by %d:%d"
                  file-path mode owner group)

        (if (equal (get-ogm file-path) (list owner group mode))

        (if (equal (get-mog file-path) (list mode owner group))

            (set-ogm file-path owner group mode)))

            (set-mog file-path mode owner group)))

        (set-ogm file-path owner group mode))))))

        (set-mog file-path mode owner group))))))

(defun dir-exists (dir-path owner group mode)

(defun dir-exists (dir-path mode owner group)

        (if (equal (get-ogm dp) (list owner group mode))

        (if (equal (get-mog dp) (list mode owner group))

          (set-ogm dp owner group mode)))

          (set-mog dp mode owner group)))

        (set-ogm dp owner n-group mode))))))

        (set-mog dp owner n-group mode))))))

              (copy-ogm file-path new)

              (copy-mog file-path new)

        (copy-ogm dest-file-path tmp)

        (copy-mog dest-file-path tmp)

           (copy-ogm dest ft)

           (copy-mog dest ft)

(defun file-exists-with-entire-contents (file-path o g m desc contents)
  (file-exists file-path o g m)

(defun file-exists-with-entire-contents (file-path m o g desc contents)
  (file-exists file-path m o g)

        close(fn)

        close(_STRING[fn])