diff --git a/src/edge_table.rs b/src/edge_table.rs
index a0649a473..6d9f38fdd 100644
--- a/src/edge_table.rs
+++ b/src/edge_table.rs
@@ -27,21 +27,21 @@ impl PartialEq for EdgeTableRow {
 }
 
 fn make_edge_table_row(table: &EdgeTable, pos: tsk_id_t) -> Option<EdgeTableRow> {
-    // panic is okay here, as we are handling a bad
-    // input value before we first call this to
-    // set up the iterator
-    let p = crate::SizeType::try_from(pos).unwrap();
-    if p < table.num_rows() {
-        let table_ref = table.table_;
-        let rv = EdgeTableRow {
-            id: pos.into(),
-            left: table.left(pos).unwrap(),
-            right: table.right(pos).unwrap(),
-            parent: table.parent(pos).unwrap(),
-            child: table.child(pos).unwrap(),
-            metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
-        };
-        Some(rv)
+    if let Ok(p) = crate::SizeType::try_from(pos) {
+        if p < table.num_rows() {
+            let table_ref = table.table_;
+            let rv = EdgeTableRow {
+                id: pos.into(),
+                left: table.left(pos).unwrap(),
+                right: table.right(pos).unwrap(),
+                parent: table.parent(pos).unwrap(),
+                child: table.child(pos).unwrap(),
+                metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
+            };
+            Some(rv)
+        } else {
+            None
+        }
     } else {
         None
     }
diff --git a/src/individual_table.rs b/src/individual_table.rs
index 1ebc52038..12e3c666e 100644
--- a/src/individual_table.rs
+++ b/src/individual_table.rs
@@ -52,20 +52,20 @@ pub struct IndividualTable<'a> {
 }
 
 fn make_individual_table_row(table: &IndividualTable, pos: tsk_id_t) -> Option<IndividualTableRow> {
-    // panic is okay here, as we are handling a bad
-    // input value before we first call this to
-    // set up the iterator
-    let p = crate::SizeType::try_from(pos).unwrap();
-    if p < table.num_rows() {
-        let table_ref = table.table_;
-        let rv = IndividualTableRow {
-            id: pos.into(),
-            flags: table.flags(pos).unwrap(),
-            location: table.location(pos).unwrap().map(|s| s.to_vec()),
-            parents: table.parents(pos).unwrap().map(|s| s.to_vec()),
-            metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
-        };
-        Some(rv)
+    if let Ok(p) = crate::SizeType::try_from(pos) {
+        if p < table.num_rows() {
+            let table_ref = table.table_;
+            let rv = IndividualTableRow {
+                id: pos.into(),
+                flags: table.flags(pos).unwrap(),
+                location: table.location(pos).unwrap().map(|s| s.to_vec()),
+                parents: table.parents(pos).unwrap().map(|s| s.to_vec()),
+                metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
+            };
+            Some(rv)
+        } else {
+            None
+        }
     } else {
         None
     }
diff --git a/src/migration_table.rs b/src/migration_table.rs
index 27a4dd3a2..7fbf54ddd 100644
--- a/src/migration_table.rs
+++ b/src/migration_table.rs
@@ -33,22 +33,22 @@ impl PartialEq for MigrationTableRow {
 }
 
 fn make_migration_table_row(table: &MigrationTable, pos: tsk_id_t) -> Option<MigrationTableRow> {
-    // panic is okay here, as we are handling a bad
-    // input value before we first call this to
-    // set up the iterator
-    let p = crate::SizeType::try_from(pos).unwrap();
-    if p < table.num_rows() {
-        let table_ref = table.table_;
-        Some(MigrationTableRow {
-            id: pos.into(),
-            left: table.left(pos).unwrap(),
-            right: table.right(pos).unwrap(),
-            node: table.node(pos).unwrap(),
-            source: table.source(pos).unwrap(),
-            dest: table.dest(pos).unwrap(),
-            time: table.time(pos).unwrap(),
-            metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
-        })
+    if let Ok(p) = crate::SizeType::try_from(pos) {
+        if p < table.num_rows() {
+            let table_ref = table.table_;
+            Some(MigrationTableRow {
+                id: pos.into(),
+                left: table.left(pos).unwrap(),
+                right: table.right(pos).unwrap(),
+                node: table.node(pos).unwrap(),
+                source: table.source(pos).unwrap(),
+                dest: table.dest(pos).unwrap(),
+                time: table.time(pos).unwrap(),
+                metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
+            })
+        } else {
+            None
+        }
     } else {
         None
     }
diff --git a/src/mutation_table.rs b/src/mutation_table.rs
index 272e77225..be4bdf6e5 100644
--- a/src/mutation_table.rs
+++ b/src/mutation_table.rs
@@ -30,22 +30,22 @@ impl PartialEq for MutationTableRow {
 }
 
 fn make_mutation_table_row(table: &MutationTable, pos: tsk_id_t) -> Option<MutationTableRow> {
-    // panic is okay here, as we are handling a bad
-    // input value before we first call this to
-    // set up the iterator
-    let p = crate::SizeType::try_from(pos).unwrap();
-    if p < table.num_rows() {
-        let table_ref = table.table_;
-        let rv = MutationTableRow {
-            id: pos.into(),
-            site: table.site(pos).unwrap(),
-            node: table.node(pos).unwrap(),
-            parent: table.parent(pos).unwrap(),
-            time: table.time(pos).unwrap(),
-            derived_state: table.derived_state(pos).unwrap().map(|s| s.to_vec()),
-            metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
-        };
-        Some(rv)
+    if let Ok(p) = crate::SizeType::try_from(pos) {
+        if p < table.num_rows() {
+            let table_ref = table.table_;
+            let rv = MutationTableRow {
+                id: pos.into(),
+                site: table.site(pos).unwrap(),
+                node: table.node(pos).unwrap(),
+                parent: table.parent(pos).unwrap(),
+                time: table.time(pos).unwrap(),
+                derived_state: table.derived_state(pos).unwrap().map(|s| s.to_vec()),
+                metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
+            };
+            Some(rv)
+        } else {
+            None
+        }
     } else {
         None
     }
diff --git a/src/node_table.rs b/src/node_table.rs
index e750dbcc1..52b2b4f6a 100644
--- a/src/node_table.rs
+++ b/src/node_table.rs
@@ -29,20 +29,20 @@ impl PartialEq for NodeTableRow {
 }
 
 fn make_node_table_row(table: &NodeTable, pos: tsk_id_t) -> Option<NodeTableRow> {
-    // panic is okay here, as we are handling a bad
-    // input value before we first call this to
-    // set up the iterator
-    let p = crate::SizeType::try_from(pos).unwrap();
-    if p < table.num_rows() {
-        let table_ref = table.table_;
-        Some(NodeTableRow {
-            id: pos.into(),
-            time: table.time(pos).unwrap(),
-            flags: table.flags(pos).unwrap(),
-            population: table.population(pos).unwrap(),
-            individual: table.individual(pos).unwrap(),
-            metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
-        })
+    if let Ok(p) = crate::SizeType::try_from(pos) {
+        if p < table.num_rows() {
+            let table_ref = table.table_;
+            Some(NodeTableRow {
+                id: pos.into(),
+                time: table.time(pos).unwrap(),
+                flags: table.flags(pos).unwrap(),
+                population: table.population(pos).unwrap(),
+                individual: table.individual(pos).unwrap(),
+                metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
+            })
+        } else {
+            None
+        }
     } else {
         None
     }
diff --git a/src/population_table.rs b/src/population_table.rs
index d366e1be6..42c11fc6e 100644
--- a/src/population_table.rs
+++ b/src/population_table.rs
@@ -20,17 +20,17 @@ impl PartialEq for PopulationTableRow {
 }
 
 fn make_population_table_row(table: &PopulationTable, pos: tsk_id_t) -> Option<PopulationTableRow> {
-    // panic is okay here, as we are handling a bad
-    // input value before we first call this to
-    // set up the iterator
-    let p = crate::SizeType::try_from(pos).unwrap();
-    if p < table.num_rows() {
-        let table_ref = table.table_;
-        let rv = PopulationTableRow {
-            id: pos.into(),
-            metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
-        };
-        Some(rv)
+    if let Ok(p) = crate::SizeType::try_from(pos) {
+        if p < table.num_rows() {
+            let table_ref = table.table_;
+            let rv = PopulationTableRow {
+                id: pos.into(),
+                metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
+            };
+            Some(rv)
+        } else {
+            None
+        }
     } else {
         None
     }
diff --git a/src/provenance.rs b/src/provenance.rs
index 055a7f449..7cfd7d792 100644
--- a/src/provenance.rs
+++ b/src/provenance.rs
@@ -45,16 +45,16 @@ impl std::fmt::Display for ProvenanceTableRow {
 }
 
 fn make_provenance_row(table: &ProvenanceTable, pos: tsk_id_t) -> Option<ProvenanceTableRow> {
-    // panic is okay here, as we are handling a bad
-    // input value before we first call this to
-    // set up the iterator
-    let p = crate::SizeType::try_from(pos).unwrap();
-    if p < table.num_rows() {
-        Some(ProvenanceTableRow {
-            id: pos.into(),
-            timestamp: table.timestamp(pos).unwrap(),
-            record: table.record(pos).unwrap(),
-        })
+    if let Ok(p) = crate::SizeType::try_from(pos) {
+        if p < table.num_rows() {
+            Some(ProvenanceTableRow {
+                id: pos.into(),
+                timestamp: table.timestamp(pos).unwrap(),
+                record: table.record(pos).unwrap(),
+            })
+        } else {
+            None
+        }
     } else {
         None
     }
diff --git a/src/site_table.rs b/src/site_table.rs
index bd9eaffb7..add82e5ad 100644
--- a/src/site_table.rs
+++ b/src/site_table.rs
@@ -25,19 +25,19 @@ impl PartialEq for SiteTableRow {
 }
 
 fn make_site_table_row(table: &SiteTable, pos: tsk_id_t) -> Option<SiteTableRow> {
-    // panic is okay here, as we are handling a bad
-    // input value before we first call this to
-    // set up the iterator
-    let p = crate::SizeType::try_from(pos).unwrap();
-    if p < table.num_rows() {
-        let table_ref = table.table_;
-        let rv = SiteTableRow {
-            id: pos.into(),
-            position: table.position(pos).unwrap(),
-            ancestral_state: table.ancestral_state(pos).unwrap().map(|s| s.to_vec()),
-            metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
-        };
-        Some(rv)
+    if let Ok(p) = crate::SizeType::try_from(pos) {
+        if p < table.num_rows() {
+            let table_ref = table.table_;
+            let rv = SiteTableRow {
+                id: pos.into(),
+                position: table.position(pos).unwrap(),
+                ancestral_state: table.ancestral_state(pos).unwrap().map(|s| s.to_vec()),
+                metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
+            };
+            Some(rv)
+        } else {
+            None
+        }
     } else {
         None
     }