diff --git a/networks.rkt b/networks.rkt
index 53fbe9c..6f9caff 100644
--- a/networks.rkt
+++ b/networks.rkt
@@ -95,6 +95,8 @@
                [read-org-sbfs/state (->* (string?) (#:headers boolean?) (listof sbf/state?))]
                [print-org-tbfs/state (->* ((non-empty-listof tbf/state?)) (#:headers boolean?)
                                           (listof (listof (or/c number? symbol?))))]
+               [print-org-sbfs/state (->* ((non-empty-listof tbf/state?)) (#:headers boolean?)
+                                          (listof (listof (or/c number? symbol?))))]
                [tbf/state-tabulate* (->* ((non-empty-listof tbf/state?)) (#:headers boolean?)
                                          (listof (listof (or/c symbol? number?))))]
                [tbf/state-tabulate (->* (tbf/state?) (#:headers boolean?)
@@ -1161,6 +1163,31 @@
     (check-equal? (print-org-tbfs/state tbfs)
                   '((a b θ) (1 2 3) (-2 1 1)))))
 
+;;; Like print-org-tbfs/state, but expects a list of SBFs.  The
+;;; thresholds are therefore not included in the output.
+;;;
+;;; All sbf/state in the list must have the same inputs.  The function
+;;; does not check this property.
+;;;
+;;; If #:headers is #f, does not print the names of the inputs of the
+;;; TBFs.  If #:headers is #t, the output starts by a list giving the
+;;; names of the variables.
+(define (print-org-sbfs/state sbfs #:headers [headers #t])
+  (define table (for/list ([sbf (in-list sbfs)])
+                  (hash-map (tbf/state-w sbf) (λ (_ w) w) #t)))
+  (if headers
+      (cons (hash-map (tbf/state-w (car sbfs)) (λ (x _) x) #t)
+            table)
+      table))
+
+(module+ test
+  (define sbfs (list (make-sbf/state '((a . 1) (b . 2)))
+                     (make-sbf/state '((a . -2) (b . 1)))))
+  (check-equal? (print-org-sbfs/state sbfs)
+                '((a b) (1 2) (-2 1)))
+  (check-equal? (print-org-sbfs/state sbfs #:headers #f)
+                '((1 2) (-2 1))))
+
 ;;; Tabulates a list of tbf/state.
 ;;;
 ;;; As in the case of tbf-tabulate*, the result is a list of lists