diff --git a/installer/resources/core/RTGOperationsManual.pdf b/installer/resources/core/RTGOperationsManual.pdf
index 45b5938f4..e517a8d1f 100644
Binary files a/installer/resources/core/RTGOperationsManual.pdf and b/installer/resources/core/RTGOperationsManual.pdf differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/00b47fa9220275347363dd17597c6ce4efc96fa5.png b/installer/resources/core/RTGOperationsManual/_images/math/00b47fa9220275347363dd17597c6ce4efc96fa5.png
new file mode 100644
index 000000000..ae9335d8e
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/00b47fa9220275347363dd17597c6ce4efc96fa5.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/0118ce53bf328bf7fa4d2751f727ce6ed1a759fd.png b/installer/resources/core/RTGOperationsManual/_images/math/0118ce53bf328bf7fa4d2751f727ce6ed1a759fd.png
new file mode 100644
index 000000000..0bd0247a0
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/0118ce53bf328bf7fa4d2751f727ce6ed1a759fd.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/0d6ecf115a0fefc045135d4dbfcfe920262c1b81.png b/installer/resources/core/RTGOperationsManual/_images/math/0d6ecf115a0fefc045135d4dbfcfe920262c1b81.png
deleted file mode 100644
index 9ec83410f..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/0d6ecf115a0fefc045135d4dbfcfe920262c1b81.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/1dbc400fcc213305415872f9f625cd2828f97a00.png b/installer/resources/core/RTGOperationsManual/_images/math/1dbc400fcc213305415872f9f625cd2828f97a00.png
deleted file mode 100644
index 185831550..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/1dbc400fcc213305415872f9f625cd2828f97a00.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/1dda4b44764a929f5d95a12343b22b3343e7993e.png b/installer/resources/core/RTGOperationsManual/_images/math/1dda4b44764a929f5d95a12343b22b3343e7993e.png
new file mode 100644
index 000000000..d1fbf2d3a
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/1dda4b44764a929f5d95a12343b22b3343e7993e.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/23991ec1fa444bd42d05816c69d1ba02c12a264e.png b/installer/resources/core/RTGOperationsManual/_images/math/23991ec1fa444bd42d05816c69d1ba02c12a264e.png
new file mode 100644
index 000000000..a080af3de
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/23991ec1fa444bd42d05816c69d1ba02c12a264e.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/2483bfc119f473931364741eadb1b413b84e3dff.png b/installer/resources/core/RTGOperationsManual/_images/math/2483bfc119f473931364741eadb1b413b84e3dff.png
deleted file mode 100644
index 1e81dd7d4..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/2483bfc119f473931364741eadb1b413b84e3dff.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/24a4a3d3565eacdc678ca2e8cda9c27eac9abe6a.png b/installer/resources/core/RTGOperationsManual/_images/math/24a4a3d3565eacdc678ca2e8cda9c27eac9abe6a.png
deleted file mode 100644
index 0c4c772b0..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/24a4a3d3565eacdc678ca2e8cda9c27eac9abe6a.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/276ab2f76e62085e8ec1a3fb0c5fff842c0b98e4.png b/installer/resources/core/RTGOperationsManual/_images/math/276ab2f76e62085e8ec1a3fb0c5fff842c0b98e4.png
deleted file mode 100644
index 1884219c3..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/276ab2f76e62085e8ec1a3fb0c5fff842c0b98e4.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/28357bd43b973b6fe3b43cd8cb18a02b20d55648.png b/installer/resources/core/RTGOperationsManual/_images/math/28357bd43b973b6fe3b43cd8cb18a02b20d55648.png
deleted file mode 100644
index 1c499f5f0..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/28357bd43b973b6fe3b43cd8cb18a02b20d55648.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/2895eb405a03db49e2217253743e51b83144c2ac.png b/installer/resources/core/RTGOperationsManual/_images/math/2895eb405a03db49e2217253743e51b83144c2ac.png
new file mode 100644
index 000000000..9588b2f4b
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/2895eb405a03db49e2217253743e51b83144c2ac.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/2cfe4bba60af0396a6d88125e6619fa19cc59310.png b/installer/resources/core/RTGOperationsManual/_images/math/2cfe4bba60af0396a6d88125e6619fa19cc59310.png
deleted file mode 100644
index b312397e8..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/2cfe4bba60af0396a6d88125e6619fa19cc59310.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/3a8b75e5acf08db588e4dceb7fb37bd6e45954e5.png b/installer/resources/core/RTGOperationsManual/_images/math/3a8b75e5acf08db588e4dceb7fb37bd6e45954e5.png
deleted file mode 100644
index 2dfd0c40e..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/3a8b75e5acf08db588e4dceb7fb37bd6e45954e5.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/3d714ca7cb77ae0a59a33942b07a97523eb2ede6.png b/installer/resources/core/RTGOperationsManual/_images/math/3d714ca7cb77ae0a59a33942b07a97523eb2ede6.png
deleted file mode 100644
index 5aa3f7673..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/3d714ca7cb77ae0a59a33942b07a97523eb2ede6.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/3e33daea0596958aba9bd9cf28865a39b7e48b25.png b/installer/resources/core/RTGOperationsManual/_images/math/3e33daea0596958aba9bd9cf28865a39b7e48b25.png
new file mode 100644
index 000000000..d93f294f6
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/3e33daea0596958aba9bd9cf28865a39b7e48b25.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/4370f8a24787d16b6631cfde4d5e7bc06d8d42c7.png b/installer/resources/core/RTGOperationsManual/_images/math/4370f8a24787d16b6631cfde4d5e7bc06d8d42c7.png
new file mode 100644
index 000000000..6323a0f1c
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/4370f8a24787d16b6631cfde4d5e7bc06d8d42c7.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/4b0ffe0e53244b2c1bff21382be9a5ab326276d1.png b/installer/resources/core/RTGOperationsManual/_images/math/4b0ffe0e53244b2c1bff21382be9a5ab326276d1.png
deleted file mode 100644
index 65d24238d..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/4b0ffe0e53244b2c1bff21382be9a5ab326276d1.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/5163a30eacf7ec6ef0a4bacd6f37adc97e59a22e.png b/installer/resources/core/RTGOperationsManual/_images/math/5163a30eacf7ec6ef0a4bacd6f37adc97e59a22e.png
deleted file mode 100644
index 9276590a4..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/5163a30eacf7ec6ef0a4bacd6f37adc97e59a22e.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/52ddc0cde6d632f631533173562fe3ca375b1f32.png b/installer/resources/core/RTGOperationsManual/_images/math/52ddc0cde6d632f631533173562fe3ca375b1f32.png
new file mode 100644
index 000000000..9b4d0e8a5
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/52ddc0cde6d632f631533173562fe3ca375b1f32.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/567fdf012fd3643c1df136a2e28f66591b626323.png b/installer/resources/core/RTGOperationsManual/_images/math/567fdf012fd3643c1df136a2e28f66591b626323.png
deleted file mode 100644
index 193982e4b..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/567fdf012fd3643c1df136a2e28f66591b626323.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/5698fa961e23bd31116fc14bcc700c3c82564201.png b/installer/resources/core/RTGOperationsManual/_images/math/5698fa961e23bd31116fc14bcc700c3c82564201.png
deleted file mode 100644
index 10a378632..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/5698fa961e23bd31116fc14bcc700c3c82564201.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/57540cfddc027fe046444894db8bb84952eaff1f.png b/installer/resources/core/RTGOperationsManual/_images/math/57540cfddc027fe046444894db8bb84952eaff1f.png
new file mode 100644
index 000000000..a0312b18c
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/57540cfddc027fe046444894db8bb84952eaff1f.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/593c511ee9aeb89e927882c5cb67418a46da3828.png b/installer/resources/core/RTGOperationsManual/_images/math/593c511ee9aeb89e927882c5cb67418a46da3828.png
new file mode 100644
index 000000000..be84ca9ad
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/593c511ee9aeb89e927882c5cb67418a46da3828.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/5a939c5280da7202ca4531f175a7780ad5e1f80a.png b/installer/resources/core/RTGOperationsManual/_images/math/5a939c5280da7202ca4531f175a7780ad5e1f80a.png
new file mode 100644
index 000000000..4ebda0d92
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/5a939c5280da7202ca4531f175a7780ad5e1f80a.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/5cef678b81febf5ec6b208c557e607eed45b9e2a.png b/installer/resources/core/RTGOperationsManual/_images/math/5cef678b81febf5ec6b208c557e607eed45b9e2a.png
deleted file mode 100644
index 21ec2ead4..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/5cef678b81febf5ec6b208c557e607eed45b9e2a.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/60ec5a4e636f260cafc63c490e2da12d8e36b418.png b/installer/resources/core/RTGOperationsManual/_images/math/60ec5a4e636f260cafc63c490e2da12d8e36b418.png
deleted file mode 100644
index 2007f22d1..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/60ec5a4e636f260cafc63c490e2da12d8e36b418.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/61e31c976978a6cea362a491cd9d463454c1e0fb.png b/installer/resources/core/RTGOperationsManual/_images/math/61e31c976978a6cea362a491cd9d463454c1e0fb.png
deleted file mode 100644
index b0370162c..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/61e31c976978a6cea362a491cd9d463454c1e0fb.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/6596b3f1d72eeb3b72dd1cdaaae199a4a3b1a412.png b/installer/resources/core/RTGOperationsManual/_images/math/6596b3f1d72eeb3b72dd1cdaaae199a4a3b1a412.png
new file mode 100644
index 000000000..b313b252b
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/6596b3f1d72eeb3b72dd1cdaaae199a4a3b1a412.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/66e94f41a0f1e5615bd662691764d652b37d7338.png b/installer/resources/core/RTGOperationsManual/_images/math/66e94f41a0f1e5615bd662691764d652b37d7338.png
deleted file mode 100644
index 38b91cb9d..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/66e94f41a0f1e5615bd662691764d652b37d7338.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/67e012a427a90dc0c0f8a2d5939a95e5f6ffe591.png b/installer/resources/core/RTGOperationsManual/_images/math/67e012a427a90dc0c0f8a2d5939a95e5f6ffe591.png
new file mode 100644
index 000000000..18bcc39a8
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/67e012a427a90dc0c0f8a2d5939a95e5f6ffe591.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/684381a21cd73ebbf43b63a087d3f7410ee99ce8.png b/installer/resources/core/RTGOperationsManual/_images/math/684381a21cd73ebbf43b63a087d3f7410ee99ce8.png
deleted file mode 100644
index dcac5aa56..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/684381a21cd73ebbf43b63a087d3f7410ee99ce8.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/6c754ae3fc49dc56e236eb95ef00cfdcad3df594.png b/installer/resources/core/RTGOperationsManual/_images/math/6c754ae3fc49dc56e236eb95ef00cfdcad3df594.png
new file mode 100644
index 000000000..8325634c6
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/6c754ae3fc49dc56e236eb95ef00cfdcad3df594.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/76f1d8ace30435987c01a00ca53a71cba1f40e6c.png b/installer/resources/core/RTGOperationsManual/_images/math/76f1d8ace30435987c01a00ca53a71cba1f40e6c.png
deleted file mode 100644
index cfb47f4bc..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/76f1d8ace30435987c01a00ca53a71cba1f40e6c.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/888f7c323ac0341871e867220ae2d76467d74d6e.png b/installer/resources/core/RTGOperationsManual/_images/math/888f7c323ac0341871e867220ae2d76467d74d6e.png
new file mode 100644
index 000000000..c91738acf
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/888f7c323ac0341871e867220ae2d76467d74d6e.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/92ddcd7319ecbea8436f1b18fbebf544a38e4c69.png b/installer/resources/core/RTGOperationsManual/_images/math/92ddcd7319ecbea8436f1b18fbebf544a38e4c69.png
new file mode 100644
index 000000000..0e25e38e8
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/92ddcd7319ecbea8436f1b18fbebf544a38e4c69.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/9dcbbef8e0f76051d388013b90a95bec3069e484.png b/installer/resources/core/RTGOperationsManual/_images/math/9dcbbef8e0f76051d388013b90a95bec3069e484.png
deleted file mode 100644
index 87f5e3167..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/9dcbbef8e0f76051d388013b90a95bec3069e484.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/9e32cdd0b4d023c3e9b3e724291a03bdbcbee572.png b/installer/resources/core/RTGOperationsManual/_images/math/9e32cdd0b4d023c3e9b3e724291a03bdbcbee572.png
new file mode 100644
index 000000000..f95e01d61
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/9e32cdd0b4d023c3e9b3e724291a03bdbcbee572.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/a59f68a4202623bb859a7093f0316bf466e6f75d.png b/installer/resources/core/RTGOperationsManual/_images/math/a59f68a4202623bb859a7093f0316bf466e6f75d.png
deleted file mode 100644
index 2047e4714..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/a59f68a4202623bb859a7093f0316bf466e6f75d.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/af517d52259b23914a79dc82c765d702ec5cf7b1.png b/installer/resources/core/RTGOperationsManual/_images/math/af517d52259b23914a79dc82c765d702ec5cf7b1.png
new file mode 100644
index 000000000..a423e5012
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/af517d52259b23914a79dc82c765d702ec5cf7b1.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/b4e2012103f1c4a304de5f04d2c95b2fa7ddcd73.png b/installer/resources/core/RTGOperationsManual/_images/math/b4e2012103f1c4a304de5f04d2c95b2fa7ddcd73.png
deleted file mode 100644
index 5de77dae4..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/b4e2012103f1c4a304de5f04d2c95b2fa7ddcd73.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/b6f66d1803a9dcb5f12f25c57d4e43fb6584ca7e.png b/installer/resources/core/RTGOperationsManual/_images/math/b6f66d1803a9dcb5f12f25c57d4e43fb6584ca7e.png
new file mode 100644
index 000000000..f4e2d3ab4
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/b6f66d1803a9dcb5f12f25c57d4e43fb6584ca7e.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/b81c7a12342c0ee157b2c3f1bcfc4f91642187dc.png b/installer/resources/core/RTGOperationsManual/_images/math/b81c7a12342c0ee157b2c3f1bcfc4f91642187dc.png
new file mode 100644
index 000000000..5c52c4169
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/b81c7a12342c0ee157b2c3f1bcfc4f91642187dc.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/b988975be41fd13b4d091c10202ba19374643586.png b/installer/resources/core/RTGOperationsManual/_images/math/b988975be41fd13b4d091c10202ba19374643586.png
new file mode 100644
index 000000000..a10fe36f7
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/b988975be41fd13b4d091c10202ba19374643586.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/ba8123ebfe56a852560851932a86adaef704bbb7.png b/installer/resources/core/RTGOperationsManual/_images/math/ba8123ebfe56a852560851932a86adaef704bbb7.png
deleted file mode 100644
index 7eefdd7c6..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/ba8123ebfe56a852560851932a86adaef704bbb7.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/c2aa3dff9bffb099e9dff196fd36aed56ec16baf.png b/installer/resources/core/RTGOperationsManual/_images/math/c2aa3dff9bffb099e9dff196fd36aed56ec16baf.png
new file mode 100644
index 000000000..e1683da7b
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/c2aa3dff9bffb099e9dff196fd36aed56ec16baf.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/c61adab5a368b41156d78099e64eaef7d3a9fb30.png b/installer/resources/core/RTGOperationsManual/_images/math/c61adab5a368b41156d78099e64eaef7d3a9fb30.png
new file mode 100644
index 000000000..8e415eee8
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/c61adab5a368b41156d78099e64eaef7d3a9fb30.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/cefc603e5658facb747581f9567192993f21c7ab.png b/installer/resources/core/RTGOperationsManual/_images/math/cefc603e5658facb747581f9567192993f21c7ab.png
new file mode 100644
index 000000000..749d58820
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/cefc603e5658facb747581f9567192993f21c7ab.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/d87c941fdcf46735e757ab196fe03da2ea08ec45.png b/installer/resources/core/RTGOperationsManual/_images/math/d87c941fdcf46735e757ab196fe03da2ea08ec45.png
deleted file mode 100644
index f9a489b71..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/d87c941fdcf46735e757ab196fe03da2ea08ec45.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/e11f2701c4a39c7fe543a6c4150b421d50f1c159.png b/installer/resources/core/RTGOperationsManual/_images/math/e11f2701c4a39c7fe543a6c4150b421d50f1c159.png
deleted file mode 100644
index 991b8ed27..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_images/math/e11f2701c4a39c7fe543a6c4150b421d50f1c159.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_images/math/f13fefe97363643ae6879e8f163616d0cf50ab3f.png b/installer/resources/core/RTGOperationsManual/_images/math/f13fefe97363643ae6879e8f163616d0cf50ab3f.png
new file mode 100644
index 000000000..b5370a08a
Binary files /dev/null and b/installer/resources/core/RTGOperationsManual/_images/math/f13fefe97363643ae6879e8f163616d0cf50ab3f.png differ
diff --git a/installer/resources/core/RTGOperationsManual/_sources/appendix.rst.txt b/installer/resources/core/RTGOperationsManual/_sources/appendix.rst.txt
index a9d2baa69..da3bf8eae 100644
--- a/installer/resources/core/RTGOperationsManual/_sources/appendix.rst.txt
+++ b/installer/resources/core/RTGOperationsManual/_sources/appendix.rst.txt
@@ -120,7 +120,8 @@ other contigs. It is specified with the following structure:
 
   either	def	<ploidy>	<shape>
 
-The *ploidy* field is one of ``diploid``, ``haploid``, ``polyploid`` or
+The *ploidy* field is one of ``haploid``, ``diploid``, ``triploid``,
+``tetraploid``, ``pentaploid``, ``hexaploid``, ``polyploid`` or
 ``none``. The *shape* field is one of ``circular`` or ``linear``.
 
 The specific chromosome settings lines are similar to the default
@@ -350,7 +351,7 @@ Within the context of a ``--keep-expr`` or ``record`` function these
 variables will provide access to the String representation of the VCF
 column of the same name.
 
-.. code-block:: text
+.. code-block:: javascript
 
   CHROM; // "1"
   POS; // "11259340"
@@ -363,7 +364,7 @@ ALT, FILTER
 
 Will retrieve an array of the values in the column.
 
-.. code-block:: text
+.. code-block:: javascript
 
   ALT; // ["C", "T"]
   FILTER; // ["PASS"]
@@ -378,7 +379,7 @@ Missing fields will be represented by "``.``". Assigning to these
 properties will update the VCF record. This will be undefined for fields not
 declared in the header.
 
-.. code-block:: text
+.. code-block:: javascript
 
   INFO.DP; // "795"
   INFO.ABC; // "4,5"
@@ -392,7 +393,7 @@ format fields for each sample. The string representation of values in
 the sample column are accessible as properties on the string matching
 the sample name named after the ``FORMAT`` field ``ID``.
 
-.. code-block:: text
+.. code-block:: javascript
 
   'NA12877'.GT; // "1/2"
   'NA12878'.GT; // "1/0"
@@ -410,10 +411,10 @@ Most components of VCF records can be written or updated in a fairly
 natural manner by direct assignment in order to make modifications. For
 example:
 
-.. code-block:: text
+.. code-block:: javascript
 
   CHROM = "chr1";      // Will change the CHROM value
-  POS = 42;            // Will change the POS value               
+  POS = 42;            // Will change the POS value
   ID = "rs23987382";   // Will change the ID value
   QUAL = "50";         // Will change the QUAL value
   FILTER = "FAIL";     // Will set the FILTER value
@@ -429,12 +430,12 @@ and ``ALT``) are considered immutable and can not currently be altered.
           or tool.  Depending on the new value assigned to ``CHROM`` it may
           also be necessary to modify the sequence dictionary in the VCF
           header to reflect the change (see :ref:`VCF header modification`).
-   
+
 
 Direct assignment to ``ID`` and ``FILTER`` fields accept either a string
 containing semicolon separated values, or a list of values. For example:
 
-.. code-block:: text
+.. code-block:: javascript
 
     ID = 'rs23987382;COSM3805';
     ID = ['rs23987382', 'COSM3805'];
@@ -450,7 +451,7 @@ Adding a filter to existing filters is a common operation and can be
 accomplished by the above assignment methods, for example by adding a
 value to the existing list and then setting the result:
 
-.. code-block:: text
+.. code-block:: javascript
 
     var f = FILTER;
     f.push('BOING');
@@ -459,7 +460,7 @@ value to the existing list and then setting the result:
 However, since this is a little unwieldy, a convenience function called
 `add()` can be used (and may be chained):
 
-.. code-block:: text
+.. code-block:: javascript
 
     FILTER.add('BOING');
     FILTER.add(['BOING', 'DOING');
@@ -474,41 +475,103 @@ Functions are provided that allow the addition of new ``FILTER``,
 recommended that the following functions only be used within the
 run-once portion of ``--javascript``.
 
-ensureFormatHeader(FORMAT\_HEADER\_STRING)
-``````````````````````````````````````````
+ensureFormatHeader({FORMAT\_HEADER\_STRING})
+````````````````````````````````````````````
 
 Add a new ``FORMAT`` field to the VCF if it is not already present. This
 will add a ``FORMAT`` declaration line to the header and define the
 corresponding accessor methods for use in record processing.
 
-.. code-block:: text
+.. code-block:: javascript
 
   ensureFormatHeader('##FORMAT=<ID=GL,Number=G,Type=Float,' +
     'Description="Log_10 scaled genotype likelihoods.">');
 
-ensureInfoHeader(INFO\_HEADER\_STRING)
-``````````````````````````````````````
+ensureInfoHeader({INFO\_HEADER\_STRING})
+````````````````````````````````````````
 
 Add a new ``INFO`` field to the VCF if it is not already present. This
 will add an ``INFO`` declaration line to the header and define the
 corresponding accessor methods for use in record processing.
 
-.. code-block:: text
+.. code-block:: javascript
 
   ensureInfoHeader('##INFO=<ID=CT,Number=1,Type=Integer,' +
     'Description="Coverage threshold that was applied">');
 
-ensureFilterHeader(FILTER\_HEADER\_STRING)
-``````````````````````````````````````````
+ensureFilterHeader({FILTER\_HEADER\_STRING})
+````````````````````````````````````````````
 
 Add a new ``FILTER`` field to the VCF header if it is not already
 present. This will add an ``FILTER`` declaration line to the header.
 
-.. code-block:: text
+.. code-block:: javascript
 
   ensureFilterHeader('##INFO=<ID=FAIL_VAL,' +
     'Description="Failed validation">');
 
+
+Testing for overlap with genomic regions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+One common use case is to test whether any given VCF record overlaps or
+is contained within a set of genomic regions. Regions may be loaded from
+either an external BED file or VCF file in the run-once portion of the
+JavaScript by either of the following:
+
+Regions.fromBed({FILENAME})
+```````````````````````````
+
+Load the specified BED file into a `regions` object. For example:
+
+.. code-block:: javascript
+
+  var myregions = Regions.fromBed('/path/to/regions.bed');
+
+Regions.fromVcf({FILENAME})
+```````````````````````````
+
+Load the specified VCF file into a `regions` object. For example:
+
+.. code-block:: javascript
+
+  var myregions = Regions.fromVcf('/path/to/regions.vcf');
+
+
+Having loaded a set of genomic regions, this can be used to test for
+region overlaps using the following methods:
+
+{REGIONS\_OBJECT}.overlaps({CHROM}, {START}, {END})
+```````````````````````````````````````````````````
+
+Return true if the loaded regions overlap the specified interval.  This
+function is typically used within the ``record`` function to test the
+coordinates of the current VCF record, e.g.:
+
+.. code-block:: javascript
+
+    function record() {
+        if (myregions.overlaps(CHROM, POS, POS + REF.length)) {
+            // do something if the record overlaps any region
+        }
+    }
+
+{REGIONS\_OBJECT}.encloses({CHROM}, {START}, {END})
+```````````````````````````````````````````````````
+
+Return true if the loaded regions entirely encloses the supplied
+interval.  This function is typically used within the ``record``
+function to test the coordinates of the current VCF record, e.g.:
+
+.. code-block:: javascript
+
+    function record() {
+        if (myregions.encloses(CHROM, POS, POS + REF.length)) {
+            // do something if the record is fully enclosed by any region
+        }
+    }
+
+
 Additional information and functions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -517,37 +580,37 @@ SAMPLES
 
 This variable contains an array of the sample names in the VCF header.
 
-.. code-block:: text
+.. code-block:: javascript
 
   SAMPLES; // ['NA12877', 'NA12878']
 
 print({STRING})
 ```````````````
 
-Writes the provided string to standard output.
+Write the provided string to standard output.
 
-.. code-block:: text
+.. code-block:: javascript
 
   print('The samples are: ' + SAMPLES);
 
 error({STRING})
 ```````````````
 
-Writes the provided string to standard error.
+Write the provided string to standard error.
 
-.. code-block:: text
+.. code-block:: javascript
 
   error('The samples are: ' + SAMPLES);
 
 checkMinVersion(RTG_MINIMUM_VERSION)
 ````````````````````````````````````
 
-Checks the version of RTG that the script is running under, and exits
+Check the version of RTG that the script is running under, and exits
 with an error message if the version of RTG does not meet the minimum
 required version. This is useful when distributing scripts that make use
 of features that are not present in earlier versions of RTG.
 
-.. code-block:: text
+.. code-block:: javascript
 
   checkMinVersion('3.9.2');
 
diff --git a/installer/resources/core/RTGOperationsManual/_static/ajax-loader.gif b/installer/resources/core/RTGOperationsManual/_static/ajax-loader.gif
deleted file mode 100644
index 61faf8cab..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_static/ajax-loader.gif and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_static/basic.css b/installer/resources/core/RTGOperationsManual/_static/basic.css
index 0807176ec..295d6dad8 100644
--- a/installer/resources/core/RTGOperationsManual/_static/basic.css
+++ b/installer/resources/core/RTGOperationsManual/_static/basic.css
@@ -4,7 +4,7 @@
  *
  * Sphinx stylesheet -- basic theme.
  *
- * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS.
+ * :copyright: Copyright 2007-2020 by the Sphinx team, see AUTHORS.
  * :license: BSD, see LICENSE for details.
  *
  */
@@ -15,6 +15,12 @@ div.clearer {
     clear: both;
 }
 
+div.section::after {
+    display: block;
+    content: '';
+    clear: left;
+}
+
 /* -- relbar ---------------------------------------------------------------- */
 
 div.related {
@@ -49,7 +55,7 @@ div.sphinxsidebarwrapper {
 
 div.sphinxsidebar {
     float: left;
-    width: 230px;
+    width: 210px;
     margin-left: -100%;
     font-size: 90%;
     word-wrap: break-word;
@@ -231,6 +237,16 @@ a.headerlink {
     visibility: hidden;
 }
 
+a.brackets:before,
+span.brackets > a:before{
+    content: "[";
+}
+
+a.brackets:after,
+span.brackets > a:after {
+    content: "]";
+}
+
 h1:hover > a.headerlink,
 h2:hover > a.headerlink,
 h3:hover > a.headerlink,
@@ -279,6 +295,12 @@ img.align-center, .figure.align-center, object.align-center {
   margin-right: auto;
 }
 
+img.align-default, .figure.align-default {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+}
+
 .align-left {
     text-align: left;
 }
@@ -287,6 +309,10 @@ img.align-center, .figure.align-center, object.align-center {
     text-align: center;
 }
 
+.align-default {
+    text-align: center;
+}
+
 .align-right {
     text-align: right;
 }
@@ -296,21 +322,27 @@ img.align-center, .figure.align-center, object.align-center {
 div.sidebar {
     margin: 0 0 0.5em 1em;
     border: 1px solid #ddb;
-    padding: 7px 7px 0 7px;
+    padding: 7px;
     background-color: #ffe;
     width: 40%;
     float: right;
+    clear: right;
+    overflow-x: auto;
 }
 
 p.sidebar-title {
     font-weight: bold;
 }
 
+div.admonition, div.topic, blockquote {
+    clear: left;
+}
+
 /* -- topics ---------------------------------------------------------------- */
 
 div.topic {
     border: 1px solid #ccc;
-    padding: 7px 7px 0 7px;
+    padding: 7px;
     margin: 10px 0 10px 0;
 }
 
@@ -332,10 +364,6 @@ div.admonition dt {
     font-weight: bold;
 }
 
-div.admonition dl {
-    margin-bottom: 0;
-}
-
 p.admonition-title {
     margin: 0px 10px 5px 0px;
     font-weight: bold;
@@ -346,9 +374,28 @@ div.body p.centered {
     margin-top: 25px;
 }
 
+/* -- content of sidebars/topics/admonitions -------------------------------- */
+
+div.sidebar > :last-child,
+div.topic > :last-child,
+div.admonition > :last-child {
+    margin-bottom: 0;
+}
+
+div.sidebar::after,
+div.topic::after,
+div.admonition::after,
+blockquote::after {
+    display: block;
+    content: '';
+    clear: both;
+}
+
 /* -- tables ---------------------------------------------------------------- */
 
 table.docutils {
+    margin-top: 10px;
+    margin-bottom: 10px;
     border: 0;
     border-collapse: collapse;
 }
@@ -358,6 +405,11 @@ table.align-center {
     margin-right: auto;
 }
 
+table.align-default {
+    margin-left: auto;
+    margin-right: auto;
+}
+
 table caption span.caption-number {
     font-style: italic;
 }
@@ -391,6 +443,16 @@ table.citation td {
     border-bottom: none;
 }
 
+th > :first-child,
+td > :first-child {
+    margin-top: 0px;
+}
+
+th > :last-child,
+td > :last-child {
+    margin-bottom: 0px;
+}
+
 /* -- figures --------------------------------------------------------------- */
 
 div.figure {
@@ -433,6 +495,10 @@ table.field-list td, table.field-list th {
 
 /* -- hlist styles ---------------------------------------------------------- */
 
+table.hlist {
+    margin: 1em 0;
+}
+
 table.hlist td {
     vertical-align: top;
 }
@@ -460,11 +526,78 @@ ol.upperroman {
     list-style: upper-roman;
 }
 
+:not(li) > ol > li:first-child > :first-child,
+:not(li) > ul > li:first-child > :first-child {
+    margin-top: 0px;
+}
+
+:not(li) > ol > li:last-child > :last-child,
+:not(li) > ul > li:last-child > :last-child {
+    margin-bottom: 0px;
+}
+
+ol.simple ol p,
+ol.simple ul p,
+ul.simple ol p,
+ul.simple ul p {
+    margin-top: 0;
+}
+
+ol.simple > li:not(:first-child) > p,
+ul.simple > li:not(:first-child) > p {
+    margin-top: 0;
+}
+
+ol.simple p,
+ul.simple p {
+    margin-bottom: 0;
+}
+
+dl.footnote > dt,
+dl.citation > dt {
+    float: left;
+    margin-right: 0.5em;
+}
+
+dl.footnote > dd,
+dl.citation > dd {
+    margin-bottom: 0em;
+}
+
+dl.footnote > dd:after,
+dl.citation > dd:after {
+    content: "";
+    clear: both;
+}
+
+dl.field-list {
+    display: grid;
+    grid-template-columns: fit-content(30%) auto;
+}
+
+dl.field-list > dt {
+    font-weight: bold;
+    word-break: break-word;
+    padding-left: 0.5em;
+    padding-right: 5px;
+}
+
+dl.field-list > dt:after {
+    content: ":";
+}
+
+dl.field-list > dd {
+    padding-left: 0.5em;
+    margin-top: 0em;
+    margin-left: 0em;
+    margin-bottom: 0em;
+}
+
 dl {
     margin-bottom: 15px;
 }
 
-dd p {
+dd > :first-child {
     margin-top: 0px;
 }
 
@@ -478,6 +611,11 @@ dd {
     margin-left: 30px;
 }
 
+dl > dd:last-child,
+dl > dd:last-child > :last-child {
+    margin-bottom: 0;
+}
+
 dt:target, span.highlighted {
     background-color: #fbe54e;
 }
@@ -537,6 +675,12 @@ dl.glossary dt {
     font-style: oblique;
 }
 
+.classifier:before {
+    font-style: normal;
+    margin: 0.5em;
+    content: ":";
+}
+
 abbr, acronym {
     border-bottom: dotted 1px;
     cursor: help;
@@ -549,6 +693,10 @@ pre {
     overflow-y: hidden;  /* fixes display issues on Chrome browsers */
 }
 
+pre, div[class|="highlight"] {
+    clear: both;
+}
+
 span.pre {
     -moz-hyphens: none;
     -ms-hyphens: none;
@@ -556,22 +704,57 @@ span.pre {
     hyphens: none;
 }
 
+div[class^="highlight-"] {
+    margin: 1em 0;
+}
+
 td.linenos pre {
-    padding: 5px 0px;
     border: 0;
     background-color: transparent;
     color: #aaa;
 }
 
 table.highlighttable {
-    margin-left: 0.5em;
+    display: block;
+}
+
+table.highlighttable tbody {
+    display: block;
+}
+
+table.highlighttable tr {
+    display: flex;
 }
 
 table.highlighttable td {
-    padding: 0 0.5em 0 0.5em;
+    margin: 0;
+    padding: 0;
+}
+
+table.highlighttable td.linenos {
+    padding-right: 0.5em;
+}
+
+table.highlighttable td.code {
+    flex: 1;
+    overflow: hidden;
+}
+
+.highlight .hll {
+    display: block;
+}
+
+div.highlight pre,
+table.highlighttable pre {
+    margin: 0;
+}
+
+div.code-block-caption + div {
+    margin-top: 0;
 }
 
 div.code-block-caption {
+    margin-top: 1em;
     padding: 2px 5px;
     font-size: small;
 }
@@ -580,8 +763,9 @@ div.code-block-caption code {
     background-color: transparent;
 }
 
-div.code-block-caption + div > div.highlight > pre {
-    margin-top: 0;
+table.highlighttable td.linenos,
+div.doctest > div.highlight span.gp {  /* gp: Generic.Prompt */
+    user-select: none;
 }
 
 div.code-block-caption span.caption-number {
@@ -593,11 +777,7 @@ div.code-block-caption span.caption-text {
 }
 
 div.literal-block-wrapper {
-    padding: 1em 1em 0;
-}
-
-div.literal-block-wrapper div.highlight {
-    margin: 0;
+    margin: 1em 0;
 }
 
 code.descname {
@@ -648,8 +828,7 @@ span.eqno {
 }
 
 span.eqno a.headerlink {
-    position: relative;
-    left: 0px;
+    position: absolute;
     z-index: 1;
 }
 
diff --git a/installer/resources/core/RTGOperationsManual/_static/bizstyle.js b/installer/resources/core/RTGOperationsManual/_static/bizstyle.js
index a304904b7..672c96079 100644
--- a/installer/resources/core/RTGOperationsManual/_static/bizstyle.js
+++ b/installer/resources/core/RTGOperationsManual/_static/bizstyle.js
@@ -36,6 +36,6 @@ $(window).resize(function(){
         $("li.nav-item-0 a").text("Top");
     }
     else {
-        $("li.nav-item-0 a").text("RTG Core Operations Manual v3.11");
+        $("li.nav-item-0 a").text("RTG Core Operations Manual v3.12");
     }
 });
\ No newline at end of file
diff --git a/installer/resources/core/RTGOperationsManual/_static/comment-bright.png b/installer/resources/core/RTGOperationsManual/_static/comment-bright.png
deleted file mode 100644
index 15e27edb1..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_static/comment-bright.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_static/comment-close.png b/installer/resources/core/RTGOperationsManual/_static/comment-close.png
deleted file mode 100644
index 4d91bcf57..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_static/comment-close.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_static/comment.png b/installer/resources/core/RTGOperationsManual/_static/comment.png
deleted file mode 100644
index dfbc0cbd5..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_static/comment.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_static/doctools.js b/installer/resources/core/RTGOperationsManual/_static/doctools.js
index 344db17dd..daccd209d 100644
--- a/installer/resources/core/RTGOperationsManual/_static/doctools.js
+++ b/installer/resources/core/RTGOperationsManual/_static/doctools.js
@@ -4,7 +4,7 @@
  *
  * Sphinx JavaScript utilities for all documentation.
  *
- * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS.
+ * :copyright: Copyright 2007-2020 by the Sphinx team, see AUTHORS.
  * :license: BSD, see LICENSE for details.
  *
  */
@@ -87,14 +87,13 @@ jQuery.fn.highlightText = function(text, className) {
           node.nextSibling));
         node.nodeValue = val.substr(0, pos);
         if (isInSVG) {
-          var bbox = span.getBBox();
           var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
-       	  rect.x.baseVal.value = bbox.x;
+          var bbox = node.parentElement.getBBox();
+          rect.x.baseVal.value = bbox.x;
           rect.y.baseVal.value = bbox.y;
           rect.width.baseVal.value = bbox.width;
           rect.height.baseVal.value = bbox.height;
           rect.setAttribute('class', className);
-          var parentOfText = node.parentNode.parentNode;
           addItems.push({
               "parent": node.parentNode,
               "target": rect});
@@ -284,10 +283,11 @@ var Documentation = {
   },
 
   initOnKeyListeners: function() {
-    $(document).keyup(function(event) {
+    $(document).keydown(function(event) {
       var activeElementType = document.activeElement.tagName;
       // don't navigate when in search box or textarea
-      if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') {
+      if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT'
+          && !event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey) {
         switch (event.keyCode) {
           case 37: // left
             var prevHref = $('link[rel="prev"]').prop('href');
diff --git a/installer/resources/core/RTGOperationsManual/_static/documentation_options.js b/installer/resources/core/RTGOperationsManual/_static/documentation_options.js
index 53ee09118..6624cfe46 100644
--- a/installer/resources/core/RTGOperationsManual/_static/documentation_options.js
+++ b/installer/resources/core/RTGOperationsManual/_static/documentation_options.js
@@ -1,10 +1,12 @@
 var DOCUMENTATION_OPTIONS = {
     URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
-    VERSION: '3.11',
+    VERSION: '3.12',
     LANGUAGE: 'None',
     COLLAPSE_INDEX: false,
+    BUILDER: 'html',
     FILE_SUFFIX: '.html',
+    LINK_SUFFIX: '.html',
     HAS_SOURCE: true,
     SOURCELINK_SUFFIX: '.txt',
-    NAVIGATION_WITH_KEYS: false,
+    NAVIGATION_WITH_KEYS: false
 };
\ No newline at end of file
diff --git a/installer/resources/core/RTGOperationsManual/_static/down-pressed.png b/installer/resources/core/RTGOperationsManual/_static/down-pressed.png
deleted file mode 100644
index 5756c8cad..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_static/down-pressed.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_static/down.png b/installer/resources/core/RTGOperationsManual/_static/down.png
deleted file mode 100644
index 1b3bdad2c..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_static/down.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_static/jquery-3.2.1.js b/installer/resources/core/RTGOperationsManual/_static/jquery-3.5.1.js
similarity index 81%
rename from installer/resources/core/RTGOperationsManual/_static/jquery-3.2.1.js
rename to installer/resources/core/RTGOperationsManual/_static/jquery-3.5.1.js
index d2d8ca479..50937333b 100644
--- a/installer/resources/core/RTGOperationsManual/_static/jquery-3.2.1.js
+++ b/installer/resources/core/RTGOperationsManual/_static/jquery-3.5.1.js
@@ -1,5 +1,5 @@
 /*!
- * jQuery JavaScript Library v3.2.1
+ * jQuery JavaScript Library v3.5.1
  * https://jquery.com/
  *
  * Includes Sizzle.js
@@ -9,7 +9,7 @@
  * Released under the MIT license
  * https://jquery.org/license
  *
- * Date: 2017-03-20T18:59Z
+ * Date: 2020-05-04T22:49Z
  */
 ( function( global, factory ) {
 
@@ -47,13 +47,16 @@
 
 var arr = [];
 
-var document = window.document;
-
 var getProto = Object.getPrototypeOf;
 
 var slice = arr.slice;
 
-var concat = arr.concat;
+var flat = arr.flat ? function( array ) {
+	return arr.flat.call( array );
+} : function( array ) {
+	return arr.concat.apply( [], array );
+};
+
 
 var push = arr.push;
 
@@ -71,16 +74,72 @@ var ObjectFunctionString = fnToString.call( Object );
 
 var support = {};
 
+var isFunction = function isFunction( obj ) {
+
+      // Support: Chrome <=57, Firefox <=52
+      // In some browsers, typeof returns "function" for HTML <object> elements
+      // (i.e., `typeof document.createElement( "object" ) === "function"`).
+      // We don't want to classify *any* DOM node as a function.
+      return typeof obj === "function" && typeof obj.nodeType !== "number";
+  };
+
+
+var isWindow = function isWindow( obj ) {
+		return obj != null && obj === obj.window;
+	};
+
+
+var document = window.document;
 
 
-	function DOMEval( code, doc ) {
+
+	var preservedScriptAttributes = {
+		type: true,
+		src: true,
+		nonce: true,
+		noModule: true
+	};
+
+	function DOMEval( code, node, doc ) {
 		doc = doc || document;
 
-		var script = doc.createElement( "script" );
+		var i, val,
+			script = doc.createElement( "script" );
 
 		script.text = code;
+		if ( node ) {
+			for ( i in preservedScriptAttributes ) {
+
+				// Support: Firefox 64+, Edge 18+
+				// Some browsers don't support the "nonce" property on scripts.
+				// On the other hand, just using `getAttribute` is not enough as
+				// the `nonce` attribute is reset to an empty string whenever it
+				// becomes browsing-context connected.
+				// See https://github.com/whatwg/html/issues/2369
+				// See https://html.spec.whatwg.org/#nonce-attributes
+				// The `node.getAttribute` check was added for the sake of
+				// `jQuery.globalEval` so that it can fake a nonce-containing node
+				// via an object.
+				val = node[ i ] || node.getAttribute && node.getAttribute( i );
+				if ( val ) {
+					script.setAttribute( i, val );
+				}
+			}
+		}
 		doc.head.appendChild( script ).parentNode.removeChild( script );
 	}
+
+
+function toType( obj ) {
+	if ( obj == null ) {
+		return obj + "";
+	}
+
+	// Support: Android <=2.3 only (functionish RegExp)
+	return typeof obj === "object" || typeof obj === "function" ?
+		class2type[ toString.call( obj ) ] || "object" :
+		typeof obj;
+}
 /* global Symbol */
 // Defining this global in .eslintrc.json would create a danger of using the global
 // unguarded in another place, it seems safer to define global only for this module
@@ -88,7 +147,7 @@ var support = {};
 
 
 var
-	version = "3.2.1",
+	version = "3.5.1",
 
 	// Define a local copy of jQuery
 	jQuery = function( selector, context ) {
@@ -96,19 +155,6 @@ var
 		// The jQuery object is actually just the init constructor 'enhanced'
 		// Need init if jQuery is called (just allow error to be thrown if not included)
 		return new jQuery.fn.init( selector, context );
-	},
-
-	// Support: Android <=4.0 only
-	// Make sure we trim BOM and NBSP
-	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
-
-	// Matches dashed string for camelizing
-	rmsPrefix = /^-ms-/,
-	rdashAlpha = /-([a-z])/g,
-
-	// Used by jQuery.camelCase as callback to replace()
-	fcamelCase = function( all, letter ) {
-		return letter.toUpperCase();
 	};
 
 jQuery.fn = jQuery.prototype = {
@@ -175,6 +221,18 @@ jQuery.fn = jQuery.prototype = {
 		return this.eq( -1 );
 	},
 
+	even: function() {
+		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
+			return ( i + 1 ) % 2;
+		} ) );
+	},
+
+	odd: function() {
+		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
+			return i % 2;
+		} ) );
+	},
+
 	eq: function( i ) {
 		var len = this.length,
 			j = +i + ( i < 0 ? len : 0 );
@@ -209,7 +267,7 @@ jQuery.extend = jQuery.fn.extend = function() {
 	}
 
 	// Handle case when target is a string or something (possible in deep copy)
-	if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
+	if ( typeof target !== "object" && !isFunction( target ) ) {
 		target = {};
 	}
 
@@ -226,25 +284,28 @@ jQuery.extend = jQuery.fn.extend = function() {
 
 			// Extend the base object
 			for ( name in options ) {
-				src = target[ name ];
 				copy = options[ name ];
 
+				// Prevent Object.prototype pollution
 				// Prevent never-ending loop
-				if ( target === copy ) {
+				if ( name === "__proto__" || target === copy ) {
 					continue;
 				}
 
 				// Recurse if we're merging plain objects or arrays
 				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
 					( copyIsArray = Array.isArray( copy ) ) ) ) {
+					src = target[ name ];
 
-					if ( copyIsArray ) {
-						copyIsArray = false;
-						clone = src && Array.isArray( src ) ? src : [];
-
+					// Ensure proper type for the source value
+					if ( copyIsArray && !Array.isArray( src ) ) {
+						clone = [];
+					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
+						clone = {};
 					} else {
-						clone = src && jQuery.isPlainObject( src ) ? src : {};
+						clone = src;
 					}
+					copyIsArray = false;
 
 					// Never move original objects, clone them
 					target[ name ] = jQuery.extend( deep, clone, copy );
@@ -275,28 +336,6 @@ jQuery.extend( {
 
 	noop: function() {},
 
-	isFunction: function( obj ) {
-		return jQuery.type( obj ) === "function";
-	},
-
-	isWindow: function( obj ) {
-		return obj != null && obj === obj.window;
-	},
-
-	isNumeric: function( obj ) {
-
-		// As of jQuery 3.0, isNumeric is limited to
-		// strings and numbers (primitives or objects)
-		// that can be coerced to finite numbers (gh-2662)
-		var type = jQuery.type( obj );
-		return ( type === "number" || type === "string" ) &&
-
-			// parseFloat NaNs numeric-cast false positives ("")
-			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
-			// subtraction forces infinities to NaN
-			!isNaN( obj - parseFloat( obj ) );
-	},
-
 	isPlainObject: function( obj ) {
 		var proto, Ctor;
 
@@ -319,9 +358,6 @@ jQuery.extend( {
 	},
 
 	isEmptyObject: function( obj ) {
-
-		/* eslint-disable no-unused-vars */
-		// See https://github.com/eslint/eslint/issues/6125
 		var name;
 
 		for ( name in obj ) {
@@ -330,27 +366,10 @@ jQuery.extend( {
 		return true;
 	},
 
-	type: function( obj ) {
-		if ( obj == null ) {
-			return obj + "";
-		}
-
-		// Support: Android <=2.3 only (functionish RegExp)
-		return typeof obj === "object" || typeof obj === "function" ?
-			class2type[ toString.call( obj ) ] || "object" :
-			typeof obj;
-	},
-
-	// Evaluates a script in a global context
-	globalEval: function( code ) {
-		DOMEval( code );
-	},
-
-	// Convert dashed to camelCase; used by the css and data modules
-	// Support: IE <=9 - 11, Edge 12 - 13
-	// Microsoft forgot to hump their vendor prefix (#9572)
-	camelCase: function( string ) {
-		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
+	// Evaluates a script in a provided context; falls back to the global one
+	// if not specified.
+	globalEval: function( code, options, doc ) {
+		DOMEval( code, { nonce: options && options.nonce }, doc );
 	},
 
 	each: function( obj, callback ) {
@@ -374,13 +393,6 @@ jQuery.extend( {
 		return obj;
 	},
 
-	// Support: Android <=4.0 only
-	trim: function( text ) {
-		return text == null ?
-			"" :
-			( text + "" ).replace( rtrim, "" );
-	},
-
 	// results is for internal usage only
 	makeArray: function( arr, results ) {
 		var ret = results || [];
@@ -467,43 +479,12 @@ jQuery.extend( {
 		}
 
 		// Flatten any nested arrays
-		return concat.apply( [], ret );
+		return flat( ret );
 	},
 
 	// A global GUID counter for objects
 	guid: 1,
 
-	// Bind a function to a context, optionally partially applying any
-	// arguments.
-	proxy: function( fn, context ) {
-		var tmp, args, proxy;
-
-		if ( typeof context === "string" ) {
-			tmp = fn[ context ];
-			context = fn;
-			fn = tmp;
-		}
-
-		// Quick check to determine if target is callable, in the spec
-		// this throws a TypeError, but we will just return undefined.
-		if ( !jQuery.isFunction( fn ) ) {
-			return undefined;
-		}
-
-		// Simulated bind
-		args = slice.call( arguments, 2 );
-		proxy = function() {
-			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
-		};
-
-		// Set the guid of unique handler to the same of original handler, so it can be removed
-		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
-
-		return proxy;
-	},
-
-	now: Date.now,
-
 	// jQuery.support is not used in Core but other projects attach their
 	// properties to it so it needs to exist.
 	support: support
@@ -515,7 +496,7 @@ if ( typeof Symbol === "function" ) {
 
 // Populate the class2type map
 jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
-function( i, name ) {
+function( _i, name ) {
 	class2type[ "[object " + name + "]" ] = name.toLowerCase();
 } );
 
@@ -526,9 +507,9 @@ function isArrayLike( obj ) {
 	// hasOwn isn't used here due to false negatives
 	// regarding Nodelist length in IE
 	var length = !!obj && "length" in obj && obj.length,
-		type = jQuery.type( obj );
+		type = toType( obj );
 
-	if ( type === "function" || jQuery.isWindow( obj ) ) {
+	if ( isFunction( obj ) || isWindow( obj ) ) {
 		return false;
 	}
 
@@ -537,17 +518,16 @@ function isArrayLike( obj ) {
 }
 var Sizzle =
 /*!
- * Sizzle CSS Selector Engine v2.3.3
+ * Sizzle CSS Selector Engine v2.3.5
  * https://sizzlejs.com/
  *
- * Copyright jQuery Foundation and other contributors
+ * Copyright JS Foundation and other contributors
  * Released under the MIT license
- * http://jquery.org/license
+ * https://js.foundation/
  *
- * Date: 2016-08-08
+ * Date: 2020-03-14
  */
-(function( window ) {
-
+( function( window ) {
 var i,
 	support,
 	Expr,
@@ -578,6 +558,7 @@ var i,
 	classCache = createCache(),
 	tokenCache = createCache(),
 	compilerCache = createCache(),
+	nonnativeSelectorCache = createCache(),
 	sortOrder = function( a, b ) {
 		if ( a === b ) {
 			hasDuplicate = true;
@@ -586,61 +567,71 @@ var i,
 	},
 
 	// Instance methods
-	hasOwn = ({}).hasOwnProperty,
+	hasOwn = ( {} ).hasOwnProperty,
 	arr = [],
 	pop = arr.pop,
-	push_native = arr.push,
+	pushNative = arr.push,
 	push = arr.push,
 	slice = arr.slice,
+
 	// Use a stripped-down indexOf as it's faster than native
 	// https://jsperf.com/thor-indexof-vs-for/5
 	indexOf = function( list, elem ) {
 		var i = 0,
 			len = list.length;
 		for ( ; i < len; i++ ) {
-			if ( list[i] === elem ) {
+			if ( list[ i ] === elem ) {
 				return i;
 			}
 		}
 		return -1;
 	},
 
-	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
+	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
+		"ismap|loop|multiple|open|readonly|required|scoped",
 
 	// Regular expressions
 
 	// http://www.w3.org/TR/css3-selectors/#whitespace
 	whitespace = "[\\x20\\t\\r\\n\\f]",
 
-	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
-	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
+	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
+	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
+		"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
 
 	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
 	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
+
 		// Operator (capture 2)
 		"*([*^$|!~]?=)" + whitespace +
-		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
-		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
-		"*\\]",
+
+		// "Attribute values must be CSS identifiers [capture 5]
+		// or strings [capture 3 or capture 4]"
+		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
+		whitespace + "*\\]",
 
 	pseudos = ":(" + identifier + ")(?:\\((" +
+
 		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
 		// 1. quoted (capture 3; capture 4 or capture 5)
 		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
+
 		// 2. simple (capture 6)
 		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
+
 		// 3. anything else (capture 2)
 		".*" +
 		")\\)|)",
 
 	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
 	rwhitespace = new RegExp( whitespace + "+", "g" ),
-	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
+	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
+		whitespace + "+$", "g" ),
 
 	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
-	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
-
-	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
+	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
+		"*" ),
+	rdescend = new RegExp( whitespace + "|>" ),
 
 	rpseudo = new RegExp( pseudos ),
 	ridentifier = new RegExp( "^" + identifier + "$" ),
@@ -651,16 +642,19 @@ var i,
 		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
 		"ATTR": new RegExp( "^" + attributes ),
 		"PSEUDO": new RegExp( "^" + pseudos ),
-		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
-			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
-			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
+		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
+			whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
+			whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
 		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
+
 		// For use in libraries implementing .is()
 		// We use this for POS matching in `select`
-		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
-			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
+		"needsContext": new RegExp( "^" + whitespace +
+			"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
+			"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
 	},
 
+	rhtml = /HTML$/i,
 	rinputs = /^(?:input|select|textarea|button)$/i,
 	rheader = /^h\d$/i,
 
@@ -673,18 +667,21 @@ var i,
 
 	// CSS escapes
 	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
-	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
-	funescape = function( _, escaped, escapedWhitespace ) {
-		var high = "0x" + escaped - 0x10000;
-		// NaN means non-codepoint
-		// Support: Firefox<24
-		// Workaround erroneous numeric interpretation of +"0x"
-		return high !== high || escapedWhitespace ?
-			escaped :
+	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
+	funescape = function( escape, nonHex ) {
+		var high = "0x" + escape.slice( 1 ) - 0x10000;
+
+		return nonHex ?
+
+			// Strip the backslash prefix from a non-hex escape sequence
+			nonHex :
+
+			// Replace a hexadecimal escape sequence with the encoded Unicode code point
+			// Support: IE <=11+
+			// For values outside the Basic Multilingual Plane (BMP), manually construct a
+			// surrogate pair
 			high < 0 ?
-				// BMP codepoint
 				String.fromCharCode( high + 0x10000 ) :
-				// Supplemental Plane codepoint (surrogate pair)
 				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
 	},
 
@@ -700,7 +697,8 @@ var i,
 			}
 
 			// Control characters and (dependent upon position) numbers get escaped as code points
-			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
+			return ch.slice( 0, -1 ) + "\\" +
+				ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
 		}
 
 		// Other potentially-special ASCII characters get backslash-escaped
@@ -715,9 +713,9 @@ var i,
 		setDocument();
 	},
 
-	disabledAncestor = addCombinator(
+	inDisabledFieldset = addCombinator(
 		function( elem ) {
-			return elem.disabled === true && ("form" in elem || "label" in elem);
+			return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
 		},
 		{ dir: "parentNode", next: "legend" }
 	);
@@ -725,18 +723,20 @@ var i,
 // Optimize for push.apply( _, NodeList )
 try {
 	push.apply(
-		(arr = slice.call( preferredDoc.childNodes )),
+		( arr = slice.call( preferredDoc.childNodes ) ),
 		preferredDoc.childNodes
 	);
+
 	// Support: Android<4.0
 	// Detect silently failing push.apply
+	// eslint-disable-next-line no-unused-expressions
 	arr[ preferredDoc.childNodes.length ].nodeType;
 } catch ( e ) {
 	push = { apply: arr.length ?
 
 		// Leverage slice if possible
 		function( target, els ) {
-			push_native.apply( target, slice.call(els) );
+			pushNative.apply( target, slice.call( els ) );
 		} :
 
 		// Support: IE<9
@@ -744,8 +744,9 @@ try {
 		function( target, els ) {
 			var j = target.length,
 				i = 0;
+
 			// Can't trust NodeList.length
-			while ( (target[j++] = els[i++]) ) {}
+			while ( ( target[ j++ ] = els[ i++ ] ) ) {}
 			target.length = j - 1;
 		}
 	};
@@ -769,24 +770,21 @@ function Sizzle( selector, context, results, seed ) {
 
 	// Try to shortcut find operations (as opposed to filters) in HTML documents
 	if ( !seed ) {
-
-		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
-			setDocument( context );
-		}
+		setDocument( context );
 		context = context || document;
 
 		if ( documentIsHTML ) {
 
 			// If the selector is sufficiently simple, try using a "get*By*" DOM method
 			// (excepting DocumentFragment context, where the methods don't exist)
-			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
+			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
 
 				// ID selector
-				if ( (m = match[1]) ) {
+				if ( ( m = match[ 1 ] ) ) {
 
 					// Document context
 					if ( nodeType === 9 ) {
-						if ( (elem = context.getElementById( m )) ) {
+						if ( ( elem = context.getElementById( m ) ) ) {
 
 							// Support: IE, Opera, Webkit
 							// TODO: identify versions
@@ -805,7 +803,7 @@ function Sizzle( selector, context, results, seed ) {
 						// Support: IE, Opera, Webkit
 						// TODO: identify versions
 						// getElementById can match elements by name instead of ID
-						if ( newContext && (elem = newContext.getElementById( m )) &&
+						if ( newContext && ( elem = newContext.getElementById( m ) ) &&
 							contains( context, elem ) &&
 							elem.id === m ) {
 
@@ -815,12 +813,12 @@ function Sizzle( selector, context, results, seed ) {
 					}
 
 				// Type selector
-				} else if ( match[2] ) {
+				} else if ( match[ 2 ] ) {
 					push.apply( results, context.getElementsByTagName( selector ) );
 					return results;
 
 				// Class selector
-				} else if ( (m = match[3]) && support.getElementsByClassName &&
+				} else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
 					context.getElementsByClassName ) {
 
 					push.apply( results, context.getElementsByClassName( m ) );
@@ -830,50 +828,62 @@ function Sizzle( selector, context, results, seed ) {
 
 			// Take advantage of querySelectorAll
 			if ( support.qsa &&
-				!compilerCache[ selector + " " ] &&
-				(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
-
-				if ( nodeType !== 1 ) {
-					newContext = context;
-					newSelector = selector;
+				!nonnativeSelectorCache[ selector + " " ] &&
+				( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
 
-				// qSA looks outside Element context, which is not what we want
-				// Thanks to Andrew Dupont for this workaround technique
-				// Support: IE <=8
+				// Support: IE 8 only
 				// Exclude object elements
-				} else if ( context.nodeName.toLowerCase() !== "object" ) {
+				( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
 
-					// Capture the context ID, setting it first if necessary
-					if ( (nid = context.getAttribute( "id" )) ) {
-						nid = nid.replace( rcssescape, fcssescape );
-					} else {
-						context.setAttribute( "id", (nid = expando) );
+				newSelector = selector;
+				newContext = context;
+
+				// qSA considers elements outside a scoping root when evaluating child or
+				// descendant combinators, which is not what we want.
+				// In such cases, we work around the behavior by prefixing every selector in the
+				// list with an ID selector referencing the scope context.
+				// The technique has to be used as well when a leading combinator is used
+				// as such selectors are not recognized by querySelectorAll.
+				// Thanks to Andrew Dupont for this technique.
+				if ( nodeType === 1 &&
+					( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
+
+					// Expand context for sibling selectors
+					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
+						context;
+
+					// We can use :scope instead of the ID hack if the browser
+					// supports it & if we're not changing the context.
+					if ( newContext !== context || !support.scope ) {
+
+						// Capture the context ID, setting it first if necessary
+						if ( ( nid = context.getAttribute( "id" ) ) ) {
+							nid = nid.replace( rcssescape, fcssescape );
+						} else {
+							context.setAttribute( "id", ( nid = expando ) );
+						}
 					}
 
 					// Prefix every selector in the list
 					groups = tokenize( selector );
 					i = groups.length;
 					while ( i-- ) {
-						groups[i] = "#" + nid + " " + toSelector( groups[i] );
+						groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
+							toSelector( groups[ i ] );
 					}
 					newSelector = groups.join( "," );
-
-					// Expand context for sibling selectors
-					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
-						context;
 				}
 
-				if ( newSelector ) {
-					try {
-						push.apply( results,
-							newContext.querySelectorAll( newSelector )
-						);
-						return results;
-					} catch ( qsaError ) {
-					} finally {
-						if ( nid === expando ) {
-							context.removeAttribute( "id" );
-						}
+				try {
+					push.apply( results,
+						newContext.querySelectorAll( newSelector )
+					);
+					return results;
+				} catch ( qsaError ) {
+					nonnativeSelectorCache( selector, true );
+				} finally {
+					if ( nid === expando ) {
+						context.removeAttribute( "id" );
 					}
 				}
 			}
@@ -894,12 +904,14 @@ function createCache() {
 	var keys = [];
 
 	function cache( key, value ) {
+
 		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
 		if ( keys.push( key + " " ) > Expr.cacheLength ) {
+
 			// Only keep the most recent entries
 			delete cache[ keys.shift() ];
 		}
-		return (cache[ key + " " ] = value);
+		return ( cache[ key + " " ] = value );
 	}
 	return cache;
 }
@@ -918,17 +930,19 @@ function markFunction( fn ) {
  * @param {Function} fn Passed the created element and returns a boolean result
  */
 function assert( fn ) {
-	var el = document.createElement("fieldset");
+	var el = document.createElement( "fieldset" );
 
 	try {
 		return !!fn( el );
-	} catch (e) {
+	} catch ( e ) {
 		return false;
 	} finally {
+
 		// Remove from its parent by default
 		if ( el.parentNode ) {
 			el.parentNode.removeChild( el );
 		}
+
 		// release memory in IE
 		el = null;
 	}
@@ -940,11 +954,11 @@ function assert( fn ) {
  * @param {Function} handler The method that will be applied
  */
 function addHandle( attrs, handler ) {
-	var arr = attrs.split("|"),
+	var arr = attrs.split( "|" ),
 		i = arr.length;
 
 	while ( i-- ) {
-		Expr.attrHandle[ arr[i] ] = handler;
+		Expr.attrHandle[ arr[ i ] ] = handler;
 	}
 }
 
@@ -966,7 +980,7 @@ function siblingCheck( a, b ) {
 
 	// Check if b follows a
 	if ( cur ) {
-		while ( (cur = cur.nextSibling) ) {
+		while ( ( cur = cur.nextSibling ) ) {
 			if ( cur === b ) {
 				return -1;
 			}
@@ -994,7 +1008,7 @@ function createInputPseudo( type ) {
 function createButtonPseudo( type ) {
 	return function( elem ) {
 		var name = elem.nodeName.toLowerCase();
-		return (name === "input" || name === "button") && elem.type === type;
+		return ( name === "input" || name === "button" ) && elem.type === type;
 	};
 }
 
@@ -1037,7 +1051,7 @@ function createDisabledPseudo( disabled ) {
 					// Where there is no isDisabled, check manually
 					/* jshint -W018 */
 					elem.isDisabled !== !disabled &&
-						disabledAncestor( elem ) === disabled;
+					inDisabledFieldset( elem ) === disabled;
 			}
 
 			return elem.disabled === disabled;
@@ -1059,21 +1073,21 @@ function createDisabledPseudo( disabled ) {
  * @param {Function} fn
  */
 function createPositionalPseudo( fn ) {
-	return markFunction(function( argument ) {
+	return markFunction( function( argument ) {
 		argument = +argument;
-		return markFunction(function( seed, matches ) {
+		return markFunction( function( seed, matches ) {
 			var j,
 				matchIndexes = fn( [], seed.length, argument ),
 				i = matchIndexes.length;
 
 			// Match elements found at the specified indexes
 			while ( i-- ) {
-				if ( seed[ (j = matchIndexes[i]) ] ) {
-					seed[j] = !(matches[j] = seed[j]);
+				if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
+					seed[ j ] = !( matches[ j ] = seed[ j ] );
 				}
 			}
-		});
-	});
+		} );
+	} );
 }
 
 /**
@@ -1094,10 +1108,13 @@ support = Sizzle.support = {};
  * @returns {Boolean} True iff elem is a non-HTML XML node
  */
 isXML = Sizzle.isXML = function( elem ) {
-	// documentElement is verified for cases where it doesn't yet exist
-	// (such as loading iframes in IE - #4833)
-	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
-	return documentElement ? documentElement.nodeName !== "HTML" : false;
+	var namespace = elem.namespaceURI,
+		docElem = ( elem.ownerDocument || elem ).documentElement;
+
+	// Support: IE <=8
+	// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
+	// https://bugs.jquery.com/ticket/4833
+	return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
 };
 
 /**
@@ -1110,7 +1127,11 @@ setDocument = Sizzle.setDocument = function( node ) {
 		doc = node ? node.ownerDocument || node : preferredDoc;
 
 	// Return early if doc is invalid or already selected
-	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
+	// Support: IE 11+, Edge 17 - 18+
+	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+	// two documents; shallow comparisons work.
+	// eslint-disable-next-line eqeqeq
+	if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
 		return document;
 	}
 
@@ -1119,10 +1140,14 @@ setDocument = Sizzle.setDocument = function( node ) {
 	docElem = document.documentElement;
 	documentIsHTML = !isXML( document );
 
-	// Support: IE 9-11, Edge
+	// Support: IE 9 - 11+, Edge 12 - 18+
 	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
-	if ( preferredDoc !== document &&
-		(subWindow = document.defaultView) && subWindow.top !== subWindow ) {
+	// Support: IE 11+, Edge 17 - 18+
+	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+	// two documents; shallow comparisons work.
+	// eslint-disable-next-line eqeqeq
+	if ( preferredDoc != document &&
+		( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
 
 		// Support: IE 11, Edge
 		if ( subWindow.addEventListener ) {
@@ -1134,25 +1159,36 @@ setDocument = Sizzle.setDocument = function( node ) {
 		}
 	}
 
+	// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
+	// Safari 4 - 5 only, Opera <=11.6 - 12.x only
+	// IE/Edge & older browsers don't support the :scope pseudo-class.
+	// Support: Safari 6.0 only
+	// Safari 6.0 supports :scope but it's an alias of :root there.
+	support.scope = assert( function( el ) {
+		docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
+		return typeof el.querySelectorAll !== "undefined" &&
+			!el.querySelectorAll( ":scope fieldset div" ).length;
+	} );
+
 	/* Attributes
 	---------------------------------------------------------------------- */
 
 	// Support: IE<8
 	// Verify that getAttribute really returns attributes and not properties
 	// (excepting IE8 booleans)
-	support.attributes = assert(function( el ) {
+	support.attributes = assert( function( el ) {
 		el.className = "i";
-		return !el.getAttribute("className");
-	});
+		return !el.getAttribute( "className" );
+	} );
 
 	/* getElement(s)By*
 	---------------------------------------------------------------------- */
 
 	// Check if getElementsByTagName("*") returns only elements
-	support.getElementsByTagName = assert(function( el ) {
-		el.appendChild( document.createComment("") );
-		return !el.getElementsByTagName("*").length;
-	});
+	support.getElementsByTagName = assert( function( el ) {
+		el.appendChild( document.createComment( "" ) );
+		return !el.getElementsByTagName( "*" ).length;
+	} );
 
 	// Support: IE<9
 	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
@@ -1161,38 +1197,38 @@ setDocument = Sizzle.setDocument = function( node ) {
 	// Check if getElementById returns elements by name
 	// The broken getElementById methods don't pick up programmatically-set names,
 	// so use a roundabout getElementsByName test
-	support.getById = assert(function( el ) {
+	support.getById = assert( function( el ) {
 		docElem.appendChild( el ).id = expando;
 		return !document.getElementsByName || !document.getElementsByName( expando ).length;
-	});
+	} );
 
 	// ID filter and find
 	if ( support.getById ) {
-		Expr.filter["ID"] = function( id ) {
+		Expr.filter[ "ID" ] = function( id ) {
 			var attrId = id.replace( runescape, funescape );
 			return function( elem ) {
-				return elem.getAttribute("id") === attrId;
+				return elem.getAttribute( "id" ) === attrId;
 			};
 		};
-		Expr.find["ID"] = function( id, context ) {
+		Expr.find[ "ID" ] = function( id, context ) {
 			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
 				var elem = context.getElementById( id );
 				return elem ? [ elem ] : [];
 			}
 		};
 	} else {
-		Expr.filter["ID"] =  function( id ) {
+		Expr.filter[ "ID" ] =  function( id ) {
 			var attrId = id.replace( runescape, funescape );
 			return function( elem ) {
 				var node = typeof elem.getAttributeNode !== "undefined" &&
-					elem.getAttributeNode("id");
+					elem.getAttributeNode( "id" );
 				return node && node.value === attrId;
 			};
 		};
 
 		// Support: IE 6 - 7 only
 		// getElementById is not reliable as a find shortcut
-		Expr.find["ID"] = function( id, context ) {
+		Expr.find[ "ID" ] = function( id, context ) {
 			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
 				var node, i, elems,
 					elem = context.getElementById( id );
@@ -1200,7 +1236,7 @@ setDocument = Sizzle.setDocument = function( node ) {
 				if ( elem ) {
 
 					// Verify the id attribute
-					node = elem.getAttributeNode("id");
+					node = elem.getAttributeNode( "id" );
 					if ( node && node.value === id ) {
 						return [ elem ];
 					}
@@ -1208,8 +1244,8 @@ setDocument = Sizzle.setDocument = function( node ) {
 					// Fall back on getElementsByName
 					elems = context.getElementsByName( id );
 					i = 0;
-					while ( (elem = elems[i++]) ) {
-						node = elem.getAttributeNode("id");
+					while ( ( elem = elems[ i++ ] ) ) {
+						node = elem.getAttributeNode( "id" );
 						if ( node && node.value === id ) {
 							return [ elem ];
 						}
@@ -1222,7 +1258,7 @@ setDocument = Sizzle.setDocument = function( node ) {
 	}
 
 	// Tag
-	Expr.find["TAG"] = support.getElementsByTagName ?
+	Expr.find[ "TAG" ] = support.getElementsByTagName ?
 		function( tag, context ) {
 			if ( typeof context.getElementsByTagName !== "undefined" ) {
 				return context.getElementsByTagName( tag );
@@ -1237,12 +1273,13 @@ setDocument = Sizzle.setDocument = function( node ) {
 			var elem,
 				tmp = [],
 				i = 0,
+
 				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
 				results = context.getElementsByTagName( tag );
 
 			// Filter out possible comments
 			if ( tag === "*" ) {
-				while ( (elem = results[i++]) ) {
+				while ( ( elem = results[ i++ ] ) ) {
 					if ( elem.nodeType === 1 ) {
 						tmp.push( elem );
 					}
@@ -1254,7 +1291,7 @@ setDocument = Sizzle.setDocument = function( node ) {
 		};
 
 	// Class
-	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
+	Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
 		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
 			return context.getElementsByClassName( className );
 		}
@@ -1275,10 +1312,14 @@ setDocument = Sizzle.setDocument = function( node ) {
 	// See https://bugs.jquery.com/ticket/13378
 	rbuggyQSA = [];
 
-	if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
+	if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
+
 		// Build QSA regex
 		// Regex strategy adopted from Diego Perini
-		assert(function( el ) {
+		assert( function( el ) {
+
+			var input;
+
 			// Select is set to empty string on purpose
 			// This is to test IE's treatment of not explicitly
 			// setting a boolean content attribute,
@@ -1292,78 +1333,98 @@ setDocument = Sizzle.setDocument = function( node ) {
 			// Nothing should be selected when empty strings follow ^= or $= or *=
 			// The test attribute must be unknown in Opera but "safe" for WinRT
 			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
-			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
+			if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
 				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
 			}
 
 			// Support: IE8
 			// Boolean attributes and "value" are not treated correctly
-			if ( !el.querySelectorAll("[selected]").length ) {
+			if ( !el.querySelectorAll( "[selected]" ).length ) {
 				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
 			}
 
 			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
 			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
-				rbuggyQSA.push("~=");
+				rbuggyQSA.push( "~=" );
+			}
+
+			// Support: IE 11+, Edge 15 - 18+
+			// IE 11/Edge don't find elements on a `[name='']` query in some cases.
+			// Adding a temporary attribute to the document before the selection works
+			// around the issue.
+			// Interestingly, IE 10 & older don't seem to have the issue.
+			input = document.createElement( "input" );
+			input.setAttribute( "name", "" );
+			el.appendChild( input );
+			if ( !el.querySelectorAll( "[name='']" ).length ) {
+				rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
+					whitespace + "*(?:''|\"\")" );
 			}
 
 			// Webkit/Opera - :checked should return selected option elements
 			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
 			// IE8 throws error here and will not see later tests
-			if ( !el.querySelectorAll(":checked").length ) {
-				rbuggyQSA.push(":checked");
+			if ( !el.querySelectorAll( ":checked" ).length ) {
+				rbuggyQSA.push( ":checked" );
 			}
 
 			// Support: Safari 8+, iOS 8+
 			// https://bugs.webkit.org/show_bug.cgi?id=136851
 			// In-page `selector#id sibling-combinator selector` fails
 			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
-				rbuggyQSA.push(".#.+[+~]");
+				rbuggyQSA.push( ".#.+[+~]" );
 			}
-		});
 
-		assert(function( el ) {
+			// Support: Firefox <=3.6 - 5 only
+			// Old Firefox doesn't throw on a badly-escaped identifier.
+			el.querySelectorAll( "\\\f" );
+			rbuggyQSA.push( "[\\r\\n\\f]" );
+		} );
+
+		assert( function( el ) {
 			el.innerHTML = "<a href='' disabled='disabled'></a>" +
 				"<select disabled='disabled'><option/></select>";
 
 			// Support: Windows 8 Native Apps
 			// The type and name attributes are restricted during .innerHTML assignment
-			var input = document.createElement("input");
+			var input = document.createElement( "input" );
 			input.setAttribute( "type", "hidden" );
 			el.appendChild( input ).setAttribute( "name", "D" );
 
 			// Support: IE8
 			// Enforce case-sensitivity of name attribute
-			if ( el.querySelectorAll("[name=d]").length ) {
+			if ( el.querySelectorAll( "[name=d]" ).length ) {
 				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
 			}
 
 			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
 			// IE8 throws error here and will not see later tests
-			if ( el.querySelectorAll(":enabled").length !== 2 ) {
+			if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
 				rbuggyQSA.push( ":enabled", ":disabled" );
 			}
 
 			// Support: IE9-11+
 			// IE's :disabled selector does not pick up the children of disabled fieldsets
 			docElem.appendChild( el ).disabled = true;
-			if ( el.querySelectorAll(":disabled").length !== 2 ) {
+			if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
 				rbuggyQSA.push( ":enabled", ":disabled" );
 			}
 
+			// Support: Opera 10 - 11 only
 			// Opera 10-11 does not throw on post-comma invalid pseudos
-			el.querySelectorAll("*,:x");
-			rbuggyQSA.push(",.*:");
-		});
+			el.querySelectorAll( "*,:x" );
+			rbuggyQSA.push( ",.*:" );
+		} );
 	}
 
-	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
+	if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
 		docElem.webkitMatchesSelector ||
 		docElem.mozMatchesSelector ||
 		docElem.oMatchesSelector ||
-		docElem.msMatchesSelector) )) ) {
+		docElem.msMatchesSelector ) ) ) ) {
+
+		assert( function( el ) {
 
-		assert(function( el ) {
 			// Check to see if it's possible to do matchesSelector
 			// on a disconnected node (IE 9)
 			support.disconnectedMatch = matches.call( el, "*" );
@@ -1372,11 +1433,11 @@ setDocument = Sizzle.setDocument = function( node ) {
 			// Gecko does not error, returns false instead
 			matches.call( el, "[s!='']:x" );
 			rbuggyMatches.push( "!=", pseudos );
-		});
+		} );
 	}
 
-	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
-	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
+	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
+	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
 
 	/* Contains
 	---------------------------------------------------------------------- */
@@ -1393,11 +1454,11 @@ setDocument = Sizzle.setDocument = function( node ) {
 				adown.contains ?
 					adown.contains( bup ) :
 					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
-			));
+			) );
 		} :
 		function( a, b ) {
 			if ( b ) {
-				while ( (b = b.parentNode) ) {
+				while ( ( b = b.parentNode ) ) {
 					if ( b === a ) {
 						return true;
 					}
@@ -1426,7 +1487,11 @@ setDocument = Sizzle.setDocument = function( node ) {
 		}
 
 		// Calculate position if both inputs belong to the same document
-		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
+		// Support: IE 11+, Edge 17 - 18+
+		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+		// two documents; shallow comparisons work.
+		// eslint-disable-next-line eqeqeq
+		compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
 			a.compareDocumentPosition( b ) :
 
 			// Otherwise we know they are disconnected
@@ -1434,13 +1499,24 @@ setDocument = Sizzle.setDocument = function( node ) {
 
 		// Disconnected nodes
 		if ( compare & 1 ||
-			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
+			( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
 
 			// Choose the first element that is related to our preferred document
-			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
+			// Support: IE 11+, Edge 17 - 18+
+			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+			// two documents; shallow comparisons work.
+			// eslint-disable-next-line eqeqeq
+			if ( a == document || a.ownerDocument == preferredDoc &&
+				contains( preferredDoc, a ) ) {
 				return -1;
 			}
-			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
+
+			// Support: IE 11+, Edge 17 - 18+
+			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+			// two documents; shallow comparisons work.
+			// eslint-disable-next-line eqeqeq
+			if ( b == document || b.ownerDocument == preferredDoc &&
+				contains( preferredDoc, b ) ) {
 				return 1;
 			}
 
@@ -1453,6 +1529,7 @@ setDocument = Sizzle.setDocument = function( node ) {
 		return compare & 4 ? -1 : 1;
 	} :
 	function( a, b ) {
+
 		// Exit early if the nodes are identical
 		if ( a === b ) {
 			hasDuplicate = true;
@@ -1468,8 +1545,14 @@ setDocument = Sizzle.setDocument = function( node ) {
 
 		// Parentless nodes are either documents or disconnected
 		if ( !aup || !bup ) {
-			return a === document ? -1 :
-				b === document ? 1 :
+
+			// Support: IE 11+, Edge 17 - 18+
+			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+			// two documents; shallow comparisons work.
+			/* eslint-disable eqeqeq */
+			return a == document ? -1 :
+				b == document ? 1 :
+				/* eslint-enable eqeqeq */
 				aup ? -1 :
 				bup ? 1 :
 				sortInput ?
@@ -1483,26 +1566,32 @@ setDocument = Sizzle.setDocument = function( node ) {
 
 		// Otherwise we need full lists of their ancestors for comparison
 		cur = a;
-		while ( (cur = cur.parentNode) ) {
+		while ( ( cur = cur.parentNode ) ) {
 			ap.unshift( cur );
 		}
 		cur = b;
-		while ( (cur = cur.parentNode) ) {
+		while ( ( cur = cur.parentNode ) ) {
 			bp.unshift( cur );
 		}
 
 		// Walk down the tree looking for a discrepancy
-		while ( ap[i] === bp[i] ) {
+		while ( ap[ i ] === bp[ i ] ) {
 			i++;
 		}
 
 		return i ?
+
 			// Do a sibling check if the nodes have a common ancestor
-			siblingCheck( ap[i], bp[i] ) :
+			siblingCheck( ap[ i ], bp[ i ] ) :
 
 			// Otherwise nodes in our document sort first
-			ap[i] === preferredDoc ? -1 :
-			bp[i] === preferredDoc ? 1 :
+			// Support: IE 11+, Edge 17 - 18+
+			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+			// two documents; shallow comparisons work.
+			/* eslint-disable eqeqeq */
+			ap[ i ] == preferredDoc ? -1 :
+			bp[ i ] == preferredDoc ? 1 :
+			/* eslint-enable eqeqeq */
 			0;
 	};
 
@@ -1514,16 +1603,10 @@ Sizzle.matches = function( expr, elements ) {
 };
 
 Sizzle.matchesSelector = function( elem, expr ) {
-	// Set document vars if needed
-	if ( ( elem.ownerDocument || elem ) !== document ) {
-		setDocument( elem );
-	}
-
-	// Make sure that attribute selectors are quoted
-	expr = expr.replace( rattributeQuotes, "='$1']" );
+	setDocument( elem );
 
 	if ( support.matchesSelector && documentIsHTML &&
-		!compilerCache[ expr + " " ] &&
+		!nonnativeSelectorCache[ expr + " " ] &&
 		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
 		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
 
@@ -1532,32 +1615,46 @@ Sizzle.matchesSelector = function( elem, expr ) {
 
 			// IE 9's matchesSelector returns false on disconnected nodes
 			if ( ret || support.disconnectedMatch ||
-					// As well, disconnected nodes are said to be in a document
-					// fragment in IE 9
-					elem.document && elem.document.nodeType !== 11 ) {
+
+				// As well, disconnected nodes are said to be in a document
+				// fragment in IE 9
+				elem.document && elem.document.nodeType !== 11 ) {
 				return ret;
 			}
-		} catch (e) {}
+		} catch ( e ) {
+			nonnativeSelectorCache( expr, true );
+		}
 	}
 
 	return Sizzle( expr, document, null, [ elem ] ).length > 0;
 };
 
 Sizzle.contains = function( context, elem ) {
+
 	// Set document vars if needed
-	if ( ( context.ownerDocument || context ) !== document ) {
+	// Support: IE 11+, Edge 17 - 18+
+	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+	// two documents; shallow comparisons work.
+	// eslint-disable-next-line eqeqeq
+	if ( ( context.ownerDocument || context ) != document ) {
 		setDocument( context );
 	}
 	return contains( context, elem );
 };
 
 Sizzle.attr = function( elem, name ) {
+
 	// Set document vars if needed
-	if ( ( elem.ownerDocument || elem ) !== document ) {
+	// Support: IE 11+, Edge 17 - 18+
+	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+	// two documents; shallow comparisons work.
+	// eslint-disable-next-line eqeqeq
+	if ( ( elem.ownerDocument || elem ) != document ) {
 		setDocument( elem );
 	}
 
 	var fn = Expr.attrHandle[ name.toLowerCase() ],
+
 		// Don't get fooled by Object.prototype properties (jQuery #13807)
 		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
 			fn( elem, name, !documentIsHTML ) :
@@ -1567,13 +1664,13 @@ Sizzle.attr = function( elem, name ) {
 		val :
 		support.attributes || !documentIsHTML ?
 			elem.getAttribute( name ) :
-			(val = elem.getAttributeNode(name)) && val.specified ?
+			( val = elem.getAttributeNode( name ) ) && val.specified ?
 				val.value :
 				null;
 };
 
 Sizzle.escape = function( sel ) {
-	return (sel + "").replace( rcssescape, fcssescape );
+	return ( sel + "" ).replace( rcssescape, fcssescape );
 };
 
 Sizzle.error = function( msg ) {
@@ -1596,7 +1693,7 @@ Sizzle.uniqueSort = function( results ) {
 	results.sort( sortOrder );
 
 	if ( hasDuplicate ) {
-		while ( (elem = results[i++]) ) {
+		while ( ( elem = results[ i++ ] ) ) {
 			if ( elem === results[ i ] ) {
 				j = duplicates.push( i );
 			}
@@ -1624,17 +1721,21 @@ getText = Sizzle.getText = function( elem ) {
 		nodeType = elem.nodeType;
 
 	if ( !nodeType ) {
+
 		// If no nodeType, this is expected to be an array
-		while ( (node = elem[i++]) ) {
+		while ( ( node = elem[ i++ ] ) ) {
+
 			// Do not traverse comment nodes
 			ret += getText( node );
 		}
 	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
+
 		// Use textContent for elements
 		// innerText usage removed for consistency of new lines (jQuery #11153)
 		if ( typeof elem.textContent === "string" ) {
 			return elem.textContent;
 		} else {
+
 			// Traverse its children
 			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
 				ret += getText( elem );
@@ -1643,6 +1744,7 @@ getText = Sizzle.getText = function( elem ) {
 	} else if ( nodeType === 3 || nodeType === 4 ) {
 		return elem.nodeValue;
 	}
+
 	// Do not include comment or processing instruction nodes
 
 	return ret;
@@ -1670,19 +1772,21 @@ Expr = Sizzle.selectors = {
 
 	preFilter: {
 		"ATTR": function( match ) {
-			match[1] = match[1].replace( runescape, funescape );
+			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
 
 			// Move the given value to match[3] whether quoted or unquoted
-			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
+			match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
+				match[ 5 ] || "" ).replace( runescape, funescape );
 
-			if ( match[2] === "~=" ) {
-				match[3] = " " + match[3] + " ";
+			if ( match[ 2 ] === "~=" ) {
+				match[ 3 ] = " " + match[ 3 ] + " ";
 			}
 
 			return match.slice( 0, 4 );
 		},
 
 		"CHILD": function( match ) {
+
 			/* matches from matchExpr["CHILD"]
 				1 type (only|nth|...)
 				2 what (child|of-type)
@@ -1693,22 +1797,25 @@ Expr = Sizzle.selectors = {
 				7 sign of y-component
 				8 y of y-component
 			*/
-			match[1] = match[1].toLowerCase();
+			match[ 1 ] = match[ 1 ].toLowerCase();
+
+			if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
 
-			if ( match[1].slice( 0, 3 ) === "nth" ) {
 				// nth-* requires argument
-				if ( !match[3] ) {
-					Sizzle.error( match[0] );
+				if ( !match[ 3 ] ) {
+					Sizzle.error( match[ 0 ] );
 				}
 
 				// numeric x and y parameters for Expr.filter.CHILD
 				// remember that false/true cast respectively to 0/1
-				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
-				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
+				match[ 4 ] = +( match[ 4 ] ?
+					match[ 5 ] + ( match[ 6 ] || 1 ) :
+					2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
+				match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
 
-			// other types prohibit arguments
-			} else if ( match[3] ) {
-				Sizzle.error( match[0] );
+				// other types prohibit arguments
+			} else if ( match[ 3 ] ) {
+				Sizzle.error( match[ 0 ] );
 			}
 
 			return match;
@@ -1716,26 +1823,28 @@ Expr = Sizzle.selectors = {
 
 		"PSEUDO": function( match ) {
 			var excess,
-				unquoted = !match[6] && match[2];
+				unquoted = !match[ 6 ] && match[ 2 ];
 
-			if ( matchExpr["CHILD"].test( match[0] ) ) {
+			if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
 				return null;
 			}
 
 			// Accept quoted arguments as-is
-			if ( match[3] ) {
-				match[2] = match[4] || match[5] || "";
+			if ( match[ 3 ] ) {
+				match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
 
 			// Strip excess characters from unquoted arguments
 			} else if ( unquoted && rpseudo.test( unquoted ) &&
+
 				// Get excess from tokenize (recursively)
-				(excess = tokenize( unquoted, true )) &&
+				( excess = tokenize( unquoted, true ) ) &&
+
 				// advance to the next closing parenthesis
-				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
+				( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
 
 				// excess is a negative index
-				match[0] = match[0].slice( 0, excess );
-				match[2] = unquoted.slice( 0, excess );
+				match[ 0 ] = match[ 0 ].slice( 0, excess );
+				match[ 2 ] = unquoted.slice( 0, excess );
 			}
 
 			// Return only captures needed by the pseudo filter method (type and argument)
@@ -1748,7 +1857,9 @@ Expr = Sizzle.selectors = {
 		"TAG": function( nodeNameSelector ) {
 			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
 			return nodeNameSelector === "*" ?
-				function() { return true; } :
+				function() {
+					return true;
+				} :
 				function( elem ) {
 					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
 				};
@@ -1758,10 +1869,16 @@ Expr = Sizzle.selectors = {
 			var pattern = classCache[ className + " " ];
 
 			return pattern ||
-				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
-				classCache( className, function( elem ) {
-					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
-				});
+				( pattern = new RegExp( "(^|" + whitespace +
+					")" + className + "(" + whitespace + "|$)" ) ) && classCache(
+						className, function( elem ) {
+							return pattern.test(
+								typeof elem.className === "string" && elem.className ||
+								typeof elem.getAttribute !== "undefined" &&
+									elem.getAttribute( "class" ) ||
+								""
+							);
+				} );
 		},
 
 		"ATTR": function( name, operator, check ) {
@@ -1777,6 +1894,8 @@ Expr = Sizzle.selectors = {
 
 				result += "";
 
+				/* eslint-disable max-len */
+
 				return operator === "=" ? result === check :
 					operator === "!=" ? result !== check :
 					operator === "^=" ? check && result.indexOf( check ) === 0 :
@@ -1785,10 +1904,12 @@ Expr = Sizzle.selectors = {
 					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
 					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
 					false;
+				/* eslint-enable max-len */
+
 			};
 		},
 
-		"CHILD": function( type, what, argument, first, last ) {
+		"CHILD": function( type, what, _argument, first, last ) {
 			var simple = type.slice( 0, 3 ) !== "nth",
 				forward = type.slice( -4 ) !== "last",
 				ofType = what === "of-type";
@@ -1800,7 +1921,7 @@ Expr = Sizzle.selectors = {
 					return !!elem.parentNode;
 				} :
 
-				function( elem, context, xml ) {
+				function( elem, _context, xml ) {
 					var cache, uniqueCache, outerCache, node, nodeIndex, start,
 						dir = simple !== forward ? "nextSibling" : "previousSibling",
 						parent = elem.parentNode,
@@ -1814,7 +1935,7 @@ Expr = Sizzle.selectors = {
 						if ( simple ) {
 							while ( dir ) {
 								node = elem;
-								while ( (node = node[ dir ]) ) {
+								while ( ( node = node[ dir ] ) ) {
 									if ( ofType ?
 										node.nodeName.toLowerCase() === name :
 										node.nodeType === 1 ) {
@@ -1822,6 +1943,7 @@ Expr = Sizzle.selectors = {
 										return false;
 									}
 								}
+
 								// Reverse direction for :only-* (if we haven't yet done so)
 								start = dir = type === "only" && !start && "nextSibling";
 							}
@@ -1837,22 +1959,22 @@ Expr = Sizzle.selectors = {
 
 							// ...in a gzip-friendly way
 							node = parent;
-							outerCache = node[ expando ] || (node[ expando ] = {});
+							outerCache = node[ expando ] || ( node[ expando ] = {} );
 
 							// Support: IE <9 only
 							// Defend against cloned attroperties (jQuery gh-1709)
 							uniqueCache = outerCache[ node.uniqueID ] ||
-								(outerCache[ node.uniqueID ] = {});
+								( outerCache[ node.uniqueID ] = {} );
 
 							cache = uniqueCache[ type ] || [];
 							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
 							diff = nodeIndex && cache[ 2 ];
 							node = nodeIndex && parent.childNodes[ nodeIndex ];
 
-							while ( (node = ++nodeIndex && node && node[ dir ] ||
+							while ( ( node = ++nodeIndex && node && node[ dir ] ||
 
 								// Fallback to seeking `elem` from the start
-								(diff = nodeIndex = 0) || start.pop()) ) {
+								( diff = nodeIndex = 0 ) || start.pop() ) ) {
 
 								// When found, cache indexes on `parent` and break
 								if ( node.nodeType === 1 && ++diff && node === elem ) {
@@ -1862,16 +1984,18 @@ Expr = Sizzle.selectors = {
 							}
 
 						} else {
+
 							// Use previously-cached element index if available
 							if ( useCache ) {
+
 								// ...in a gzip-friendly way
 								node = elem;
-								outerCache = node[ expando ] || (node[ expando ] = {});
+								outerCache = node[ expando ] || ( node[ expando ] = {} );
 
 								// Support: IE <9 only
 								// Defend against cloned attroperties (jQuery gh-1709)
 								uniqueCache = outerCache[ node.uniqueID ] ||
-									(outerCache[ node.uniqueID ] = {});
+									( outerCache[ node.uniqueID ] = {} );
 
 								cache = uniqueCache[ type ] || [];
 								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
@@ -1881,9 +2005,10 @@ Expr = Sizzle.selectors = {
 							// xml :nth-child(...)
 							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
 							if ( diff === false ) {
+
 								// Use the same loop as above to seek `elem` from the start
-								while ( (node = ++nodeIndex && node && node[ dir ] ||
-									(diff = nodeIndex = 0) || start.pop()) ) {
+								while ( ( node = ++nodeIndex && node && node[ dir ] ||
+									( diff = nodeIndex = 0 ) || start.pop() ) ) {
 
 									if ( ( ofType ?
 										node.nodeName.toLowerCase() === name :
@@ -1892,12 +2017,13 @@ Expr = Sizzle.selectors = {
 
 										// Cache the index of each encountered element
 										if ( useCache ) {
-											outerCache = node[ expando ] || (node[ expando ] = {});
+											outerCache = node[ expando ] ||
+												( node[ expando ] = {} );
 
 											// Support: IE <9 only
 											// Defend against cloned attroperties (jQuery gh-1709)
 											uniqueCache = outerCache[ node.uniqueID ] ||
-												(outerCache[ node.uniqueID ] = {});
+												( outerCache[ node.uniqueID ] = {} );
 
 											uniqueCache[ type ] = [ dirruns, diff ];
 										}
@@ -1918,6 +2044,7 @@ Expr = Sizzle.selectors = {
 		},
 
 		"PSEUDO": function( pseudo, argument ) {
+
 			// pseudo-class names are case-insensitive
 			// http://www.w3.org/TR/selectors/#pseudo-classes
 			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
@@ -1937,15 +2064,15 @@ Expr = Sizzle.selectors = {
 			if ( fn.length > 1 ) {
 				args = [ pseudo, pseudo, "", argument ];
 				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
-					markFunction(function( seed, matches ) {
+					markFunction( function( seed, matches ) {
 						var idx,
 							matched = fn( seed, argument ),
 							i = matched.length;
 						while ( i-- ) {
-							idx = indexOf( seed, matched[i] );
-							seed[ idx ] = !( matches[ idx ] = matched[i] );
+							idx = indexOf( seed, matched[ i ] );
+							seed[ idx ] = !( matches[ idx ] = matched[ i ] );
 						}
-					}) :
+					} ) :
 					function( elem ) {
 						return fn( elem, 0, args );
 					};
@@ -1956,8 +2083,10 @@ Expr = Sizzle.selectors = {
 	},
 
 	pseudos: {
+
 		// Potentially complex pseudos
-		"not": markFunction(function( selector ) {
+		"not": markFunction( function( selector ) {
+
 			// Trim the selector passed to compile
 			// to avoid treating leading and trailing
 			// spaces as combinators
@@ -1966,39 +2095,40 @@ Expr = Sizzle.selectors = {
 				matcher = compile( selector.replace( rtrim, "$1" ) );
 
 			return matcher[ expando ] ?
-				markFunction(function( seed, matches, context, xml ) {
+				markFunction( function( seed, matches, _context, xml ) {
 					var elem,
 						unmatched = matcher( seed, null, xml, [] ),
 						i = seed.length;
 
 					// Match elements unmatched by `matcher`
 					while ( i-- ) {
-						if ( (elem = unmatched[i]) ) {
-							seed[i] = !(matches[i] = elem);
+						if ( ( elem = unmatched[ i ] ) ) {
+							seed[ i ] = !( matches[ i ] = elem );
 						}
 					}
-				}) :
-				function( elem, context, xml ) {
-					input[0] = elem;
+				} ) :
+				function( elem, _context, xml ) {
+					input[ 0 ] = elem;
 					matcher( input, null, xml, results );
+
 					// Don't keep the element (issue #299)
-					input[0] = null;
+					input[ 0 ] = null;
 					return !results.pop();
 				};
-		}),
+		} ),
 
-		"has": markFunction(function( selector ) {
+		"has": markFunction( function( selector ) {
 			return function( elem ) {
 				return Sizzle( selector, elem ).length > 0;
 			};
-		}),
+		} ),
 
-		"contains": markFunction(function( text ) {
+		"contains": markFunction( function( text ) {
 			text = text.replace( runescape, funescape );
 			return function( elem ) {
-				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
+				return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
 			};
-		}),
+		} ),
 
 		// "Whether an element is represented by a :lang() selector
 		// is based solely on the element's language value
@@ -2008,25 +2138,26 @@ Expr = Sizzle.selectors = {
 		// The identifier C does not have to be a valid language name."
 		// http://www.w3.org/TR/selectors/#lang-pseudo
 		"lang": markFunction( function( lang ) {
+
 			// lang value must be a valid identifier
-			if ( !ridentifier.test(lang || "") ) {
+			if ( !ridentifier.test( lang || "" ) ) {
 				Sizzle.error( "unsupported lang: " + lang );
 			}
 			lang = lang.replace( runescape, funescape ).toLowerCase();
 			return function( elem ) {
 				var elemLang;
 				do {
-					if ( (elemLang = documentIsHTML ?
+					if ( ( elemLang = documentIsHTML ?
 						elem.lang :
-						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
+						elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
 
 						elemLang = elemLang.toLowerCase();
 						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
 					}
-				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
+				} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
 				return false;
 			};
-		}),
+		} ),
 
 		// Miscellaneous
 		"target": function( elem ) {
@@ -2039,7 +2170,9 @@ Expr = Sizzle.selectors = {
 		},
 
 		"focus": function( elem ) {
-			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
+			return elem === document.activeElement &&
+				( !document.hasFocus || document.hasFocus() ) &&
+				!!( elem.type || elem.href || ~elem.tabIndex );
 		},
 
 		// Boolean properties
@@ -2047,16 +2180,20 @@ Expr = Sizzle.selectors = {
 		"disabled": createDisabledPseudo( true ),
 
 		"checked": function( elem ) {
+
 			// In CSS3, :checked should return both checked and selected elements
 			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
 			var nodeName = elem.nodeName.toLowerCase();
-			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
+			return ( nodeName === "input" && !!elem.checked ) ||
+				( nodeName === "option" && !!elem.selected );
 		},
 
 		"selected": function( elem ) {
+
 			// Accessing this property makes selected-by-default
 			// options in Safari work properly
 			if ( elem.parentNode ) {
+				// eslint-disable-next-line no-unused-expressions
 				elem.parentNode.selectedIndex;
 			}
 
@@ -2065,6 +2202,7 @@ Expr = Sizzle.selectors = {
 
 		// Contents
 		"empty": function( elem ) {
+
 			// http://www.w3.org/TR/selectors/#empty-pseudo
 			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
 			//   but not by others (comment: 8; processing instruction: 7; etc.)
@@ -2078,7 +2216,7 @@ Expr = Sizzle.selectors = {
 		},
 
 		"parent": function( elem ) {
-			return !Expr.pseudos["empty"]( elem );
+			return !Expr.pseudos[ "empty" ]( elem );
 		},
 
 		// Element/input types
@@ -2102,57 +2240,62 @@ Expr = Sizzle.selectors = {
 
 				// Support: IE<8
 				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
-				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
+				( ( attr = elem.getAttribute( "type" ) ) == null ||
+					attr.toLowerCase() === "text" );
 		},
 
 		// Position-in-collection
-		"first": createPositionalPseudo(function() {
+		"first": createPositionalPseudo( function() {
 			return [ 0 ];
-		}),
+		} ),
 
-		"last": createPositionalPseudo(function( matchIndexes, length ) {
+		"last": createPositionalPseudo( function( _matchIndexes, length ) {
 			return [ length - 1 ];
-		}),
+		} ),
 
-		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
+		"eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
 			return [ argument < 0 ? argument + length : argument ];
-		}),
+		} ),
 
-		"even": createPositionalPseudo(function( matchIndexes, length ) {
+		"even": createPositionalPseudo( function( matchIndexes, length ) {
 			var i = 0;
 			for ( ; i < length; i += 2 ) {
 				matchIndexes.push( i );
 			}
 			return matchIndexes;
-		}),
+		} ),
 
-		"odd": createPositionalPseudo(function( matchIndexes, length ) {
+		"odd": createPositionalPseudo( function( matchIndexes, length ) {
 			var i = 1;
 			for ( ; i < length; i += 2 ) {
 				matchIndexes.push( i );
 			}
 			return matchIndexes;
-		}),
+		} ),
 
-		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
-			var i = argument < 0 ? argument + length : argument;
+		"lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
+			var i = argument < 0 ?
+				argument + length :
+				argument > length ?
+					length :
+					argument;
 			for ( ; --i >= 0; ) {
 				matchIndexes.push( i );
 			}
 			return matchIndexes;
-		}),
+		} ),
 
-		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
+		"gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
 			var i = argument < 0 ? argument + length : argument;
 			for ( ; ++i < length; ) {
 				matchIndexes.push( i );
 			}
 			return matchIndexes;
-		})
+		} )
 	}
 };
 
-Expr.pseudos["nth"] = Expr.pseudos["eq"];
+Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
 
 // Add button/input type pseudos
 for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
@@ -2183,37 +2326,39 @@ tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
 	while ( soFar ) {
 
 		// Comma and first run
-		if ( !matched || (match = rcomma.exec( soFar )) ) {
+		if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
 			if ( match ) {
+
 				// Don't consume trailing commas as valid
-				soFar = soFar.slice( match[0].length ) || soFar;
+				soFar = soFar.slice( match[ 0 ].length ) || soFar;
 			}
-			groups.push( (tokens = []) );
+			groups.push( ( tokens = [] ) );
 		}
 
 		matched = false;
 
 		// Combinators
-		if ( (match = rcombinators.exec( soFar )) ) {
+		if ( ( match = rcombinators.exec( soFar ) ) ) {
 			matched = match.shift();
-			tokens.push({
+			tokens.push( {
 				value: matched,
+
 				// Cast descendant combinators to space
-				type: match[0].replace( rtrim, " " )
-			});
+				type: match[ 0 ].replace( rtrim, " " )
+			} );
 			soFar = soFar.slice( matched.length );
 		}
 
 		// Filters
 		for ( type in Expr.filter ) {
-			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
-				(match = preFilters[ type ]( match ))) ) {
+			if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
+				( match = preFilters[ type ]( match ) ) ) ) {
 				matched = match.shift();
-				tokens.push({
+				tokens.push( {
 					value: matched,
 					type: type,
 					matches: match
-				});
+				} );
 				soFar = soFar.slice( matched.length );
 			}
 		}
@@ -2230,6 +2375,7 @@ tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
 		soFar.length :
 		soFar ?
 			Sizzle.error( selector ) :
+
 			// Cache the tokens
 			tokenCache( selector, groups ).slice( 0 );
 };
@@ -2239,7 +2385,7 @@ function toSelector( tokens ) {
 		len = tokens.length,
 		selector = "";
 	for ( ; i < len; i++ ) {
-		selector += tokens[i].value;
+		selector += tokens[ i ].value;
 	}
 	return selector;
 }
@@ -2252,9 +2398,10 @@ function addCombinator( matcher, combinator, base ) {
 		doneName = done++;
 
 	return combinator.first ?
+
 		// Check against closest ancestor/preceding element
 		function( elem, context, xml ) {
-			while ( (elem = elem[ dir ]) ) {
+			while ( ( elem = elem[ dir ] ) ) {
 				if ( elem.nodeType === 1 || checkNonElements ) {
 					return matcher( elem, context, xml );
 				}
@@ -2269,7 +2416,7 @@ function addCombinator( matcher, combinator, base ) {
 
 			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
 			if ( xml ) {
-				while ( (elem = elem[ dir ]) ) {
+				while ( ( elem = elem[ dir ] ) ) {
 					if ( elem.nodeType === 1 || checkNonElements ) {
 						if ( matcher( elem, context, xml ) ) {
 							return true;
@@ -2277,27 +2424,29 @@ function addCombinator( matcher, combinator, base ) {
 					}
 				}
 			} else {
-				while ( (elem = elem[ dir ]) ) {
+				while ( ( elem = elem[ dir ] ) ) {
 					if ( elem.nodeType === 1 || checkNonElements ) {
-						outerCache = elem[ expando ] || (elem[ expando ] = {});
+						outerCache = elem[ expando ] || ( elem[ expando ] = {} );
 
 						// Support: IE <9 only
 						// Defend against cloned attroperties (jQuery gh-1709)
-						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
+						uniqueCache = outerCache[ elem.uniqueID ] ||
+							( outerCache[ elem.uniqueID ] = {} );
 
 						if ( skip && skip === elem.nodeName.toLowerCase() ) {
 							elem = elem[ dir ] || elem;
-						} else if ( (oldCache = uniqueCache[ key ]) &&
+						} else if ( ( oldCache = uniqueCache[ key ] ) &&
 							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
 
 							// Assign to newCache so results back-propagate to previous elements
-							return (newCache[ 2 ] = oldCache[ 2 ]);
+							return ( newCache[ 2 ] = oldCache[ 2 ] );
 						} else {
+
 							// Reuse newcache so results back-propagate to previous elements
 							uniqueCache[ key ] = newCache;
 
 							// A match means we're done; a fail means we have to keep checking
-							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
+							if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
 								return true;
 							}
 						}
@@ -2313,20 +2462,20 @@ function elementMatcher( matchers ) {
 		function( elem, context, xml ) {
 			var i = matchers.length;
 			while ( i-- ) {
-				if ( !matchers[i]( elem, context, xml ) ) {
+				if ( !matchers[ i ]( elem, context, xml ) ) {
 					return false;
 				}
 			}
 			return true;
 		} :
-		matchers[0];
+		matchers[ 0 ];
 }
 
 function multipleContexts( selector, contexts, results ) {
 	var i = 0,
 		len = contexts.length;
 	for ( ; i < len; i++ ) {
-		Sizzle( selector, contexts[i], results );
+		Sizzle( selector, contexts[ i ], results );
 	}
 	return results;
 }
@@ -2339,7 +2488,7 @@ function condense( unmatched, map, filter, context, xml ) {
 		mapped = map != null;
 
 	for ( ; i < len; i++ ) {
-		if ( (elem = unmatched[i]) ) {
+		if ( ( elem = unmatched[ i ] ) ) {
 			if ( !filter || filter( elem, context, xml ) ) {
 				newUnmatched.push( elem );
 				if ( mapped ) {
@@ -2359,14 +2508,18 @@ function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postS
 	if ( postFinder && !postFinder[ expando ] ) {
 		postFinder = setMatcher( postFinder, postSelector );
 	}
-	return markFunction(function( seed, results, context, xml ) {
+	return markFunction( function( seed, results, context, xml ) {
 		var temp, i, elem,
 			preMap = [],
 			postMap = [],
 			preexisting = results.length,
 
 			// Get initial elements from seed or context
-			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
+			elems = seed || multipleContexts(
+				selector || "*",
+				context.nodeType ? [ context ] : context,
+				[]
+			),
 
 			// Prefilter to get matcher input, preserving a map for seed-results synchronization
 			matcherIn = preFilter && ( seed || !selector ) ?
@@ -2374,6 +2527,7 @@ function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postS
 				elems,
 
 			matcherOut = matcher ?
+
 				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
 				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
 
@@ -2397,8 +2551,8 @@ function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postS
 			// Un-match failing elements by moving them back to matcherIn
 			i = temp.length;
 			while ( i-- ) {
-				if ( (elem = temp[i]) ) {
-					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
+				if ( ( elem = temp[ i ] ) ) {
+					matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
 				}
 			}
 		}
@@ -2406,25 +2560,27 @@ function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postS
 		if ( seed ) {
 			if ( postFinder || preFilter ) {
 				if ( postFinder ) {
+
 					// Get the final matcherOut by condensing this intermediate into postFinder contexts
 					temp = [];
 					i = matcherOut.length;
 					while ( i-- ) {
-						if ( (elem = matcherOut[i]) ) {
+						if ( ( elem = matcherOut[ i ] ) ) {
+
 							// Restore matcherIn since elem is not yet a final match
-							temp.push( (matcherIn[i] = elem) );
+							temp.push( ( matcherIn[ i ] = elem ) );
 						}
 					}
-					postFinder( null, (matcherOut = []), temp, xml );
+					postFinder( null, ( matcherOut = [] ), temp, xml );
 				}
 
 				// Move matched elements from seed to results to keep them synchronized
 				i = matcherOut.length;
 				while ( i-- ) {
-					if ( (elem = matcherOut[i]) &&
-						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
+					if ( ( elem = matcherOut[ i ] ) &&
+						( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
 
-						seed[temp] = !(results[temp] = elem);
+						seed[ temp ] = !( results[ temp ] = elem );
 					}
 				}
 			}
@@ -2442,14 +2598,14 @@ function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postS
 				push.apply( results, matcherOut );
 			}
 		}
-	});
+	} );
 }
 
 function matcherFromTokens( tokens ) {
 	var checkContext, matcher, j,
 		len = tokens.length,
-		leadingRelative = Expr.relative[ tokens[0].type ],
-		implicitRelative = leadingRelative || Expr.relative[" "],
+		leadingRelative = Expr.relative[ tokens[ 0 ].type ],
+		implicitRelative = leadingRelative || Expr.relative[ " " ],
 		i = leadingRelative ? 1 : 0,
 
 		// The foundational matcher ensures that elements are reachable from top-level context(s)
@@ -2461,38 +2617,43 @@ function matcherFromTokens( tokens ) {
 		}, implicitRelative, true ),
 		matchers = [ function( elem, context, xml ) {
 			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
-				(checkContext = context).nodeType ?
+				( checkContext = context ).nodeType ?
 					matchContext( elem, context, xml ) :
 					matchAnyContext( elem, context, xml ) );
+
 			// Avoid hanging onto element (issue #299)
 			checkContext = null;
 			return ret;
 		} ];
 
 	for ( ; i < len; i++ ) {
-		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
-			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
+		if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
+			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
 		} else {
-			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
+			matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
 
 			// Return special upon seeing a positional matcher
 			if ( matcher[ expando ] ) {
+
 				// Find the next relative operator (if any) for proper handling
 				j = ++i;
 				for ( ; j < len; j++ ) {
-					if ( Expr.relative[ tokens[j].type ] ) {
+					if ( Expr.relative[ tokens[ j ].type ] ) {
 						break;
 					}
 				}
 				return setMatcher(
 					i > 1 && elementMatcher( matchers ),
 					i > 1 && toSelector(
-						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
-						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
+
+					// If the preceding token was a descendant combinator, insert an implicit any-element `*`
+					tokens
+						.slice( 0, i - 1 )
+						.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
 					).replace( rtrim, "$1" ),
 					matcher,
 					i < j && matcherFromTokens( tokens.slice( i, j ) ),
-					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
+					j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
 					j < len && toSelector( tokens )
 				);
 			}
@@ -2513,28 +2674,40 @@ function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
 				unmatched = seed && [],
 				setMatched = [],
 				contextBackup = outermostContext,
+
 				// We must always have either seed elements or outermost context
-				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
+				elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
+
 				// Use integer dirruns iff this is the outermost matcher
-				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
+				dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
 				len = elems.length;
 
 			if ( outermost ) {
-				outermostContext = context === document || context || outermost;
+
+				// Support: IE 11+, Edge 17 - 18+
+				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+				// two documents; shallow comparisons work.
+				// eslint-disable-next-line eqeqeq
+				outermostContext = context == document || context || outermost;
 			}
 
 			// Add elements passing elementMatchers directly to results
 			// Support: IE<9, Safari
 			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
-			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
+			for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
 				if ( byElement && elem ) {
 					j = 0;
-					if ( !context && elem.ownerDocument !== document ) {
+
+					// Support: IE 11+, Edge 17 - 18+
+					// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+					// two documents; shallow comparisons work.
+					// eslint-disable-next-line eqeqeq
+					if ( !context && elem.ownerDocument != document ) {
 						setDocument( elem );
 						xml = !documentIsHTML;
 					}
-					while ( (matcher = elementMatchers[j++]) ) {
-						if ( matcher( elem, context || document, xml) ) {
+					while ( ( matcher = elementMatchers[ j++ ] ) ) {
+						if ( matcher( elem, context || document, xml ) ) {
 							results.push( elem );
 							break;
 						}
@@ -2546,8 +2719,9 @@ function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
 
 				// Track unmatched elements for set filters
 				if ( bySet ) {
+
 					// They will have gone through all possible matchers
-					if ( (elem = !matcher && elem) ) {
+					if ( ( elem = !matcher && elem ) ) {
 						matchedCount--;
 					}
 
@@ -2571,16 +2745,17 @@ function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
 			// numerically zero.
 			if ( bySet && i !== matchedCount ) {
 				j = 0;
-				while ( (matcher = setMatchers[j++]) ) {
+				while ( ( matcher = setMatchers[ j++ ] ) ) {
 					matcher( unmatched, setMatched, context, xml );
 				}
 
 				if ( seed ) {
+
 					// Reintegrate element matches to eliminate the need for sorting
 					if ( matchedCount > 0 ) {
 						while ( i-- ) {
-							if ( !(unmatched[i] || setMatched[i]) ) {
-								setMatched[i] = pop.call( results );
+							if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
+								setMatched[ i ] = pop.call( results );
 							}
 						}
 					}
@@ -2621,13 +2796,14 @@ compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
 		cached = compilerCache[ selector + " " ];
 
 	if ( !cached ) {
+
 		// Generate a function of recursive functions that can be used to check each element
 		if ( !match ) {
 			match = tokenize( selector );
 		}
 		i = match.length;
 		while ( i-- ) {
-			cached = matcherFromTokens( match[i] );
+			cached = matcherFromTokens( match[ i ] );
 			if ( cached[ expando ] ) {
 				setMatchers.push( cached );
 			} else {
@@ -2636,7 +2812,10 @@ compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
 		}
 
 		// Cache the compiled function
-		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
+		cached = compilerCache(
+			selector,
+			matcherFromGroupMatchers( elementMatchers, setMatchers )
+		);
 
 		// Save selector and tokenization
 		cached.selector = selector;
@@ -2656,7 +2835,7 @@ compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
 select = Sizzle.select = function( selector, context, results, seed ) {
 	var i, tokens, token, type, find,
 		compiled = typeof selector === "function" && selector,
-		match = !seed && tokenize( (selector = compiled.selector || selector) );
+		match = !seed && tokenize( ( selector = compiled.selector || selector ) );
 
 	results = results || [];
 
@@ -2665,11 +2844,12 @@ select = Sizzle.select = function( selector, context, results, seed ) {
 	if ( match.length === 1 ) {
 
 		// Reduce context if the leading compound selector is an ID
-		tokens = match[0] = match[0].slice( 0 );
-		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
-				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
+		tokens = match[ 0 ] = match[ 0 ].slice( 0 );
+		if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
+			context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
 
-			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
+			context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
+				.replace( runescape, funescape ), context ) || [] )[ 0 ];
 			if ( !context ) {
 				return results;
 
@@ -2682,20 +2862,22 @@ select = Sizzle.select = function( selector, context, results, seed ) {
 		}
 
 		// Fetch a seed set for right-to-left matching
-		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
+		i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
 		while ( i-- ) {
-			token = tokens[i];
+			token = tokens[ i ];
 
 			// Abort if we hit a combinator
-			if ( Expr.relative[ (type = token.type) ] ) {
+			if ( Expr.relative[ ( type = token.type ) ] ) {
 				break;
 			}
-			if ( (find = Expr.find[ type ]) ) {
+			if ( ( find = Expr.find[ type ] ) ) {
+
 				// Search, expanding context for leading sibling combinators
-				if ( (seed = find(
-					token.matches[0].replace( runescape, funescape ),
-					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
-				)) ) {
+				if ( ( seed = find(
+					token.matches[ 0 ].replace( runescape, funescape ),
+					rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
+						context
+				) ) ) {
 
 					// If seed is empty or no tokens remain, we can return early
 					tokens.splice( i, 1 );
@@ -2726,7 +2908,7 @@ select = Sizzle.select = function( selector, context, results, seed ) {
 // One-time assignments
 
 // Sort stability
-support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
+support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
 
 // Support: Chrome 14-35+
 // Always assume duplicates if they aren't passed to the comparison function
@@ -2737,58 +2919,59 @@ setDocument();
 
 // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
 // Detached nodes confoundingly follow *each other*
-support.sortDetached = assert(function( el ) {
+support.sortDetached = assert( function( el ) {
+
 	// Should return 1, but returns 4 (following)
-	return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
-});
+	return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
+} );
 
 // Support: IE<8
 // Prevent attribute/property "interpolation"
 // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
-if ( !assert(function( el ) {
+if ( !assert( function( el ) {
 	el.innerHTML = "<a href='#'></a>";
-	return el.firstChild.getAttribute("href") === "#" ;
-}) ) {
+	return el.firstChild.getAttribute( "href" ) === "#";
+} ) ) {
 	addHandle( "type|href|height|width", function( elem, name, isXML ) {
 		if ( !isXML ) {
 			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
 		}
-	});
+	} );
 }
 
 // Support: IE<9
 // Use defaultValue in place of getAttribute("value")
-if ( !support.attributes || !assert(function( el ) {
+if ( !support.attributes || !assert( function( el ) {
 	el.innerHTML = "<input/>";
 	el.firstChild.setAttribute( "value", "" );
 	return el.firstChild.getAttribute( "value" ) === "";
-}) ) {
-	addHandle( "value", function( elem, name, isXML ) {
+} ) ) {
+	addHandle( "value", function( elem, _name, isXML ) {
 		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
 			return elem.defaultValue;
 		}
-	});
+	} );
 }
 
 // Support: IE<9
 // Use getAttributeNode to fetch booleans when getAttribute lies
-if ( !assert(function( el ) {
-	return el.getAttribute("disabled") == null;
-}) ) {
+if ( !assert( function( el ) {
+	return el.getAttribute( "disabled" ) == null;
+} ) ) {
 	addHandle( booleans, function( elem, name, isXML ) {
 		var val;
 		if ( !isXML ) {
 			return elem[ name ] === true ? name.toLowerCase() :
-					(val = elem.getAttributeNode( name )) && val.specified ?
+				( val = elem.getAttributeNode( name ) ) && val.specified ?
 					val.value :
-				null;
+					null;
 		}
-	});
+	} );
 }
 
 return Sizzle;
 
-})( window );
+} )( window );
 
 
 
@@ -2848,11 +3031,9 @@ var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|
 
 
 
-var risSimple = /^.[^:#\[\.,]*$/;
-
 // Implement the identical functionality for filter and not
 function winnow( elements, qualifier, not ) {
-	if ( jQuery.isFunction( qualifier ) ) {
+	if ( isFunction( qualifier ) ) {
 		return jQuery.grep( elements, function( elem, i ) {
 			return !!qualifier.call( elem, i, elem ) !== not;
 		} );
@@ -2872,16 +3053,8 @@ function winnow( elements, qualifier, not ) {
 		} );
 	}
 
-	// Simple selector that can be filtered directly, removing non-Elements
-	if ( risSimple.test( qualifier ) ) {
-		return jQuery.filter( qualifier, elements, not );
-	}
-
-	// Complex selector, compare the two sets, removing non-Elements
-	qualifier = jQuery.filter( qualifier, elements );
-	return jQuery.grep( elements, function( elem ) {
-		return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1;
-	} );
+	// Filtered directly for both simple and complex selectors
+	return jQuery.filter( qualifier, elements, not );
 }
 
 jQuery.filter = function( expr, elems, not ) {
@@ -3002,7 +3175,7 @@ var rootjQuery,
 						for ( match in context ) {
 
 							// Properties of context are called as methods if possible
-							if ( jQuery.isFunction( this[ match ] ) ) {
+							if ( isFunction( this[ match ] ) ) {
 								this[ match ]( context[ match ] );
 
 							// ...and otherwise set as attributes
@@ -3045,7 +3218,7 @@ var rootjQuery,
 
 		// HANDLE: $(function)
 		// Shortcut for document ready
-		} else if ( jQuery.isFunction( selector ) ) {
+		} else if ( isFunction( selector ) ) {
 			return root.ready !== undefined ?
 				root.ready( selector ) :
 
@@ -3167,7 +3340,7 @@ jQuery.each( {
 	parents: function( elem ) {
 		return dir( elem, "parentNode" );
 	},
-	parentsUntil: function( elem, i, until ) {
+	parentsUntil: function( elem, _i, until ) {
 		return dir( elem, "parentNode", until );
 	},
 	next: function( elem ) {
@@ -3182,10 +3355,10 @@ jQuery.each( {
 	prevAll: function( elem ) {
 		return dir( elem, "previousSibling" );
 	},
-	nextUntil: function( elem, i, until ) {
+	nextUntil: function( elem, _i, until ) {
 		return dir( elem, "nextSibling", until );
 	},
-	prevUntil: function( elem, i, until ) {
+	prevUntil: function( elem, _i, until ) {
 		return dir( elem, "previousSibling", until );
 	},
 	siblings: function( elem ) {
@@ -3195,18 +3368,24 @@ jQuery.each( {
 		return siblings( elem.firstChild );
 	},
 	contents: function( elem ) {
-        if ( nodeName( elem, "iframe" ) ) {
-            return elem.contentDocument;
-        }
+		if ( elem.contentDocument != null &&
 
-        // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
-        // Treat the template element as a regular one in browsers that
-        // don't support it.
-        if ( nodeName( elem, "template" ) ) {
-            elem = elem.content || elem;
-        }
+			// Support: IE 11+
+			// <object> elements with no `data` attribute has an object
+			// `contentDocument` with a `null` prototype.
+			getProto( elem.contentDocument ) ) {
 
-        return jQuery.merge( [], elem.childNodes );
+			return elem.contentDocument;
+		}
+
+		// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
+		// Treat the template element as a regular one in browsers that
+		// don't support it.
+		if ( nodeName( elem, "template" ) ) {
+			elem = elem.content || elem;
+		}
+
+		return jQuery.merge( [], elem.childNodes );
 	}
 }, function( name, fn ) {
 	jQuery.fn[ name ] = function( until, selector ) {
@@ -3360,11 +3539,11 @@ jQuery.Callbacks = function( options ) {
 
 					( function add( args ) {
 						jQuery.each( args, function( _, arg ) {
-							if ( jQuery.isFunction( arg ) ) {
+							if ( isFunction( arg ) ) {
 								if ( !options.unique || !self.has( arg ) ) {
 									list.push( arg );
 								}
-							} else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {
+							} else if ( arg && arg.length && toType( arg ) !== "string" ) {
 
 								// Inspect recursively
 								add( arg );
@@ -3479,11 +3658,11 @@ function adoptValue( value, resolve, reject, noValue ) {
 	try {
 
 		// Check for promise aspect first to privilege synchronous behavior
-		if ( value && jQuery.isFunction( ( method = value.promise ) ) ) {
+		if ( value && isFunction( ( method = value.promise ) ) ) {
 			method.call( value ).done( resolve ).fail( reject );
 
 		// Other thenables
-		} else if ( value && jQuery.isFunction( ( method = value.then ) ) ) {
+		} else if ( value && isFunction( ( method = value.then ) ) ) {
 			method.call( value, resolve, reject );
 
 		// Other non-thenables
@@ -3538,17 +3717,17 @@ jQuery.extend( {
 					var fns = arguments;
 
 					return jQuery.Deferred( function( newDefer ) {
-						jQuery.each( tuples, function( i, tuple ) {
+						jQuery.each( tuples, function( _i, tuple ) {
 
 							// Map tuples (progress, done, fail) to arguments (done, fail, progress)
-							var fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
+							var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
 
 							// deferred.progress(function() { bind to newDefer or newDefer.notify })
 							// deferred.done(function() { bind to newDefer or newDefer.resolve })
 							// deferred.fail(function() { bind to newDefer or newDefer.reject })
 							deferred[ tuple[ 1 ] ]( function() {
 								var returned = fn && fn.apply( this, arguments );
-								if ( returned && jQuery.isFunction( returned.promise ) ) {
+								if ( returned && isFunction( returned.promise ) ) {
 									returned.promise()
 										.progress( newDefer.notify )
 										.done( newDefer.resolve )
@@ -3602,7 +3781,7 @@ jQuery.extend( {
 										returned.then;
 
 									// Handle a returned thenable
-									if ( jQuery.isFunction( then ) ) {
+									if ( isFunction( then ) ) {
 
 										// Special processors (notify) just wait for resolution
 										if ( special ) {
@@ -3698,7 +3877,7 @@ jQuery.extend( {
 							resolve(
 								0,
 								newDefer,
-								jQuery.isFunction( onProgress ) ?
+								isFunction( onProgress ) ?
 									onProgress :
 									Identity,
 								newDefer.notifyWith
@@ -3710,7 +3889,7 @@ jQuery.extend( {
 							resolve(
 								0,
 								newDefer,
-								jQuery.isFunction( onFulfilled ) ?
+								isFunction( onFulfilled ) ?
 									onFulfilled :
 									Identity
 							)
@@ -3721,7 +3900,7 @@ jQuery.extend( {
 							resolve(
 								0,
 								newDefer,
-								jQuery.isFunction( onRejected ) ?
+								isFunction( onRejected ) ?
 									onRejected :
 									Thrower
 							)
@@ -3761,8 +3940,15 @@ jQuery.extend( {
 					// fulfilled_callbacks.disable
 					tuples[ 3 - i ][ 2 ].disable,
 
+					// rejected_handlers.disable
+					// fulfilled_handlers.disable
+					tuples[ 3 - i ][ 3 ].disable,
+
 					// progress_callbacks.lock
-					tuples[ 0 ][ 2 ].lock
+					tuples[ 0 ][ 2 ].lock,
+
+					// progress_handlers.lock
+					tuples[ 0 ][ 3 ].lock
 				);
 			}
 
@@ -3832,7 +4018,7 @@ jQuery.extend( {
 
 			// Use .then() to unwrap secondary thenables (cf. gh-3000)
 			if ( master.state() === "pending" ||
-				jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
+				isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
 
 				return master.then();
 			}
@@ -3960,7 +4146,7 @@ var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
 		bulk = key == null;
 
 	// Sets many values
-	if ( jQuery.type( key ) === "object" ) {
+	if ( toType( key ) === "object" ) {
 		chainable = true;
 		for ( i in key ) {
 			access( elems, fn, i, key[ i ], true, emptyGet, raw );
@@ -3970,7 +4156,7 @@ var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
 	} else if ( value !== undefined ) {
 		chainable = true;
 
-		if ( !jQuery.isFunction( value ) ) {
+		if ( !isFunction( value ) ) {
 			raw = true;
 		}
 
@@ -3984,7 +4170,7 @@ var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
 			// ...except when executing function values
 			} else {
 				bulk = fn;
-				fn = function( elem, key, value ) {
+				fn = function( elem, _key, value ) {
 					return bulk.call( jQuery( elem ), value );
 				};
 			}
@@ -4012,6 +4198,23 @@ var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
 
 	return len ? fn( elems[ 0 ], key ) : emptyGet;
 };
+
+
+// Matches dashed string for camelizing
+var rmsPrefix = /^-ms-/,
+	rdashAlpha = /-([a-z])/g;
+
+// Used by camelCase as callback to replace()
+function fcamelCase( _all, letter ) {
+	return letter.toUpperCase();
+}
+
+// Convert dashed to camelCase; used by the css and data modules
+// Support: IE <=9 - 11, Edge 12 - 15
+// Microsoft forgot to hump their vendor prefix (#9572)
+function camelCase( string ) {
+	return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
+}
 var acceptData = function( owner ) {
 
 	// Accepts only:
@@ -4074,14 +4277,14 @@ Data.prototype = {
 		// Handle: [ owner, key, value ] args
 		// Always use camelCase key (gh-2257)
 		if ( typeof data === "string" ) {
-			cache[ jQuery.camelCase( data ) ] = value;
+			cache[ camelCase( data ) ] = value;
 
 		// Handle: [ owner, { properties } ] args
 		} else {
 
 			// Copy the properties one-by-one to the cache object
 			for ( prop in data ) {
-				cache[ jQuery.camelCase( prop ) ] = data[ prop ];
+				cache[ camelCase( prop ) ] = data[ prop ];
 			}
 		}
 		return cache;
@@ -4091,7 +4294,7 @@ Data.prototype = {
 			this.cache( owner ) :
 
 			// Always use camelCase key (gh-2257)
-			owner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ];
+			owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
 	},
 	access: function( owner, key, value ) {
 
@@ -4139,9 +4342,9 @@ Data.prototype = {
 
 				// If key is an array of keys...
 				// We always set camelCase keys, so remove that.
-				key = key.map( jQuery.camelCase );
+				key = key.map( camelCase );
 			} else {
-				key = jQuery.camelCase( key );
+				key = camelCase( key );
 
 				// If a key with the spaces exists, use it.
 				// Otherwise, create an array by matching non-whitespace
@@ -4287,7 +4490,7 @@ jQuery.fn.extend( {
 						if ( attrs[ i ] ) {
 							name = attrs[ i ].name;
 							if ( name.indexOf( "data-" ) === 0 ) {
-								name = jQuery.camelCase( name.slice( 5 ) );
+								name = camelCase( name.slice( 5 ) );
 								dataAttr( elem, name, data[ name ] );
 							}
 						}
@@ -4491,6 +4694,26 @@ var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
 
 var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
 
+var documentElement = document.documentElement;
+
+
+
+	var isAttached = function( elem ) {
+			return jQuery.contains( elem.ownerDocument, elem );
+		},
+		composed = { composed: true };
+
+	// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
+	// Check attachment across shadow DOM boundaries when possible (gh-3504)
+	// Support: iOS 10.0-10.2 only
+	// Early iOS 10 versions support `attachShadow` but not `getRootNode`,
+	// leading to errors. We need to check for `getRootNode`.
+	if ( documentElement.getRootNode ) {
+		isAttached = function( elem ) {
+			return jQuery.contains( elem.ownerDocument, elem ) ||
+				elem.getRootNode( composed ) === elem.ownerDocument;
+		};
+	}
 var isHiddenWithinTree = function( elem, el ) {
 
 		// isHiddenWithinTree might be called from jQuery#filter function;
@@ -4505,37 +4728,15 @@ var isHiddenWithinTree = function( elem, el ) {
 			// Support: Firefox <=43 - 45
 			// Disconnected elements can have computed display: none, so first confirm that elem is
 			// in the document.
-			jQuery.contains( elem.ownerDocument, elem ) &&
+			isAttached( elem ) &&
 
 			jQuery.css( elem, "display" ) === "none";
 	};
 
-var swap = function( elem, options, callback, args ) {
-	var ret, name,
-		old = {};
-
-	// Remember the old values, and insert the new ones
-	for ( name in options ) {
-		old[ name ] = elem.style[ name ];
-		elem.style[ name ] = options[ name ];
-	}
-
-	ret = callback.apply( elem, args || [] );
-
-	// Revert the old values
-	for ( name in options ) {
-		elem.style[ name ] = old[ name ];
-	}
-
-	return ret;
-};
-
-
 
 
 function adjustCSS( elem, prop, valueParts, tween ) {
-	var adjusted,
-		scale = 1,
+	var adjusted, scale,
 		maxIterations = 20,
 		currentValue = tween ?
 			function() {
@@ -4548,35 +4749,39 @@ function adjustCSS( elem, prop, valueParts, tween ) {
 		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
 
 		// Starting value computation is required for potential unit mismatches
-		initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
+		initialInUnit = elem.nodeType &&
+			( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
 			rcssNum.exec( jQuery.css( elem, prop ) );
 
 	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
 
+		// Support: Firefox <=54
+		// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
+		initial = initial / 2;
+
 		// Trust units reported by jQuery.css
 		unit = unit || initialInUnit[ 3 ];
 
-		// Make sure we update the tween properties later on
-		valueParts = valueParts || [];
-
 		// Iteratively approximate from a nonzero starting point
 		initialInUnit = +initial || 1;
 
-		do {
-
-			// If previous iteration zeroed out, double until we get *something*.
-			// Use string for doubling so we don't accidentally see scale as unchanged below
-			scale = scale || ".5";
+		while ( maxIterations-- ) {
 
-			// Adjust and apply
-			initialInUnit = initialInUnit / scale;
+			// Evaluate and update our best guess (doubling guesses that zero out).
+			// Finish if the scale equals or crosses 1 (making the old*new product non-positive).
 			jQuery.style( elem, prop, initialInUnit + unit );
+			if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
+				maxIterations = 0;
+			}
+			initialInUnit = initialInUnit / scale;
 
-		// Update scale, tolerating zero or NaN from tween.cur()
-		// Break the loop if scale is unchanged or perfect, or if we've just had enough.
-		} while (
-			scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
-		);
+		}
+
+		initialInUnit = initialInUnit * 2;
+		jQuery.style( elem, prop, initialInUnit + unit );
+
+		// Make sure we update the tween properties later on
+		valueParts = valueParts || [];
 	}
 
 	if ( valueParts ) {
@@ -4692,17 +4897,46 @@ jQuery.fn.extend( {
 } );
 var rcheckableType = ( /^(?:checkbox|radio)$/i );
 
-var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i );
+var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
 
-var rscriptType = ( /^$|\/(?:java|ecma)script/i );
+var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
 
 
 
-// We have to close these tags to support XHTML (#13200)
-var wrapMap = {
+( function() {
+	var fragment = document.createDocumentFragment(),
+		div = fragment.appendChild( document.createElement( "div" ) ),
+		input = document.createElement( "input" );
+
+	// Support: Android 4.0 - 4.3 only
+	// Check state lost if the name is set (#11217)
+	// Support: Windows Web Apps (WWA)
+	// `name` and `type` must use .setAttribute for WWA (#14901)
+	input.setAttribute( "type", "radio" );
+	input.setAttribute( "checked", "checked" );
+	input.setAttribute( "name", "t" );
+
+	div.appendChild( input );
+
+	// Support: Android <=4.1 only
+	// Older WebKit doesn't clone checked state correctly in fragments
+	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+	// Support: IE <=11 only
+	// Make sure textarea (and checkbox) defaultValue is properly cloned
+	div.innerHTML = "<textarea>x</textarea>";
+	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
 
 	// Support: IE <=9 only
-	option: [ 1, "<select multiple='multiple'>", "</select>" ],
+	// IE <=9 replaces <option> tags with their contents when inserted outside of
+	// the select element.
+	div.innerHTML = "<option></option>";
+	support.option = !!div.lastChild;
+} )();
+
+
+// We have to close these tags to support XHTML (#13200)
+var wrapMap = {
 
 	// XHTML parsers do not magically insert elements in the
 	// same way that tag soup parsers do. So we cannot shorten
@@ -4715,12 +4949,14 @@ var wrapMap = {
 	_default: [ 0, "", "" ]
 };
 
-// Support: IE <=9 only
-wrapMap.optgroup = wrapMap.option;
-
 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
 wrapMap.th = wrapMap.td;
 
+// Support: IE <=9 only
+if ( !support.option ) {
+	wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ];
+}
+
 
 function getAll( context, tag ) {
 
@@ -4764,7 +5000,7 @@ function setGlobalEval( elems, refElements ) {
 var rhtml = /<|&#?\w+;/;
 
 function buildFragment( elems, context, scripts, selection, ignored ) {
-	var elem, tmp, tag, wrap, contains, j,
+	var elem, tmp, tag, wrap, attached, j,
 		fragment = context.createDocumentFragment(),
 		nodes = [],
 		i = 0,
@@ -4776,7 +5012,7 @@ function buildFragment( elems, context, scripts, selection, ignored ) {
 		if ( elem || elem === 0 ) {
 
 			// Add nodes directly
-			if ( jQuery.type( elem ) === "object" ) {
+			if ( toType( elem ) === "object" ) {
 
 				// Support: Android <=4.0 only, PhantomJS 1 only
 				// push.apply(_, arraylike) throws on ancient WebKit
@@ -4828,13 +5064,13 @@ function buildFragment( elems, context, scripts, selection, ignored ) {
 			continue;
 		}
 
-		contains = jQuery.contains( elem.ownerDocument, elem );
+		attached = isAttached( elem );
 
 		// Append to fragment
 		tmp = getAll( fragment.appendChild( elem ), "script" );
 
 		// Preserve script evaluation history
-		if ( contains ) {
+		if ( attached ) {
 			setGlobalEval( tmp );
 		}
 
@@ -4853,34 +5089,6 @@ function buildFragment( elems, context, scripts, selection, ignored ) {
 }
 
 
-( function() {
-	var fragment = document.createDocumentFragment(),
-		div = fragment.appendChild( document.createElement( "div" ) ),
-		input = document.createElement( "input" );
-
-	// Support: Android 4.0 - 4.3 only
-	// Check state lost if the name is set (#11217)
-	// Support: Windows Web Apps (WWA)
-	// `name` and `type` must use .setAttribute for WWA (#14901)
-	input.setAttribute( "type", "radio" );
-	input.setAttribute( "checked", "checked" );
-	input.setAttribute( "name", "t" );
-
-	div.appendChild( input );
-
-	// Support: Android <=4.1 only
-	// Older WebKit doesn't clone checked state correctly in fragments
-	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
-
-	// Support: IE <=11 only
-	// Make sure textarea (and checkbox) defaultValue is properly cloned
-	div.innerHTML = "<textarea>x</textarea>";
-	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
-} )();
-var documentElement = document.documentElement;
-
-
-
 var
 	rkeyEvent = /^key/,
 	rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
@@ -4894,8 +5102,19 @@ function returnFalse() {
 	return false;
 }
 
+// Support: IE <=9 - 11+
+// focus() and blur() are asynchronous, except when they are no-op.
+// So expect focus to be synchronous when the element is already active,
+// and blur to be synchronous when the element is not already active.
+// (focus and blur are always synchronous in other supported browsers,
+// this just defines when we can count on it).
+function expectSync( elem, type ) {
+	return ( elem === safeActiveElement() ) === ( type === "focus" );
+}
+
 // Support: IE <=9 only
-// See #13393 for more info
+// Accessing document.activeElement can throw unexpectedly
+// https://bugs.jquery.com/ticket/13393
 function safeActiveElement() {
 	try {
 		return document.activeElement;
@@ -4978,8 +5197,8 @@ jQuery.event = {
 			special, handlers, type, namespaces, origType,
 			elemData = dataPriv.get( elem );
 
-		// Don't attach events to noData or text/comment nodes (but allow plain objects)
-		if ( !elemData ) {
+		// Only attach events to objects that accept data
+		if ( !acceptData( elem ) ) {
 			return;
 		}
 
@@ -5003,7 +5222,7 @@ jQuery.event = {
 
 		// Init the element's event structure and main handler, if this is the first
 		if ( !( events = elemData.events ) ) {
-			events = elemData.events = {};
+			events = elemData.events = Object.create( null );
 		}
 		if ( !( eventHandle = elemData.handle ) ) {
 			eventHandle = elemData.handle = function( e ) {
@@ -5161,12 +5380,15 @@ jQuery.event = {
 
 	dispatch: function( nativeEvent ) {
 
-		// Make a writable jQuery.Event from the native event object
-		var event = jQuery.event.fix( nativeEvent );
-
 		var i, j, ret, matched, handleObj, handlerQueue,
 			args = new Array( arguments.length ),
-			handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
+
+			// Make a writable jQuery.Event from the native event object
+			event = jQuery.event.fix( nativeEvent ),
+
+			handlers = (
+					dataPriv.get( this, "events" ) || Object.create( null )
+				)[ event.type ] || [],
 			special = jQuery.event.special[ event.type ] || {};
 
 		// Use the fix-ed jQuery.Event rather than the (read-only) native event
@@ -5195,9 +5417,10 @@ jQuery.event = {
 			while ( ( handleObj = matched.handlers[ j++ ] ) &&
 				!event.isImmediatePropagationStopped() ) {
 
-				// Triggered event must either 1) have no namespace, or 2) have namespace(s)
-				// a subset or equal to those in the bound event (both can have no namespace).
-				if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
+				// If the event is namespaced, then each handler is only invoked if it is
+				// specially universal or its namespaces are a superset of the event's.
+				if ( !event.rnamespace || handleObj.namespace === false ||
+					event.rnamespace.test( handleObj.namespace ) ) {
 
 					event.handleObj = handleObj;
 					event.data = handleObj.data;
@@ -5286,7 +5509,7 @@ jQuery.event = {
 			enumerable: true,
 			configurable: true,
 
-			get: jQuery.isFunction( hook ) ?
+			get: isFunction( hook ) ?
 				function() {
 					if ( this.originalEvent ) {
 							return hook( this.originalEvent );
@@ -5321,39 +5544,51 @@ jQuery.event = {
 			// Prevent triggered image.load events from bubbling to window.load
 			noBubble: true
 		},
-		focus: {
+		click: {
 
-			// Fire native event if possible so blur/focus sequence is correct
-			trigger: function() {
-				if ( this !== safeActiveElement() && this.focus ) {
-					this.focus();
-					return false;
-				}
-			},
-			delegateType: "focusin"
-		},
-		blur: {
-			trigger: function() {
-				if ( this === safeActiveElement() && this.blur ) {
-					this.blur();
-					return false;
+			// Utilize native event to ensure correct state for checkable inputs
+			setup: function( data ) {
+
+				// For mutual compressibility with _default, replace `this` access with a local var.
+				// `|| data` is dead code meant only to preserve the variable through minification.
+				var el = this || data;
+
+				// Claim the first handler
+				if ( rcheckableType.test( el.type ) &&
+					el.click && nodeName( el, "input" ) ) {
+
+					// dataPriv.set( el, "click", ... )
+					leverageNative( el, "click", returnTrue );
 				}
+
+				// Return false to allow normal processing in the caller
+				return false;
 			},
-			delegateType: "focusout"
-		},
-		click: {
+			trigger: function( data ) {
 
-			// For checkbox, fire native event so checked state will be right
-			trigger: function() {
-				if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) {
-					this.click();
-					return false;
+				// For mutual compressibility with _default, replace `this` access with a local var.
+				// `|| data` is dead code meant only to preserve the variable through minification.
+				var el = this || data;
+
+				// Force setup before triggering a click
+				if ( rcheckableType.test( el.type ) &&
+					el.click && nodeName( el, "input" ) ) {
+
+					leverageNative( el, "click" );
 				}
+
+				// Return non-false to allow normal event-path propagation
+				return true;
 			},
 
-			// For cross-browser consistency, don't fire native .click() on links
+			// For cross-browser consistency, suppress native .click() on links
+			// Also prevent it if we're currently inside a leveraged native-event stack
 			_default: function( event ) {
-				return nodeName( event.target, "a" );
+				var target = event.target;
+				return rcheckableType.test( target.type ) &&
+					target.click && nodeName( target, "input" ) &&
+					dataPriv.get( target, "click" ) ||
+					nodeName( target, "a" );
 			}
 		},
 
@@ -5367,8 +5602,95 @@ jQuery.event = {
 				}
 			}
 		}
-	}
-};
+	}
+};
+
+// Ensure the presence of an event listener that handles manually-triggered
+// synthetic events by interrupting progress until reinvoked in response to
+// *native* events that it fires directly, ensuring that state changes have
+// already occurred before other listeners are invoked.
+function leverageNative( el, type, expectSync ) {
+
+	// Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add
+	if ( !expectSync ) {
+		if ( dataPriv.get( el, type ) === undefined ) {
+			jQuery.event.add( el, type, returnTrue );
+		}
+		return;
+	}
+
+	// Register the controller as a special universal handler for all event namespaces
+	dataPriv.set( el, type, false );
+	jQuery.event.add( el, type, {
+		namespace: false,
+		handler: function( event ) {
+			var notAsync, result,
+				saved = dataPriv.get( this, type );
+
+			if ( ( event.isTrigger & 1 ) && this[ type ] ) {
+
+				// Interrupt processing of the outer synthetic .trigger()ed event
+				// Saved data should be false in such cases, but might be a leftover capture object
+				// from an async native handler (gh-4350)
+				if ( !saved.length ) {
+
+					// Store arguments for use when handling the inner native event
+					// There will always be at least one argument (an event object), so this array
+					// will not be confused with a leftover capture object.
+					saved = slice.call( arguments );
+					dataPriv.set( this, type, saved );
+
+					// Trigger the native event and capture its result
+					// Support: IE <=9 - 11+
+					// focus() and blur() are asynchronous
+					notAsync = expectSync( this, type );
+					this[ type ]();
+					result = dataPriv.get( this, type );
+					if ( saved !== result || notAsync ) {
+						dataPriv.set( this, type, false );
+					} else {
+						result = {};
+					}
+					if ( saved !== result ) {
+
+						// Cancel the outer synthetic event
+						event.stopImmediatePropagation();
+						event.preventDefault();
+						return result.value;
+					}
+
+				// If this is an inner synthetic event for an event with a bubbling surrogate
+				// (focus or blur), assume that the surrogate already propagated from triggering the
+				// native event and prevent that from happening again here.
+				// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
+				// bubbling surrogate propagates *after* the non-bubbling base), but that seems
+				// less bad than duplication.
+				} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
+					event.stopPropagation();
+				}
+
+			// If this is a native event triggered above, everything is now in order
+			// Fire an inner synthetic event with the original arguments
+			} else if ( saved.length ) {
+
+				// ...and capture the result
+				dataPriv.set( this, type, {
+					value: jQuery.event.trigger(
+
+						// Support: IE <=9 - 11+
+						// Extend with the prototype to reset the above stopImmediatePropagation()
+						jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),
+						saved.slice( 1 ),
+						this
+					)
+				} );
+
+				// Abort handling of the native event
+				event.stopImmediatePropagation();
+			}
+		}
+	} );
+}
 
 jQuery.removeEvent = function( elem, type, handle ) {
 
@@ -5421,7 +5743,7 @@ jQuery.Event = function( src, props ) {
 	}
 
 	// Create a timestamp if incoming event doesn't have one
-	this.timeStamp = src && src.timeStamp || jQuery.now();
+	this.timeStamp = src && src.timeStamp || Date.now();
 
 	// Mark it as fixed
 	this[ jQuery.expando ] = true;
@@ -5482,6 +5804,7 @@ jQuery.each( {
 	shiftKey: true,
 	view: true,
 	"char": true,
+	code: true,
 	charCode: true,
 	key: true,
 	keyCode: true,
@@ -5528,6 +5851,33 @@ jQuery.each( {
 	}
 }, jQuery.event.addProp );
 
+jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
+	jQuery.event.special[ type ] = {
+
+		// Utilize native event if possible so blur/focus sequence is correct
+		setup: function() {
+
+			// Claim the first handler
+			// dataPriv.set( this, "focus", ... )
+			// dataPriv.set( this, "blur", ... )
+			leverageNative( this, type, expectSync );
+
+			// Return false to allow normal processing in the caller
+			return false;
+		},
+		trigger: function() {
+
+			// Force setup before trigger
+			leverageNative( this, type );
+
+			// Return non-false to allow normal event-path propagation
+			return true;
+		},
+
+		delegateType: delegateType
+	};
+} );
+
 // Create mouseenter/leave events using mouseover/out and event-time checks
 // so that event delegation works in jQuery.
 // Do the same for pointerenter/pointerleave and pointerover/pointerout
@@ -5613,21 +5963,13 @@ jQuery.fn.extend( {
 
 var
 
-	/* eslint-disable max-len */
-
-	// See https://github.com/eslint/eslint/issues/3229
-	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
-
-	/* eslint-enable */
-
-	// Support: IE <=10 - 11, Edge 12 - 13
+	// Support: IE <=10 - 11, Edge 12 - 13 only
 	// In IE/Edge using regex groups here causes severe slowdowns.
 	// See https://connect.microsoft.com/IE/feedback/details/1736512/
 	rnoInnerhtml = /<script|<style|<link/i,
 
 	// checked="checked" or checked
 	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
-	rscriptTypeMasked = /^true\/(.*)/,
 	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
 
 // Prefer a tbody over its parent table for containing new rows
@@ -5635,7 +5977,7 @@ function manipulationTarget( elem, content ) {
 	if ( nodeName( elem, "table" ) &&
 		nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
 
-		return jQuery( ">tbody", elem )[ 0 ] || elem;
+		return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
 	}
 
 	return elem;
@@ -5647,10 +5989,8 @@ function disableScript( elem ) {
 	return elem;
 }
 function restoreScript( elem ) {
-	var match = rscriptTypeMasked.exec( elem.type );
-
-	if ( match ) {
-		elem.type = match[ 1 ];
+	if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
+		elem.type = elem.type.slice( 5 );
 	} else {
 		elem.removeAttribute( "type" );
 	}
@@ -5659,7 +5999,7 @@ function restoreScript( elem ) {
 }
 
 function cloneCopyEvent( src, dest ) {
-	var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
+	var i, l, type, pdataOld, udataOld, udataCur, events;
 
 	if ( dest.nodeType !== 1 ) {
 		return;
@@ -5667,13 +6007,11 @@ function cloneCopyEvent( src, dest ) {
 
 	// 1. Copy private data: events, handlers, etc.
 	if ( dataPriv.hasData( src ) ) {
-		pdataOld = dataPriv.access( src );
-		pdataCur = dataPriv.set( dest, pdataOld );
+		pdataOld = dataPriv.get( src );
 		events = pdataOld.events;
 
 		if ( events ) {
-			delete pdataCur.handle;
-			pdataCur.events = {};
+			dataPriv.remove( dest, "handle events" );
 
 			for ( type in events ) {
 				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
@@ -5709,22 +6047,22 @@ function fixInput( src, dest ) {
 function domManip( collection, args, callback, ignored ) {
 
 	// Flatten any nested arrays
-	args = concat.apply( [], args );
+	args = flat( args );
 
 	var fragment, first, scripts, hasScripts, node, doc,
 		i = 0,
 		l = collection.length,
 		iNoClone = l - 1,
 		value = args[ 0 ],
-		isFunction = jQuery.isFunction( value );
+		valueIsFunction = isFunction( value );
 
 	// We can't cloneNode fragments that contain checked, in WebKit
-	if ( isFunction ||
+	if ( valueIsFunction ||
 			( l > 1 && typeof value === "string" &&
 				!support.checkClone && rchecked.test( value ) ) ) {
 		return collection.each( function( index ) {
 			var self = collection.eq( index );
-			if ( isFunction ) {
+			if ( valueIsFunction ) {
 				args[ 0 ] = value.call( this, index, self.html() );
 			}
 			domManip( self, args, callback, ignored );
@@ -5778,14 +6116,16 @@ function domManip( collection, args, callback, ignored ) {
 						!dataPriv.access( node, "globalEval" ) &&
 						jQuery.contains( doc, node ) ) {
 
-						if ( node.src ) {
+						if ( node.src && ( node.type || "" ).toLowerCase()  !== "module" ) {
 
 							// Optional AJAX dependency, but won't run scripts if not present
-							if ( jQuery._evalUrl ) {
-								jQuery._evalUrl( node.src );
+							if ( jQuery._evalUrl && !node.noModule ) {
+								jQuery._evalUrl( node.src, {
+									nonce: node.nonce || node.getAttribute( "nonce" )
+								}, doc );
 							}
 						} else {
-							DOMEval( node.textContent.replace( rcleanScript, "" ), doc );
+							DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );
 						}
 					}
 				}
@@ -5807,7 +6147,7 @@ function remove( elem, selector, keepData ) {
 		}
 
 		if ( node.parentNode ) {
-			if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
+			if ( keepData && isAttached( node ) ) {
 				setGlobalEval( getAll( node, "script" ) );
 			}
 			node.parentNode.removeChild( node );
@@ -5819,13 +6159,13 @@ function remove( elem, selector, keepData ) {
 
 jQuery.extend( {
 	htmlPrefilter: function( html ) {
-		return html.replace( rxhtmlTag, "<$1></$2>" );
+		return html;
 	},
 
 	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
 		var i, l, srcElements, destElements,
 			clone = elem.cloneNode( true ),
-			inPage = jQuery.contains( elem.ownerDocument, elem );
+			inPage = isAttached( elem );
 
 		// Fix IE cloning issues
 		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
@@ -6065,8 +6405,6 @@ jQuery.each( {
 		return this.pushStack( ret );
 	};
 } );
-var rmargin = ( /^margin/ );
-
 var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
 
 var getStyles = function( elem ) {
@@ -6083,6 +6421,29 @@ var getStyles = function( elem ) {
 		return view.getComputedStyle( elem );
 	};
 
+var swap = function( elem, options, callback ) {
+	var ret, name,
+		old = {};
+
+	// Remember the old values, and insert the new ones
+	for ( name in options ) {
+		old[ name ] = elem.style[ name ];
+		elem.style[ name ] = options[ name ];
+	}
+
+	ret = callback.call( elem );
+
+	// Revert the old values
+	for ( name in options ) {
+		elem.style[ name ] = old[ name ];
+	}
+
+	return ret;
+};
+
+
+var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
+
 
 
 ( function() {
@@ -6096,25 +6457,35 @@ var getStyles = function( elem ) {
 			return;
 		}
 
+		container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
+			"margin-top:1px;padding:0;border:0";
 		div.style.cssText =
-			"box-sizing:border-box;" +
-			"position:relative;display:block;" +
+			"position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
 			"margin:auto;border:1px;padding:1px;" +
-			"top:1%;width:50%";
-		div.innerHTML = "";
-		documentElement.appendChild( container );
+			"width:60%;top:1%";
+		documentElement.appendChild( container ).appendChild( div );
 
 		var divStyle = window.getComputedStyle( div );
 		pixelPositionVal = divStyle.top !== "1%";
 
 		// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
-		reliableMarginLeftVal = divStyle.marginLeft === "2px";
-		boxSizingReliableVal = divStyle.width === "4px";
+		reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
 
-		// Support: Android 4.0 - 4.3 only
+		// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
 		// Some styles come back with percentage values, even though they shouldn't
-		div.style.marginRight = "50%";
-		pixelMarginRightVal = divStyle.marginRight === "4px";
+		div.style.right = "60%";
+		pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
+
+		// Support: IE 9 - 11 only
+		// Detect misreporting of content dimensions for box-sizing:border-box elements
+		boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
+
+		// Support: IE 9 only
+		// Detect overflow:scroll screwiness (gh-3699)
+		// Support: Chrome <=64
+		// Don't get tricked when zoom affects offsetWidth (gh-4029)
+		div.style.position = "absolute";
+		scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
 
 		documentElement.removeChild( container );
 
@@ -6123,7 +6494,12 @@ var getStyles = function( elem ) {
 		div = null;
 	}
 
-	var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
+	function roundPixelMeasures( measure ) {
+		return Math.round( parseFloat( measure ) );
+	}
+
+	var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
+		reliableTrDimensionsVal, reliableMarginLeftVal,
 		container = document.createElement( "div" ),
 		div = document.createElement( "div" );
 
@@ -6138,26 +6514,55 @@ var getStyles = function( elem ) {
 	div.cloneNode( true ).style.backgroundClip = "";
 	support.clearCloneStyle = div.style.backgroundClip === "content-box";
 
-	container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
-		"padding:0;margin-top:1px;position:absolute";
-	container.appendChild( div );
-
 	jQuery.extend( support, {
-		pixelPosition: function() {
-			computeStyleTests();
-			return pixelPositionVal;
-		},
 		boxSizingReliable: function() {
 			computeStyleTests();
 			return boxSizingReliableVal;
 		},
-		pixelMarginRight: function() {
+		pixelBoxStyles: function() {
 			computeStyleTests();
-			return pixelMarginRightVal;
+			return pixelBoxStylesVal;
+		},
+		pixelPosition: function() {
+			computeStyleTests();
+			return pixelPositionVal;
 		},
 		reliableMarginLeft: function() {
 			computeStyleTests();
 			return reliableMarginLeftVal;
+		},
+		scrollboxSize: function() {
+			computeStyleTests();
+			return scrollboxSizeVal;
+		},
+
+		// Support: IE 9 - 11+, Edge 15 - 18+
+		// IE/Edge misreport `getComputedStyle` of table rows with width/height
+		// set in CSS while `offset*` properties report correct values.
+		// Behavior in IE 9 is more subtle than in newer versions & it passes
+		// some versions of this test; make sure not to make it pass there!
+		reliableTrDimensions: function() {
+			var table, tr, trChild, trStyle;
+			if ( reliableTrDimensionsVal == null ) {
+				table = document.createElement( "table" );
+				tr = document.createElement( "tr" );
+				trChild = document.createElement( "div" );
+
+				table.style.cssText = "position:absolute;left:-11111px";
+				tr.style.height = "1px";
+				trChild.style.height = "9px";
+
+				documentElement
+					.appendChild( table )
+					.appendChild( tr )
+					.appendChild( trChild );
+
+				trStyle = window.getComputedStyle( tr );
+				reliableTrDimensionsVal = parseInt( trStyle.height ) > 3;
+
+				documentElement.removeChild( table );
+			}
+			return reliableTrDimensionsVal;
 		}
 	} );
 } )();
@@ -6180,7 +6585,7 @@ function curCSS( elem, name, computed ) {
 	if ( computed ) {
 		ret = computed.getPropertyValue( name ) || computed[ name ];
 
-		if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
+		if ( ret === "" && !isAttached( elem ) ) {
 			ret = jQuery.style( elem, name );
 		}
 
@@ -6189,7 +6594,7 @@ function curCSS( elem, name, computed ) {
 		// but width seems to be reliably pixels.
 		// This is against the CSSOM draft spec:
 		// https://drafts.csswg.org/cssom/#resolved-values
-		if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
+		if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
 
 			// Remember the original values
 			width = style.width;
@@ -6236,30 +6641,13 @@ function addGetHookIf( conditionFn, hookFn ) {
 }
 
 
-var
-
-	// Swappable if display is none or starts with table
-	// except "table", "table-cell", or "table-caption"
-	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
-	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
-	rcustomProp = /^--/,
-	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
-	cssNormalTransform = {
-		letterSpacing: "0",
-		fontWeight: "400"
-	},
-
-	cssPrefixes = [ "Webkit", "Moz", "ms" ],
-	emptyStyle = document.createElement( "div" ).style;
+var cssPrefixes = [ "Webkit", "Moz", "ms" ],
+	emptyStyle = document.createElement( "div" ).style,
+	vendorProps = {};
 
-// Return a css property mapped to a potentially vendor prefixed property
+// Return a vendor-prefixed property or undefined
 function vendorPropName( name ) {
 
-	// Shortcut for names that are not vendor prefixed
-	if ( name in emptyStyle ) {
-		return name;
-	}
-
 	// Check for vendor prefixed names
 	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
 		i = cssPrefixes.length;
@@ -6272,17 +6660,34 @@ function vendorPropName( name ) {
 	}
 }
 
-// Return a property mapped along what jQuery.cssProps suggests or to
-// a vendor prefixed property.
+// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
 function finalPropName( name ) {
-	var ret = jQuery.cssProps[ name ];
-	if ( !ret ) {
-		ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;
+	var final = jQuery.cssProps[ name ] || vendorProps[ name ];
+
+	if ( final ) {
+		return final;
 	}
-	return ret;
+	if ( name in emptyStyle ) {
+		return name;
+	}
+	return vendorProps[ name ] = vendorPropName( name ) || name;
 }
 
-function setPositiveNumber( elem, value, subtract ) {
+
+var
+
+	// Swappable if display is none or starts with table
+	// except "table", "table-cell", or "table-caption"
+	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
+	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
+	rcustomProp = /^--/,
+	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
+	cssNormalTransform = {
+		letterSpacing: "0",
+		fontWeight: "400"
+	};
+
+function setPositiveNumber( _elem, value, subtract ) {
 
 	// Any relative (+/-) values have already been
 	// normalized at this point
@@ -6294,87 +6699,146 @@ function setPositiveNumber( elem, value, subtract ) {
 		value;
 }
 
-function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
-	var i,
-		val = 0;
-
-	// If we already have the right measurement, avoid augmentation
-	if ( extra === ( isBorderBox ? "border" : "content" ) ) {
-		i = 4;
+function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
+	var i = dimension === "width" ? 1 : 0,
+		extra = 0,
+		delta = 0;
 
-	// Otherwise initialize for horizontal or vertical properties
-	} else {
-		i = name === "width" ? 1 : 0;
+	// Adjustment may not be necessary
+	if ( box === ( isBorderBox ? "border" : "content" ) ) {
+		return 0;
 	}
 
 	for ( ; i < 4; i += 2 ) {
 
-		// Both box models exclude margin, so add it if we want it
-		if ( extra === "margin" ) {
-			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
+		// Both box models exclude margin
+		if ( box === "margin" ) {
+			delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
 		}
 
-		if ( isBorderBox ) {
+		// If we get here with a content-box, we're seeking "padding" or "border" or "margin"
+		if ( !isBorderBox ) {
 
-			// border-box includes padding, so remove it if we want content
-			if ( extra === "content" ) {
-				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
-			}
+			// Add padding
+			delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
 
-			// At this point, extra isn't border nor margin, so remove border
-			if ( extra !== "margin" ) {
-				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+			// For "border" or "margin", add border
+			if ( box !== "padding" ) {
+				delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+
+			// But still keep track of it otherwise
+			} else {
+				extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 			}
+
+		// If we get here with a border-box (content + padding + border), we're seeking "content" or
+		// "padding" or "margin"
 		} else {
 
-			// At this point, extra isn't content, so add padding
-			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+			// For "content", subtract padding
+			if ( box === "content" ) {
+				delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+			}
 
-			// At this point, extra isn't content nor padding, so add border
-			if ( extra !== "padding" ) {
-				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+			// For "content" or "padding", subtract border
+			if ( box !== "margin" ) {
+				delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 			}
 		}
 	}
 
-	return val;
+	// Account for positive content-box scroll gutter when requested by providing computedVal
+	if ( !isBorderBox && computedVal >= 0 ) {
+
+		// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
+		// Assuming integer scroll gutter, subtract the rest and round down
+		delta += Math.max( 0, Math.ceil(
+			elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
+			computedVal -
+			delta -
+			extra -
+			0.5
+
+		// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
+		// Use an explicit zero to avoid NaN (gh-3964)
+		) ) || 0;
+	}
+
+	return delta;
 }
 
-function getWidthOrHeight( elem, name, extra ) {
+function getWidthOrHeight( elem, dimension, extra ) {
 
 	// Start with computed style
-	var valueIsBorderBox,
-		styles = getStyles( elem ),
-		val = curCSS( elem, name, styles ),
-		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
+	var styles = getStyles( elem ),
+
+		// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
+		// Fake content-box until we know it's needed to know the true value.
+		boxSizingNeeded = !support.boxSizingReliable() || extra,
+		isBorderBox = boxSizingNeeded &&
+			jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
+		valueIsBorderBox = isBorderBox,
 
-	// Computed unit is not pixels. Stop here and return.
+		val = curCSS( elem, dimension, styles ),
+		offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
+
+	// Support: Firefox <=54
+	// Return a confounding non-pixel value or feign ignorance, as appropriate.
 	if ( rnumnonpx.test( val ) ) {
-		return val;
+		if ( !extra ) {
+			return val;
+		}
+		val = "auto";
 	}
 
-	// Check for style in case a browser which returns unreliable values
-	// for getComputedStyle silently falls back to the reliable elem.style
-	valueIsBorderBox = isBorderBox &&
-		( support.boxSizingReliable() || val === elem.style[ name ] );
 
-	// Fall back to offsetWidth/Height when value is "auto"
-	// This happens for inline elements with no explicit setting (gh-3571)
-	if ( val === "auto" ) {
-		val = elem[ "offset" + name[ 0 ].toUpperCase() + name.slice( 1 ) ];
+	// Support: IE 9 - 11 only
+	// Use offsetWidth/offsetHeight for when box sizing is unreliable.
+	// In those cases, the computed value can be trusted to be border-box.
+	if ( ( !support.boxSizingReliable() && isBorderBox ||
+
+		// Support: IE 10 - 11+, Edge 15 - 18+
+		// IE/Edge misreport `getComputedStyle` of table rows with width/height
+		// set in CSS while `offset*` properties report correct values.
+		// Interestingly, in some cases IE 9 doesn't suffer from this issue.
+		!support.reliableTrDimensions() && nodeName( elem, "tr" ) ||
+
+		// Fall back to offsetWidth/offsetHeight when value is "auto"
+		// This happens for inline elements with no explicit setting (gh-3571)
+		val === "auto" ||
+
+		// Support: Android <=4.1 - 4.3 only
+		// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
+		!parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
+
+		// Make sure the element is visible & connected
+		elem.getClientRects().length ) {
+
+		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
+
+		// Where available, offsetWidth/offsetHeight approximate border box dimensions.
+		// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
+		// retrieved value as a content box dimension.
+		valueIsBorderBox = offsetProp in elem;
+		if ( valueIsBorderBox ) {
+			val = elem[ offsetProp ];
+		}
 	}
 
-	// Normalize "", auto, and prepare for extra
+	// Normalize "" and auto
 	val = parseFloat( val ) || 0;
 
-	// Use the active box-sizing model to add/subtract irrelevant styles
+	// Adjust for the element's box model
 	return ( val +
-		augmentWidthOrHeight(
+		boxModelAdjustment(
 			elem,
-			name,
+			dimension,
 			extra || ( isBorderBox ? "border" : "content" ),
 			valueIsBorderBox,
-			styles
+			styles,
+
+			// Provide the current computed size to request scroll gutter calculation (gh-3589)
+			val
 		)
 	) + "px";
 }
@@ -6404,6 +6868,13 @@ jQuery.extend( {
 		"flexGrow": true,
 		"flexShrink": true,
 		"fontWeight": true,
+		"gridArea": true,
+		"gridColumn": true,
+		"gridColumnEnd": true,
+		"gridColumnStart": true,
+		"gridRow": true,
+		"gridRowEnd": true,
+		"gridRowStart": true,
 		"lineHeight": true,
 		"opacity": true,
 		"order": true,
@@ -6415,9 +6886,7 @@ jQuery.extend( {
 
 	// Add in properties whose names you wish to fix before
 	// setting or getting the value
-	cssProps: {
-		"float": "cssFloat"
-	},
+	cssProps: {},
 
 	// Get and set the style property on a DOM Node
 	style: function( elem, name, value, extra ) {
@@ -6429,7 +6898,7 @@ jQuery.extend( {
 
 		// Make sure that we're working with the right name
 		var ret, type, hooks,
-			origName = jQuery.camelCase( name ),
+			origName = camelCase( name ),
 			isCustomProp = rcustomProp.test( name ),
 			style = elem.style;
 
@@ -6461,7 +6930,9 @@ jQuery.extend( {
 			}
 
 			// If a number was passed in, add the unit (except for certain CSS properties)
-			if ( type === "number" ) {
+			// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
+			// "px" to a few hardcoded values.
+			if ( type === "number" && !isCustomProp ) {
 				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
 			}
 
@@ -6497,7 +6968,7 @@ jQuery.extend( {
 
 	css: function( elem, name, extra, styles ) {
 		var val, num, hooks,
-			origName = jQuery.camelCase( name ),
+			origName = camelCase( name ),
 			isCustomProp = rcustomProp.test( name );
 
 		// Make sure that we're working with the right name. We don't
@@ -6535,8 +7006,8 @@ jQuery.extend( {
 	}
 } );
 
-jQuery.each( [ "height", "width" ], function( i, name ) {
-	jQuery.cssHooks[ name ] = {
+jQuery.each( [ "height", "width" ], function( _i, dimension ) {
+	jQuery.cssHooks[ dimension ] = {
 		get: function( elem, computed, extra ) {
 			if ( computed ) {
 
@@ -6552,29 +7023,52 @@ jQuery.each( [ "height", "width" ], function( i, name ) {
 					// in IE throws an error.
 					( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
 						swap( elem, cssShow, function() {
-							return getWidthOrHeight( elem, name, extra );
+							return getWidthOrHeight( elem, dimension, extra );
 						} ) :
-						getWidthOrHeight( elem, name, extra );
+						getWidthOrHeight( elem, dimension, extra );
 			}
 		},
 
 		set: function( elem, value, extra ) {
 			var matches,
-				styles = extra && getStyles( elem ),
-				subtract = extra && augmentWidthOrHeight(
-					elem,
-					name,
-					extra,
+				styles = getStyles( elem ),
+
+				// Only read styles.position if the test has a chance to fail
+				// to avoid forcing a reflow.
+				scrollboxSizeBuggy = !support.scrollboxSize() &&
+					styles.position === "absolute",
+
+				// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
+				boxSizingNeeded = scrollboxSizeBuggy || extra,
+				isBorderBox = boxSizingNeeded &&
 					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
-					styles
+				subtract = extra ?
+					boxModelAdjustment(
+						elem,
+						dimension,
+						extra,
+						isBorderBox,
+						styles
+					) :
+					0;
+
+			// Account for unreliable border-box dimensions by comparing offset* to computed and
+			// faking a content-box to get border and padding (gh-3699)
+			if ( isBorderBox && scrollboxSizeBuggy ) {
+				subtract -= Math.ceil(
+					elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
+					parseFloat( styles[ dimension ] ) -
+					boxModelAdjustment( elem, dimension, "border", false, styles ) -
+					0.5
 				);
+			}
 
 			// Convert to pixels if value adjustment is needed
 			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
 				( matches[ 3 ] || "px" ) !== "px" ) {
 
-				elem.style[ name ] = value;
-				value = jQuery.css( elem, name );
+				elem.style[ dimension ] = value;
+				value = jQuery.css( elem, dimension );
 			}
 
 			return setPositiveNumber( elem, value, subtract );
@@ -6618,7 +7112,7 @@ jQuery.each( {
 		}
 	};
 
-	if ( !rmargin.test( prefix ) ) {
+	if ( prefix !== "margin" ) {
 		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
 	}
 } );
@@ -6728,9 +7222,9 @@ Tween.propHooks = {
 			// Use .style if available and use plain properties where available.
 			if ( jQuery.fx.step[ tween.prop ] ) {
 				jQuery.fx.step[ tween.prop ]( tween );
-			} else if ( tween.elem.nodeType === 1 &&
-				( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
-					jQuery.cssHooks[ tween.prop ] ) ) {
+			} else if ( tween.elem.nodeType === 1 && (
+					jQuery.cssHooks[ tween.prop ] ||
+					tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {
 				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
 			} else {
 				tween.elem[ tween.prop ] = tween.now;
@@ -6789,7 +7283,7 @@ function createFxNow() {
 	window.setTimeout( function() {
 		fxNow = undefined;
 	} );
-	return ( fxNow = jQuery.now() );
+	return ( fxNow = Date.now() );
 }
 
 // Generate parameters to create a standard animation
@@ -6893,9 +7387,10 @@ function defaultPrefilter( elem, props, opts ) {
 	// Restrict "overflow" and "display" styles during box animations
 	if ( isBox && elem.nodeType === 1 ) {
 
-		// Support: IE <=9 - 11, Edge 12 - 13
+		// Support: IE <=9 - 11, Edge 12 - 15
 		// Record all 3 overflow attributes because IE does not infer the shorthand
-		// from identically-valued overflowX and overflowY
+		// from identically-valued overflowX and overflowY and Edge just mirrors
+		// the overflowX value there.
 		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
 
 		// Identify a display type, preferring old show/hide data over the CSS cascade
@@ -7003,7 +7498,7 @@ function propFilter( props, specialEasing ) {
 
 	// camelCase, specialEasing and expand cssHook pass
 	for ( index in props ) {
-		name = jQuery.camelCase( index );
+		name = camelCase( index );
 		easing = specialEasing[ name ];
 		value = props[ index ];
 		if ( Array.isArray( value ) ) {
@@ -7128,9 +7623,9 @@ function Animation( elem, properties, options ) {
 	for ( ; index < length; index++ ) {
 		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
 		if ( result ) {
-			if ( jQuery.isFunction( result.stop ) ) {
+			if ( isFunction( result.stop ) ) {
 				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
-					jQuery.proxy( result.stop, result );
+					result.stop.bind( result );
 			}
 			return result;
 		}
@@ -7138,7 +7633,7 @@ function Animation( elem, properties, options ) {
 
 	jQuery.map( props, createTween, animation );
 
-	if ( jQuery.isFunction( animation.opts.start ) ) {
+	if ( isFunction( animation.opts.start ) ) {
 		animation.opts.start.call( elem, animation );
 	}
 
@@ -7171,7 +7666,7 @@ jQuery.Animation = jQuery.extend( Animation, {
 	},
 
 	tweener: function( props, callback ) {
-		if ( jQuery.isFunction( props ) ) {
+		if ( isFunction( props ) ) {
 			callback = props;
 			props = [ "*" ];
 		} else {
@@ -7203,9 +7698,9 @@ jQuery.Animation = jQuery.extend( Animation, {
 jQuery.speed = function( speed, easing, fn ) {
 	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
 		complete: fn || !fn && easing ||
-			jQuery.isFunction( speed ) && speed,
+			isFunction( speed ) && speed,
 		duration: speed,
-		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
+		easing: fn && easing || easing && !isFunction( easing ) && easing
 	};
 
 	// Go to the end state if fx are off
@@ -7232,7 +7727,7 @@ jQuery.speed = function( speed, easing, fn ) {
 	opt.old = opt.complete;
 
 	opt.complete = function() {
-		if ( jQuery.isFunction( opt.old ) ) {
+		if ( isFunction( opt.old ) ) {
 			opt.old.call( this );
 		}
 
@@ -7284,7 +7779,7 @@ jQuery.fn.extend( {
 			clearQueue = type;
 			type = undefined;
 		}
-		if ( clearQueue && type !== false ) {
+		if ( clearQueue ) {
 			this.queue( type || "fx", [] );
 		}
 
@@ -7367,7 +7862,7 @@ jQuery.fn.extend( {
 	}
 } );
 
-jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
+jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) {
 	var cssFn = jQuery.fn[ name ];
 	jQuery.fn[ name ] = function( speed, easing, callback ) {
 		return speed == null || typeof speed === "boolean" ?
@@ -7396,7 +7891,7 @@ jQuery.fx.tick = function() {
 		i = 0,
 		timers = jQuery.timers;
 
-	fxNow = jQuery.now();
+	fxNow = Date.now();
 
 	for ( ; i < timers.length; i++ ) {
 		timer = timers[ i ];
@@ -7588,7 +8083,7 @@ boolHook = {
 	}
 };
 
-jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
+jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) {
 	var getter = attrHandle[ name ] || jQuery.find.attr;
 
 	attrHandle[ name ] = function( elem, name, isXML ) {
@@ -7749,7 +8244,7 @@ jQuery.each( [
 
 
 	// Strip and collapse whitespace according to HTML spec
-	// https://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace
+	// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
 	function stripAndCollapse( value ) {
 		var tokens = value.match( rnothtmlwhite ) || [];
 		return tokens.join( " " );
@@ -7760,20 +8255,30 @@ function getClass( elem ) {
 	return elem.getAttribute && elem.getAttribute( "class" ) || "";
 }
 
+function classesToArray( value ) {
+	if ( Array.isArray( value ) ) {
+		return value;
+	}
+	if ( typeof value === "string" ) {
+		return value.match( rnothtmlwhite ) || [];
+	}
+	return [];
+}
+
 jQuery.fn.extend( {
 	addClass: function( value ) {
 		var classes, elem, cur, curValue, clazz, j, finalValue,
 			i = 0;
 
-		if ( jQuery.isFunction( value ) ) {
+		if ( isFunction( value ) ) {
 			return this.each( function( j ) {
 				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
 			} );
 		}
 
-		if ( typeof value === "string" && value ) {
-			classes = value.match( rnothtmlwhite ) || [];
+		classes = classesToArray( value );
 
+		if ( classes.length ) {
 			while ( ( elem = this[ i++ ] ) ) {
 				curValue = getClass( elem );
 				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
@@ -7802,7 +8307,7 @@ jQuery.fn.extend( {
 		var classes, elem, cur, curValue, clazz, j, finalValue,
 			i = 0;
 
-		if ( jQuery.isFunction( value ) ) {
+		if ( isFunction( value ) ) {
 			return this.each( function( j ) {
 				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
 			} );
@@ -7812,9 +8317,9 @@ jQuery.fn.extend( {
 			return this.attr( "class", "" );
 		}
 
-		if ( typeof value === "string" && value ) {
-			classes = value.match( rnothtmlwhite ) || [];
+		classes = classesToArray( value );
 
+		if ( classes.length ) {
 			while ( ( elem = this[ i++ ] ) ) {
 				curValue = getClass( elem );
 
@@ -7844,13 +8349,14 @@ jQuery.fn.extend( {
 	},
 
 	toggleClass: function( value, stateVal ) {
-		var type = typeof value;
+		var type = typeof value,
+			isValidValue = type === "string" || Array.isArray( value );
 
-		if ( typeof stateVal === "boolean" && type === "string" ) {
+		if ( typeof stateVal === "boolean" && isValidValue ) {
 			return stateVal ? this.addClass( value ) : this.removeClass( value );
 		}
 
-		if ( jQuery.isFunction( value ) ) {
+		if ( isFunction( value ) ) {
 			return this.each( function( i ) {
 				jQuery( this ).toggleClass(
 					value.call( this, i, getClass( this ), stateVal ),
@@ -7862,12 +8368,12 @@ jQuery.fn.extend( {
 		return this.each( function() {
 			var className, i, self, classNames;
 
-			if ( type === "string" ) {
+			if ( isValidValue ) {
 
 				// Toggle individual class names
 				i = 0;
 				self = jQuery( this );
-				classNames = value.match( rnothtmlwhite ) || [];
+				classNames = classesToArray( value );
 
 				while ( ( className = classNames[ i++ ] ) ) {
 
@@ -7926,7 +8432,7 @@ var rreturn = /\r/g;
 
 jQuery.fn.extend( {
 	val: function( value ) {
-		var hooks, ret, isFunction,
+		var hooks, ret, valueIsFunction,
 			elem = this[ 0 ];
 
 		if ( !arguments.length ) {
@@ -7955,7 +8461,7 @@ jQuery.fn.extend( {
 			return;
 		}
 
-		isFunction = jQuery.isFunction( value );
+		valueIsFunction = isFunction( value );
 
 		return this.each( function( i ) {
 			var val;
@@ -7964,7 +8470,7 @@ jQuery.fn.extend( {
 				return;
 			}
 
-			if ( isFunction ) {
+			if ( valueIsFunction ) {
 				val = value.call( this, i, jQuery( this ).val() );
 			} else {
 				val = value;
@@ -8106,18 +8612,24 @@ jQuery.each( [ "radio", "checkbox" ], function() {
 // Return jQuery for attributes-only inclusion
 
 
-var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
+support.focusin = "onfocusin" in window;
+
+
+var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+	stopPropagationCallback = function( e ) {
+		e.stopPropagation();
+	};
 
 jQuery.extend( jQuery.event, {
 
 	trigger: function( event, data, elem, onlyHandlers ) {
 
-		var i, cur, tmp, bubbleType, ontype, handle, special,
+		var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
 			eventPath = [ elem || document ],
 			type = hasOwn.call( event, "type" ) ? event.type : event,
 			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
 
-		cur = tmp = elem = elem || document;
+		cur = lastElement = tmp = elem = elem || document;
 
 		// Don't do events on text and comment nodes
 		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
@@ -8169,7 +8681,7 @@ jQuery.extend( jQuery.event, {
 
 		// Determine event propagation path in advance, per W3C events spec (#9951)
 		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
-		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
+		if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
 
 			bubbleType = special.delegateType || type;
 			if ( !rfocusMorph.test( bubbleType + type ) ) {
@@ -8189,13 +8701,15 @@ jQuery.extend( jQuery.event, {
 		// Fire handlers on the event path
 		i = 0;
 		while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
-
+			lastElement = cur;
 			event.type = i > 1 ?
 				bubbleType :
 				special.bindType || type;
 
 			// jQuery handler
-			handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
+			handle = (
+					dataPriv.get( cur, "events" ) || Object.create( null )
+				)[ event.type ] &&
 				dataPriv.get( cur, "handle" );
 			if ( handle ) {
 				handle.apply( cur, data );
@@ -8221,7 +8735,7 @@ jQuery.extend( jQuery.event, {
 
 				// Call a native DOM method on the target with the same name as the event.
 				// Don't do default actions on window, that's where global variables be (#6170)
-				if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {
+				if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
 
 					// Don't re-trigger an onFOO event when we call its FOO() method
 					tmp = elem[ ontype ];
@@ -8232,7 +8746,17 @@ jQuery.extend( jQuery.event, {
 
 					// Prevent re-triggering of the same event, since we already bubbled it above
 					jQuery.event.triggered = type;
+
+					if ( event.isPropagationStopped() ) {
+						lastElement.addEventListener( type, stopPropagationCallback );
+					}
+
 					elem[ type ]();
+
+					if ( event.isPropagationStopped() ) {
+						lastElement.removeEventListener( type, stopPropagationCallback );
+					}
+
 					jQuery.event.triggered = undefined;
 
 					if ( tmp ) {
@@ -8278,31 +8802,6 @@ jQuery.fn.extend( {
 } );
 
 
-jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
-	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
-	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
-	function( i, name ) {
-
-	// Handle event binding
-	jQuery.fn[ name ] = function( data, fn ) {
-		return arguments.length > 0 ?
-			this.on( name, null, data, fn ) :
-			this.trigger( name );
-	};
-} );
-
-jQuery.fn.extend( {
-	hover: function( fnOver, fnOut ) {
-		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
-	}
-} );
-
-
-
-
-support.focusin = "onfocusin" in window;
-
-
 // Support: Firefox <=44
 // Firefox doesn't have focus(in | out) events
 // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
@@ -8321,7 +8820,10 @@ if ( !support.focusin ) {
 
 		jQuery.event.special[ fix ] = {
 			setup: function() {
-				var doc = this.ownerDocument || this,
+
+				// Handle: regular nodes (via `this.ownerDocument`), window
+				// (via `this.document`) & document (via `this`).
+				var doc = this.ownerDocument || this.document || this,
 					attaches = dataPriv.access( doc, fix );
 
 				if ( !attaches ) {
@@ -8330,7 +8832,7 @@ if ( !support.focusin ) {
 				dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
 			},
 			teardown: function() {
-				var doc = this.ownerDocument || this,
+				var doc = this.ownerDocument || this.document || this,
 					attaches = dataPriv.access( doc, fix ) - 1;
 
 				if ( !attaches ) {
@@ -8346,7 +8848,7 @@ if ( !support.focusin ) {
 }
 var location = window.location;
 
-var nonce = jQuery.now();
+var nonce = { guid: Date.now() };
 
 var rquery = ( /\?/ );
 
@@ -8404,7 +8906,7 @@ function buildParams( prefix, obj, traditional, add ) {
 			}
 		} );
 
-	} else if ( !traditional && jQuery.type( obj ) === "object" ) {
+	} else if ( !traditional && toType( obj ) === "object" ) {
 
 		// Serialize object item.
 		for ( name in obj ) {
@@ -8426,7 +8928,7 @@ jQuery.param = function( a, traditional ) {
 		add = function( key, valueOrFunction ) {
 
 			// If value is a function, invoke it and use its return value
-			var value = jQuery.isFunction( valueOrFunction ) ?
+			var value = isFunction( valueOrFunction ) ?
 				valueOrFunction() :
 				valueOrFunction;
 
@@ -8434,6 +8936,10 @@ jQuery.param = function( a, traditional ) {
 				encodeURIComponent( value == null ? "" : value );
 		};
 
+	if ( a == null ) {
+		return "";
+	}
+
 	// If an array was passed in, assume that it is an array of form elements.
 	if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
 
@@ -8474,7 +8980,7 @@ jQuery.fn.extend( {
 				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
 				( this.checked || !rcheckableType.test( type ) );
 		} )
-		.map( function( i, elem ) {
+		.map( function( _i, elem ) {
 			var val = jQuery( this ).val();
 
 			if ( val == null ) {
@@ -8544,7 +9050,7 @@ function addToPrefiltersOrTransports( structure ) {
 			i = 0,
 			dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
 
-		if ( jQuery.isFunction( func ) ) {
+		if ( isFunction( func ) ) {
 
 			// For each dataType in the dataTypeExpression
 			while ( ( dataType = dataTypes[ i++ ] ) ) {
@@ -8936,12 +9442,14 @@ jQuery.extend( {
 						if ( !responseHeaders ) {
 							responseHeaders = {};
 							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
-								responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
+								responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
+									( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
+										.concat( match[ 2 ] );
 							}
 						}
-						match = responseHeaders[ key.toLowerCase() ];
+						match = responseHeaders[ key.toLowerCase() + " " ];
 					}
-					return match == null ? null : match;
+					return match == null ? null : match.join( ", " );
 				},
 
 				// Raw string
@@ -9016,7 +9524,7 @@ jQuery.extend( {
 		if ( s.crossDomain == null ) {
 			urlAnchor = document.createElement( "a" );
 
-			// Support: IE <=8 - 11, Edge 12 - 13
+			// Support: IE <=8 - 11, Edge 12 - 15
 			// IE throws exception on accessing the href property if url is malformed,
 			// e.g. http://example.com:80x/
 			try {
@@ -9074,8 +9582,8 @@ jQuery.extend( {
 			// Remember the hash so we can put it back
 			uncached = s.url.slice( cacheURL.length );
 
-			// If data is available, append data to url
-			if ( s.data ) {
+			// If data is available and should be processed, append data to url
+			if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
 				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
 
 				// #9682: remove data so that it's not used in an eventual retry
@@ -9085,7 +9593,8 @@ jQuery.extend( {
 			// Add or update anti-cache param if needed
 			if ( s.cache === false ) {
 				cacheURL = cacheURL.replace( rantiCache, "$1" );
-				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
+				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) +
+					uncached;
 			}
 
 			// Put hash and anti-cache on the URL that will be requested (gh-1732)
@@ -9218,6 +9727,11 @@ jQuery.extend( {
 				response = ajaxHandleResponses( s, jqXHR, responses );
 			}
 
+			// Use a noop converter for missing script
+			if ( !isSuccess && jQuery.inArray( "script", s.dataTypes ) > -1 ) {
+				s.converters[ "text script" ] = function() {};
+			}
+
 			// Convert no matter what (that way responseXXX fields are always set)
 			response = ajaxConvert( s, response, jqXHR, isSuccess );
 
@@ -9308,11 +9822,11 @@ jQuery.extend( {
 	}
 } );
 
-jQuery.each( [ "get", "post" ], function( i, method ) {
+jQuery.each( [ "get", "post" ], function( _i, method ) {
 	jQuery[ method ] = function( url, data, callback, type ) {
 
 		// Shift arguments if data argument was omitted
-		if ( jQuery.isFunction( data ) ) {
+		if ( isFunction( data ) ) {
 			type = type || callback;
 			callback = data;
 			data = undefined;
@@ -9329,8 +9843,17 @@ jQuery.each( [ "get", "post" ], function( i, method ) {
 	};
 } );
 
+jQuery.ajaxPrefilter( function( s ) {
+	var i;
+	for ( i in s.headers ) {
+		if ( i.toLowerCase() === "content-type" ) {
+			s.contentType = s.headers[ i ] || "";
+		}
+	}
+} );
+
 
-jQuery._evalUrl = function( url ) {
+jQuery._evalUrl = function( url, options, doc ) {
 	return jQuery.ajax( {
 		url: url,
 
@@ -9340,7 +9863,16 @@ jQuery._evalUrl = function( url ) {
 		cache: true,
 		async: false,
 		global: false,
-		"throws": true
+
+		// Only evaluate the response if it is successful (gh-4126)
+		// dataFilter is not invoked for failure responses, so using it instead
+		// of the default converter is kludgy but it works.
+		converters: {
+			"text script": function() {}
+		},
+		dataFilter: function( response ) {
+			jQuery.globalEval( response, options, doc );
+		}
 	} );
 };
 
@@ -9350,7 +9882,7 @@ jQuery.fn.extend( {
 		var wrap;
 
 		if ( this[ 0 ] ) {
-			if ( jQuery.isFunction( html ) ) {
+			if ( isFunction( html ) ) {
 				html = html.call( this[ 0 ] );
 			}
 
@@ -9376,7 +9908,7 @@ jQuery.fn.extend( {
 	},
 
 	wrapInner: function( html ) {
-		if ( jQuery.isFunction( html ) ) {
+		if ( isFunction( html ) ) {
 			return this.each( function( i ) {
 				jQuery( this ).wrapInner( html.call( this, i ) );
 			} );
@@ -9396,10 +9928,10 @@ jQuery.fn.extend( {
 	},
 
 	wrap: function( html ) {
-		var isFunction = jQuery.isFunction( html );
+		var htmlIsFunction = isFunction( html );
 
 		return this.each( function( i ) {
-			jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );
+			jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
 		} );
 	},
 
@@ -9491,7 +10023,8 @@ jQuery.ajaxTransport( function( options ) {
 					return function() {
 						if ( callback ) {
 							callback = errorCallback = xhr.onload =
-								xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;
+								xhr.onerror = xhr.onabort = xhr.ontimeout =
+									xhr.onreadystatechange = null;
 
 							if ( type === "abort" ) {
 								xhr.abort();
@@ -9531,7 +10064,7 @@ jQuery.ajaxTransport( function( options ) {
 
 				// Listen to events
 				xhr.onload = callback();
-				errorCallback = xhr.onerror = callback( "error" );
+				errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
 
 				// Support: IE 9 only
 				// Use onreadystatechange to replace onabort
@@ -9622,24 +10155,21 @@ jQuery.ajaxPrefilter( "script", function( s ) {
 // Bind script tag hack transport
 jQuery.ajaxTransport( "script", function( s ) {
 
-	// This transport only deals with cross domain requests
-	if ( s.crossDomain ) {
+	// This transport only deals with cross domain or forced-by-attrs requests
+	if ( s.crossDomain || s.scriptAttrs ) {
 		var script, callback;
 		return {
 			send: function( _, complete ) {
-				script = jQuery( "<script>" ).prop( {
-					charset: s.scriptCharset,
-					src: s.url
-				} ).on(
-					"load error",
-					callback = function( evt ) {
+				script = jQuery( "<script>" )
+					.attr( s.scriptAttrs || {} )
+					.prop( { charset: s.scriptCharset, src: s.url } )
+					.on( "load error", callback = function( evt ) {
 						script.remove();
 						callback = null;
 						if ( evt ) {
 							complete( evt.type === "error" ? 404 : 200, evt.type );
 						}
-					}
-				);
+					} );
 
 				// Use native DOM manipulation to avoid our domManip AJAX trickery
 				document.head.appendChild( script[ 0 ] );
@@ -9663,7 +10193,7 @@ var oldCallbacks = [],
 jQuery.ajaxSetup( {
 	jsonp: "callback",
 	jsonpCallback: function() {
-		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
+		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) );
 		this[ callback ] = true;
 		return callback;
 	}
@@ -9685,7 +10215,7 @@ jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
 	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
 
 		// Get callback name, remembering preexisting value associated with it
-		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
+		callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?
 			s.jsonpCallback() :
 			s.jsonpCallback;
 
@@ -9736,7 +10266,7 @@ jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
 			}
 
 			// Call if it was a function and we have a response
-			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
+			if ( responseContainer && isFunction( overwritten ) ) {
 				overwritten( responseContainer[ 0 ] );
 			}
 
@@ -9828,7 +10358,7 @@ jQuery.fn.load = function( url, params, callback ) {
 	}
 
 	// If it's a function
-	if ( jQuery.isFunction( params ) ) {
+	if ( isFunction( params ) ) {
 
 		// We assume that it's the callback
 		callback = params;
@@ -9880,23 +10410,6 @@ jQuery.fn.load = function( url, params, callback ) {
 
 
 
-// Attach a bunch of functions for handling common AJAX events
-jQuery.each( [
-	"ajaxStart",
-	"ajaxStop",
-	"ajaxComplete",
-	"ajaxError",
-	"ajaxSuccess",
-	"ajaxSend"
-], function( i, type ) {
-	jQuery.fn[ type ] = function( fn ) {
-		return this.on( type, fn );
-	};
-} );
-
-
-
-
 jQuery.expr.pseudos.animated = function( elem ) {
 	return jQuery.grep( jQuery.timers, function( fn ) {
 		return elem === fn.elem;
@@ -9936,7 +10449,7 @@ jQuery.offset = {
 			curLeft = parseFloat( curCSSLeft ) || 0;
 		}
 
-		if ( jQuery.isFunction( options ) ) {
+		if ( isFunction( options ) ) {
 
 			// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
 			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
@@ -9953,12 +10466,20 @@ jQuery.offset = {
 			options.using.call( elem, props );
 
 		} else {
+			if ( typeof props.top === "number" ) {
+				props.top += "px";
+			}
+			if ( typeof props.left === "number" ) {
+				props.left += "px";
+			}
 			curElem.css( props );
 		}
 	}
 };
 
 jQuery.fn.extend( {
+
+	// offset() relates an element's border box to the document origin
 	offset: function( options ) {
 
 		// Preserve chaining for setter
@@ -9970,7 +10491,7 @@ jQuery.fn.extend( {
 				} );
 		}
 
-		var doc, docElem, rect, win,
+		var rect, win,
 			elem = this[ 0 ];
 
 		if ( !elem ) {
@@ -9985,50 +10506,52 @@ jQuery.fn.extend( {
 			return { top: 0, left: 0 };
 		}
 
+		// Get document-relative position by adding viewport scroll to viewport-relative gBCR
 		rect = elem.getBoundingClientRect();
-
-		doc = elem.ownerDocument;
-		docElem = doc.documentElement;
-		win = doc.defaultView;
-
+		win = elem.ownerDocument.defaultView;
 		return {
-			top: rect.top + win.pageYOffset - docElem.clientTop,
-			left: rect.left + win.pageXOffset - docElem.clientLeft
+			top: rect.top + win.pageYOffset,
+			left: rect.left + win.pageXOffset
 		};
 	},
 
+	// position() relates an element's margin box to its offset parent's padding box
+	// This corresponds to the behavior of CSS absolute positioning
 	position: function() {
 		if ( !this[ 0 ] ) {
 			return;
 		}
 
-		var offsetParent, offset,
+		var offsetParent, offset, doc,
 			elem = this[ 0 ],
 			parentOffset = { top: 0, left: 0 };
 
-		// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
-		// because it is its only offset parent
+		// position:fixed elements are offset from the viewport, which itself always has zero offset
 		if ( jQuery.css( elem, "position" ) === "fixed" ) {
 
-			// Assume getBoundingClientRect is there when computed position is fixed
+			// Assume position:fixed implies availability of getBoundingClientRect
 			offset = elem.getBoundingClientRect();
 
 		} else {
+			offset = this.offset();
 
-			// Get *real* offsetParent
-			offsetParent = this.offsetParent();
+			// Account for the *real* offset parent, which can be the document or its root element
+			// when a statically positioned element is identified
+			doc = elem.ownerDocument;
+			offsetParent = elem.offsetParent || doc.documentElement;
+			while ( offsetParent &&
+				( offsetParent === doc.body || offsetParent === doc.documentElement ) &&
+				jQuery.css( offsetParent, "position" ) === "static" ) {
 
-			// Get correct offsets
-			offset = this.offset();
-			if ( !nodeName( offsetParent[ 0 ], "html" ) ) {
-				parentOffset = offsetParent.offset();
+				offsetParent = offsetParent.parentNode;
 			}
+			if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {
 
-			// Add offsetParent borders
-			parentOffset = {
-				top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ),
-				left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true )
-			};
+				// Incorporate borders into its offset, since they are outside its content origin
+				parentOffset = jQuery( offsetParent ).offset();
+				parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );
+				parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );
+			}
 		}
 
 		// Subtract parent offsets and element margins
@@ -10070,7 +10593,7 @@ jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function(
 
 			// Coalesce documents and windows
 			var win;
-			if ( jQuery.isWindow( elem ) ) {
+			if ( isWindow( elem ) ) {
 				win = elem;
 			} else if ( elem.nodeType === 9 ) {
 				win = elem.defaultView;
@@ -10099,7 +10622,7 @@ jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function(
 // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
 // getComputedStyle returns percent when specified for top/left/bottom/right;
 // rather than make the css module depend on the offset module, just check for it here
-jQuery.each( [ "top", "left" ], function( i, prop ) {
+jQuery.each( [ "top", "left" ], function( _i, prop ) {
 	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
 		function( elem, computed ) {
 			if ( computed ) {
@@ -10128,7 +10651,7 @@ jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
 			return access( this, function( elem, type, value ) {
 				var doc;
 
-				if ( jQuery.isWindow( elem ) ) {
+				if ( isWindow( elem ) ) {
 
 					// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
 					return funcName.indexOf( "outer" ) === 0 ?
@@ -10162,6 +10685,22 @@ jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
 } );
 
 
+jQuery.each( [
+	"ajaxStart",
+	"ajaxStop",
+	"ajaxComplete",
+	"ajaxError",
+	"ajaxSuccess",
+	"ajaxSend"
+], function( _i, type ) {
+	jQuery.fn[ type ] = function( fn ) {
+		return this.on( type, fn );
+	};
+} );
+
+
+
+
 jQuery.fn.extend( {
 
 	bind: function( types, data, fn ) {
@@ -10180,9 +10719,64 @@ jQuery.fn.extend( {
 		return arguments.length === 1 ?
 			this.off( selector, "**" ) :
 			this.off( types, selector || "**", fn );
+	},
+
+	hover: function( fnOver, fnOut ) {
+		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
 	}
 } );
 
+jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
+	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
+	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
+	function( _i, name ) {
+
+		// Handle event binding
+		jQuery.fn[ name ] = function( data, fn ) {
+			return arguments.length > 0 ?
+				this.on( name, null, data, fn ) :
+				this.trigger( name );
+		};
+	} );
+
+
+
+
+// Support: Android <=4.0 only
+// Make sure we trim BOM and NBSP
+var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
+
+// Bind a function to a context, optionally partially applying any
+// arguments.
+// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
+// However, it is not slated for removal any time soon
+jQuery.proxy = function( fn, context ) {
+	var tmp, args, proxy;
+
+	if ( typeof context === "string" ) {
+		tmp = fn[ context ];
+		context = fn;
+		fn = tmp;
+	}
+
+	// Quick check to determine if target is callable, in the spec
+	// this throws a TypeError, but we will just return undefined.
+	if ( !isFunction( fn ) ) {
+		return undefined;
+	}
+
+	// Simulated bind
+	args = slice.call( arguments, 2 );
+	proxy = function() {
+		return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
+	};
+
+	// Set the guid of unique handler to the same of original handler, so it can be removed
+	proxy.guid = fn.guid = fn.guid || jQuery.guid++;
+
+	return proxy;
+};
+
 jQuery.holdReady = function( hold ) {
 	if ( hold ) {
 		jQuery.readyWait++;
@@ -10193,7 +10787,32 @@ jQuery.holdReady = function( hold ) {
 jQuery.isArray = Array.isArray;
 jQuery.parseJSON = JSON.parse;
 jQuery.nodeName = nodeName;
+jQuery.isFunction = isFunction;
+jQuery.isWindow = isWindow;
+jQuery.camelCase = camelCase;
+jQuery.type = toType;
+
+jQuery.now = Date.now;
+
+jQuery.isNumeric = function( obj ) {
 
+	// As of jQuery 3.0, isNumeric is limited to
+	// strings and numbers (primitives or objects)
+	// that can be coerced to finite numbers (gh-2662)
+	var type = jQuery.type( obj );
+	return ( type === "number" || type === "string" ) &&
+
+		// parseFloat NaNs numeric-cast false positives ("")
+		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
+		// subtraction forces infinities to NaN
+		!isNaN( obj - parseFloat( obj ) );
+};
+
+jQuery.trim = function( text ) {
+	return text == null ?
+		"" :
+		( text + "" ).replace( rtrim, "" );
+};
 
 
 
@@ -10242,7 +10861,7 @@ jQuery.noConflict = function( deep ) {
 // Expose jQuery and $ identifiers, even in AMD
 // (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
 // and CommonJS for browser emulators (#13566)
-if ( !noGlobal ) {
+if ( typeof noGlobal === "undefined" ) {
 	window.jQuery = window.$ = jQuery;
 }
 
diff --git a/installer/resources/core/RTGOperationsManual/_static/jquery.js b/installer/resources/core/RTGOperationsManual/_static/jquery.js
index 644d35e27..b0614034a 100644
--- a/installer/resources/core/RTGOperationsManual/_static/jquery.js
+++ b/installer/resources/core/RTGOperationsManual/_static/jquery.js
@@ -1,4 +1,2 @@
-/*! jQuery v3.2.1 | (c) JS Foundation and other contributors | jquery.org/license */
-!function(a,b){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){"use strict";var c=[],d=a.document,e=Object.getPrototypeOf,f=c.slice,g=c.concat,h=c.push,i=c.indexOf,j={},k=j.toString,l=j.hasOwnProperty,m=l.toString,n=m.call(Object),o={};function p(a,b){b=b||d;var c=b.createElement("script");c.text=a,b.head.appendChild(c).parentNode.removeChild(c)}var q="3.2.1",r=function(a,b){return new r.fn.init(a,b)},s=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,t=/^-ms-/,u=/-([a-z])/g,v=function(a,b){return b.toUpperCase()};r.fn=r.prototype={jquery:q,constructor:r,length:0,toArray:function(){return f.call(this)},get:function(a){return null==a?f.call(this):a<0?this[a+this.length]:this[a]},pushStack:function(a){var b=r.merge(this.constructor(),a);return b.prevObject=this,b},each:function(a){return r.each(this,a)},map:function(a){return this.pushStack(r.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(f.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(a<0?b:0);return this.pushStack(c>=0&&c<b?[this[c]]:[])},end:function(){return this.prevObject||this.constructor()},push:h,sort:c.sort,splice:c.splice},r.extend=r.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||r.isFunction(g)||(g={}),h===i&&(g=this,h--);h<i;h++)if(null!=(a=arguments[h]))for(b in a)c=g[b],d=a[b],g!==d&&(j&&d&&(r.isPlainObject(d)||(e=Array.isArray(d)))?(e?(e=!1,f=c&&Array.isArray(c)?c:[]):f=c&&r.isPlainObject(c)?c:{},g[b]=r.extend(j,f,d)):void 0!==d&&(g[b]=d));return g},r.extend({expando:"jQuery"+(q+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===r.type(a)},isWindow:function(a){return null!=a&&a===a.window},isNumeric:function(a){var b=r.type(a);return("number"===b||"string"===b)&&!isNaN(a-parseFloat(a))},isPlainObject:function(a){var b,c;return!(!a||"[object Object]"!==k.call(a))&&(!(b=e(a))||(c=l.call(b,"constructor")&&b.constructor,"function"==typeof c&&m.call(c)===n))},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?j[k.call(a)]||"object":typeof a},globalEval:function(a){p(a)},camelCase:function(a){return a.replace(t,"ms-").replace(u,v)},each:function(a,b){var c,d=0;if(w(a)){for(c=a.length;d<c;d++)if(b.call(a[d],d,a[d])===!1)break}else for(d in a)if(b.call(a[d],d,a[d])===!1)break;return a},trim:function(a){return null==a?"":(a+"").replace(s,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(w(Object(a))?r.merge(c,"string"==typeof a?[a]:a):h.call(c,a)),c},inArray:function(a,b,c){return null==b?-1:i.call(b,a,c)},merge:function(a,b){for(var c=+b.length,d=0,e=a.length;d<c;d++)a[e++]=b[d];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;f<g;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,e,f=0,h=[];if(w(a))for(d=a.length;f<d;f++)e=b(a[f],f,c),null!=e&&h.push(e);else for(f in a)e=b(a[f],f,c),null!=e&&h.push(e);return g.apply([],h)},guid:1,proxy:function(a,b){var c,d,e;if("string"==typeof b&&(c=a[b],b=a,a=c),r.isFunction(a))return d=f.call(arguments,2),e=function(){return a.apply(b||this,d.concat(f.call(arguments)))},e.guid=a.guid=a.guid||r.guid++,e},now:Date.now,support:o}),"function"==typeof Symbol&&(r.fn[Symbol.iterator]=c[Symbol.iterator]),r.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(a,b){j["[object "+b+"]"]=b.toLowerCase()});function w(a){var b=!!a&&"length"in a&&a.length,c=r.type(a);return"function"!==c&&!r.isWindow(a)&&("array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a)}var x=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u="sizzle"+1*new Date,v=a.document,w=0,x=0,y=ha(),z=ha(),A=ha(),B=function(a,b){return a===b&&(l=!0),0},C={}.hasOwnProperty,D=[],E=D.pop,F=D.push,G=D.push,H=D.slice,I=function(a,b){for(var c=0,d=a.length;c<d;c++)if(a[c]===b)return c;return-1},J="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",K="[\\x20\\t\\r\\n\\f]",L="(?:\\\\.|[\\w-]|[^\0-\\xa0])+",M="\\["+K+"*("+L+")(?:"+K+"*([*^$|!~]?=)"+K+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+L+"))|)"+K+"*\\]",N=":("+L+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+M+")*)|.*)\\)|)",O=new RegExp(K+"+","g"),P=new RegExp("^"+K+"+|((?:^|[^\\\\])(?:\\\\.)*)"+K+"+$","g"),Q=new RegExp("^"+K+"*,"+K+"*"),R=new RegExp("^"+K+"*([>+~]|"+K+")"+K+"*"),S=new RegExp("="+K+"*([^\\]'\"]*?)"+K+"*\\]","g"),T=new RegExp(N),U=new RegExp("^"+L+"$"),V={ID:new RegExp("^#("+L+")"),CLASS:new RegExp("^\\.("+L+")"),TAG:new RegExp("^("+L+"|[*])"),ATTR:new RegExp("^"+M),PSEUDO:new RegExp("^"+N),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+K+"*(even|odd|(([+-]|)(\\d*)n|)"+K+"*(?:([+-]|)"+K+"*(\\d+)|))"+K+"*\\)|)","i"),bool:new RegExp("^(?:"+J+")$","i"),needsContext:new RegExp("^"+K+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+K+"*((?:-\\d)?\\d*)"+K+"*\\)|)(?=[^-]|$)","i")},W=/^(?:input|select|textarea|button)$/i,X=/^h\d$/i,Y=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,$=/[+~]/,_=new RegExp("\\\\([\\da-f]{1,6}"+K+"?|("+K+")|.)","ig"),aa=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:d<0?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)},ba=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ca=function(a,b){return b?"\0"===a?"\ufffd":a.slice(0,-1)+"\\"+a.charCodeAt(a.length-1).toString(16)+" ":"\\"+a},da=function(){m()},ea=ta(function(a){return a.disabled===!0&&("form"in a||"label"in a)},{dir:"parentNode",next:"legend"});try{G.apply(D=H.call(v.childNodes),v.childNodes),D[v.childNodes.length].nodeType}catch(fa){G={apply:D.length?function(a,b){F.apply(a,H.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function ga(a,b,d,e){var f,h,j,k,l,o,r,s=b&&b.ownerDocument,w=b?b.nodeType:9;if(d=d||[],"string"!=typeof a||!a||1!==w&&9!==w&&11!==w)return d;if(!e&&((b?b.ownerDocument||b:v)!==n&&m(b),b=b||n,p)){if(11!==w&&(l=Z.exec(a)))if(f=l[1]){if(9===w){if(!(j=b.getElementById(f)))return d;if(j.id===f)return d.push(j),d}else if(s&&(j=s.getElementById(f))&&t(b,j)&&j.id===f)return d.push(j),d}else{if(l[2])return G.apply(d,b.getElementsByTagName(a)),d;if((f=l[3])&&c.getElementsByClassName&&b.getElementsByClassName)return G.apply(d,b.getElementsByClassName(f)),d}if(c.qsa&&!A[a+" "]&&(!q||!q.test(a))){if(1!==w)s=b,r=a;else if("object"!==b.nodeName.toLowerCase()){(k=b.getAttribute("id"))?k=k.replace(ba,ca):b.setAttribute("id",k=u),o=g(a),h=o.length;while(h--)o[h]="#"+k+" "+sa(o[h]);r=o.join(","),s=$.test(a)&&qa(b.parentNode)||b}if(r)try{return G.apply(d,s.querySelectorAll(r)),d}catch(x){}finally{k===u&&b.removeAttribute("id")}}}return i(a.replace(P,"$1"),b,d,e)}function ha(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function ia(a){return a[u]=!0,a}function ja(a){var b=n.createElement("fieldset");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function ka(a,b){var c=a.split("|"),e=c.length;while(e--)d.attrHandle[c[e]]=b}function la(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&a.sourceIndex-b.sourceIndex;if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function ma(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function na(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function oa(a){return function(b){return"form"in b?b.parentNode&&b.disabled===!1?"label"in b?"label"in b.parentNode?b.parentNode.disabled===a:b.disabled===a:b.isDisabled===a||b.isDisabled!==!a&&ea(b)===a:b.disabled===a:"label"in b&&b.disabled===a}}function pa(a){return ia(function(b){return b=+b,ia(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function qa(a){return a&&"undefined"!=typeof a.getElementsByTagName&&a}c=ga.support={},f=ga.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return!!b&&"HTML"!==b.nodeName},m=ga.setDocument=function(a){var b,e,g=a?a.ownerDocument||a:v;return g!==n&&9===g.nodeType&&g.documentElement?(n=g,o=n.documentElement,p=!f(n),v!==n&&(e=n.defaultView)&&e.top!==e&&(e.addEventListener?e.addEventListener("unload",da,!1):e.attachEvent&&e.attachEvent("onunload",da)),c.attributes=ja(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=ja(function(a){return a.appendChild(n.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=Y.test(n.getElementsByClassName),c.getById=ja(function(a){return o.appendChild(a).id=u,!n.getElementsByName||!n.getElementsByName(u).length}),c.getById?(d.filter.ID=function(a){var b=a.replace(_,aa);return function(a){return a.getAttribute("id")===b}},d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c=b.getElementById(a);return c?[c]:[]}}):(d.filter.ID=function(a){var b=a.replace(_,aa);return function(a){var c="undefined"!=typeof a.getAttributeNode&&a.getAttributeNode("id");return c&&c.value===b}},d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c,d,e,f=b.getElementById(a);if(f){if(c=f.getAttributeNode("id"),c&&c.value===a)return[f];e=b.getElementsByName(a),d=0;while(f=e[d++])if(c=f.getAttributeNode("id"),c&&c.value===a)return[f]}return[]}}),d.find.TAG=c.getElementsByTagName?function(a,b){return"undefined"!=typeof b.getElementsByTagName?b.getElementsByTagName(a):c.qsa?b.querySelectorAll(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){if("undefined"!=typeof b.getElementsByClassName&&p)return b.getElementsByClassName(a)},r=[],q=[],(c.qsa=Y.test(n.querySelectorAll))&&(ja(function(a){o.appendChild(a).innerHTML="<a id='"+u+"'></a><select id='"+u+"-\r\\' msallowcapture=''><option selected=''></option></select>",a.querySelectorAll("[msallowcapture^='']").length&&q.push("[*^$]="+K+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||q.push("\\["+K+"*(?:value|"+J+")"),a.querySelectorAll("[id~="+u+"-]").length||q.push("~="),a.querySelectorAll(":checked").length||q.push(":checked"),a.querySelectorAll("a#"+u+"+*").length||q.push(".#.+[+~]")}),ja(function(a){a.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var b=n.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&q.push("name"+K+"*[*^$|!~]?="),2!==a.querySelectorAll(":enabled").length&&q.push(":enabled",":disabled"),o.appendChild(a).disabled=!0,2!==a.querySelectorAll(":disabled").length&&q.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),q.push(",.*:")})),(c.matchesSelector=Y.test(s=o.matches||o.webkitMatchesSelector||o.mozMatchesSelector||o.oMatchesSelector||o.msMatchesSelector))&&ja(function(a){c.disconnectedMatch=s.call(a,"*"),s.call(a,"[s!='']:x"),r.push("!=",N)}),q=q.length&&new RegExp(q.join("|")),r=r.length&&new RegExp(r.join("|")),b=Y.test(o.compareDocumentPosition),t=b||Y.test(o.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},B=b?function(a,b){if(a===b)return l=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===n||a.ownerDocument===v&&t(v,a)?-1:b===n||b.ownerDocument===v&&t(v,b)?1:k?I(k,a)-I(k,b):0:4&d?-1:1)}:function(a,b){if(a===b)return l=!0,0;var c,d=0,e=a.parentNode,f=b.parentNode,g=[a],h=[b];if(!e||!f)return a===n?-1:b===n?1:e?-1:f?1:k?I(k,a)-I(k,b):0;if(e===f)return la(a,b);c=a;while(c=c.parentNode)g.unshift(c);c=b;while(c=c.parentNode)h.unshift(c);while(g[d]===h[d])d++;return d?la(g[d],h[d]):g[d]===v?-1:h[d]===v?1:0},n):n},ga.matches=function(a,b){return ga(a,null,null,b)},ga.matchesSelector=function(a,b){if((a.ownerDocument||a)!==n&&m(a),b=b.replace(S,"='$1']"),c.matchesSelector&&p&&!A[b+" "]&&(!r||!r.test(b))&&(!q||!q.test(b)))try{var d=s.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return ga(b,n,null,[a]).length>0},ga.contains=function(a,b){return(a.ownerDocument||a)!==n&&m(a),t(a,b)},ga.attr=function(a,b){(a.ownerDocument||a)!==n&&m(a);var e=d.attrHandle[b.toLowerCase()],f=e&&C.call(d.attrHandle,b.toLowerCase())?e(a,b,!p):void 0;return void 0!==f?f:c.attributes||!p?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},ga.escape=function(a){return(a+"").replace(ba,ca)},ga.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},ga.uniqueSort=function(a){var b,d=[],e=0,f=0;if(l=!c.detectDuplicates,k=!c.sortStable&&a.slice(0),a.sort(B),l){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return k=null,a},e=ga.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=ga.selectors={cacheLength:50,createPseudo:ia,match:V,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(_,aa),a[3]=(a[3]||a[4]||a[5]||"").replace(_,aa),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||ga.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&ga.error(a[0]),a},PSEUDO:function(a){var b,c=!a[6]&&a[2];return V.CHILD.test(a[0])?null:(a[3]?a[2]=a[4]||a[5]||"":c&&T.test(c)&&(b=g(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(_,aa).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=y[a+" "];return b||(b=new RegExp("(^|"+K+")"+a+"("+K+"|$)"))&&y(a,function(a){return b.test("string"==typeof a.className&&a.className||"undefined"!=typeof a.getAttribute&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=ga.attr(d,a);return null==e?"!="===b:!b||(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e.replace(O," ")+" ").indexOf(c)>-1:"|="===b&&(e===c||e.slice(0,c.length+1)===c+"-"))}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),s=!i&&!h,t=!1;if(q){if(f){while(p){m=b;while(m=m[p])if(h?m.nodeName.toLowerCase()===r:1===m.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&s){m=q,l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),j=k[a]||[],n=j[0]===w&&j[1],t=n&&j[2],m=n&&q.childNodes[n];while(m=++n&&m&&m[p]||(t=n=0)||o.pop())if(1===m.nodeType&&++t&&m===b){k[a]=[w,n,t];break}}else if(s&&(m=b,l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),j=k[a]||[],n=j[0]===w&&j[1],t=n),t===!1)while(m=++n&&m&&m[p]||(t=n=0)||o.pop())if((h?m.nodeName.toLowerCase()===r:1===m.nodeType)&&++t&&(s&&(l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),k[a]=[w,t]),m===b))break;return t-=e,t===d||t%d===0&&t/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||ga.error("unsupported pseudo: "+a);return e[u]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?ia(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=I(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:ia(function(a){var b=[],c=[],d=h(a.replace(P,"$1"));return d[u]?ia(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),b[0]=null,!c.pop()}}),has:ia(function(a){return function(b){return ga(a,b).length>0}}),contains:ia(function(a){return a=a.replace(_,aa),function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:ia(function(a){return U.test(a||"")||ga.error("unsupported lang: "+a),a=a.replace(_,aa).toLowerCase(),function(b){var c;do if(c=p?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===o},focus:function(a){return a===n.activeElement&&(!n.hasFocus||n.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:oa(!1),disabled:oa(!0),checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return X.test(a.nodeName)},input:function(a){return W.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:pa(function(){return[0]}),last:pa(function(a,b){return[b-1]}),eq:pa(function(a,b,c){return[c<0?c+b:c]}),even:pa(function(a,b){for(var c=0;c<b;c+=2)a.push(c);return a}),odd:pa(function(a,b){for(var c=1;c<b;c+=2)a.push(c);return a}),lt:pa(function(a,b,c){for(var d=c<0?c+b:c;--d>=0;)a.push(d);return a}),gt:pa(function(a,b,c){for(var d=c<0?c+b:c;++d<b;)a.push(d);return a})}},d.pseudos.nth=d.pseudos.eq;for(b in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})d.pseudos[b]=ma(b);for(b in{submit:!0,reset:!0})d.pseudos[b]=na(b);function ra(){}ra.prototype=d.filters=d.pseudos,d.setFilters=new ra,g=ga.tokenize=function(a,b){var c,e,f,g,h,i,j,k=z[a+" "];if(k)return b?0:k.slice(0);h=a,i=[],j=d.preFilter;while(h){c&&!(e=Q.exec(h))||(e&&(h=h.slice(e[0].length)||h),i.push(f=[])),c=!1,(e=R.exec(h))&&(c=e.shift(),f.push({value:c,type:e[0].replace(P," ")}),h=h.slice(c.length));for(g in d.filter)!(e=V[g].exec(h))||j[g]&&!(e=j[g](e))||(c=e.shift(),f.push({value:c,type:g,matches:e}),h=h.slice(c.length));if(!c)break}return b?h.length:h?ga.error(a):z(a,i).slice(0)};function sa(a){for(var b=0,c=a.length,d="";b<c;b++)d+=a[b].value;return d}function ta(a,b,c){var d=b.dir,e=b.next,f=e||d,g=c&&"parentNode"===f,h=x++;return b.first?function(b,c,e){while(b=b[d])if(1===b.nodeType||g)return a(b,c,e);return!1}:function(b,c,i){var j,k,l,m=[w,h];if(i){while(b=b[d])if((1===b.nodeType||g)&&a(b,c,i))return!0}else while(b=b[d])if(1===b.nodeType||g)if(l=b[u]||(b[u]={}),k=l[b.uniqueID]||(l[b.uniqueID]={}),e&&e===b.nodeName.toLowerCase())b=b[d]||b;else{if((j=k[f])&&j[0]===w&&j[1]===h)return m[2]=j[2];if(k[f]=m,m[2]=a(b,c,i))return!0}return!1}}function ua(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function va(a,b,c){for(var d=0,e=b.length;d<e;d++)ga(a,b[d],c);return c}function wa(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;h<i;h++)(f=a[h])&&(c&&!c(f,d,e)||(g.push(f),j&&b.push(h)));return g}function xa(a,b,c,d,e,f){return d&&!d[u]&&(d=xa(d)),e&&!e[u]&&(e=xa(e,f)),ia(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||va(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:wa(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=wa(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?I(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=wa(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):G.apply(g,r)})}function ya(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],h=g||d.relative[" "],i=g?1:0,k=ta(function(a){return a===b},h,!0),l=ta(function(a){return I(b,a)>-1},h,!0),m=[function(a,c,d){var e=!g&&(d||c!==j)||((b=c).nodeType?k(a,c,d):l(a,c,d));return b=null,e}];i<f;i++)if(c=d.relative[a[i].type])m=[ta(ua(m),c)];else{if(c=d.filter[a[i].type].apply(null,a[i].matches),c[u]){for(e=++i;e<f;e++)if(d.relative[a[e].type])break;return xa(i>1&&ua(m),i>1&&sa(a.slice(0,i-1).concat({value:" "===a[i-2].type?"*":""})).replace(P,"$1"),c,i<e&&ya(a.slice(i,e)),e<f&&ya(a=a.slice(e)),e<f&&sa(a))}m.push(c)}return ua(m)}function za(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,h,i,k){var l,o,q,r=0,s="0",t=f&&[],u=[],v=j,x=f||e&&d.find.TAG("*",k),y=w+=null==v?1:Math.random()||.1,z=x.length;for(k&&(j=g===n||g||k);s!==z&&null!=(l=x[s]);s++){if(e&&l){o=0,g||l.ownerDocument===n||(m(l),h=!p);while(q=a[o++])if(q(l,g||n,h)){i.push(l);break}k&&(w=y)}c&&((l=!q&&l)&&r--,f&&t.push(l))}if(r+=s,c&&s!==r){o=0;while(q=b[o++])q(t,u,g,h);if(f){if(r>0)while(s--)t[s]||u[s]||(u[s]=E.call(i));u=wa(u)}G.apply(i,u),k&&!f&&u.length>0&&r+b.length>1&&ga.uniqueSort(i)}return k&&(w=y,j=v),t};return c?ia(f):f}return h=ga.compile=function(a,b){var c,d=[],e=[],f=A[a+" "];if(!f){b||(b=g(a)),c=b.length;while(c--)f=ya(b[c]),f[u]?d.push(f):e.push(f);f=A(a,za(e,d)),f.selector=a}return f},i=ga.select=function(a,b,c,e){var f,i,j,k,l,m="function"==typeof a&&a,n=!e&&g(a=m.selector||a);if(c=c||[],1===n.length){if(i=n[0]=n[0].slice(0),i.length>2&&"ID"===(j=i[0]).type&&9===b.nodeType&&p&&d.relative[i[1].type]){if(b=(d.find.ID(j.matches[0].replace(_,aa),b)||[])[0],!b)return c;m&&(b=b.parentNode),a=a.slice(i.shift().value.length)}f=V.needsContext.test(a)?0:i.length;while(f--){if(j=i[f],d.relative[k=j.type])break;if((l=d.find[k])&&(e=l(j.matches[0].replace(_,aa),$.test(i[0].type)&&qa(b.parentNode)||b))){if(i.splice(f,1),a=e.length&&sa(i),!a)return G.apply(c,e),c;break}}}return(m||h(a,n))(e,b,!p,c,!b||$.test(a)&&qa(b.parentNode)||b),c},c.sortStable=u.split("").sort(B).join("")===u,c.detectDuplicates=!!l,m(),c.sortDetached=ja(function(a){return 1&a.compareDocumentPosition(n.createElement("fieldset"))}),ja(function(a){return a.innerHTML="<a href='#'></a>","#"===a.firstChild.getAttribute("href")})||ka("type|href|height|width",function(a,b,c){if(!c)return a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&ja(function(a){return a.innerHTML="<input/>",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||ka("value",function(a,b,c){if(!c&&"input"===a.nodeName.toLowerCase())return a.defaultValue}),ja(function(a){return null==a.getAttribute("disabled")})||ka(J,function(a,b,c){var d;if(!c)return a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),ga}(a);r.find=x,r.expr=x.selectors,r.expr[":"]=r.expr.pseudos,r.uniqueSort=r.unique=x.uniqueSort,r.text=x.getText,r.isXMLDoc=x.isXML,r.contains=x.contains,r.escapeSelector=x.escape;var y=function(a,b,c){var d=[],e=void 0!==c;while((a=a[b])&&9!==a.nodeType)if(1===a.nodeType){if(e&&r(a).is(c))break;d.push(a)}return d},z=function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c},A=r.expr.match.needsContext;function B(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()}var C=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i,D=/^.[^:#\[\.,]*$/;function E(a,b,c){return r.isFunction(b)?r.grep(a,function(a,d){return!!b.call(a,d,a)!==c}):b.nodeType?r.grep(a,function(a){return a===b!==c}):"string"!=typeof b?r.grep(a,function(a){return i.call(b,a)>-1!==c}):D.test(b)?r.filter(b,a,c):(b=r.filter(b,a),r.grep(a,function(a){return i.call(b,a)>-1!==c&&1===a.nodeType}))}r.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?r.find.matchesSelector(d,a)?[d]:[]:r.find.matches(a,r.grep(b,function(a){return 1===a.nodeType}))},r.fn.extend({find:function(a){var b,c,d=this.length,e=this;if("string"!=typeof a)return this.pushStack(r(a).filter(function(){for(b=0;b<d;b++)if(r.contains(e[b],this))return!0}));for(c=this.pushStack([]),b=0;b<d;b++)r.find(a,e[b],c);return d>1?r.uniqueSort(c):c},filter:function(a){return this.pushStack(E(this,a||[],!1))},not:function(a){return this.pushStack(E(this,a||[],!0))},is:function(a){return!!E(this,"string"==typeof a&&A.test(a)?r(a):a||[],!1).length}});var F,G=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,H=r.fn.init=function(a,b,c){var e,f;if(!a)return this;if(c=c||F,"string"==typeof a){if(e="<"===a[0]&&">"===a[a.length-1]&&a.length>=3?[null,a,null]:G.exec(a),!e||!e[1]&&b)return!b||b.jquery?(b||c).find(a):this.constructor(b).find(a);if(e[1]){if(b=b instanceof r?b[0]:b,r.merge(this,r.parseHTML(e[1],b&&b.nodeType?b.ownerDocument||b:d,!0)),C.test(e[1])&&r.isPlainObject(b))for(e in b)r.isFunction(this[e])?this[e](b[e]):this.attr(e,b[e]);return this}return f=d.getElementById(e[2]),f&&(this[0]=f,this.length=1),this}return a.nodeType?(this[0]=a,this.length=1,this):r.isFunction(a)?void 0!==c.ready?c.ready(a):a(r):r.makeArray(a,this)};H.prototype=r.fn,F=r(d);var I=/^(?:parents|prev(?:Until|All))/,J={children:!0,contents:!0,next:!0,prev:!0};r.fn.extend({has:function(a){var b=r(a,this),c=b.length;return this.filter(function(){for(var a=0;a<c;a++)if(r.contains(this,b[a]))return!0})},closest:function(a,b){var c,d=0,e=this.length,f=[],g="string"!=typeof a&&r(a);if(!A.test(a))for(;d<e;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&r.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?r.uniqueSort(f):f)},index:function(a){return a?"string"==typeof a?i.call(r(a),this[0]):i.call(this,a.jquery?a[0]:a):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(r.uniqueSort(r.merge(this.get(),r(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function K(a,b){while((a=a[b])&&1!==a.nodeType);return a}r.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return y(a,"parentNode")},parentsUntil:function(a,b,c){return y(a,"parentNode",c)},next:function(a){return K(a,"nextSibling")},prev:function(a){return K(a,"previousSibling")},nextAll:function(a){return y(a,"nextSibling")},prevAll:function(a){return y(a,"previousSibling")},nextUntil:function(a,b,c){return y(a,"nextSibling",c)},prevUntil:function(a,b,c){return y(a,"previousSibling",c)},siblings:function(a){return z((a.parentNode||{}).firstChild,a)},children:function(a){return z(a.firstChild)},contents:function(a){return B(a,"iframe")?a.contentDocument:(B(a,"template")&&(a=a.content||a),r.merge([],a.childNodes))}},function(a,b){r.fn[a]=function(c,d){var e=r.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=r.filter(d,e)),this.length>1&&(J[a]||r.uniqueSort(e),I.test(a)&&e.reverse()),this.pushStack(e)}});var L=/[^\x20\t\r\n\f]+/g;function M(a){var b={};return r.each(a.match(L)||[],function(a,c){b[c]=!0}),b}r.Callbacks=function(a){a="string"==typeof a?M(a):r.extend({},a);var b,c,d,e,f=[],g=[],h=-1,i=function(){for(e=e||a.once,d=b=!0;g.length;h=-1){c=g.shift();while(++h<f.length)f[h].apply(c[0],c[1])===!1&&a.stopOnFalse&&(h=f.length,c=!1)}a.memory||(c=!1),b=!1,e&&(f=c?[]:"")},j={add:function(){return f&&(c&&!b&&(h=f.length-1,g.push(c)),function d(b){r.each(b,function(b,c){r.isFunction(c)?a.unique&&j.has(c)||f.push(c):c&&c.length&&"string"!==r.type(c)&&d(c)})}(arguments),c&&!b&&i()),this},remove:function(){return r.each(arguments,function(a,b){var c;while((c=r.inArray(b,f,c))>-1)f.splice(c,1),c<=h&&h--}),this},has:function(a){return a?r.inArray(a,f)>-1:f.length>0},empty:function(){return f&&(f=[]),this},disable:function(){return e=g=[],f=c="",this},disabled:function(){return!f},lock:function(){return e=g=[],c||b||(f=c=""),this},locked:function(){return!!e},fireWith:function(a,c){return e||(c=c||[],c=[a,c.slice?c.slice():c],g.push(c),b||i()),this},fire:function(){return j.fireWith(this,arguments),this},fired:function(){return!!d}};return j};function N(a){return a}function O(a){throw a}function P(a,b,c,d){var e;try{a&&r.isFunction(e=a.promise)?e.call(a).done(b).fail(c):a&&r.isFunction(e=a.then)?e.call(a,b,c):b.apply(void 0,[a].slice(d))}catch(a){c.apply(void 0,[a])}}r.extend({Deferred:function(b){var c=[["notify","progress",r.Callbacks("memory"),r.Callbacks("memory"),2],["resolve","done",r.Callbacks("once memory"),r.Callbacks("once memory"),0,"resolved"],["reject","fail",r.Callbacks("once memory"),r.Callbacks("once memory"),1,"rejected"]],d="pending",e={state:function(){return d},always:function(){return f.done(arguments).fail(arguments),this},"catch":function(a){return e.then(null,a)},pipe:function(){var a=arguments;return r.Deferred(function(b){r.each(c,function(c,d){var e=r.isFunction(a[d[4]])&&a[d[4]];f[d[1]](function(){var a=e&&e.apply(this,arguments);a&&r.isFunction(a.promise)?a.promise().progress(b.notify).done(b.resolve).fail(b.reject):b[d[0]+"With"](this,e?[a]:arguments)})}),a=null}).promise()},then:function(b,d,e){var f=0;function g(b,c,d,e){return function(){var h=this,i=arguments,j=function(){var a,j;if(!(b<f)){if(a=d.apply(h,i),a===c.promise())throw new TypeError("Thenable self-resolution");j=a&&("object"==typeof a||"function"==typeof a)&&a.then,r.isFunction(j)?e?j.call(a,g(f,c,N,e),g(f,c,O,e)):(f++,j.call(a,g(f,c,N,e),g(f,c,O,e),g(f,c,N,c.notifyWith))):(d!==N&&(h=void 0,i=[a]),(e||c.resolveWith)(h,i))}},k=e?j:function(){try{j()}catch(a){r.Deferred.exceptionHook&&r.Deferred.exceptionHook(a,k.stackTrace),b+1>=f&&(d!==O&&(h=void 0,i=[a]),c.rejectWith(h,i))}};b?k():(r.Deferred.getStackHook&&(k.stackTrace=r.Deferred.getStackHook()),a.setTimeout(k))}}return r.Deferred(function(a){c[0][3].add(g(0,a,r.isFunction(e)?e:N,a.notifyWith)),c[1][3].add(g(0,a,r.isFunction(b)?b:N)),c[2][3].add(g(0,a,r.isFunction(d)?d:O))}).promise()},promise:function(a){return null!=a?r.extend(a,e):e}},f={};return r.each(c,function(a,b){var g=b[2],h=b[5];e[b[1]]=g.add,h&&g.add(function(){d=h},c[3-a][2].disable,c[0][2].lock),g.add(b[3].fire),f[b[0]]=function(){return f[b[0]+"With"](this===f?void 0:this,arguments),this},f[b[0]+"With"]=g.fireWith}),e.promise(f),b&&b.call(f,f),f},when:function(a){var b=arguments.length,c=b,d=Array(c),e=f.call(arguments),g=r.Deferred(),h=function(a){return function(c){d[a]=this,e[a]=arguments.length>1?f.call(arguments):c,--b||g.resolveWith(d,e)}};if(b<=1&&(P(a,g.done(h(c)).resolve,g.reject,!b),"pending"===g.state()||r.isFunction(e[c]&&e[c].then)))return g.then();while(c--)P(e[c],h(c),g.reject);return g.promise()}});var Q=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;r.Deferred.exceptionHook=function(b,c){a.console&&a.console.warn&&b&&Q.test(b.name)&&a.console.warn("jQuery.Deferred exception: "+b.message,b.stack,c)},r.readyException=function(b){a.setTimeout(function(){throw b})};var R=r.Deferred();r.fn.ready=function(a){return R.then(a)["catch"](function(a){r.readyException(a)}),this},r.extend({isReady:!1,readyWait:1,ready:function(a){(a===!0?--r.readyWait:r.isReady)||(r.isReady=!0,a!==!0&&--r.readyWait>0||R.resolveWith(d,[r]))}}),r.ready.then=R.then;function S(){d.removeEventListener("DOMContentLoaded",S),
-a.removeEventListener("load",S),r.ready()}"complete"===d.readyState||"loading"!==d.readyState&&!d.documentElement.doScroll?a.setTimeout(r.ready):(d.addEventListener("DOMContentLoaded",S),a.addEventListener("load",S));var T=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===r.type(c)){e=!0;for(h in c)T(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,r.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(r(a),c)})),b))for(;h<i;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},U=function(a){return 1===a.nodeType||9===a.nodeType||!+a.nodeType};function V(){this.expando=r.expando+V.uid++}V.uid=1,V.prototype={cache:function(a){var b=a[this.expando];return b||(b={},U(a)&&(a.nodeType?a[this.expando]=b:Object.defineProperty(a,this.expando,{value:b,configurable:!0}))),b},set:function(a,b,c){var d,e=this.cache(a);if("string"==typeof b)e[r.camelCase(b)]=c;else for(d in b)e[r.camelCase(d)]=b[d];return e},get:function(a,b){return void 0===b?this.cache(a):a[this.expando]&&a[this.expando][r.camelCase(b)]},access:function(a,b,c){return void 0===b||b&&"string"==typeof b&&void 0===c?this.get(a,b):(this.set(a,b,c),void 0!==c?c:b)},remove:function(a,b){var c,d=a[this.expando];if(void 0!==d){if(void 0!==b){Array.isArray(b)?b=b.map(r.camelCase):(b=r.camelCase(b),b=b in d?[b]:b.match(L)||[]),c=b.length;while(c--)delete d[b[c]]}(void 0===b||r.isEmptyObject(d))&&(a.nodeType?a[this.expando]=void 0:delete a[this.expando])}},hasData:function(a){var b=a[this.expando];return void 0!==b&&!r.isEmptyObject(b)}};var W=new V,X=new V,Y=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,Z=/[A-Z]/g;function $(a){return"true"===a||"false"!==a&&("null"===a?null:a===+a+""?+a:Y.test(a)?JSON.parse(a):a)}function _(a,b,c){var d;if(void 0===c&&1===a.nodeType)if(d="data-"+b.replace(Z,"-$&").toLowerCase(),c=a.getAttribute(d),"string"==typeof c){try{c=$(c)}catch(e){}X.set(a,b,c)}else c=void 0;return c}r.extend({hasData:function(a){return X.hasData(a)||W.hasData(a)},data:function(a,b,c){return X.access(a,b,c)},removeData:function(a,b){X.remove(a,b)},_data:function(a,b,c){return W.access(a,b,c)},_removeData:function(a,b){W.remove(a,b)}}),r.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=X.get(f),1===f.nodeType&&!W.get(f,"hasDataAttrs"))){c=g.length;while(c--)g[c]&&(d=g[c].name,0===d.indexOf("data-")&&(d=r.camelCase(d.slice(5)),_(f,d,e[d])));W.set(f,"hasDataAttrs",!0)}return e}return"object"==typeof a?this.each(function(){X.set(this,a)}):T(this,function(b){var c;if(f&&void 0===b){if(c=X.get(f,a),void 0!==c)return c;if(c=_(f,a),void 0!==c)return c}else this.each(function(){X.set(this,a,b)})},null,b,arguments.length>1,null,!0)},removeData:function(a){return this.each(function(){X.remove(this,a)})}}),r.extend({queue:function(a,b,c){var d;if(a)return b=(b||"fx")+"queue",d=W.get(a,b),c&&(!d||Array.isArray(c)?d=W.access(a,b,r.makeArray(c)):d.push(c)),d||[]},dequeue:function(a,b){b=b||"fx";var c=r.queue(a,b),d=c.length,e=c.shift(),f=r._queueHooks(a,b),g=function(){r.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return W.get(a,c)||W.access(a,c,{empty:r.Callbacks("once memory").add(function(){W.remove(a,[b+"queue",c])})})}}),r.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length<c?r.queue(this[0],a):void 0===b?this:this.each(function(){var c=r.queue(this,a,b);r._queueHooks(this,a),"fx"===a&&"inprogress"!==c[0]&&r.dequeue(this,a)})},dequeue:function(a){return this.each(function(){r.dequeue(this,a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,b){var c,d=1,e=r.Deferred(),f=this,g=this.length,h=function(){--d||e.resolveWith(f,[f])};"string"!=typeof a&&(b=a,a=void 0),a=a||"fx";while(g--)c=W.get(f[g],a+"queueHooks"),c&&c.empty&&(d++,c.empty.add(h));return h(),e.promise(b)}});var aa=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,ba=new RegExp("^(?:([+-])=|)("+aa+")([a-z%]*)$","i"),ca=["Top","Right","Bottom","Left"],da=function(a,b){return a=b||a,"none"===a.style.display||""===a.style.display&&r.contains(a.ownerDocument,a)&&"none"===r.css(a,"display")},ea=function(a,b,c,d){var e,f,g={};for(f in b)g[f]=a.style[f],a.style[f]=b[f];e=c.apply(a,d||[]);for(f in b)a.style[f]=g[f];return e};function fa(a,b,c,d){var e,f=1,g=20,h=d?function(){return d.cur()}:function(){return r.css(a,b,"")},i=h(),j=c&&c[3]||(r.cssNumber[b]?"":"px"),k=(r.cssNumber[b]||"px"!==j&&+i)&&ba.exec(r.css(a,b));if(k&&k[3]!==j){j=j||k[3],c=c||[],k=+i||1;do f=f||".5",k/=f,r.style(a,b,k+j);while(f!==(f=h()/i)&&1!==f&&--g)}return c&&(k=+k||+i||0,e=c[1]?k+(c[1]+1)*c[2]:+c[2],d&&(d.unit=j,d.start=k,d.end=e)),e}var ga={};function ha(a){var b,c=a.ownerDocument,d=a.nodeName,e=ga[d];return e?e:(b=c.body.appendChild(c.createElement(d)),e=r.css(b,"display"),b.parentNode.removeChild(b),"none"===e&&(e="block"),ga[d]=e,e)}function ia(a,b){for(var c,d,e=[],f=0,g=a.length;f<g;f++)d=a[f],d.style&&(c=d.style.display,b?("none"===c&&(e[f]=W.get(d,"display")||null,e[f]||(d.style.display="")),""===d.style.display&&da(d)&&(e[f]=ha(d))):"none"!==c&&(e[f]="none",W.set(d,"display",c)));for(f=0;f<g;f++)null!=e[f]&&(a[f].style.display=e[f]);return a}r.fn.extend({show:function(){return ia(this,!0)},hide:function(){return ia(this)},toggle:function(a){return"boolean"==typeof a?a?this.show():this.hide():this.each(function(){da(this)?r(this).show():r(this).hide()})}});var ja=/^(?:checkbox|radio)$/i,ka=/<([a-z][^\/\0>\x20\t\r\n\f]+)/i,la=/^$|\/(?:java|ecma)script/i,ma={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};ma.optgroup=ma.option,ma.tbody=ma.tfoot=ma.colgroup=ma.caption=ma.thead,ma.th=ma.td;function na(a,b){var c;return c="undefined"!=typeof a.getElementsByTagName?a.getElementsByTagName(b||"*"):"undefined"!=typeof a.querySelectorAll?a.querySelectorAll(b||"*"):[],void 0===b||b&&B(a,b)?r.merge([a],c):c}function oa(a,b){for(var c=0,d=a.length;c<d;c++)W.set(a[c],"globalEval",!b||W.get(b[c],"globalEval"))}var pa=/<|&#?\w+;/;function qa(a,b,c,d,e){for(var f,g,h,i,j,k,l=b.createDocumentFragment(),m=[],n=0,o=a.length;n<o;n++)if(f=a[n],f||0===f)if("object"===r.type(f))r.merge(m,f.nodeType?[f]:f);else if(pa.test(f)){g=g||l.appendChild(b.createElement("div")),h=(ka.exec(f)||["",""])[1].toLowerCase(),i=ma[h]||ma._default,g.innerHTML=i[1]+r.htmlPrefilter(f)+i[2],k=i[0];while(k--)g=g.lastChild;r.merge(m,g.childNodes),g=l.firstChild,g.textContent=""}else m.push(b.createTextNode(f));l.textContent="",n=0;while(f=m[n++])if(d&&r.inArray(f,d)>-1)e&&e.push(f);else if(j=r.contains(f.ownerDocument,f),g=na(l.appendChild(f),"script"),j&&oa(g),c){k=0;while(f=g[k++])la.test(f.type||"")&&c.push(f)}return l}!function(){var a=d.createDocumentFragment(),b=a.appendChild(d.createElement("div")),c=d.createElement("input");c.setAttribute("type","radio"),c.setAttribute("checked","checked"),c.setAttribute("name","t"),b.appendChild(c),o.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,b.innerHTML="<textarea>x</textarea>",o.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue}();var ra=d.documentElement,sa=/^key/,ta=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,ua=/^([^.]*)(?:\.(.+)|)/;function va(){return!0}function wa(){return!1}function xa(){try{return d.activeElement}catch(a){}}function ya(a,b,c,d,e,f){var g,h;if("object"==typeof b){"string"!=typeof c&&(d=d||c,c=void 0);for(h in b)ya(a,h,c,d,b[h],f);return a}if(null==d&&null==e?(e=c,d=c=void 0):null==e&&("string"==typeof c?(e=d,d=void 0):(e=d,d=c,c=void 0)),e===!1)e=wa;else if(!e)return a;return 1===f&&(g=e,e=function(a){return r().off(a),g.apply(this,arguments)},e.guid=g.guid||(g.guid=r.guid++)),a.each(function(){r.event.add(this,b,e,d,c)})}r.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,p,q=W.get(a);if(q){c.handler&&(f=c,c=f.handler,e=f.selector),e&&r.find.matchesSelector(ra,e),c.guid||(c.guid=r.guid++),(i=q.events)||(i=q.events={}),(g=q.handle)||(g=q.handle=function(b){return"undefined"!=typeof r&&r.event.triggered!==b.type?r.event.dispatch.apply(a,arguments):void 0}),b=(b||"").match(L)||[""],j=b.length;while(j--)h=ua.exec(b[j])||[],n=p=h[1],o=(h[2]||"").split(".").sort(),n&&(l=r.event.special[n]||{},n=(e?l.delegateType:l.bindType)||n,l=r.event.special[n]||{},k=r.extend({type:n,origType:p,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&r.expr.match.needsContext.test(e),namespace:o.join(".")},f),(m=i[n])||(m=i[n]=[],m.delegateCount=0,l.setup&&l.setup.call(a,d,o,g)!==!1||a.addEventListener&&a.addEventListener(n,g)),l.add&&(l.add.call(a,k),k.handler.guid||(k.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,k):m.push(k),r.event.global[n]=!0)}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,p,q=W.hasData(a)&&W.get(a);if(q&&(i=q.events)){b=(b||"").match(L)||[""],j=b.length;while(j--)if(h=ua.exec(b[j])||[],n=p=h[1],o=(h[2]||"").split(".").sort(),n){l=r.event.special[n]||{},n=(d?l.delegateType:l.bindType)||n,m=i[n]||[],h=h[2]&&new RegExp("(^|\\.)"+o.join("\\.(?:.*\\.|)")+"(\\.|$)"),g=f=m.length;while(f--)k=m[f],!e&&p!==k.origType||c&&c.guid!==k.guid||h&&!h.test(k.namespace)||d&&d!==k.selector&&("**"!==d||!k.selector)||(m.splice(f,1),k.selector&&m.delegateCount--,l.remove&&l.remove.call(a,k));g&&!m.length&&(l.teardown&&l.teardown.call(a,o,q.handle)!==!1||r.removeEvent(a,n,q.handle),delete i[n])}else for(n in i)r.event.remove(a,n+b[j],c,d,!0);r.isEmptyObject(i)&&W.remove(a,"handle events")}},dispatch:function(a){var b=r.event.fix(a),c,d,e,f,g,h,i=new Array(arguments.length),j=(W.get(this,"events")||{})[b.type]||[],k=r.event.special[b.type]||{};for(i[0]=b,c=1;c<arguments.length;c++)i[c]=arguments[c];if(b.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,b)!==!1){h=r.event.handlers.call(this,b,j),c=0;while((f=h[c++])&&!b.isPropagationStopped()){b.currentTarget=f.elem,d=0;while((g=f.handlers[d++])&&!b.isImmediatePropagationStopped())b.rnamespace&&!b.rnamespace.test(g.namespace)||(b.handleObj=g,b.data=g.data,e=((r.event.special[g.origType]||{}).handle||g.handler).apply(f.elem,i),void 0!==e&&(b.result=e)===!1&&(b.preventDefault(),b.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,b),b.result}},handlers:function(a,b){var c,d,e,f,g,h=[],i=b.delegateCount,j=a.target;if(i&&j.nodeType&&!("click"===a.type&&a.button>=1))for(;j!==this;j=j.parentNode||this)if(1===j.nodeType&&("click"!==a.type||j.disabled!==!0)){for(f=[],g={},c=0;c<i;c++)d=b[c],e=d.selector+" ",void 0===g[e]&&(g[e]=d.needsContext?r(e,this).index(j)>-1:r.find(e,this,null,[j]).length),g[e]&&f.push(d);f.length&&h.push({elem:j,handlers:f})}return j=this,i<b.length&&h.push({elem:j,handlers:b.slice(i)}),h},addProp:function(a,b){Object.defineProperty(r.Event.prototype,a,{enumerable:!0,configurable:!0,get:r.isFunction(b)?function(){if(this.originalEvent)return b(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[a]},set:function(b){Object.defineProperty(this,a,{enumerable:!0,configurable:!0,writable:!0,value:b})}})},fix:function(a){return a[r.expando]?a:new r.Event(a)},special:{load:{noBubble:!0},focus:{trigger:function(){if(this!==xa()&&this.focus)return this.focus(),!1},delegateType:"focusin"},blur:{trigger:function(){if(this===xa()&&this.blur)return this.blur(),!1},delegateType:"focusout"},click:{trigger:function(){if("checkbox"===this.type&&this.click&&B(this,"input"))return this.click(),!1},_default:function(a){return B(a.target,"a")}},beforeunload:{postDispatch:function(a){void 0!==a.result&&a.originalEvent&&(a.originalEvent.returnValue=a.result)}}}},r.removeEvent=function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c)},r.Event=function(a,b){return this instanceof r.Event?(a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||void 0===a.defaultPrevented&&a.returnValue===!1?va:wa,this.target=a.target&&3===a.target.nodeType?a.target.parentNode:a.target,this.currentTarget=a.currentTarget,this.relatedTarget=a.relatedTarget):this.type=a,b&&r.extend(this,b),this.timeStamp=a&&a.timeStamp||r.now(),void(this[r.expando]=!0)):new r.Event(a,b)},r.Event.prototype={constructor:r.Event,isDefaultPrevented:wa,isPropagationStopped:wa,isImmediatePropagationStopped:wa,isSimulated:!1,preventDefault:function(){var a=this.originalEvent;this.isDefaultPrevented=va,a&&!this.isSimulated&&a.preventDefault()},stopPropagation:function(){var a=this.originalEvent;this.isPropagationStopped=va,a&&!this.isSimulated&&a.stopPropagation()},stopImmediatePropagation:function(){var a=this.originalEvent;this.isImmediatePropagationStopped=va,a&&!this.isSimulated&&a.stopImmediatePropagation(),this.stopPropagation()}},r.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(a){var b=a.button;return null==a.which&&sa.test(a.type)?null!=a.charCode?a.charCode:a.keyCode:!a.which&&void 0!==b&&ta.test(a.type)?1&b?1:2&b?3:4&b?2:0:a.which}},r.event.addProp),r.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(a,b){r.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj;return e&&(e===d||r.contains(d,e))||(a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b),c}}}),r.fn.extend({on:function(a,b,c,d){return ya(this,a,b,c,d)},one:function(a,b,c,d){return ya(this,a,b,c,d,1)},off:function(a,b,c){var d,e;if(a&&a.preventDefault&&a.handleObj)return d=a.handleObj,r(a.delegateTarget).off(d.namespace?d.origType+"."+d.namespace:d.origType,d.selector,d.handler),this;if("object"==typeof a){for(e in a)this.off(e,b,a[e]);return this}return b!==!1&&"function"!=typeof b||(c=b,b=void 0),c===!1&&(c=wa),this.each(function(){r.event.remove(this,a,c,b)})}});var za=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,Aa=/<script|<style|<link/i,Ba=/checked\s*(?:[^=]|=\s*.checked.)/i,Ca=/^true\/(.*)/,Da=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function Ea(a,b){return B(a,"table")&&B(11!==b.nodeType?b:b.firstChild,"tr")?r(">tbody",a)[0]||a:a}function Fa(a){return a.type=(null!==a.getAttribute("type"))+"/"+a.type,a}function Ga(a){var b=Ca.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function Ha(a,b){var c,d,e,f,g,h,i,j;if(1===b.nodeType){if(W.hasData(a)&&(f=W.access(a),g=W.set(b,f),j=f.events)){delete g.handle,g.events={};for(e in j)for(c=0,d=j[e].length;c<d;c++)r.event.add(b,e,j[e][c])}X.hasData(a)&&(h=X.access(a),i=r.extend({},h),X.set(b,i))}}function Ia(a,b){var c=b.nodeName.toLowerCase();"input"===c&&ja.test(a.type)?b.checked=a.checked:"input"!==c&&"textarea"!==c||(b.defaultValue=a.defaultValue)}function Ja(a,b,c,d){b=g.apply([],b);var e,f,h,i,j,k,l=0,m=a.length,n=m-1,q=b[0],s=r.isFunction(q);if(s||m>1&&"string"==typeof q&&!o.checkClone&&Ba.test(q))return a.each(function(e){var f=a.eq(e);s&&(b[0]=q.call(this,e,f.html())),Ja(f,b,c,d)});if(m&&(e=qa(b,a[0].ownerDocument,!1,a,d),f=e.firstChild,1===e.childNodes.length&&(e=f),f||d)){for(h=r.map(na(e,"script"),Fa),i=h.length;l<m;l++)j=e,l!==n&&(j=r.clone(j,!0,!0),i&&r.merge(h,na(j,"script"))),c.call(a[l],j,l);if(i)for(k=h[h.length-1].ownerDocument,r.map(h,Ga),l=0;l<i;l++)j=h[l],la.test(j.type||"")&&!W.access(j,"globalEval")&&r.contains(k,j)&&(j.src?r._evalUrl&&r._evalUrl(j.src):p(j.textContent.replace(Da,""),k))}return a}function Ka(a,b,c){for(var d,e=b?r.filter(b,a):a,f=0;null!=(d=e[f]);f++)c||1!==d.nodeType||r.cleanData(na(d)),d.parentNode&&(c&&r.contains(d.ownerDocument,d)&&oa(na(d,"script")),d.parentNode.removeChild(d));return a}r.extend({htmlPrefilter:function(a){return a.replace(za,"<$1></$2>")},clone:function(a,b,c){var d,e,f,g,h=a.cloneNode(!0),i=r.contains(a.ownerDocument,a);if(!(o.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||r.isXMLDoc(a)))for(g=na(h),f=na(a),d=0,e=f.length;d<e;d++)Ia(f[d],g[d]);if(b)if(c)for(f=f||na(a),g=g||na(h),d=0,e=f.length;d<e;d++)Ha(f[d],g[d]);else Ha(a,h);return g=na(h,"script"),g.length>0&&oa(g,!i&&na(a,"script")),h},cleanData:function(a){for(var b,c,d,e=r.event.special,f=0;void 0!==(c=a[f]);f++)if(U(c)){if(b=c[W.expando]){if(b.events)for(d in b.events)e[d]?r.event.remove(c,d):r.removeEvent(c,d,b.handle);c[W.expando]=void 0}c[X.expando]&&(c[X.expando]=void 0)}}}),r.fn.extend({detach:function(a){return Ka(this,a,!0)},remove:function(a){return Ka(this,a)},text:function(a){return T(this,function(a){return void 0===a?r.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=a)})},null,a,arguments.length)},append:function(){return Ja(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ea(this,a);b.appendChild(a)}})},prepend:function(){return Ja(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ea(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return Ja(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return Ja(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},empty:function(){for(var a,b=0;null!=(a=this[b]);b++)1===a.nodeType&&(r.cleanData(na(a,!1)),a.textContent="");return this},clone:function(a,b){return a=null!=a&&a,b=null==b?a:b,this.map(function(){return r.clone(this,a,b)})},html:function(a){return T(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a&&1===b.nodeType)return b.innerHTML;if("string"==typeof a&&!Aa.test(a)&&!ma[(ka.exec(a)||["",""])[1].toLowerCase()]){a=r.htmlPrefilter(a);try{for(;c<d;c++)b=this[c]||{},1===b.nodeType&&(r.cleanData(na(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=[];return Ja(this,arguments,function(b){var c=this.parentNode;r.inArray(this,a)<0&&(r.cleanData(na(this)),c&&c.replaceChild(b,this))},a)}}),r.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){r.fn[a]=function(a){for(var c,d=[],e=r(a),f=e.length-1,g=0;g<=f;g++)c=g===f?this:this.clone(!0),r(e[g])[b](c),h.apply(d,c.get());return this.pushStack(d)}});var La=/^margin/,Ma=new RegExp("^("+aa+")(?!px)[a-z%]+$","i"),Na=function(b){var c=b.ownerDocument.defaultView;return c&&c.opener||(c=a),c.getComputedStyle(b)};!function(){function b(){if(i){i.style.cssText="box-sizing:border-box;position:relative;display:block;margin:auto;border:1px;padding:1px;top:1%;width:50%",i.innerHTML="",ra.appendChild(h);var b=a.getComputedStyle(i);c="1%"!==b.top,g="2px"===b.marginLeft,e="4px"===b.width,i.style.marginRight="50%",f="4px"===b.marginRight,ra.removeChild(h),i=null}}var c,e,f,g,h=d.createElement("div"),i=d.createElement("div");i.style&&(i.style.backgroundClip="content-box",i.cloneNode(!0).style.backgroundClip="",o.clearCloneStyle="content-box"===i.style.backgroundClip,h.style.cssText="border:0;width:8px;height:0;top:0;left:-9999px;padding:0;margin-top:1px;position:absolute",h.appendChild(i),r.extend(o,{pixelPosition:function(){return b(),c},boxSizingReliable:function(){return b(),e},pixelMarginRight:function(){return b(),f},reliableMarginLeft:function(){return b(),g}}))}();function Oa(a,b,c){var d,e,f,g,h=a.style;return c=c||Na(a),c&&(g=c.getPropertyValue(b)||c[b],""!==g||r.contains(a.ownerDocument,a)||(g=r.style(a,b)),!o.pixelMarginRight()&&Ma.test(g)&&La.test(b)&&(d=h.width,e=h.minWidth,f=h.maxWidth,h.minWidth=h.maxWidth=h.width=g,g=c.width,h.width=d,h.minWidth=e,h.maxWidth=f)),void 0!==g?g+"":g}function Pa(a,b){return{get:function(){return a()?void delete this.get:(this.get=b).apply(this,arguments)}}}var Qa=/^(none|table(?!-c[ea]).+)/,Ra=/^--/,Sa={position:"absolute",visibility:"hidden",display:"block"},Ta={letterSpacing:"0",fontWeight:"400"},Ua=["Webkit","Moz","ms"],Va=d.createElement("div").style;function Wa(a){if(a in Va)return a;var b=a[0].toUpperCase()+a.slice(1),c=Ua.length;while(c--)if(a=Ua[c]+b,a in Va)return a}function Xa(a){var b=r.cssProps[a];return b||(b=r.cssProps[a]=Wa(a)||a),b}function Ya(a,b,c){var d=ba.exec(b);return d?Math.max(0,d[2]-(c||0))+(d[3]||"px"):b}function Za(a,b,c,d,e){var f,g=0;for(f=c===(d?"border":"content")?4:"width"===b?1:0;f<4;f+=2)"margin"===c&&(g+=r.css(a,c+ca[f],!0,e)),d?("content"===c&&(g-=r.css(a,"padding"+ca[f],!0,e)),"margin"!==c&&(g-=r.css(a,"border"+ca[f]+"Width",!0,e))):(g+=r.css(a,"padding"+ca[f],!0,e),"padding"!==c&&(g+=r.css(a,"border"+ca[f]+"Width",!0,e)));return g}function $a(a,b,c){var d,e=Na(a),f=Oa(a,b,e),g="border-box"===r.css(a,"boxSizing",!1,e);return Ma.test(f)?f:(d=g&&(o.boxSizingReliable()||f===a.style[b]),"auto"===f&&(f=a["offset"+b[0].toUpperCase()+b.slice(1)]),f=parseFloat(f)||0,f+Za(a,b,c||(g?"border":"content"),d,e)+"px")}r.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=Oa(a,"opacity");return""===c?"1":c}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":"cssFloat"},style:function(a,b,c,d){if(a&&3!==a.nodeType&&8!==a.nodeType&&a.style){var e,f,g,h=r.camelCase(b),i=Ra.test(b),j=a.style;return i||(b=Xa(h)),g=r.cssHooks[b]||r.cssHooks[h],void 0===c?g&&"get"in g&&void 0!==(e=g.get(a,!1,d))?e:j[b]:(f=typeof c,"string"===f&&(e=ba.exec(c))&&e[1]&&(c=fa(a,b,e),f="number"),null!=c&&c===c&&("number"===f&&(c+=e&&e[3]||(r.cssNumber[h]?"":"px")),o.clearCloneStyle||""!==c||0!==b.indexOf("background")||(j[b]="inherit"),g&&"set"in g&&void 0===(c=g.set(a,c,d))||(i?j.setProperty(b,c):j[b]=c)),void 0)}},css:function(a,b,c,d){var e,f,g,h=r.camelCase(b),i=Ra.test(b);return i||(b=Xa(h)),g=r.cssHooks[b]||r.cssHooks[h],g&&"get"in g&&(e=g.get(a,!0,c)),void 0===e&&(e=Oa(a,b,d)),"normal"===e&&b in Ta&&(e=Ta[b]),""===c||c?(f=parseFloat(e),c===!0||isFinite(f)?f||0:e):e}}),r.each(["height","width"],function(a,b){r.cssHooks[b]={get:function(a,c,d){if(c)return!Qa.test(r.css(a,"display"))||a.getClientRects().length&&a.getBoundingClientRect().width?$a(a,b,d):ea(a,Sa,function(){return $a(a,b,d)})},set:function(a,c,d){var e,f=d&&Na(a),g=d&&Za(a,b,d,"border-box"===r.css(a,"boxSizing",!1,f),f);return g&&(e=ba.exec(c))&&"px"!==(e[3]||"px")&&(a.style[b]=c,c=r.css(a,b)),Ya(a,c,g)}}}),r.cssHooks.marginLeft=Pa(o.reliableMarginLeft,function(a,b){if(b)return(parseFloat(Oa(a,"marginLeft"))||a.getBoundingClientRect().left-ea(a,{marginLeft:0},function(){return a.getBoundingClientRect().left}))+"px"}),r.each({margin:"",padding:"",border:"Width"},function(a,b){r.cssHooks[a+b]={expand:function(c){for(var d=0,e={},f="string"==typeof c?c.split(" "):[c];d<4;d++)e[a+ca[d]+b]=f[d]||f[d-2]||f[0];return e}},La.test(a)||(r.cssHooks[a+b].set=Ya)}),r.fn.extend({css:function(a,b){return T(this,function(a,b,c){var d,e,f={},g=0;if(Array.isArray(b)){for(d=Na(a),e=b.length;g<e;g++)f[b[g]]=r.css(a,b[g],!1,d);return f}return void 0!==c?r.style(a,b,c):r.css(a,b)},a,b,arguments.length>1)}});function _a(a,b,c,d,e){return new _a.prototype.init(a,b,c,d,e)}r.Tween=_a,_a.prototype={constructor:_a,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||r.easing._default,this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(r.cssNumber[c]?"":"px")},cur:function(){var a=_a.propHooks[this.prop];return a&&a.get?a.get(this):_a.propHooks._default.get(this)},run:function(a){var b,c=_a.propHooks[this.prop];return this.options.duration?this.pos=b=r.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):_a.propHooks._default.set(this),this}},_a.prototype.init.prototype=_a.prototype,_a.propHooks={_default:{get:function(a){var b;return 1!==a.elem.nodeType||null!=a.elem[a.prop]&&null==a.elem.style[a.prop]?a.elem[a.prop]:(b=r.css(a.elem,a.prop,""),b&&"auto"!==b?b:0)},set:function(a){r.fx.step[a.prop]?r.fx.step[a.prop](a):1!==a.elem.nodeType||null==a.elem.style[r.cssProps[a.prop]]&&!r.cssHooks[a.prop]?a.elem[a.prop]=a.now:r.style(a.elem,a.prop,a.now+a.unit)}}},_a.propHooks.scrollTop=_a.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},r.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2},_default:"swing"},r.fx=_a.prototype.init,r.fx.step={};var ab,bb,cb=/^(?:toggle|show|hide)$/,db=/queueHooks$/;function eb(){bb&&(d.hidden===!1&&a.requestAnimationFrame?a.requestAnimationFrame(eb):a.setTimeout(eb,r.fx.interval),r.fx.tick())}function fb(){return a.setTimeout(function(){ab=void 0}),ab=r.now()}function gb(a,b){var c,d=0,e={height:a};for(b=b?1:0;d<4;d+=2-b)c=ca[d],e["margin"+c]=e["padding"+c]=a;return b&&(e.opacity=e.width=a),e}function hb(a,b,c){for(var d,e=(kb.tweeners[b]||[]).concat(kb.tweeners["*"]),f=0,g=e.length;f<g;f++)if(d=e[f].call(c,b,a))return d}function ib(a,b,c){var d,e,f,g,h,i,j,k,l="width"in b||"height"in b,m=this,n={},o=a.style,p=a.nodeType&&da(a),q=W.get(a,"fxshow");c.queue||(g=r._queueHooks(a,"fx"),null==g.unqueued&&(g.unqueued=0,h=g.empty.fire,g.empty.fire=function(){g.unqueued||h()}),g.unqueued++,m.always(function(){m.always(function(){g.unqueued--,r.queue(a,"fx").length||g.empty.fire()})}));for(d in b)if(e=b[d],cb.test(e)){if(delete b[d],f=f||"toggle"===e,e===(p?"hide":"show")){if("show"!==e||!q||void 0===q[d])continue;p=!0}n[d]=q&&q[d]||r.style(a,d)}if(i=!r.isEmptyObject(b),i||!r.isEmptyObject(n)){l&&1===a.nodeType&&(c.overflow=[o.overflow,o.overflowX,o.overflowY],j=q&&q.display,null==j&&(j=W.get(a,"display")),k=r.css(a,"display"),"none"===k&&(j?k=j:(ia([a],!0),j=a.style.display||j,k=r.css(a,"display"),ia([a]))),("inline"===k||"inline-block"===k&&null!=j)&&"none"===r.css(a,"float")&&(i||(m.done(function(){o.display=j}),null==j&&(k=o.display,j="none"===k?"":k)),o.display="inline-block")),c.overflow&&(o.overflow="hidden",m.always(function(){o.overflow=c.overflow[0],o.overflowX=c.overflow[1],o.overflowY=c.overflow[2]})),i=!1;for(d in n)i||(q?"hidden"in q&&(p=q.hidden):q=W.access(a,"fxshow",{display:j}),f&&(q.hidden=!p),p&&ia([a],!0),m.done(function(){p||ia([a]),W.remove(a,"fxshow");for(d in n)r.style(a,d,n[d])})),i=hb(p?q[d]:0,d,m),d in q||(q[d]=i.start,p&&(i.end=i.start,i.start=0))}}function jb(a,b){var c,d,e,f,g;for(c in a)if(d=r.camelCase(c),e=b[d],f=a[c],Array.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=r.cssHooks[d],g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}function kb(a,b,c){var d,e,f=0,g=kb.prefilters.length,h=r.Deferred().always(function(){delete i.elem}),i=function(){if(e)return!1;for(var b=ab||fb(),c=Math.max(0,j.startTime+j.duration-b),d=c/j.duration||0,f=1-d,g=0,i=j.tweens.length;g<i;g++)j.tweens[g].run(f);return h.notifyWith(a,[j,f,c]),f<1&&i?c:(i||h.notifyWith(a,[j,1,0]),h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:r.extend({},b),opts:r.extend(!0,{specialEasing:{},easing:r.easing._default},c),originalProperties:b,originalOptions:c,startTime:ab||fb(),duration:c.duration,tweens:[],createTween:function(b,c){var d=r.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(d),d},stop:function(b){var c=0,d=b?j.tweens.length:0;if(e)return this;for(e=!0;c<d;c++)j.tweens[c].run(1);return b?(h.notifyWith(a,[j,1,0]),h.resolveWith(a,[j,b])):h.rejectWith(a,[j,b]),this}}),k=j.props;for(jb(k,j.opts.specialEasing);f<g;f++)if(d=kb.prefilters[f].call(j,a,k,j.opts))return r.isFunction(d.stop)&&(r._queueHooks(j.elem,j.opts.queue).stop=r.proxy(d.stop,d)),d;return r.map(k,hb,j),r.isFunction(j.opts.start)&&j.opts.start.call(a,j),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always),r.fx.timer(r.extend(i,{elem:a,anim:j,queue:j.opts.queue})),j}r.Animation=r.extend(kb,{tweeners:{"*":[function(a,b){var c=this.createTween(a,b);return fa(c.elem,a,ba.exec(b),c),c}]},tweener:function(a,b){r.isFunction(a)?(b=a,a=["*"]):a=a.match(L);for(var c,d=0,e=a.length;d<e;d++)c=a[d],kb.tweeners[c]=kb.tweeners[c]||[],kb.tweeners[c].unshift(b)},prefilters:[ib],prefilter:function(a,b){b?kb.prefilters.unshift(a):kb.prefilters.push(a)}}),r.speed=function(a,b,c){var d=a&&"object"==typeof a?r.extend({},a):{complete:c||!c&&b||r.isFunction(a)&&a,duration:a,easing:c&&b||b&&!r.isFunction(b)&&b};return r.fx.off?d.duration=0:"number"!=typeof d.duration&&(d.duration in r.fx.speeds?d.duration=r.fx.speeds[d.duration]:d.duration=r.fx.speeds._default),null!=d.queue&&d.queue!==!0||(d.queue="fx"),d.old=d.complete,d.complete=function(){r.isFunction(d.old)&&d.old.call(this),d.queue&&r.dequeue(this,d.queue)},d},r.fn.extend({fadeTo:function(a,b,c,d){return this.filter(da).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=r.isEmptyObject(a),f=r.speed(b,c,d),g=function(){var b=kb(this,r.extend({},a),f);(e||W.get(this,"finish"))&&b.stop(!0)};return g.finish=g,e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,b,c){var d=function(a){var b=a.stop;delete a.stop,b(c)};return"string"!=typeof a&&(c=b,b=a,a=void 0),b&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,e=null!=a&&a+"queueHooks",f=r.timers,g=W.get(this);if(e)g[e]&&g[e].stop&&d(g[e]);else for(e in g)g[e]&&g[e].stop&&db.test(e)&&d(g[e]);for(e=f.length;e--;)f[e].elem!==this||null!=a&&f[e].queue!==a||(f[e].anim.stop(c),b=!1,f.splice(e,1));!b&&c||r.dequeue(this,a)})},finish:function(a){return a!==!1&&(a=a||"fx"),this.each(function(){var b,c=W.get(this),d=c[a+"queue"],e=c[a+"queueHooks"],f=r.timers,g=d?d.length:0;for(c.finish=!0,r.queue(this,a,[]),e&&e.stop&&e.stop.call(this,!0),b=f.length;b--;)f[b].elem===this&&f[b].queue===a&&(f[b].anim.stop(!0),f.splice(b,1));for(b=0;b<g;b++)d[b]&&d[b].finish&&d[b].finish.call(this);delete c.finish})}}),r.each(["toggle","show","hide"],function(a,b){var c=r.fn[b];r.fn[b]=function(a,d,e){return null==a||"boolean"==typeof a?c.apply(this,arguments):this.animate(gb(b,!0),a,d,e)}}),r.each({slideDown:gb("show"),slideUp:gb("hide"),slideToggle:gb("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){r.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),r.timers=[],r.fx.tick=function(){var a,b=0,c=r.timers;for(ab=r.now();b<c.length;b++)a=c[b],a()||c[b]!==a||c.splice(b--,1);c.length||r.fx.stop(),ab=void 0},r.fx.timer=function(a){r.timers.push(a),r.fx.start()},r.fx.interval=13,r.fx.start=function(){bb||(bb=!0,eb())},r.fx.stop=function(){bb=null},r.fx.speeds={slow:600,fast:200,_default:400},r.fn.delay=function(b,c){return b=r.fx?r.fx.speeds[b]||b:b,c=c||"fx",this.queue(c,function(c,d){var e=a.setTimeout(c,b);d.stop=function(){a.clearTimeout(e)}})},function(){var a=d.createElement("input"),b=d.createElement("select"),c=b.appendChild(d.createElement("option"));a.type="checkbox",o.checkOn=""!==a.value,o.optSelected=c.selected,a=d.createElement("input"),a.value="t",a.type="radio",o.radioValue="t"===a.value}();var lb,mb=r.expr.attrHandle;r.fn.extend({attr:function(a,b){return T(this,r.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){r.removeAttr(this,a)})}}),r.extend({attr:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return"undefined"==typeof a.getAttribute?r.prop(a,b,c):(1===f&&r.isXMLDoc(a)||(e=r.attrHooks[b.toLowerCase()]||(r.expr.match.bool.test(b)?lb:void 0)),void 0!==c?null===c?void r.removeAttr(a,b):e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:(a.setAttribute(b,c+""),c):e&&"get"in e&&null!==(d=e.get(a,b))?d:(d=r.find.attr(a,b),
-null==d?void 0:d))},attrHooks:{type:{set:function(a,b){if(!o.radioValue&&"radio"===b&&B(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}}},removeAttr:function(a,b){var c,d=0,e=b&&b.match(L);if(e&&1===a.nodeType)while(c=e[d++])a.removeAttribute(c)}}),lb={set:function(a,b,c){return b===!1?r.removeAttr(a,c):a.setAttribute(c,c),c}},r.each(r.expr.match.bool.source.match(/\w+/g),function(a,b){var c=mb[b]||r.find.attr;mb[b]=function(a,b,d){var e,f,g=b.toLowerCase();return d||(f=mb[g],mb[g]=e,e=null!=c(a,b,d)?g:null,mb[g]=f),e}});var nb=/^(?:input|select|textarea|button)$/i,ob=/^(?:a|area)$/i;r.fn.extend({prop:function(a,b){return T(this,r.prop,a,b,arguments.length>1)},removeProp:function(a){return this.each(function(){delete this[r.propFix[a]||a]})}}),r.extend({prop:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return 1===f&&r.isXMLDoc(a)||(b=r.propFix[b]||b,e=r.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){var b=r.find.attr(a,"tabindex");return b?parseInt(b,10):nb.test(a.nodeName)||ob.test(a.nodeName)&&a.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),o.optSelected||(r.propHooks.selected={get:function(a){var b=a.parentNode;return b&&b.parentNode&&b.parentNode.selectedIndex,null},set:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex)}}),r.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){r.propFix[this.toLowerCase()]=this});function pb(a){var b=a.match(L)||[];return b.join(" ")}function qb(a){return a.getAttribute&&a.getAttribute("class")||""}r.fn.extend({addClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).addClass(a.call(this,b,qb(this)))});if("string"==typeof a&&a){b=a.match(L)||[];while(c=this[i++])if(e=qb(c),d=1===c.nodeType&&" "+pb(e)+" "){g=0;while(f=b[g++])d.indexOf(" "+f+" ")<0&&(d+=f+" ");h=pb(d),e!==h&&c.setAttribute("class",h)}}return this},removeClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).removeClass(a.call(this,b,qb(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof a&&a){b=a.match(L)||[];while(c=this[i++])if(e=qb(c),d=1===c.nodeType&&" "+pb(e)+" "){g=0;while(f=b[g++])while(d.indexOf(" "+f+" ")>-1)d=d.replace(" "+f+" "," ");h=pb(d),e!==h&&c.setAttribute("class",h)}}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):r.isFunction(a)?this.each(function(c){r(this).toggleClass(a.call(this,c,qb(this),b),b)}):this.each(function(){var b,d,e,f;if("string"===c){d=0,e=r(this),f=a.match(L)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else void 0!==a&&"boolean"!==c||(b=qb(this),b&&W.set(this,"__className__",b),this.setAttribute&&this.setAttribute("class",b||a===!1?"":W.get(this,"__className__")||""))})},hasClass:function(a){var b,c,d=0;b=" "+a+" ";while(c=this[d++])if(1===c.nodeType&&(" "+pb(qb(c))+" ").indexOf(b)>-1)return!0;return!1}});var rb=/\r/g;r.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=r.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,r(this).val()):a,null==e?e="":"number"==typeof e?e+="":Array.isArray(e)&&(e=r.map(e,function(a){return null==a?"":a+""})),b=r.valHooks[this.type]||r.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=r.valHooks[e.type]||r.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(rb,""):null==c?"":c)}}}),r.extend({valHooks:{option:{get:function(a){var b=r.find.attr(a,"value");return null!=b?b:pb(r.text(a))}},select:{get:function(a){var b,c,d,e=a.options,f=a.selectedIndex,g="select-one"===a.type,h=g?null:[],i=g?f+1:e.length;for(d=f<0?i:g?f:0;d<i;d++)if(c=e[d],(c.selected||d===f)&&!c.disabled&&(!c.parentNode.disabled||!B(c.parentNode,"optgroup"))){if(b=r(c).val(),g)return b;h.push(b)}return h},set:function(a,b){var c,d,e=a.options,f=r.makeArray(b),g=e.length;while(g--)d=e[g],(d.selected=r.inArray(r.valHooks.option.get(d),f)>-1)&&(c=!0);return c||(a.selectedIndex=-1),f}}}}),r.each(["radio","checkbox"],function(){r.valHooks[this]={set:function(a,b){if(Array.isArray(b))return a.checked=r.inArray(r(a).val(),b)>-1}},o.checkOn||(r.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})});var sb=/^(?:focusinfocus|focusoutblur)$/;r.extend(r.event,{trigger:function(b,c,e,f){var g,h,i,j,k,m,n,o=[e||d],p=l.call(b,"type")?b.type:b,q=l.call(b,"namespace")?b.namespace.split("."):[];if(h=i=e=e||d,3!==e.nodeType&&8!==e.nodeType&&!sb.test(p+r.event.triggered)&&(p.indexOf(".")>-1&&(q=p.split("."),p=q.shift(),q.sort()),k=p.indexOf(":")<0&&"on"+p,b=b[r.expando]?b:new r.Event(p,"object"==typeof b&&b),b.isTrigger=f?2:3,b.namespace=q.join("."),b.rnamespace=b.namespace?new RegExp("(^|\\.)"+q.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=e),c=null==c?[b]:r.makeArray(c,[b]),n=r.event.special[p]||{},f||!n.trigger||n.trigger.apply(e,c)!==!1)){if(!f&&!n.noBubble&&!r.isWindow(e)){for(j=n.delegateType||p,sb.test(j+p)||(h=h.parentNode);h;h=h.parentNode)o.push(h),i=h;i===(e.ownerDocument||d)&&o.push(i.defaultView||i.parentWindow||a)}g=0;while((h=o[g++])&&!b.isPropagationStopped())b.type=g>1?j:n.bindType||p,m=(W.get(h,"events")||{})[b.type]&&W.get(h,"handle"),m&&m.apply(h,c),m=k&&h[k],m&&m.apply&&U(h)&&(b.result=m.apply(h,c),b.result===!1&&b.preventDefault());return b.type=p,f||b.isDefaultPrevented()||n._default&&n._default.apply(o.pop(),c)!==!1||!U(e)||k&&r.isFunction(e[p])&&!r.isWindow(e)&&(i=e[k],i&&(e[k]=null),r.event.triggered=p,e[p](),r.event.triggered=void 0,i&&(e[k]=i)),b.result}},simulate:function(a,b,c){var d=r.extend(new r.Event,c,{type:a,isSimulated:!0});r.event.trigger(d,null,b)}}),r.fn.extend({trigger:function(a,b){return this.each(function(){r.event.trigger(a,b,this)})},triggerHandler:function(a,b){var c=this[0];if(c)return r.event.trigger(a,b,c,!0)}}),r.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(a,b){r.fn[b]=function(a,c){return arguments.length>0?this.on(b,null,a,c):this.trigger(b)}}),r.fn.extend({hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),o.focusin="onfocusin"in a,o.focusin||r.each({focus:"focusin",blur:"focusout"},function(a,b){var c=function(a){r.event.simulate(b,a.target,r.event.fix(a))};r.event.special[b]={setup:function(){var d=this.ownerDocument||this,e=W.access(d,b);e||d.addEventListener(a,c,!0),W.access(d,b,(e||0)+1)},teardown:function(){var d=this.ownerDocument||this,e=W.access(d,b)-1;e?W.access(d,b,e):(d.removeEventListener(a,c,!0),W.remove(d,b))}}});var tb=a.location,ub=r.now(),vb=/\?/;r.parseXML=function(b){var c;if(!b||"string"!=typeof b)return null;try{c=(new a.DOMParser).parseFromString(b,"text/xml")}catch(d){c=void 0}return c&&!c.getElementsByTagName("parsererror").length||r.error("Invalid XML: "+b),c};var wb=/\[\]$/,xb=/\r?\n/g,yb=/^(?:submit|button|image|reset|file)$/i,zb=/^(?:input|select|textarea|keygen)/i;function Ab(a,b,c,d){var e;if(Array.isArray(b))r.each(b,function(b,e){c||wb.test(a)?d(a,e):Ab(a+"["+("object"==typeof e&&null!=e?b:"")+"]",e,c,d)});else if(c||"object"!==r.type(b))d(a,b);else for(e in b)Ab(a+"["+e+"]",b[e],c,d)}r.param=function(a,b){var c,d=[],e=function(a,b){var c=r.isFunction(b)?b():b;d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(null==c?"":c)};if(Array.isArray(a)||a.jquery&&!r.isPlainObject(a))r.each(a,function(){e(this.name,this.value)});else for(c in a)Ab(c,a[c],b,e);return d.join("&")},r.fn.extend({serialize:function(){return r.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var a=r.prop(this,"elements");return a?r.makeArray(a):this}).filter(function(){var a=this.type;return this.name&&!r(this).is(":disabled")&&zb.test(this.nodeName)&&!yb.test(a)&&(this.checked||!ja.test(a))}).map(function(a,b){var c=r(this).val();return null==c?null:Array.isArray(c)?r.map(c,function(a){return{name:b.name,value:a.replace(xb,"\r\n")}}):{name:b.name,value:c.replace(xb,"\r\n")}}).get()}});var Bb=/%20/g,Cb=/#.*$/,Db=/([?&])_=[^&]*/,Eb=/^(.*?):[ \t]*([^\r\n]*)$/gm,Fb=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Gb=/^(?:GET|HEAD)$/,Hb=/^\/\//,Ib={},Jb={},Kb="*/".concat("*"),Lb=d.createElement("a");Lb.href=tb.href;function Mb(a){return function(b,c){"string"!=typeof b&&(c=b,b="*");var d,e=0,f=b.toLowerCase().match(L)||[];if(r.isFunction(c))while(d=f[e++])"+"===d[0]?(d=d.slice(1)||"*",(a[d]=a[d]||[]).unshift(c)):(a[d]=a[d]||[]).push(c)}}function Nb(a,b,c,d){var e={},f=a===Jb;function g(h){var i;return e[h]=!0,r.each(a[h]||[],function(a,h){var j=h(b,c,d);return"string"!=typeof j||f||e[j]?f?!(i=j):void 0:(b.dataTypes.unshift(j),g(j),!1)}),i}return g(b.dataTypes[0])||!e["*"]&&g("*")}function Ob(a,b){var c,d,e=r.ajaxSettings.flatOptions||{};for(c in b)void 0!==b[c]&&((e[c]?a:d||(d={}))[c]=b[c]);return d&&r.extend(!0,a,d),a}function Pb(a,b,c){var d,e,f,g,h=a.contents,i=a.dataTypes;while("*"===i[0])i.shift(),void 0===d&&(d=a.mimeType||b.getResponseHeader("Content-Type"));if(d)for(e in h)if(h[e]&&h[e].test(d)){i.unshift(e);break}if(i[0]in c)f=i[0];else{for(e in c){if(!i[0]||a.converters[e+" "+i[0]]){f=e;break}g||(g=e)}f=f||g}if(f)return f!==i[0]&&i.unshift(f),c[f]}function Qb(a,b,c,d){var e,f,g,h,i,j={},k=a.dataTypes.slice();if(k[1])for(g in a.converters)j[g.toLowerCase()]=a.converters[g];f=k.shift();while(f)if(a.responseFields[f]&&(c[a.responseFields[f]]=b),!i&&d&&a.dataFilter&&(b=a.dataFilter(b,a.dataType)),i=f,f=k.shift())if("*"===f)f=i;else if("*"!==i&&i!==f){if(g=j[i+" "+f]||j["* "+f],!g)for(e in j)if(h=e.split(" "),h[1]===f&&(g=j[i+" "+h[0]]||j["* "+h[0]])){g===!0?g=j[e]:j[e]!==!0&&(f=h[0],k.unshift(h[1]));break}if(g!==!0)if(g&&a["throws"])b=g(b);else try{b=g(b)}catch(l){return{state:"parsererror",error:g?l:"No conversion from "+i+" to "+f}}}return{state:"success",data:b}}r.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:tb.href,type:"GET",isLocal:Fb.test(tb.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Kb,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":r.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(a,b){return b?Ob(Ob(a,r.ajaxSettings),b):Ob(r.ajaxSettings,a)},ajaxPrefilter:Mb(Ib),ajaxTransport:Mb(Jb),ajax:function(b,c){"object"==typeof b&&(c=b,b=void 0),c=c||{};var e,f,g,h,i,j,k,l,m,n,o=r.ajaxSetup({},c),p=o.context||o,q=o.context&&(p.nodeType||p.jquery)?r(p):r.event,s=r.Deferred(),t=r.Callbacks("once memory"),u=o.statusCode||{},v={},w={},x="canceled",y={readyState:0,getResponseHeader:function(a){var b;if(k){if(!h){h={};while(b=Eb.exec(g))h[b[1].toLowerCase()]=b[2]}b=h[a.toLowerCase()]}return null==b?null:b},getAllResponseHeaders:function(){return k?g:null},setRequestHeader:function(a,b){return null==k&&(a=w[a.toLowerCase()]=w[a.toLowerCase()]||a,v[a]=b),this},overrideMimeType:function(a){return null==k&&(o.mimeType=a),this},statusCode:function(a){var b;if(a)if(k)y.always(a[y.status]);else for(b in a)u[b]=[u[b],a[b]];return this},abort:function(a){var b=a||x;return e&&e.abort(b),A(0,b),this}};if(s.promise(y),o.url=((b||o.url||tb.href)+"").replace(Hb,tb.protocol+"//"),o.type=c.method||c.type||o.method||o.type,o.dataTypes=(o.dataType||"*").toLowerCase().match(L)||[""],null==o.crossDomain){j=d.createElement("a");try{j.href=o.url,j.href=j.href,o.crossDomain=Lb.protocol+"//"+Lb.host!=j.protocol+"//"+j.host}catch(z){o.crossDomain=!0}}if(o.data&&o.processData&&"string"!=typeof o.data&&(o.data=r.param(o.data,o.traditional)),Nb(Ib,o,c,y),k)return y;l=r.event&&o.global,l&&0===r.active++&&r.event.trigger("ajaxStart"),o.type=o.type.toUpperCase(),o.hasContent=!Gb.test(o.type),f=o.url.replace(Cb,""),o.hasContent?o.data&&o.processData&&0===(o.contentType||"").indexOf("application/x-www-form-urlencoded")&&(o.data=o.data.replace(Bb,"+")):(n=o.url.slice(f.length),o.data&&(f+=(vb.test(f)?"&":"?")+o.data,delete o.data),o.cache===!1&&(f=f.replace(Db,"$1"),n=(vb.test(f)?"&":"?")+"_="+ub++ +n),o.url=f+n),o.ifModified&&(r.lastModified[f]&&y.setRequestHeader("If-Modified-Since",r.lastModified[f]),r.etag[f]&&y.setRequestHeader("If-None-Match",r.etag[f])),(o.data&&o.hasContent&&o.contentType!==!1||c.contentType)&&y.setRequestHeader("Content-Type",o.contentType),y.setRequestHeader("Accept",o.dataTypes[0]&&o.accepts[o.dataTypes[0]]?o.accepts[o.dataTypes[0]]+("*"!==o.dataTypes[0]?", "+Kb+"; q=0.01":""):o.accepts["*"]);for(m in o.headers)y.setRequestHeader(m,o.headers[m]);if(o.beforeSend&&(o.beforeSend.call(p,y,o)===!1||k))return y.abort();if(x="abort",t.add(o.complete),y.done(o.success),y.fail(o.error),e=Nb(Jb,o,c,y)){if(y.readyState=1,l&&q.trigger("ajaxSend",[y,o]),k)return y;o.async&&o.timeout>0&&(i=a.setTimeout(function(){y.abort("timeout")},o.timeout));try{k=!1,e.send(v,A)}catch(z){if(k)throw z;A(-1,z)}}else A(-1,"No Transport");function A(b,c,d,h){var j,m,n,v,w,x=c;k||(k=!0,i&&a.clearTimeout(i),e=void 0,g=h||"",y.readyState=b>0?4:0,j=b>=200&&b<300||304===b,d&&(v=Pb(o,y,d)),v=Qb(o,v,y,j),j?(o.ifModified&&(w=y.getResponseHeader("Last-Modified"),w&&(r.lastModified[f]=w),w=y.getResponseHeader("etag"),w&&(r.etag[f]=w)),204===b||"HEAD"===o.type?x="nocontent":304===b?x="notmodified":(x=v.state,m=v.data,n=v.error,j=!n)):(n=x,!b&&x||(x="error",b<0&&(b=0))),y.status=b,y.statusText=(c||x)+"",j?s.resolveWith(p,[m,x,y]):s.rejectWith(p,[y,x,n]),y.statusCode(u),u=void 0,l&&q.trigger(j?"ajaxSuccess":"ajaxError",[y,o,j?m:n]),t.fireWith(p,[y,x]),l&&(q.trigger("ajaxComplete",[y,o]),--r.active||r.event.trigger("ajaxStop")))}return y},getJSON:function(a,b,c){return r.get(a,b,c,"json")},getScript:function(a,b){return r.get(a,void 0,b,"script")}}),r.each(["get","post"],function(a,b){r[b]=function(a,c,d,e){return r.isFunction(c)&&(e=e||d,d=c,c=void 0),r.ajax(r.extend({url:a,type:b,dataType:e,data:c,success:d},r.isPlainObject(a)&&a))}}),r._evalUrl=function(a){return r.ajax({url:a,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,"throws":!0})},r.fn.extend({wrapAll:function(a){var b;return this[0]&&(r.isFunction(a)&&(a=a.call(this[0])),b=r(a,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstElementChild)a=a.firstElementChild;return a}).append(this)),this},wrapInner:function(a){return r.isFunction(a)?this.each(function(b){r(this).wrapInner(a.call(this,b))}):this.each(function(){var b=r(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=r.isFunction(a);return this.each(function(c){r(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(a){return this.parent(a).not("body").each(function(){r(this).replaceWith(this.childNodes)}),this}}),r.expr.pseudos.hidden=function(a){return!r.expr.pseudos.visible(a)},r.expr.pseudos.visible=function(a){return!!(a.offsetWidth||a.offsetHeight||a.getClientRects().length)},r.ajaxSettings.xhr=function(){try{return new a.XMLHttpRequest}catch(b){}};var Rb={0:200,1223:204},Sb=r.ajaxSettings.xhr();o.cors=!!Sb&&"withCredentials"in Sb,o.ajax=Sb=!!Sb,r.ajaxTransport(function(b){var c,d;if(o.cors||Sb&&!b.crossDomain)return{send:function(e,f){var g,h=b.xhr();if(h.open(b.type,b.url,b.async,b.username,b.password),b.xhrFields)for(g in b.xhrFields)h[g]=b.xhrFields[g];b.mimeType&&h.overrideMimeType&&h.overrideMimeType(b.mimeType),b.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest");for(g in e)h.setRequestHeader(g,e[g]);c=function(a){return function(){c&&(c=d=h.onload=h.onerror=h.onabort=h.onreadystatechange=null,"abort"===a?h.abort():"error"===a?"number"!=typeof h.status?f(0,"error"):f(h.status,h.statusText):f(Rb[h.status]||h.status,h.statusText,"text"!==(h.responseType||"text")||"string"!=typeof h.responseText?{binary:h.response}:{text:h.responseText},h.getAllResponseHeaders()))}},h.onload=c(),d=h.onerror=c("error"),void 0!==h.onabort?h.onabort=d:h.onreadystatechange=function(){4===h.readyState&&a.setTimeout(function(){c&&d()})},c=c("abort");try{h.send(b.hasContent&&b.data||null)}catch(i){if(c)throw i}},abort:function(){c&&c()}}}),r.ajaxPrefilter(function(a){a.crossDomain&&(a.contents.script=!1)}),r.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(a){return r.globalEval(a),a}}}),r.ajaxPrefilter("script",function(a){void 0===a.cache&&(a.cache=!1),a.crossDomain&&(a.type="GET")}),r.ajaxTransport("script",function(a){if(a.crossDomain){var b,c;return{send:function(e,f){b=r("<script>").prop({charset:a.scriptCharset,src:a.url}).on("load error",c=function(a){b.remove(),c=null,a&&f("error"===a.type?404:200,a.type)}),d.head.appendChild(b[0])},abort:function(){c&&c()}}}});var Tb=[],Ub=/(=)\?(?=&|$)|\?\?/;r.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=Tb.pop()||r.expando+"_"+ub++;return this[a]=!0,a}}),r.ajaxPrefilter("json jsonp",function(b,c,d){var e,f,g,h=b.jsonp!==!1&&(Ub.test(b.url)?"url":"string"==typeof b.data&&0===(b.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ub.test(b.data)&&"data");if(h||"jsonp"===b.dataTypes[0])return e=b.jsonpCallback=r.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,h?b[h]=b[h].replace(Ub,"$1"+e):b.jsonp!==!1&&(b.url+=(vb.test(b.url)?"&":"?")+b.jsonp+"="+e),b.converters["script json"]=function(){return g||r.error(e+" was not called"),g[0]},b.dataTypes[0]="json",f=a[e],a[e]=function(){g=arguments},d.always(function(){void 0===f?r(a).removeProp(e):a[e]=f,b[e]&&(b.jsonpCallback=c.jsonpCallback,Tb.push(e)),g&&r.isFunction(f)&&f(g[0]),g=f=void 0}),"script"}),o.createHTMLDocument=function(){var a=d.implementation.createHTMLDocument("").body;return a.innerHTML="<form></form><form></form>",2===a.childNodes.length}(),r.parseHTML=function(a,b,c){if("string"!=typeof a)return[];"boolean"==typeof b&&(c=b,b=!1);var e,f,g;return b||(o.createHTMLDocument?(b=d.implementation.createHTMLDocument(""),e=b.createElement("base"),e.href=d.location.href,b.head.appendChild(e)):b=d),f=C.exec(a),g=!c&&[],f?[b.createElement(f[1])]:(f=qa([a],b,g),g&&g.length&&r(g).remove(),r.merge([],f.childNodes))},r.fn.load=function(a,b,c){var d,e,f,g=this,h=a.indexOf(" ");return h>-1&&(d=pb(a.slice(h)),a=a.slice(0,h)),r.isFunction(b)?(c=b,b=void 0):b&&"object"==typeof b&&(e="POST"),g.length>0&&r.ajax({url:a,type:e||"GET",dataType:"html",data:b}).done(function(a){f=arguments,g.html(d?r("<div>").append(r.parseHTML(a)).find(d):a)}).always(c&&function(a,b){g.each(function(){c.apply(this,f||[a.responseText,b,a])})}),this},r.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){r.fn[b]=function(a){return this.on(b,a)}}),r.expr.pseudos.animated=function(a){return r.grep(r.timers,function(b){return a===b.elem}).length},r.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=r.css(a,"position"),l=r(a),m={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=r.css(a,"top"),i=r.css(a,"left"),j=("absolute"===k||"fixed"===k)&&(f+i).indexOf("auto")>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),r.isFunction(b)&&(b=b.call(a,c,r.extend({},h))),null!=b.top&&(m.top=b.top-h.top+g),null!=b.left&&(m.left=b.left-h.left+e),"using"in b?b.using.call(a,m):l.css(m)}},r.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){r.offset.setOffset(this,a,b)});var b,c,d,e,f=this[0];if(f)return f.getClientRects().length?(d=f.getBoundingClientRect(),b=f.ownerDocument,c=b.documentElement,e=b.defaultView,{top:d.top+e.pageYOffset-c.clientTop,left:d.left+e.pageXOffset-c.clientLeft}):{top:0,left:0}},position:function(){if(this[0]){var a,b,c=this[0],d={top:0,left:0};return"fixed"===r.css(c,"position")?b=c.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),B(a[0],"html")||(d=a.offset()),d={top:d.top+r.css(a[0],"borderTopWidth",!0),left:d.left+r.css(a[0],"borderLeftWidth",!0)}),{top:b.top-d.top-r.css(c,"marginTop",!0),left:b.left-d.left-r.css(c,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent;while(a&&"static"===r.css(a,"position"))a=a.offsetParent;return a||ra})}}),r.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c="pageYOffset"===b;r.fn[a]=function(d){return T(this,function(a,d,e){var f;return r.isWindow(a)?f=a:9===a.nodeType&&(f=a.defaultView),void 0===e?f?f[b]:a[d]:void(f?f.scrollTo(c?f.pageXOffset:e,c?e:f.pageYOffset):a[d]=e)},a,d,arguments.length)}}),r.each(["top","left"],function(a,b){r.cssHooks[b]=Pa(o.pixelPosition,function(a,c){if(c)return c=Oa(a,b),Ma.test(c)?r(a).position()[b]+"px":c})}),r.each({Height:"height",Width:"width"},function(a,b){r.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){r.fn[d]=function(e,f){var g=arguments.length&&(c||"boolean"!=typeof e),h=c||(e===!0||f===!0?"margin":"border");return T(this,function(b,c,e){var f;return r.isWindow(b)?0===d.indexOf("outer")?b["inner"+a]:b.document.documentElement["client"+a]:9===b.nodeType?(f=b.documentElement,Math.max(b.body["scroll"+a],f["scroll"+a],b.body["offset"+a],f["offset"+a],f["client"+a])):void 0===e?r.css(b,c,h):r.style(b,c,e,h)},b,g?e:void 0,g)}})}),r.fn.extend({bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return 1===arguments.length?this.off(a,"**"):this.off(b,a||"**",c)}}),r.holdReady=function(a){a?r.readyWait++:r.ready(!0)},r.isArray=Array.isArray,r.parseJSON=JSON.parse,r.nodeName=B,"function"==typeof define&&define.amd&&define("jquery",[],function(){return r});var Vb=a.jQuery,Wb=a.$;return r.noConflict=function(b){return a.$===r&&(a.$=Wb),b&&a.jQuery===r&&(a.jQuery=Vb),r},b||(a.jQuery=a.$=r),r});
+/*! jQuery v3.5.1 | (c) JS Foundation and other contributors | jquery.org/license */
+!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.5.1",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}S.fn=S.prototype={jquery:f,constructor:S,length:0,toArray:function(){return s.call(this)},get:function(e){return null==e?s.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=S.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return S.each(this,e)},map:function(n){return this.pushStack(S.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(s.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(S.grep(this,function(e,t){return(t+1)%2}))},odd:function(){return this.pushStack(S.grep(this,function(e,t){return t%2}))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:u,sort:t.sort,splice:t.splice},S.extend=S.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||m(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(S.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||S.isPlainObject(n)?n:{},i=!1,a[t]=S.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},S.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==o.call(e))&&(!(t=r(e))||"function"==typeof(n=v.call(t,"constructor")&&t.constructor)&&a.call(n)===l)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){b(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(p(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},makeArray:function(e,t){var n=t||[];return null!=e&&(p(Object(e))?S.merge(n,"string"==typeof e?[e]:e):u.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:i.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(p(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g(a)},guid:1,support:y}),"function"==typeof Symbol&&(S.fn[Symbol.iterator]=t[Symbol.iterator]),S.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var d=function(n){var e,d,b,o,i,h,f,g,w,u,l,T,C,a,E,v,s,c,y,S="sizzle"+1*new Date,p=n.document,k=0,r=0,m=ue(),x=ue(),A=ue(),N=ue(),D=function(e,t){return e===t&&(l=!0),0},j={}.hasOwnProperty,t=[],q=t.pop,L=t.push,H=t.push,O=t.slice,P=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",I="(?:\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",W="\\["+M+"*("+I+")(?:"+M+"*([*^$|!~]?=)"+M+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+I+"))|)"+M+"*\\]",F=":("+I+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+W+")*)|.*)\\)|)",B=new RegExp(M+"+","g"),$=new RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=new RegExp("^"+M+"*,"+M+"*"),z=new RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="<a id='"+S+"'></a><select id='"+S+"-\r\\' msallowcapture=''><option selected=''></option></select>",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0<se(t,C,null,[e]).length},se.contains=function(e,t){return(e.ownerDocument||e)!=C&&T(e),y(e,t)},se.attr=function(e,t){(e.ownerDocument||e)!=C&&T(e);var n=b.attrHandle[t.toLowerCase()],r=n&&j.call(b.attrHandle,t.toLowerCase())?n(e,t,!E):void 0;return void 0!==r?r:d.attributes||!E?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},se.escape=function(e){return(e+"").replace(re,ie)},se.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},se.uniqueSort=function(e){var t,n=[],r=0,i=0;if(l=!d.detectDuplicates,u=!d.sortStable&&e.slice(0),e.sort(D),l){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return u=null,e},o=se.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else while(t=e[r++])n+=o(t);return n},(b=se.selectors={cacheLength:50,createPseudo:le,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(B," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(h,e,t,g,v){var y="nth"!==h.slice(0,3),m="last"!==h.slice(-4),x="of-type"===e;return 1===g&&0===v?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u,l=y!==m?"nextSibling":"previousSibling",c=e.parentNode,f=x&&e.nodeName.toLowerCase(),p=!n&&!x,d=!1;if(c){if(y){while(l){a=e;while(a=a[l])if(x?a.nodeName.toLowerCase()===f:1===a.nodeType)return!1;u=l="only"===h&&!u&&"nextSibling"}return!0}if(u=[m?c.firstChild:c.lastChild],m&&p){d=(s=(r=(i=(o=(a=c)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1])&&r[2],a=s&&c.childNodes[s];while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if(1===a.nodeType&&++d&&a===e){i[h]=[k,s,d];break}}else if(p&&(d=s=(r=(i=(o=(a=e)[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]||[])[0]===k&&r[1]),!1===d)while(a=++s&&a&&a[l]||(d=s=0)||u.pop())if((x?a.nodeName.toLowerCase()===f:1===a.nodeType)&&++d&&(p&&((i=(o=a[S]||(a[S]={}))[a.uniqueID]||(o[a.uniqueID]={}))[h]=[k,d]),a===e))break;return(d-=v)===g||d%g==0&&0<=d/g}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||se.error("unsupported pseudo: "+e);return a[S]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?le(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=P(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:le(function(e){var r=[],i=[],s=f(e.replace($,"$1"));return s[S]?le(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:le(function(t){return function(e){return 0<se(t,e).length}}),contains:le(function(t){return t=t.replace(te,ne),function(e){return-1<(e.textContent||o(e)).indexOf(t)}}),lang:le(function(n){return V.test(n||"")||se.error("unsupported lang: "+n),n=n.replace(te,ne).toLowerCase(),function(e){var t;do{if(t=E?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=n.location&&n.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===a},focus:function(e){return e===C.activeElement&&(!C.hasFocus||C.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:ge(!1),disabled:ge(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return J.test(e.nodeName)},input:function(e){return Q.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:ve(function(){return[0]}),last:ve(function(e,t){return[t-1]}),eq:ve(function(e,t,n){return[n<0?n+t:n]}),even:ve(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:ve(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:ve(function(e,t,n){for(var r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:ve(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=de(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=he(e);function me(){}function xe(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function be(s,e,t){var u=e.dir,l=e.next,c=l||u,f=t&&"parentNode"===c,p=r++;return e.first?function(e,t,n){while(e=e[u])if(1===e.nodeType||f)return s(e,t,n);return!1}:function(e,t,n){var r,i,o,a=[k,p];if(n){while(e=e[u])if((1===e.nodeType||f)&&s(e,t,n))return!0}else while(e=e[u])if(1===e.nodeType||f)if(i=(o=e[S]||(e[S]={}))[e.uniqueID]||(o[e.uniqueID]={}),l&&l===e.nodeName.toLowerCase())e=e[u]||e;else{if((r=i[c])&&r[0]===k&&r[1]===p)return a[2]=r[2];if((i[c]=a)[2]=s(e,t,n))return!0}return!1}}function we(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Te(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function Ce(d,h,g,v,y,e){return v&&!v[S]&&(v=Ce(v)),y&&!y[S]&&(y=Ce(y,e)),le(function(e,t,n,r){var i,o,a,s=[],u=[],l=t.length,c=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)se(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),f=!d||!e&&h?c:Te(c,s,d,n,r),p=g?y||(e?d:l||v)?[]:t:f;if(g&&g(f,p,n,r),v){i=Te(p,u),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(p[u[o]]=!(f[u[o]]=a))}if(e){if(y||d){if(y){i=[],o=p.length;while(o--)(a=p[o])&&i.push(f[o]=a);y(null,p=[],i,r)}o=p.length;while(o--)(a=p[o])&&-1<(i=y?P(e,a):s[o])&&(e[i]=!(t[i]=a))}}else p=Te(p===t?p.splice(l,p.length):p),y?y(null,t,p,r):H.apply(t,p)})}function Ee(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=be(function(e){return e===i},a,!0),l=be(function(e){return-1<P(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!==w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[be(we(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[S]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return Ce(1<s&&we(c),1<s&&xe(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace($,"$1"),t,s<n&&Ee(e.slice(s,n)),n<r&&Ee(e=e.slice(n)),n<r&&xe(e))}c.push(t)}return we(c)}return me.prototype=b.filters=b.pseudos,b.setFilters=new me,h=se.tokenize=function(e,t){var n,r,i,o,a,s,u,l=x[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=_.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=z.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace($," ")}),a=a.slice(n.length)),b.filter)!(r=G[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?se.error(e):x(e,s).slice(0)},f=se.compile=function(e,t){var n,v,y,m,x,r,i=[],o=[],a=A[e+" "];if(!a){t||(t=h(e)),n=t.length;while(n--)(a=Ee(t[n]))[S]?i.push(a):o.push(a);(a=A(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=k+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t==C||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument==C||(T(o),n=!E);while(s=v[a++])if(s(o,t||C,n)){r.push(o);break}i&&(k=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=q.call(r));f=Te(f)}H.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&se.uniqueSort(r)}return i&&(k=h,w=p),c},m?le(r):r))).selector=e}return a},g=se.select=function(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&h(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&E&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(te,ne),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=G.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(te,ne),ee.test(o[0].type)&&ye(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&xe(o)))return H.apply(n,r),n;break}}}return(l||f(e,c))(r,t,!E,n,!t||ee.test(e)&&ye(t.parentNode)||t),n},d.sortStable=S.split("").sort(D).join("")===S,d.detectDuplicates=!!l,T(),d.sortDetached=ce(function(e){return 1&e.compareDocumentPosition(C.createElement("fieldset"))}),ce(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||fe("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),d.attributes&&ce(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||fe("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),ce(function(e){return null==e.getAttribute("disabled")})||fe(R,function(e,t,n){var r;if(!n)return!0===e[t]?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),se}(C);S.find=d,S.expr=d.selectors,S.expr[":"]=S.expr.pseudos,S.uniqueSort=S.unique=d.uniqueSort,S.text=d.getText,S.isXMLDoc=d.isXML,S.contains=d.contains,S.escapeSelector=d.escape;var h=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&S(e).is(n))break;r.push(e)}return r},T=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},k=S.expr.match.needsContext;function A(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}var N=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function D(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1<i.call(n,e)!==r}):S.filter(n,e,r)}S.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?S.find.matchesSelector(r,e)?[r]:[]:S.find.matches(e,S.grep(t,function(e){return 1===e.nodeType}))},S.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(S(e).filter(function(){for(t=0;t<r;t++)if(S.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)S.find(e,i[t],n);return 1<r?S.uniqueSort(n):n},filter:function(e){return this.pushStack(D(this,e||[],!1))},not:function(e){return this.pushStack(D(this,e||[],!0))},is:function(e){return!!D(this,"string"==typeof e&&k.test(e)?S(e):e||[],!1).length}});var j,q=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||j,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,j=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(S.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&S(e);if(!k.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&S.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?S.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?i.call(S(e),this[0]):i.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(S.uniqueSort(S.merge(this.get(),S(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),S.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return h(e,"parentNode")},parentsUntil:function(e,t,n){return h(e,"parentNode",n)},next:function(e){return O(e,"nextSibling")},prev:function(e){return O(e,"previousSibling")},nextAll:function(e){return h(e,"nextSibling")},prevAll:function(e){return h(e,"previousSibling")},nextUntil:function(e,t,n){return h(e,"nextSibling",n)},prevUntil:function(e,t,n){return h(e,"previousSibling",n)},siblings:function(e){return T((e.parentNode||{}).firstChild,e)},children:function(e){return T(e.firstChild)},contents:function(e){return null!=e.contentDocument&&r(e.contentDocument)?e.contentDocument:(A(e,"template")&&(e=e.content||e),S.merge([],e.childNodes))}},function(r,i){S.fn[r]=function(e,t){var n=S.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=S.filter(t,n)),1<this.length&&(H[r]||S.uniqueSort(n),L.test(r)&&n.reverse()),this.pushStack(n)}});var P=/[^\x20\t\r\n\f]+/g;function R(e){return e}function M(e){throw e}function I(e,t,n,r){var i;try{e&&m(i=e.promise)?i.call(e).done(t).fail(n):e&&m(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}S.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},S.each(e.match(P)||[],function(e,t){n[t]=!0}),n):S.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){S.each(e,function(e,t){m(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==w(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return S.each(arguments,function(e,t){var n;while(-1<(n=S.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<S.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},S.extend({Deferred:function(e){var o=[["notify","progress",S.Callbacks("memory"),S.Callbacks("memory"),2],["resolve","done",S.Callbacks("once memory"),S.Callbacks("once memory"),0,"resolved"],["reject","fail",S.Callbacks("once memory"),S.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return S.Deferred(function(r){S.each(o,function(e,t){var n=m(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&m(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,m(t)?s?t.call(e,l(u,o,R,s),l(u,o,M,s)):(u++,t.call(e,l(u,o,R,s),l(u,o,M,s),l(u,o,R,o.notifyWith))):(a!==R&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){S.Deferred.exceptionHook&&S.Deferred.exceptionHook(e,t.stackTrace),u<=i+1&&(a!==M&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(S.Deferred.getStackHook&&(t.stackTrace=S.Deferred.getStackHook()),C.setTimeout(t))}}return S.Deferred(function(e){o[0][3].add(l(0,e,m(r)?r:R,e.notifyWith)),o[1][3].add(l(0,e,m(t)?t:R)),o[2][3].add(l(0,e,m(n)?n:M))}).promise()},promise:function(e){return null!=e?S.extend(e,a):a}},s={};return S.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=s.call(arguments),o=S.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?s.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(I(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||m(i[t]&&i[t].then)))return o.then();while(t--)I(i[t],a(t),o.reject);return o.promise()}});var W=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;S.Deferred.exceptionHook=function(e,t){C.console&&C.console.warn&&e&&W.test(e.name)&&C.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},S.readyException=function(e){C.setTimeout(function(){throw e})};var F=S.Deferred();function B(){E.removeEventListener("DOMContentLoaded",B),C.removeEventListener("load",B),S.ready()}S.fn.ready=function(e){return F.then(e)["catch"](function(e){S.readyException(e)}),this},S.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--S.readyWait:S.isReady)||(S.isReady=!0)!==e&&0<--S.readyWait||F.resolveWith(E,[S])}}),S.ready.then=F.then,"complete"===E.readyState||"loading"!==E.readyState&&!E.documentElement.doScroll?C.setTimeout(S.ready):(E.addEventListener("DOMContentLoaded",B),C.addEventListener("load",B));var $=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===w(n))for(s in i=!0,n)$(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,m(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(S(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},_=/^-ms-/,z=/-([a-z])/g;function U(e,t){return t.toUpperCase()}function X(e){return e.replace(_,"ms-").replace(z,U)}var V=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function G(){this.expando=S.expando+G.uid++}G.uid=1,G.prototype={cache:function(e){var t=e[this.expando];return t||(t={},V(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[X(t)]=n;else for(r in t)i[X(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][X(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(X):(t=X(t))in r?[t]:t.match(P)||[]).length;while(n--)delete r[t[n]]}(void 0===t||S.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!S.isEmptyObject(t)}};var Y=new G,Q=new G,J=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,K=/[A-Z]/g;function Z(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(K,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:J.test(i)?JSON.parse(i):i)}catch(e){}Q.set(e,t,n)}else n=void 0;return n}S.extend({hasData:function(e){return Q.hasData(e)||Y.hasData(e)},data:function(e,t,n){return Q.access(e,t,n)},removeData:function(e,t){Q.remove(e,t)},_data:function(e,t,n){return Y.access(e,t,n)},_removeData:function(e,t){Y.remove(e,t)}}),S.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=Q.get(o),1===o.nodeType&&!Y.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=X(r.slice(5)),Z(o,r,i[r]));Y.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){Q.set(this,n)}):$(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=Q.get(o,n))?t:void 0!==(t=Z(o,n))?t:void 0;this.each(function(){Q.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){Q.remove(this,e)})}}),S.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Y.get(e,t),n&&(!r||Array.isArray(n)?r=Y.access(e,t,S.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=S.queue(e,t),r=n.length,i=n.shift(),o=S._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){S.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Y.get(e,n)||Y.access(e,n,{empty:S.Callbacks("once memory").add(function(){Y.remove(e,[t+"queue",n])})})}}),S.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?S.queue(this[0],t):void 0===n?this:this.each(function(){var e=S.queue(this,t,n);S._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&S.dequeue(this,t)})},dequeue:function(e){return this.each(function(){S.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=S.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=Y.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var ee=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,te=new RegExp("^(?:([+-])=|)("+ee+")([a-z%]*)$","i"),ne=["Top","Right","Bottom","Left"],re=E.documentElement,ie=function(e){return S.contains(e.ownerDocument,e)},oe={composed:!0};re.getRootNode&&(ie=function(e){return S.contains(e.ownerDocument,e)||e.getRootNode(oe)===e.ownerDocument});var ae=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&ie(e)&&"none"===S.css(e,"display")};function se(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return S.css(e,t,"")},u=s(),l=n&&n[3]||(S.cssNumber[t]?"":"px"),c=e.nodeType&&(S.cssNumber[t]||"px"!==l&&+u)&&te.exec(S.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)S.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,S.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ue={};function le(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=Y.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&ae(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ue[s])||(o=a.body.appendChild(a.createElement(s)),u=S.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ue[s]=u)))):"none"!==n&&(l[c]="none",Y.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}S.fn.extend({show:function(){return le(this,!0)},hide:function(){return le(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){ae(this)?S(this).show():S(this).hide()})}});var ce,fe,pe=/^(?:checkbox|radio)$/i,de=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="<textarea>x</textarea>",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="<option></option>",y.option=!!ce.lastChild;var ge={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n<r;n++)Y.set(e[n],"globalEval",!t||Y.get(t[n],"globalEval"))}ge.tbody=ge.tfoot=ge.colgroup=ge.caption=ge.thead,ge.th=ge.td,y.option||(ge.optgroup=ge.option=[1,"<select multiple='multiple'>","</select>"]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===w(o))S.merge(p,o.nodeType?[o]:o);else if(me.test(o)){a=a||f.appendChild(t.createElement("div")),s=(de.exec(o)||["",""])[1].toLowerCase(),u=ge[s]||ge._default,a.innerHTML=u[1]+S.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;S.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<S.inArray(o,r))i&&i.push(o);else if(l=ie(o),a=ve(f.appendChild(o),"script"),l&&ye(a),n){c=0;while(o=a[c++])he.test(o.type||"")&&n.push(o)}return f}var be=/^key/,we=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Te=/^([^.]*)(?:\.(.+)|)/;function Ce(){return!0}function Ee(){return!1}function Se(e,t){return e===function(){try{return E.activeElement}catch(e){}}()==("focus"===t)}function ke(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)ke(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=Ee;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return S().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=S.guid++)),e.each(function(){S.event.add(this,t,i,r,n)})}function Ae(e,i,o){o?(Y.set(e,i,!1),S.event.add(e,i,{namespace:!1,handler:function(e){var t,n,r=Y.get(this,i);if(1&e.isTrigger&&this[i]){if(r.length)(S.event.special[i]||{}).delegateType&&e.stopPropagation();else if(r=s.call(arguments),Y.set(this,i,r),t=o(this,i),this[i](),r!==(n=Y.get(this,i))||t?Y.set(this,i,!1):n={},r!==n)return e.stopImmediatePropagation(),e.preventDefault(),n.value}else r.length&&(Y.set(this,i,{value:S.event.trigger(S.extend(r[0],S.Event.prototype),r.slice(1),this)}),e.stopImmediatePropagation())}})):void 0===Y.get(e,i)&&S.event.add(e,i,Ce)}S.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.get(t);if(V(t)){n.handler&&(n=(o=n).handler,i=o.selector),i&&S.find.matchesSelector(re,i),n.guid||(n.guid=S.guid++),(u=v.events)||(u=v.events=Object.create(null)),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof S&&S.event.triggered!==e.type?S.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(P)||[""]).length;while(l--)d=g=(s=Te.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=S.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=S.event.special[d]||{},c=S.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&S.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),S.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=Y.hasData(e)&&Y.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(P)||[""]).length;while(l--)if(d=g=(s=Te.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=S.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||S.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)S.event.remove(e,d+t[l],n,r,!0);S.isEmptyObject(u)&&Y.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=new Array(arguments.length),u=S.event.fix(e),l=(Y.get(this,"events")||Object.create(null))[u.type]||[],c=S.event.special[u.type]||{};for(s[0]=u,t=1;t<arguments.length;t++)s[t]=arguments[t];if(u.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,u)){a=S.event.handlers.call(this,u,l),t=0;while((i=a[t++])&&!u.isPropagationStopped()){u.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!u.isImmediatePropagationStopped())u.rnamespace&&!1!==o.namespace&&!u.rnamespace.test(o.namespace)||(u.handleObj=o,u.data=o.data,void 0!==(r=((S.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,s))&&!1===(u.result=r)&&(u.preventDefault(),u.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,u),u.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<S(i,this).index(l):S.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(S.Event.prototype,t,{enumerable:!0,configurable:!0,get:m(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[S.expando]?e:new S.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Ae(t,"click",Ce),!1},trigger:function(e){var t=this||e;return pe.test(t.type)&&t.click&&A(t,"input")&&Ae(t,"click"),!0},_default:function(e){var t=e.target;return pe.test(t.type)&&t.click&&A(t,"input")&&Y.get(t,"click")||A(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},S.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},S.Event=function(e,t){if(!(this instanceof S.Event))return new S.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?Ce:Ee,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&S.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[S.expando]=!0},S.Event.prototype={constructor:S.Event,isDefaultPrevented:Ee,isPropagationStopped:Ee,isImmediatePropagationStopped:Ee,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=Ce,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=Ce,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=Ce,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},S.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(e){var t=e.button;return null==e.which&&be.test(e.type)?null!=e.charCode?e.charCode:e.keyCode:!e.which&&void 0!==t&&we.test(e.type)?1&t?1:2&t?3:4&t?2:0:e.which}},S.event.addProp),S.each({focus:"focusin",blur:"focusout"},function(e,t){S.event.special[e]={setup:function(){return Ae(this,e,Se),!1},trigger:function(){return Ae(this,e),!0},delegateType:t}}),S.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){S.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||S.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),S.fn.extend({on:function(e,t,n,r){return ke(this,e,t,n,r)},one:function(e,t,n,r){return ke(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,S(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=Ee),this.each(function(){S.event.remove(this,e,n,t)})}});var Ne=/<script|<style|<link/i,De=/checked\s*(?:[^=]|=\s*.checked.)/i,je=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function qe(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function Le(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function He(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Oe(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n<r;n++)S.event.add(t,i,s[i][n]);Q.hasData(e)&&(o=Q.access(e),a=S.extend({},o),Q.set(t,a))}}function Pe(n,r,i,o){r=g(r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=m(d);if(h||1<f&&"string"==typeof d&&!y.checkClone&&De.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),Pe(t,r,i,o)});if(f&&(t=(e=xe(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=S.map(ve(e,"script"),Le)).length;c<f;c++)u=e,c!==p&&(u=S.clone(u,!0,!0),s&&S.merge(a,ve(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,S.map(a,He),c=0;c<s;c++)u=a[c],he.test(u.type||"")&&!Y.access(u,"globalEval")&&S.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?S._evalUrl&&!u.noModule&&S._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")},l):b(u.textContent.replace(je,""),u,l))}return n}function Re(e,t,n){for(var r,i=t?S.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||S.cleanData(ve(r)),r.parentNode&&(n&&ie(r)&&ye(ve(r,"script")),r.parentNode.removeChild(r));return e}S.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=ie(e);if(!(y.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||S.isXMLDoc(e)))for(a=ve(c),r=0,i=(o=ve(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&pe.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||ve(e),a=a||ve(c),r=0,i=o.length;r<i;r++)Oe(o[r],a[r]);else Oe(e,c);return 0<(a=ve(c,"script")).length&&ye(a,!f&&ve(e,"script")),c},cleanData:function(e){for(var t,n,r,i=S.event.special,o=0;void 0!==(n=e[o]);o++)if(V(n)){if(t=n[Y.expando]){if(t.events)for(r in t.events)i[r]?S.event.remove(n,r):S.removeEvent(n,r,t.handle);n[Y.expando]=void 0}n[Q.expando]&&(n[Q.expando]=void 0)}}}),S.fn.extend({detach:function(e){return Re(this,e,!0)},remove:function(e){return Re(this,e)},text:function(e){return $(this,function(e){return void 0===e?S.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return Pe(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||qe(this,e).appendChild(e)})},prepend:function(){return Pe(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=qe(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return Pe(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return Pe(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(S.cleanData(ve(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return S.clone(this,e,t)})},html:function(e){return $(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!Ne.test(e)&&!ge[(de.exec(e)||["",""])[1].toLowerCase()]){e=S.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(S.cleanData(ve(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return Pe(this,arguments,function(e){var t=this.parentNode;S.inArray(this,n)<0&&(S.cleanData(ve(this)),t&&t.replaceChild(e,this))},n)}}),S.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){S.fn[e]=function(e){for(var t,n=[],r=S(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),S(r[o])[a](t),u.apply(n,t.get());return this.pushStack(n)}});var Me=new RegExp("^("+ee+")(?!px)[a-z%]+$","i"),Ie=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=C),t.getComputedStyle(e)},We=function(e,t,n){var r,i,o={};for(i in t)o[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=o[i];return r},Fe=new RegExp(ne.join("|"),"i");function Be(e,t,n){var r,i,o,a,s=e.style;return(n=n||Ie(e))&&(""!==(a=n.getPropertyValue(t)||n[t])||ie(e)||(a=S.style(e,t)),!y.pixelBoxStyles()&&Me.test(a)&&Fe.test(t)&&(r=s.width,i=s.minWidth,o=s.maxWidth,s.minWidth=s.maxWidth=s.width=a,a=n.width,s.width=r,s.minWidth=i,s.maxWidth=o)),void 0!==a?a+"":a}function $e(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(l){u.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",l.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",re.appendChild(u).appendChild(l);var e=C.getComputedStyle(l);n="1%"!==e.top,s=12===t(e.marginLeft),l.style.right="60%",o=36===t(e.right),r=36===t(e.width),l.style.position="absolute",i=12===t(l.offsetWidth/3),re.removeChild(u),l=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s,u=E.createElement("div"),l=E.createElement("div");l.style&&(l.style.backgroundClip="content-box",l.cloneNode(!0).style.backgroundClip="",y.clearCloneStyle="content-box"===l.style.backgroundClip,S.extend(y,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),s},scrollboxSize:function(){return e(),i},reliableTrDimensions:function(){var e,t,n,r;return null==a&&(e=E.createElement("table"),t=E.createElement("tr"),n=E.createElement("div"),e.style.cssText="position:absolute;left:-11111px",t.style.height="1px",n.style.height="9px",re.appendChild(e).appendChild(t).appendChild(n),r=C.getComputedStyle(t),a=3<parseInt(r.height),re.removeChild(e)),a}}))}();var _e=["Webkit","Moz","ms"],ze=E.createElement("div").style,Ue={};function Xe(e){var t=S.cssProps[e]||Ue[e];return t||(e in ze?e:Ue[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=_e.length;while(n--)if((e=_e[n]+t)in ze)return e}(e)||e)}var Ve=/^(none|table(?!-c[ea]).+)/,Ge=/^--/,Ye={position:"absolute",visibility:"hidden",display:"block"},Qe={letterSpacing:"0",fontWeight:"400"};function Je(e,t,n){var r=te.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function Ke(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(u+=S.css(e,n+ne[a],!0,i)),r?("content"===n&&(u-=S.css(e,"padding"+ne[a],!0,i)),"margin"!==n&&(u-=S.css(e,"border"+ne[a]+"Width",!0,i))):(u+=S.css(e,"padding"+ne[a],!0,i),"padding"!==n?u+=S.css(e,"border"+ne[a]+"Width",!0,i):s+=S.css(e,"border"+ne[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u}function Ze(e,t,n){var r=Ie(e),i=(!y.boxSizingReliable()||n)&&"border-box"===S.css(e,"boxSizing",!1,r),o=i,a=Be(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if(Me.test(a)){if(!n)return a;a="auto"}return(!y.boxSizingReliable()&&i||!y.reliableTrDimensions()&&A(e,"tr")||"auto"===a||!parseFloat(a)&&"inline"===S.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===S.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+Ke(e,t,n||(i?"border":"content"),o,r,a)+"px"}function et(e,t,n,r,i){return new et.prototype.init(e,t,n,r,i)}S.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=Be(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=X(t),u=Ge.test(t),l=e.style;if(u||(t=Xe(s)),a=S.cssHooks[t]||S.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=te.exec(n))&&i[1]&&(n=se(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(S.cssNumber[s]?"":"px")),y.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=X(t);return Ge.test(t)||(t=Xe(s)),(a=S.cssHooks[t]||S.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=Be(e,t,r)),"normal"===i&&t in Qe&&(i=Qe[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),S.each(["height","width"],function(e,u){S.cssHooks[u]={get:function(e,t,n){if(t)return!Ve.test(S.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?Ze(e,u,n):We(e,Ye,function(){return Ze(e,u,n)})},set:function(e,t,n){var r,i=Ie(e),o=!y.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===S.css(e,"boxSizing",!1,i),s=n?Ke(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-Ke(e,u,"border",!1,i)-.5)),s&&(r=te.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=S.css(e,u)),Je(0,t,s)}}}),S.cssHooks.marginLeft=$e(y.reliableMarginLeft,function(e,t){if(t)return(parseFloat(Be(e,"marginLeft"))||e.getBoundingClientRect().left-We(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),S.each({margin:"",padding:"",border:"Width"},function(i,o){S.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+ne[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(S.cssHooks[i+o].set=Je)}),S.fn.extend({css:function(e,t){return $(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Ie(e),i=t.length;a<i;a++)o[t[a]]=S.css(e,t[a],!1,r);return o}return void 0!==n?S.style(e,t,n):S.css(e,t)},e,t,1<arguments.length)}}),((S.Tween=et).prototype={constructor:et,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||S.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(S.cssNumber[n]?"":"px")},cur:function(){var e=et.propHooks[this.prop];return e&&e.get?e.get(this):et.propHooks._default.get(this)},run:function(e){var t,n=et.propHooks[this.prop];return this.options.duration?this.pos=t=S.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):et.propHooks._default.set(this),this}}).init.prototype=et.prototype,(et.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=S.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){S.fx.step[e.prop]?S.fx.step[e.prop](e):1!==e.elem.nodeType||!S.cssHooks[e.prop]&&null==e.elem.style[Xe(e.prop)]?e.elem[e.prop]=e.now:S.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=et.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},S.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},S.fx=et.prototype.init,S.fx.step={};var tt,nt,rt,it,ot=/^(?:toggle|show|hide)$/,at=/queueHooks$/;function st(){nt&&(!1===E.hidden&&C.requestAnimationFrame?C.requestAnimationFrame(st):C.setTimeout(st,S.fx.interval),S.fx.tick())}function ut(){return C.setTimeout(function(){tt=void 0}),tt=Date.now()}function lt(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=ne[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function ct(e,t,n){for(var r,i=(ft.tweeners[t]||[]).concat(ft.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function ft(o,e,t){var n,a,r=0,i=ft.prefilters.length,s=S.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=tt||ut(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:S.extend({},e),opts:S.extend(!0,{specialEasing:{},easing:S.easing._default},t),originalProperties:e,originalOptions:t,startTime:tt||ut(),duration:t.duration,tweens:[],createTween:function(e,t){var n=S.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=X(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=S.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=ft.prefilters[r].call(l,o,c,l.opts))return m(n.stop)&&(S._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return S.map(c,ct,l),m(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),S.fx.timer(S.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}S.Animation=S.extend(ft,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return se(n.elem,e,te.exec(t),n),n}]},tweener:function(e,t){m(e)?(t=e,e=["*"]):e=e.match(P);for(var n,r=0,i=e.length;r<i;r++)n=e[r],ft.tweeners[n]=ft.tweeners[n]||[],ft.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&ae(e),v=Y.get(e,"fxshow");for(r in n.queue||(null==(a=S._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,S.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],ot.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||S.style(e,r)}if((u=!S.isEmptyObject(t))||!S.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=Y.get(e,"display")),"none"===(c=S.css(e,"display"))&&(l?c=l:(le([e],!0),l=e.style.display||l,c=S.css(e,"display"),le([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===S.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=Y.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&le([e],!0),p.done(function(){for(r in g||le([e]),Y.remove(e,"fxshow"),d)S.style(e,r,d[r])})),u=ct(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?ft.prefilters.unshift(e):ft.prefilters.push(e)}}),S.speed=function(e,t,n){var r=e&&"object"==typeof e?S.extend({},e):{complete:n||!n&&t||m(e)&&e,duration:e,easing:n&&t||t&&!m(t)&&t};return S.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in S.fx.speeds?r.duration=S.fx.speeds[r.duration]:r.duration=S.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){m(r.old)&&r.old.call(this),r.queue&&S.dequeue(this,r.queue)},r},S.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ae).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=S.isEmptyObject(t),o=S.speed(e,n,r),a=function(){var e=ft(this,S.extend({},t),o);(i||Y.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=S.timers,r=Y.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&at.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||S.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=Y.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=S.timers,o=n?n.length:0;for(t.finish=!0,S.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),S.each(["toggle","show","hide"],function(e,r){var i=S.fn[r];S.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(lt(r,!0),e,t,n)}}),S.each({slideDown:lt("show"),slideUp:lt("hide"),slideToggle:lt("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){S.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),S.timers=[],S.fx.tick=function(){var e,t=0,n=S.timers;for(tt=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||S.fx.stop(),tt=void 0},S.fx.timer=function(e){S.timers.push(e),S.fx.start()},S.fx.interval=13,S.fx.start=function(){nt||(nt=!0,st())},S.fx.stop=function(){nt=null},S.fx.speeds={slow:600,fast:200,_default:400},S.fn.delay=function(r,e){return r=S.fx&&S.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=C.setTimeout(e,r);t.stop=function(){C.clearTimeout(n)}})},rt=E.createElement("input"),it=E.createElement("select").appendChild(E.createElement("option")),rt.type="checkbox",y.checkOn=""!==rt.value,y.optSelected=it.selected,(rt=E.createElement("input")).value="t",rt.type="radio",y.radioValue="t"===rt.value;var pt,dt=S.expr.attrHandle;S.fn.extend({attr:function(e,t){return $(this,S.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){S.removeAttr(this,e)})}}),S.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?S.prop(e,t,n):(1===o&&S.isXMLDoc(e)||(i=S.attrHooks[t.toLowerCase()]||(S.expr.match.bool.test(t)?pt:void 0)),void 0!==n?null===n?void S.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=S.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!y.radioValue&&"radio"===t&&A(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(P);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),pt={set:function(e,t,n){return!1===t?S.removeAttr(e,n):e.setAttribute(n,n),n}},S.each(S.expr.match.bool.source.match(/\w+/g),function(e,t){var a=dt[t]||S.find.attr;dt[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=dt[o],dt[o]=r,r=null!=a(e,t,n)?o:null,dt[o]=i),r}});var ht=/^(?:input|select|textarea|button)$/i,gt=/^(?:a|area)$/i;function vt(e){return(e.match(P)||[]).join(" ")}function yt(e){return e.getAttribute&&e.getAttribute("class")||""}function mt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(P)||[]}S.fn.extend({prop:function(e,t){return $(this,S.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[S.propFix[e]||e]})}}),S.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&S.isXMLDoc(e)||(t=S.propFix[t]||t,i=S.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=S.find.attr(e,"tabindex");return t?parseInt(t,10):ht.test(e.nodeName)||gt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),y.optSelected||(S.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),S.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){S.propFix[this.toLowerCase()]=this}),S.fn.extend({addClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).addClass(t.call(this,e,yt(this)))});if((e=mt(t)).length)while(n=this[u++])if(i=yt(n),r=1===n.nodeType&&" "+vt(i)+" "){a=0;while(o=e[a++])r.indexOf(" "+o+" ")<0&&(r+=o+" ");i!==(s=vt(r))&&n.setAttribute("class",s)}return this},removeClass:function(t){var e,n,r,i,o,a,s,u=0;if(m(t))return this.each(function(e){S(this).removeClass(t.call(this,e,yt(this)))});if(!arguments.length)return this.attr("class","");if((e=mt(t)).length)while(n=this[u++])if(i=yt(n),r=1===n.nodeType&&" "+vt(i)+" "){a=0;while(o=e[a++])while(-1<r.indexOf(" "+o+" "))r=r.replace(" "+o+" "," ");i!==(s=vt(r))&&n.setAttribute("class",s)}return this},toggleClass:function(i,t){var o=typeof i,a="string"===o||Array.isArray(i);return"boolean"==typeof t&&a?t?this.addClass(i):this.removeClass(i):m(i)?this.each(function(e){S(this).toggleClass(i.call(this,e,yt(this),t),t)}):this.each(function(){var e,t,n,r;if(a){t=0,n=S(this),r=mt(i);while(e=r[t++])n.hasClass(e)?n.removeClass(e):n.addClass(e)}else void 0!==i&&"boolean"!==o||((e=yt(this))&&Y.set(this,"__className__",e),this.setAttribute&&this.setAttribute("class",e||!1===i?"":Y.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+vt(yt(n))+" ").indexOf(t))return!0;return!1}});var xt=/\r/g;S.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=m(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,S(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=S.map(t,function(e){return null==e?"":e+""})),(r=S.valHooks[this.type]||S.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=S.valHooks[t.type]||S.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(xt,""):null==e?"":e:void 0}}),S.extend({valHooks:{option:{get:function(e){var t=S.find.attr(e,"value");return null!=t?t:vt(S.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!A(n.parentNode,"optgroup"))){if(t=S(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=S.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<S.inArray(S.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),S.each(["radio","checkbox"],function(){S.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<S.inArray(S(e).val(),t)}},y.checkOn||(S.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})}),y.focusin="onfocusin"in C;var bt=/^(?:focusinfocus|focusoutblur)$/,wt=function(e){e.stopPropagation()};S.extend(S.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||E],d=v.call(e,"type")?e.type:e,h=v.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||E,3!==n.nodeType&&8!==n.nodeType&&!bt.test(d+S.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[S.expando]?e:new S.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:S.makeArray(t,[e]),c=S.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!x(n)){for(s=c.delegateType||d,bt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||E)&&p.push(a.defaultView||a.parentWindow||C)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(Y.get(o,"events")||Object.create(null))[e.type]&&Y.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&V(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!V(n)||u&&m(n[d])&&!x(n)&&((a=n[u])&&(n[u]=null),S.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,wt),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,wt),S.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=S.extend(new S.Event,n,{type:e,isSimulated:!0});S.event.trigger(r,null,t)}}),S.fn.extend({trigger:function(e,t){return this.each(function(){S.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return S.event.trigger(e,t,n,!0)}}),y.focusin||S.each({focus:"focusin",blur:"focusout"},function(n,r){var i=function(e){S.event.simulate(r,e.target,S.event.fix(e))};S.event.special[r]={setup:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r);t||e.addEventListener(n,i,!0),Y.access(e,r,(t||0)+1)},teardown:function(){var e=this.ownerDocument||this.document||this,t=Y.access(e,r)-1;t?Y.access(e,r,t):(e.removeEventListener(n,i,!0),Y.remove(e,r))}}});var Tt=C.location,Ct={guid:Date.now()},Et=/\?/;S.parseXML=function(e){var t;if(!e||"string"!=typeof e)return null;try{t=(new C.DOMParser).parseFromString(e,"text/xml")}catch(e){t=void 0}return t&&!t.getElementsByTagName("parsererror").length||S.error("Invalid XML: "+e),t};var St=/\[\]$/,kt=/\r?\n/g,At=/^(?:submit|button|image|reset|file)$/i,Nt=/^(?:input|select|textarea|keygen)/i;function Dt(n,e,r,i){var t;if(Array.isArray(e))S.each(e,function(e,t){r||St.test(n)?i(n,t):Dt(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==w(e))i(n,e);else for(t in e)Dt(n+"["+t+"]",e[t],r,i)}S.param=function(e,t){var n,r=[],i=function(e,t){var n=m(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!S.isPlainObject(e))S.each(e,function(){i(this.name,this.value)});else for(n in e)Dt(n,e[n],t,i);return r.join("&")},S.fn.extend({serialize:function(){return S.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=S.prop(this,"elements");return e?S.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!S(this).is(":disabled")&&Nt.test(this.nodeName)&&!At.test(e)&&(this.checked||!pe.test(e))}).map(function(e,t){var n=S(this).val();return null==n?null:Array.isArray(n)?S.map(n,function(e){return{name:t.name,value:e.replace(kt,"\r\n")}}):{name:t.name,value:n.replace(kt,"\r\n")}}).get()}});var jt=/%20/g,qt=/#.*$/,Lt=/([?&])_=[^&]*/,Ht=/^(.*?):[ \t]*([^\r\n]*)$/gm,Ot=/^(?:GET|HEAD)$/,Pt=/^\/\//,Rt={},Mt={},It="*/".concat("*"),Wt=E.createElement("a");function Ft(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(P)||[];if(m(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function Bt(t,i,o,a){var s={},u=t===Mt;function l(e){var r;return s[e]=!0,S.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function $t(e,t){var n,r,i=S.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&S.extend(!0,e,r),e}Wt.href=Tt.href,S.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Tt.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Tt.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":It,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":S.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?$t($t(e,S.ajaxSettings),t):$t(S.ajaxSettings,e)},ajaxPrefilter:Ft(Rt),ajaxTransport:Ft(Mt),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=S.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?S(y):S.event,x=S.Deferred(),b=S.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=Ht.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||Tt.href)+"").replace(Pt,Tt.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(P)||[""],null==v.crossDomain){r=E.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Wt.protocol+"//"+Wt.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=S.param(v.data,v.traditional)),Bt(Rt,v,t,T),h)return T;for(i in(g=S.event&&v.global)&&0==S.active++&&S.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Ot.test(v.type),f=v.url.replace(qt,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(jt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(Et.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(Lt,"$1"),o=(Et.test(f)?"&":"?")+"_="+Ct.guid+++o),v.url=f+o),v.ifModified&&(S.lastModified[f]&&T.setRequestHeader("If-Modified-Since",S.lastModified[f]),S.etag[f]&&T.setRequestHeader("If-None-Match",S.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+It+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=Bt(Mt,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=C.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&C.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),!i&&-1<S.inArray("script",v.dataTypes)&&(v.converters["text script"]=function(){}),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(S.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(S.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--S.active||S.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return S.get(e,t,n,"json")},getScript:function(e,t){return S.get(e,void 0,t,"script")}}),S.each(["get","post"],function(e,i){S[i]=function(e,t,n,r){return m(t)&&(r=r||n,n=t,t=void 0),S.ajax(S.extend({url:e,type:i,dataType:r,data:t,success:n},S.isPlainObject(e)&&e))}}),S.ajaxPrefilter(function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")}),S._evalUrl=function(e,t,n){return S.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){S.globalEval(e,t,n)}})},S.fn.extend({wrapAll:function(e){var t;return this[0]&&(m(e)&&(e=e.call(this[0])),t=S(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return m(n)?this.each(function(e){S(this).wrapInner(n.call(this,e))}):this.each(function(){var e=S(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=m(t);return this.each(function(e){S(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){S(this).replaceWith(this.childNodes)}),this}}),S.expr.pseudos.hidden=function(e){return!S.expr.pseudos.visible(e)},S.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},S.ajaxSettings.xhr=function(){try{return new C.XMLHttpRequest}catch(e){}};var _t={0:200,1223:204},zt=S.ajaxSettings.xhr();y.cors=!!zt&&"withCredentials"in zt,y.ajax=zt=!!zt,S.ajaxTransport(function(i){var o,a;if(y.cors||zt&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(_t[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&C.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),S.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),S.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return S.globalEval(e),e}}}),S.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),S.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=S("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var Ut,Xt=[],Vt=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Xt.pop()||S.expando+"_"+Ct.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Vt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Vt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Vt,"$1"+r):!1!==e.jsonp&&(e.url+=(Et.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Xt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((Ut=E.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===Ut.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=vt(e.slice(s)),e=e.slice(0,s)),m(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&S.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?S("<div>").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):("number"==typeof f.top&&(f.top+="px"),"number"==typeof f.left&&(f.left+="px"),c.css(f))}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=$e(y.pixelPosition,function(e,t){if(t)return t=Be(e,n),Me.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}});var Gt=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;S.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),m(e))return r=s.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(s.call(arguments)))}).guid=e.guid=e.guid||S.guid++,i},S.holdReady=function(e){e?S.readyWait++:S.ready(!0)},S.isArray=Array.isArray,S.parseJSON=JSON.parse,S.nodeName=A,S.isFunction=m,S.isWindow=x,S.camelCase=X,S.type=w,S.now=Date.now,S.isNumeric=function(e){var t=S.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},S.trim=function(e){return null==e?"":(e+"").replace(Gt,"")},"function"==typeof define&&define.amd&&define("jquery",[],function(){return S});var Yt=C.jQuery,Qt=C.$;return S.noConflict=function(e){return C.$===S&&(C.$=Qt),e&&C.jQuery===S&&(C.jQuery=Yt),S},"undefined"==typeof e&&(C.jQuery=C.$=S),S});
diff --git a/installer/resources/core/RTGOperationsManual/_static/language_data.js b/installer/resources/core/RTGOperationsManual/_static/language_data.js
index 5266fb19e..d2b4ee91b 100644
--- a/installer/resources/core/RTGOperationsManual/_static/language_data.js
+++ b/installer/resources/core/RTGOperationsManual/_static/language_data.js
@@ -5,7 +5,7 @@
  * This script contains the language-specific data used by searchtools.js,
  * namely the list of stopwords, stemmer, scorer and splitter.
  *
- * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS.
+ * :copyright: Copyright 2007-2020 by the Sphinx team, see AUTHORS.
  * :license: BSD, see LICENSE for details.
  *
  */
diff --git a/installer/resources/core/RTGOperationsManual/_static/searchtools.js b/installer/resources/core/RTGOperationsManual/_static/searchtools.js
index 5ff318066..ab5649965 100644
--- a/installer/resources/core/RTGOperationsManual/_static/searchtools.js
+++ b/installer/resources/core/RTGOperationsManual/_static/searchtools.js
@@ -4,7 +4,7 @@
  *
  * Sphinx JavaScript utilities for the full-text search.
  *
- * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS.
+ * :copyright: Copyright 2007-2020 by the Sphinx team, see AUTHORS.
  * :license: BSD, see LICENSE for details.
  *
  */
@@ -36,8 +36,10 @@ if (!Scorer) {
 
     // query found in title
     title: 15,
+    partialTitle: 7,
     // query found in terms
-    term: 5
+    term: 5,
+    partialTerm: 2
   };
 }
 
@@ -56,6 +58,19 @@ var Search = {
   _queued_query : null,
   _pulse_status : -1,
 
+  htmlToText : function(htmlString) {
+      var htmlElement = document.createElement('span');
+      htmlElement.innerHTML = htmlString;
+      $(htmlElement).find('.headerlink').remove();
+      docContent = $(htmlElement).find('[role=main]')[0];
+      if(docContent === undefined) {
+          console.warn("Content block not found. Sphinx search tries to obtain it " +
+                       "via '[role=main]'. Could you check your theme or template.");
+          return "";
+      }
+      return docContent.textContent || docContent.innerText;
+  },
+
   init : function() {
       var params = $.getQueryParameters();
       if (params.q) {
@@ -120,7 +135,7 @@ var Search = {
     this.out = $('#search-results');
     this.title = $('<h2>' + _('Searching') + '</h2>').appendTo(this.out);
     this.dots = $('<span></span>').appendTo(this.title);
-    this.status = $('<p style="display: none"></p>').appendTo(this.out);
+    this.status = $('<p class="search-summary">&nbsp;</p>').appendTo(this.out);
     this.output = $('<ul class="search"/>').appendTo(this.out);
 
     $('#search-progress').text(_('Preparing search...'));
@@ -235,7 +250,9 @@ var Search = {
       if (results.length) {
         var item = results.pop();
         var listItem = $('<li style="display:none"></li>');
-        if (DOCUMENTATION_OPTIONS.FILE_SUFFIX === '') {
+        var requestUrl = "";
+        var linkUrl = "";
+        if (DOCUMENTATION_OPTIONS.BUILDER === 'dirhtml') {
           // dirhtml builder
           var dirname = item[0] + '/';
           if (dirname.match(/\/index\/$/)) {
@@ -243,15 +260,17 @@ var Search = {
           } else if (dirname == 'index/') {
             dirname = '';
           }
-          listItem.append($('<a/>').attr('href',
-            DOCUMENTATION_OPTIONS.URL_ROOT + dirname +
-            highlightstring + item[2]).html(item[1]));
+          requestUrl = DOCUMENTATION_OPTIONS.URL_ROOT + dirname;
+          linkUrl = requestUrl;
+
         } else {
           // normal html builders
-          listItem.append($('<a/>').attr('href',
-            item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX +
-            highlightstring + item[2]).html(item[1]));
+          requestUrl = DOCUMENTATION_OPTIONS.URL_ROOT + item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX;
+          linkUrl = item[0] + DOCUMENTATION_OPTIONS.LINK_SUFFIX;
         }
+        listItem.append($('<a/>').attr('href',
+            linkUrl +
+            highlightstring + item[2]).html(item[1]));
         if (item[3]) {
           listItem.append($('<span> (' + item[3] + ')</span>'));
           Search.output.append(listItem);
@@ -259,11 +278,7 @@ var Search = {
             displayNextItem();
           });
         } else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) {
-          var suffix = DOCUMENTATION_OPTIONS.SOURCELINK_SUFFIX;
-          if (suffix === undefined) {
-            suffix = '.txt';
-          }
-          $.ajax({url: DOCUMENTATION_OPTIONS.URL_ROOT + '_sources/' + item[5] + (item[5].slice(-suffix.length) === suffix ? '' : suffix),
+          $.ajax({url: requestUrl,
                   dataType: "text",
                   complete: function(jqxhr, textstatus) {
                     var data = jqxhr.responseText;
@@ -313,12 +328,13 @@ var Search = {
     for (var prefix in objects) {
       for (var name in objects[prefix]) {
         var fullname = (prefix ? prefix + '.' : '') + name;
-        if (fullname.toLowerCase().indexOf(object) > -1) {
+        var fullnameLower = fullname.toLowerCase()
+        if (fullnameLower.indexOf(object) > -1) {
           var score = 0;
-          var parts = fullname.split('.');
+          var parts = fullnameLower.split('.');
           // check for different match types: exact matches of full name or
           // "last name" (i.e. last dotted part)
-          if (fullname == object || parts[parts.length - 1] == object) {
+          if (fullnameLower == object || parts[parts.length - 1] == object) {
             score += Scorer.objNameMatch;
           // matches in last name
           } else if (parts[parts.length - 1].indexOf(object) > -1) {
@@ -385,6 +401,19 @@ var Search = {
         {files: terms[word], score: Scorer.term},
         {files: titleterms[word], score: Scorer.title}
       ];
+      // add support for partial matches
+      if (word.length > 2) {
+        for (var w in terms) {
+          if (w.match(word) && !terms[word]) {
+            _o.push({files: terms[w], score: Scorer.partialTerm})
+          }
+        }
+        for (var w in titleterms) {
+          if (w.match(word) && !titleterms[word]) {
+              _o.push({files: titleterms[w], score: Scorer.partialTitle})
+          }
+        }
+      }
 
       // no match but word was a required one
       if ($u.every(_o, function(o){return o.files === undefined;})) {
@@ -404,7 +433,7 @@ var Search = {
         for (j = 0; j < _files.length; j++) {
           file = _files[j];
           if (!(file in scoreMap))
-            scoreMap[file] = {}
+            scoreMap[file] = {};
           scoreMap[file][word] = o.score;
         }
       });
@@ -412,7 +441,7 @@ var Search = {
       // create the mapping
       for (j = 0; j < files.length; j++) {
         file = files[j];
-        if (file in fileMap)
+        if (file in fileMap && fileMap[file].indexOf(word) === -1)
           fileMap[file].push(word);
         else
           fileMap[file] = [word];
@@ -424,8 +453,12 @@ var Search = {
       var valid = true;
 
       // check if all requirements are matched
-      if (fileMap[file].length != searchterms.length)
-          continue;
+      var filteredTermCount = // as search terms with length < 3 are discarded: ignore
+        searchterms.filter(function(term){return term.length > 2}).length
+      if (
+        fileMap[file].length != searchterms.length &&
+        fileMap[file].length != filteredTermCount
+      ) continue;
 
       // ensure that none of the excluded terms is in the search result
       for (i = 0; i < excluded.length; i++) {
@@ -456,7 +489,8 @@ var Search = {
    * words. the first one is used to find the occurrence, the
    * latter for highlighting it.
    */
-  makeSearchSummary : function(text, keywords, hlwords) {
+  makeSearchSummary : function(htmlText, keywords, hlwords) {
+    var text = Search.htmlToText(htmlText);
     var textLower = text.toLowerCase();
     var start = 0;
     $.each(keywords, function() {
diff --git a/installer/resources/core/RTGOperationsManual/_static/up-pressed.png b/installer/resources/core/RTGOperationsManual/_static/up-pressed.png
deleted file mode 100644
index acee3b68e..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_static/up-pressed.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_static/up.png b/installer/resources/core/RTGOperationsManual/_static/up.png
deleted file mode 100644
index 2a940a7da..000000000
Binary files a/installer/resources/core/RTGOperationsManual/_static/up.png and /dev/null differ
diff --git a/installer/resources/core/RTGOperationsManual/_static/websupport.js b/installer/resources/core/RTGOperationsManual/_static/websupport.js
deleted file mode 100644
index 3b4999ebf..000000000
--- a/installer/resources/core/RTGOperationsManual/_static/websupport.js
+++ /dev/null
@@ -1,808 +0,0 @@
-/*
- * websupport.js
- * ~~~~~~~~~~~~~
- *
- * sphinx.websupport utilities for all documentation.
- *
- * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-(function($) {
-  $.fn.autogrow = function() {
-    return this.each(function() {
-    var textarea = this;
-
-    $.fn.autogrow.resize(textarea);
-
-    $(textarea)
-      .focus(function() {
-        textarea.interval = setInterval(function() {
-          $.fn.autogrow.resize(textarea);
-        }, 500);
-      })
-      .blur(function() {
-        clearInterval(textarea.interval);
-      });
-    });
-  };
-
-  $.fn.autogrow.resize = function(textarea) {
-    var lineHeight = parseInt($(textarea).css('line-height'), 10);
-    var lines = textarea.value.split('\n');
-    var columns = textarea.cols;
-    var lineCount = 0;
-    $.each(lines, function() {
-      lineCount += Math.ceil(this.length / columns) || 1;
-    });
-    var height = lineHeight * (lineCount + 1);
-    $(textarea).css('height', height);
-  };
-})(jQuery);
-
-(function($) {
-  var comp, by;
-
-  function init() {
-    initEvents();
-    initComparator();
-  }
-
-  function initEvents() {
-    $(document).on("click", 'a.comment-close', function(event) {
-      event.preventDefault();
-      hide($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.vote', function(event) {
-      event.preventDefault();
-      handleVote($(this));
-    });
-    $(document).on("click", 'a.reply', function(event) {
-      event.preventDefault();
-      openReply($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.close-reply', function(event) {
-      event.preventDefault();
-      closeReply($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.sort-option', function(event) {
-      event.preventDefault();
-      handleReSort($(this));
-    });
-    $(document).on("click", 'a.show-proposal', function(event) {
-      event.preventDefault();
-      showProposal($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.hide-proposal', function(event) {
-      event.preventDefault();
-      hideProposal($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.show-propose-change', function(event) {
-      event.preventDefault();
-      showProposeChange($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.hide-propose-change', function(event) {
-      event.preventDefault();
-      hideProposeChange($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.accept-comment', function(event) {
-      event.preventDefault();
-      acceptComment($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.delete-comment', function(event) {
-      event.preventDefault();
-      deleteComment($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.comment-markup', function(event) {
-      event.preventDefault();
-      toggleCommentMarkupBox($(this).attr('id').substring(2));
-    });
-  }
-
-  /**
-   * Set comp, which is a comparator function used for sorting and
-   * inserting comments into the list.
-   */
-  function setComparator() {
-    // If the first three letters are "asc", sort in ascending order
-    // and remove the prefix.
-    if (by.substring(0,3) == 'asc') {
-      var i = by.substring(3);
-      comp = function(a, b) { return a[i] - b[i]; };
-    } else {
-      // Otherwise sort in descending order.
-      comp = function(a, b) { return b[by] - a[by]; };
-    }
-
-    // Reset link styles and format the selected sort option.
-    $('a.sel').attr('href', '#').removeClass('sel');
-    $('a.by' + by).removeAttr('href').addClass('sel');
-  }
-
-  /**
-   * Create a comp function. If the user has preferences stored in
-   * the sortBy cookie, use those, otherwise use the default.
-   */
-  function initComparator() {
-    by = 'rating'; // Default to sort by rating.
-    // If the sortBy cookie is set, use that instead.
-    if (document.cookie.length > 0) {
-      var start = document.cookie.indexOf('sortBy=');
-      if (start != -1) {
-        start = start + 7;
-        var end = document.cookie.indexOf(";", start);
-        if (end == -1) {
-          end = document.cookie.length;
-          by = unescape(document.cookie.substring(start, end));
-        }
-      }
-    }
-    setComparator();
-  }
-
-  /**
-   * Show a comment div.
-   */
-  function show(id) {
-    $('#ao' + id).hide();
-    $('#ah' + id).show();
-    var context = $.extend({id: id}, opts);
-    var popup = $(renderTemplate(popupTemplate, context)).hide();
-    popup.find('textarea[name="proposal"]').hide();
-    popup.find('a.by' + by).addClass('sel');
-    var form = popup.find('#cf' + id);
-    form.submit(function(event) {
-      event.preventDefault();
-      addComment(form);
-    });
-    $('#s' + id).after(popup);
-    popup.slideDown('fast', function() {
-      getComments(id);
-    });
-  }
-
-  /**
-   * Hide a comment div.
-   */
-  function hide(id) {
-    $('#ah' + id).hide();
-    $('#ao' + id).show();
-    var div = $('#sc' + id);
-    div.slideUp('fast', function() {
-      div.remove();
-    });
-  }
-
-  /**
-   * Perform an ajax request to get comments for a node
-   * and insert the comments into the comments tree.
-   */
-  function getComments(id) {
-    $.ajax({
-     type: 'GET',
-     url: opts.getCommentsURL,
-     data: {node: id},
-     success: function(data, textStatus, request) {
-       var ul = $('#cl' + id);
-       var speed = 100;
-       $('#cf' + id)
-         .find('textarea[name="proposal"]')
-         .data('source', data.source);
-
-       if (data.comments.length === 0) {
-         ul.html('<li>No comments yet.</li>');
-         ul.data('empty', true);
-       } else {
-         // If there are comments, sort them and put them in the list.
-         var comments = sortComments(data.comments);
-         speed = data.comments.length * 100;
-         appendComments(comments, ul);
-         ul.data('empty', false);
-       }
-       $('#cn' + id).slideUp(speed + 200);
-       ul.slideDown(speed);
-     },
-     error: function(request, textStatus, error) {
-       showError('Oops, there was a problem retrieving the comments.');
-     },
-     dataType: 'json'
-    });
-  }
-
-  /**
-   * Add a comment via ajax and insert the comment into the comment tree.
-   */
-  function addComment(form) {
-    var node_id = form.find('input[name="node"]').val();
-    var parent_id = form.find('input[name="parent"]').val();
-    var text = form.find('textarea[name="comment"]').val();
-    var proposal = form.find('textarea[name="proposal"]').val();
-
-    if (text == '') {
-      showError('Please enter a comment.');
-      return;
-    }
-
-    // Disable the form that is being submitted.
-    form.find('textarea,input').attr('disabled', 'disabled');
-
-    // Send the comment to the server.
-    $.ajax({
-      type: "POST",
-      url: opts.addCommentURL,
-      dataType: 'json',
-      data: {
-        node: node_id,
-        parent: parent_id,
-        text: text,
-        proposal: proposal
-      },
-      success: function(data, textStatus, error) {
-        // Reset the form.
-        if (node_id) {
-          hideProposeChange(node_id);
-        }
-        form.find('textarea')
-          .val('')
-          .add(form.find('input'))
-          .removeAttr('disabled');
-	var ul = $('#cl' + (node_id || parent_id));
-        if (ul.data('empty')) {
-          $(ul).empty();
-          ul.data('empty', false);
-        }
-        insertComment(data.comment);
-        var ao = $('#ao' + node_id);
-        ao.find('img').attr({'src': opts.commentBrightImage});
-        if (node_id) {
-          // if this was a "root" comment, remove the commenting box
-          // (the user can get it back by reopening the comment popup)
-          $('#ca' + node_id).slideUp();
-        }
-      },
-      error: function(request, textStatus, error) {
-        form.find('textarea,input').removeAttr('disabled');
-        showError('Oops, there was a problem adding the comment.');
-      }
-    });
-  }
-
-  /**
-   * Recursively append comments to the main comment list and children
-   * lists, creating the comment tree.
-   */
-  function appendComments(comments, ul) {
-    $.each(comments, function() {
-      var div = createCommentDiv(this);
-      ul.append($(document.createElement('li')).html(div));
-      appendComments(this.children, div.find('ul.comment-children'));
-      // To avoid stagnating data, don't store the comments children in data.
-      this.children = null;
-      div.data('comment', this);
-    });
-  }
-
-  /**
-   * After adding a new comment, it must be inserted in the correct
-   * location in the comment tree.
-   */
-  function insertComment(comment) {
-    var div = createCommentDiv(comment);
-
-    // To avoid stagnating data, don't store the comments children in data.
-    comment.children = null;
-    div.data('comment', comment);
-
-    var ul = $('#cl' + (comment.node || comment.parent));
-    var siblings = getChildren(ul);
-
-    var li = $(document.createElement('li'));
-    li.hide();
-
-    // Determine where in the parents children list to insert this comment.
-    for(var i=0; i < siblings.length; i++) {
-      if (comp(comment, siblings[i]) <= 0) {
-        $('#cd' + siblings[i].id)
-          .parent()
-          .before(li.html(div));
-        li.slideDown('fast');
-        return;
-      }
-    }
-
-    // If we get here, this comment rates lower than all the others,
-    // or it is the only comment in the list.
-    ul.append(li.html(div));
-    li.slideDown('fast');
-  }
-
-  function acceptComment(id) {
-    $.ajax({
-      type: 'POST',
-      url: opts.acceptCommentURL,
-      data: {id: id},
-      success: function(data, textStatus, request) {
-        $('#cm' + id).fadeOut('fast');
-        $('#cd' + id).removeClass('moderate');
-      },
-      error: function(request, textStatus, error) {
-        showError('Oops, there was a problem accepting the comment.');
-      }
-    });
-  }
-
-  function deleteComment(id) {
-    $.ajax({
-      type: 'POST',
-      url: opts.deleteCommentURL,
-      data: {id: id},
-      success: function(data, textStatus, request) {
-        var div = $('#cd' + id);
-        if (data == 'delete') {
-          // Moderator mode: remove the comment and all children immediately
-          div.slideUp('fast', function() {
-            div.remove();
-          });
-          return;
-        }
-        // User mode: only mark the comment as deleted
-        div
-          .find('span.user-id:first')
-          .text('[deleted]').end()
-          .find('div.comment-text:first')
-          .text('[deleted]').end()
-          .find('#cm' + id + ', #dc' + id + ', #ac' + id + ', #rc' + id +
-                ', #sp' + id + ', #hp' + id + ', #cr' + id + ', #rl' + id)
-          .remove();
-        var comment = div.data('comment');
-        comment.username = '[deleted]';
-        comment.text = '[deleted]';
-        div.data('comment', comment);
-      },
-      error: function(request, textStatus, error) {
-        showError('Oops, there was a problem deleting the comment.');
-      }
-    });
-  }
-
-  function showProposal(id) {
-    $('#sp' + id).hide();
-    $('#hp' + id).show();
-    $('#pr' + id).slideDown('fast');
-  }
-
-  function hideProposal(id) {
-    $('#hp' + id).hide();
-    $('#sp' + id).show();
-    $('#pr' + id).slideUp('fast');
-  }
-
-  function showProposeChange(id) {
-    $('#pc' + id).hide();
-    $('#hc' + id).show();
-    var textarea = $('#pt' + id);
-    textarea.val(textarea.data('source'));
-    $.fn.autogrow.resize(textarea[0]);
-    textarea.slideDown('fast');
-  }
-
-  function hideProposeChange(id) {
-    $('#hc' + id).hide();
-    $('#pc' + id).show();
-    var textarea = $('#pt' + id);
-    textarea.val('').removeAttr('disabled');
-    textarea.slideUp('fast');
-  }
-
-  function toggleCommentMarkupBox(id) {
-    $('#mb' + id).toggle();
-  }
-
-  /** Handle when the user clicks on a sort by link. */
-  function handleReSort(link) {
-    var classes = link.attr('class').split(/\s+/);
-    for (var i=0; i<classes.length; i++) {
-      if (classes[i] != 'sort-option') {
-	by = classes[i].substring(2);
-      }
-    }
-    setComparator();
-    // Save/update the sortBy cookie.
-    var expiration = new Date();
-    expiration.setDate(expiration.getDate() + 365);
-    document.cookie= 'sortBy=' + escape(by) +
-                     ';expires=' + expiration.toUTCString();
-    $('ul.comment-ul').each(function(index, ul) {
-      var comments = getChildren($(ul), true);
-      comments = sortComments(comments);
-      appendComments(comments, $(ul).empty());
-    });
-  }
-
-  /**
-   * Function to process a vote when a user clicks an arrow.
-   */
-  function handleVote(link) {
-    if (!opts.voting) {
-      showError("You'll need to login to vote.");
-      return;
-    }
-
-    var id = link.attr('id');
-    if (!id) {
-      // Didn't click on one of the voting arrows.
-      return;
-    }
-    // If it is an unvote, the new vote value is 0,
-    // Otherwise it's 1 for an upvote, or -1 for a downvote.
-    var value = 0;
-    if (id.charAt(1) != 'u') {
-      value = id.charAt(0) == 'u' ? 1 : -1;
-    }
-    // The data to be sent to the server.
-    var d = {
-      comment_id: id.substring(2),
-      value: value
-    };
-
-    // Swap the vote and unvote links.
-    link.hide();
-    $('#' + id.charAt(0) + (id.charAt(1) == 'u' ? 'v' : 'u') + d.comment_id)
-      .show();
-
-    // The div the comment is displayed in.
-    var div = $('div#cd' + d.comment_id);
-    var data = div.data('comment');
-
-    // If this is not an unvote, and the other vote arrow has
-    // already been pressed, unpress it.
-    if ((d.value !== 0) && (data.vote === d.value * -1)) {
-      $('#' + (d.value == 1 ? 'd' : 'u') + 'u' + d.comment_id).hide();
-      $('#' + (d.value == 1 ? 'd' : 'u') + 'v' + d.comment_id).show();
-    }
-
-    // Update the comments rating in the local data.
-    data.rating += (data.vote === 0) ? d.value : (d.value - data.vote);
-    data.vote = d.value;
-    div.data('comment', data);
-
-    // Change the rating text.
-    div.find('.rating:first')
-      .text(data.rating + ' point' + (data.rating == 1 ? '' : 's'));
-
-    // Send the vote information to the server.
-    $.ajax({
-      type: "POST",
-      url: opts.processVoteURL,
-      data: d,
-      error: function(request, textStatus, error) {
-        showError('Oops, there was a problem casting that vote.');
-      }
-    });
-  }
-
-  /**
-   * Open a reply form used to reply to an existing comment.
-   */
-  function openReply(id) {
-    // Swap out the reply link for the hide link
-    $('#rl' + id).hide();
-    $('#cr' + id).show();
-
-    // Add the reply li to the children ul.
-    var div = $(renderTemplate(replyTemplate, {id: id})).hide();
-    $('#cl' + id)
-      .prepend(div)
-      // Setup the submit handler for the reply form.
-      .find('#rf' + id)
-      .submit(function(event) {
-        event.preventDefault();
-        addComment($('#rf' + id));
-        closeReply(id);
-      })
-      .find('input[type=button]')
-      .click(function() {
-        closeReply(id);
-      });
-    div.slideDown('fast', function() {
-      $('#rf' + id).find('textarea').focus();
-    });
-  }
-
-  /**
-   * Close the reply form opened with openReply.
-   */
-  function closeReply(id) {
-    // Remove the reply div from the DOM.
-    $('#rd' + id).slideUp('fast', function() {
-      $(this).remove();
-    });
-
-    // Swap out the hide link for the reply link
-    $('#cr' + id).hide();
-    $('#rl' + id).show();
-  }
-
-  /**
-   * Recursively sort a tree of comments using the comp comparator.
-   */
-  function sortComments(comments) {
-    comments.sort(comp);
-    $.each(comments, function() {
-      this.children = sortComments(this.children);
-    });
-    return comments;
-  }
-
-  /**
-   * Get the children comments from a ul. If recursive is true,
-   * recursively include childrens' children.
-   */
-  function getChildren(ul, recursive) {
-    var children = [];
-    ul.children().children("[id^='cd']")
-      .each(function() {
-        var comment = $(this).data('comment');
-        if (recursive)
-          comment.children = getChildren($(this).find('#cl' + comment.id), true);
-        children.push(comment);
-      });
-    return children;
-  }
-
-  /** Create a div to display a comment in. */
-  function createCommentDiv(comment) {
-    if (!comment.displayed && !opts.moderator) {
-      return $('<div class="moderate">Thank you!  Your comment will show up '
-               + 'once it is has been approved by a moderator.</div>');
-    }
-    // Prettify the comment rating.
-    comment.pretty_rating = comment.rating + ' point' +
-      (comment.rating == 1 ? '' : 's');
-    // Make a class (for displaying not yet moderated comments differently)
-    comment.css_class = comment.displayed ? '' : ' moderate';
-    // Create a div for this comment.
-    var context = $.extend({}, opts, comment);
-    var div = $(renderTemplate(commentTemplate, context));
-
-    // If the user has voted on this comment, highlight the correct arrow.
-    if (comment.vote) {
-      var direction = (comment.vote == 1) ? 'u' : 'd';
-      div.find('#' + direction + 'v' + comment.id).hide();
-      div.find('#' + direction + 'u' + comment.id).show();
-    }
-
-    if (opts.moderator || comment.text != '[deleted]') {
-      div.find('a.reply').show();
-      if (comment.proposal_diff)
-        div.find('#sp' + comment.id).show();
-      if (opts.moderator && !comment.displayed)
-        div.find('#cm' + comment.id).show();
-      if (opts.moderator || (opts.username == comment.username))
-        div.find('#dc' + comment.id).show();
-    }
-    return div;
-  }
-
-  /**
-   * A simple template renderer. Placeholders such as <%id%> are replaced
-   * by context['id'] with items being escaped. Placeholders such as <#id#>
-   * are not escaped.
-   */
-  function renderTemplate(template, context) {
-    var esc = $(document.createElement('div'));
-
-    function handle(ph, escape) {
-      var cur = context;
-      $.each(ph.split('.'), function() {
-        cur = cur[this];
-      });
-      return escape ? esc.text(cur || "").html() : cur;
-    }
-
-    return template.replace(/<([%#])([\w\.]*)\1>/g, function() {
-      return handle(arguments[2], arguments[1] == '%' ? true : false);
-    });
-  }
-
-  /** Flash an error message briefly. */
-  function showError(message) {
-    $(document.createElement('div')).attr({'class': 'popup-error'})
-      .append($(document.createElement('div'))
-               .attr({'class': 'error-message'}).text(message))
-      .appendTo('body')
-      .fadeIn("slow")
-      .delay(2000)
-      .fadeOut("slow");
-  }
-
-  /** Add a link the user uses to open the comments popup. */
-  $.fn.comment = function() {
-    return this.each(function() {
-      var id = $(this).attr('id').substring(1);
-      var count = COMMENT_METADATA[id];
-      var title = count + ' comment' + (count == 1 ? '' : 's');
-      var image = count > 0 ? opts.commentBrightImage : opts.commentImage;
-      var addcls = count == 0 ? ' nocomment' : '';
-      $(this)
-        .append(
-          $(document.createElement('a')).attr({
-            href: '#',
-            'class': 'sphinx-comment-open' + addcls,
-            id: 'ao' + id
-          })
-            .append($(document.createElement('img')).attr({
-              src: image,
-              alt: 'comment',
-              title: title
-            }))
-            .click(function(event) {
-              event.preventDefault();
-              show($(this).attr('id').substring(2));
-            })
-        )
-        .append(
-          $(document.createElement('a')).attr({
-            href: '#',
-            'class': 'sphinx-comment-close hidden',
-            id: 'ah' + id
-          })
-            .append($(document.createElement('img')).attr({
-              src: opts.closeCommentImage,
-              alt: 'close',
-              title: 'close'
-            }))
-            .click(function(event) {
-              event.preventDefault();
-              hide($(this).attr('id').substring(2));
-            })
-        );
-    });
-  };
-
-  var opts = {
-    processVoteURL: '/_process_vote',
-    addCommentURL: '/_add_comment',
-    getCommentsURL: '/_get_comments',
-    acceptCommentURL: '/_accept_comment',
-    deleteCommentURL: '/_delete_comment',
-    commentImage: '/static/_static/comment.png',
-    closeCommentImage: '/static/_static/comment-close.png',
-    loadingImage: '/static/_static/ajax-loader.gif',
-    commentBrightImage: '/static/_static/comment-bright.png',
-    upArrow: '/static/_static/up.png',
-    downArrow: '/static/_static/down.png',
-    upArrowPressed: '/static/_static/up-pressed.png',
-    downArrowPressed: '/static/_static/down-pressed.png',
-    voting: false,
-    moderator: false
-  };
-
-  if (typeof COMMENT_OPTIONS != "undefined") {
-    opts = jQuery.extend(opts, COMMENT_OPTIONS);
-  }
-
-  var popupTemplate = '\
-    <div class="sphinx-comments" id="sc<%id%>">\
-      <p class="sort-options">\
-        Sort by:\
-        <a href="#" class="sort-option byrating">best rated</a>\
-        <a href="#" class="sort-option byascage">newest</a>\
-        <a href="#" class="sort-option byage">oldest</a>\
-      </p>\
-      <div class="comment-header">Comments</div>\
-      <div class="comment-loading" id="cn<%id%>">\
-        loading comments... <img src="<%loadingImage%>" alt="" /></div>\
-      <ul id="cl<%id%>" class="comment-ul"></ul>\
-      <div id="ca<%id%>">\
-      <p class="add-a-comment">Add a comment\
-        (<a href="#" class="comment-markup" id="ab<%id%>">markup</a>):</p>\
-      <div class="comment-markup-box" id="mb<%id%>">\
-        reStructured text markup: <i>*emph*</i>, <b>**strong**</b>, \
-        <code>``code``</code>, \
-        code blocks: <code>::</code> and an indented block after blank line</div>\
-      <form method="post" id="cf<%id%>" class="comment-form" action="">\
-        <textarea name="comment" cols="80"></textarea>\
-        <p class="propose-button">\
-          <a href="#" id="pc<%id%>" class="show-propose-change">\
-            Propose a change &#9657;\
-          </a>\
-          <a href="#" id="hc<%id%>" class="hide-propose-change">\
-            Propose a change &#9663;\
-          </a>\
-        </p>\
-        <textarea name="proposal" id="pt<%id%>" cols="80"\
-                  spellcheck="false"></textarea>\
-        <input type="submit" value="Add comment" />\
-        <input type="hidden" name="node" value="<%id%>" />\
-        <input type="hidden" name="parent" value="" />\
-      </form>\
-      </div>\
-    </div>';
-
-  var commentTemplate = '\
-    <div id="cd<%id%>" class="sphinx-comment<%css_class%>">\
-      <div class="vote">\
-        <div class="arrow">\
-          <a href="#" id="uv<%id%>" class="vote" title="vote up">\
-            <img src="<%upArrow%>" />\
-          </a>\
-          <a href="#" id="uu<%id%>" class="un vote" title="vote up">\
-            <img src="<%upArrowPressed%>" />\
-          </a>\
-        </div>\
-        <div class="arrow">\
-          <a href="#" id="dv<%id%>" class="vote" title="vote down">\
-            <img src="<%downArrow%>" id="da<%id%>" />\
-          </a>\
-          <a href="#" id="du<%id%>" class="un vote" title="vote down">\
-            <img src="<%downArrowPressed%>" />\
-          </a>\
-        </div>\
-      </div>\
-      <div class="comment-content">\
-        <p class="tagline comment">\
-          <span class="user-id"><%username%></span>\
-          <span class="rating"><%pretty_rating%></span>\
-          <span class="delta"><%time.delta%></span>\
-        </p>\
-        <div class="comment-text comment"><#text#></div>\
-        <p class="comment-opts comment">\
-          <a href="#" class="reply hidden" id="rl<%id%>">reply &#9657;</a>\
-          <a href="#" class="close-reply" id="cr<%id%>">reply &#9663;</a>\
-          <a href="#" id="sp<%id%>" class="show-proposal">proposal &#9657;</a>\
-          <a href="#" id="hp<%id%>" class="hide-proposal">proposal &#9663;</a>\
-          <a href="#" id="dc<%id%>" class="delete-comment hidden">delete</a>\
-          <span id="cm<%id%>" class="moderation hidden">\
-            <a href="#" id="ac<%id%>" class="accept-comment">accept</a>\
-          </span>\
-        </p>\
-        <pre class="proposal" id="pr<%id%>">\
-<#proposal_diff#>\
-        </pre>\
-          <ul class="comment-children" id="cl<%id%>"></ul>\
-        </div>\
-        <div class="clearleft"></div>\
-      </div>\
-    </div>';
-
-  var replyTemplate = '\
-    <li>\
-      <div class="reply-div" id="rd<%id%>">\
-        <form id="rf<%id%>">\
-          <textarea name="comment" cols="80"></textarea>\
-          <input type="submit" value="Add reply" />\
-          <input type="button" value="Cancel" />\
-          <input type="hidden" name="parent" value="<%id%>" />\
-          <input type="hidden" name="node" value="" />\
-        </form>\
-      </div>\
-    </li>';
-
-  $(document).ready(function() {
-    init();
-  });
-})(jQuery);
-
-$(document).ready(function() {
-  // add comment anchors for all paragraphs that are commentable
-  $('.sphinx-has-comment').comment();
-
-  // highlight search words in search results
-  $("div.context").each(function() {
-    var params = $.getQueryParameters();
-    var terms = (params.q) ? params.q[0].split(/\s+/) : [];
-    var result = $(this);
-    $.each(terms, function() {
-      result.highlightText(this.toLowerCase(), 'highlighted');
-    });
-  });
-
-  // directly open comment window if requested
-  var anchor = document.location.hash;
-  if (anchor.substring(0, 9) == '#comment-') {
-    $('#ao' + anchor.substring(9)).click();
-    document.location.hash = '#s' + anchor.substring(9);
-  }
-});
diff --git a/installer/resources/core/RTGOperationsManual/administration.html b/installer/resources/core/RTGOperationsManual/administration.html
index 499caaaae..3056c30a4 100644
--- a/installer/resources/core/RTGOperationsManual/administration.html
+++ b/installer/resources/core/RTGOperationsManual/administration.html
@@ -2,27 +2,27 @@
 
 <!doctype html>
 
-<html xmlns="http://www.w3.org/1999/xhtml">
+<html>
   <head>
-    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Administration &amp; Capacity Planning &#8212; RTG Core Operations Manual v3.11</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Administration &amp; Capacity Planning &#8212; RTG Core Operations Manual v3.12</title>
     <link rel="stylesheet" href="_static/bizstyle.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     
-    <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <script type="text/javascript" src="_static/language_data.js"></script>
-    <script type="text/javascript" src="_static/bizstyle.js"></script>
+    <script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+    <script src="_static/jquery.js"></script>
+    <script src="_static/underscore.js"></script>
+    <script src="_static/doctools.js"></script>
+    <script src="_static/language_data.js"></script>
+    <script src="_static/bizstyle.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
     <link rel="next" title="Appendix" href="appendix.html" />
     <link rel="prev" title="RTG product usage - baseline progressions" href="product_usage.html" />
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
     <!--[if lt IE 9]>
-    <script type="text/javascript" src="_static/css3-mediaqueries.js"></script>
+    <script src="_static/css3-mediaqueries.js"></script>
     <![endif]-->
   </head><body>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -37,47 +37,10 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="product_usage.html" title="RTG product usage - baseline progressions"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Administration &amp; Capacity Planning</a></li> 
       </ul>
-    </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-            <p class="logo"><a href="index.html">
-              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
-            </a></p>
-  <h3><a href="index.html">Table of Contents</a></h3>
-  <ul>
-<li><a class="reference internal" href="#">Administration &amp; Capacity Planning</a><ul>
-<li><a class="reference internal" href="#advanced-installation-configuration">Advanced installation configuration</a></li>
-<li><a class="reference internal" href="#run-time-performance-optimization">Run-time performance optimization</a></li>
-<li><a class="reference internal" href="#alternate-configurations">Alternate configurations</a></li>
-<li><a class="reference internal" href="#exception-management-talkback-and-log-file">Exception management - TalkBack and log file</a></li>
-<li><a class="reference internal" href="#usage-logging">Usage logging</a><ul>
-<li><a class="reference internal" href="#single-user-single-machine">Single-user, single machine</a></li>
-<li><a class="reference internal" href="#multi-user-or-multiple-machines">Multi-user or multiple machines</a></li>
-<li><a class="reference internal" href="#advanced-usage-configuration">Advanced usage configuration</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#command-line-color-highlighting">Command-line color highlighting</a></li>
-</ul>
-</li>
-</ul>
-
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="product_usage.html"
-                        title="previous chapter">RTG product usage - baseline progressions</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="appendix.html"
-                        title="next chapter">Appendix</a></p>
-  <div role="note" aria-label="source link">
-    <h3>This Page</h3>
-    <ul class="this-page-menu">
-      <li><a href="_sources/administration.rst.txt"
-            rel="nofollow">Show Source</a></li>
-    </ul>
-   </div>
-        </div>
-      </div>
+    </div>  
 
     <div class="document">
       <div class="documentwrapper">
@@ -101,55 +64,55 @@ <h2>Advanced installation configuration<a class="headerlink" href="#advanced-ins
 appropriate to the specific deployment requirements of the organization.
 On Windows systems, these variables are set in the <code class="docutils literal notranslate"><span class="pre">rtg.bat</span></code> file in the
 installation directory. These configuration variables include:</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="11%" />
-<col width="89%" />
+<col style="width: 11%" />
+<col style="width: 89%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Variable</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Variable</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RTG_MEM</span></code></td>
-<td>Specify the maximum memory for Java run-time execution. Use a G suffix for gigabytes, e.g.: <code class="docutils literal notranslate"><span class="pre">RTG_MEM=48G</span></code>. The default memory allocation is 90% of system memory.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_MEM</span></code></p></td>
+<td><p>Specify the maximum memory for Java run-time execution. Use a G suffix for gigabytes, e.g.: <code class="docutils literal notranslate"><span class="pre">RTG_MEM=48G</span></code>. The default memory allocation is 90% of system memory.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">RTG_JAVA</span></code></td>
-<td>Specify the path to Java (default assumes current path).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_JAVA</span></code></p></td>
+<td><p>Specify the path to Java (default assumes current path).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RTG_JAR</span></code></td>
-<td>Indicate the path to the <code class="docutils literal notranslate"><span class="pre">RTG.jar</span></code> executable (default assumes current path).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_JAR</span></code></p></td>
+<td><p>Indicate the path to the <code class="docutils literal notranslate"><span class="pre">RTG.jar</span></code> executable (default assumes current path).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">RTG_JAVA_OPTS</span></code></td>
-<td>Provide any additional Java JVM options.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_JAVA_OPTS</span></code></p></td>
+<td><p>Provide any additional Java JVM options.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RTG_DEFAULT_THREADS</span></code></td>
-<td>By default any RTG module with a <code class="docutils literal notranslate"><span class="pre">--threads</span></code> parameter will automatically use the number of cores as the number of threads. This setting makes the specified number the default for the <code class="docutils literal notranslate"><span class="pre">--threads</span></code> parameter instead.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_DEFAULT_THREADS</span></code></p></td>
+<td><p>By default any RTG module with a <code class="docutils literal notranslate"><span class="pre">--threads</span></code> parameter will automatically use the number of cores as the number of threads. This setting makes the specified number the default for the <code class="docutils literal notranslate"><span class="pre">--threads</span></code> parameter instead.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">RTG_PROXY</span></code></td>
-<td>Specify the http proxy server for TalkBack exception management (default is no http proxy).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_PROXY</span></code></p></td>
+<td><p>Specify the http proxy server for TalkBack exception management (default is no http proxy).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RTG_TALKBACK</span></code></td>
-<td>Send log files for crash-severity exception conditions (default is true, set to false to disable).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_TALKBACK</span></code></p></td>
+<td><p>Send log files for crash-severity exception conditions (default is true, set to false to disable).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">RTG_USAGE</span></code></td>
-<td>If set to true, enable simple usage logging.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_USAGE</span></code></p></td>
+<td><p>If set to true, enable simple usage logging.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RTG_USAGE_DIR</span></code></td>
-<td>Destination directory when performing single-user file-based usage logging.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_USAGE_DIR</span></code></p></td>
+<td><p>Destination directory when performing single-user file-based usage logging.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">RTG_USAGE_HOST</span></code></td>
-<td>Server URL when performing server-based logging.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_USAGE_HOST</span></code></p></td>
+<td><p>Server URL when performing server-based logging.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RTG_USAGE_OPTIONAL</span></code></td>
-<td>May contain a comma-separated list of the names of optional fields to include in usage logging (when enabled). Any of <code class="docutils literal notranslate"><span class="pre">username</span></code>, <code class="docutils literal notranslate"><span class="pre">hostname</span></code> and <code class="docutils literal notranslate"><span class="pre">commandline</span></code> may be set here.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_USAGE_OPTIONAL</span></code></p></td>
+<td><p>May contain a comma-separated list of the names of optional fields to include in usage logging (when enabled). Any of <code class="docutils literal notranslate"><span class="pre">username</span></code>, <code class="docutils literal notranslate"><span class="pre">hostname</span></code> and <code class="docutils literal notranslate"><span class="pre">commandline</span></code> may be set here.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">RTG_REFERENCES_DIR</span></code></td>
-<td>Specifies an alternate directory containing metagenomic pipeline reference datasets.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_REFERENCES_DIR</span></code></p></td>
+<td><p>Specifies an alternate directory containing metagenomic pipeline reference datasets.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RTG_MODELS_DIR</span></code></td>
-<td>Specifies an alternate directory containing AVR models.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RTG_MODELS_DIR</span></code></p></td>
+<td><p>Specifies an alternate directory containing AVR models.</p></td>
 </tr>
 </tbody>
 </table>
@@ -236,13 +199,13 @@ <h2>Usage logging<a class="headerlink" href="#usage-logging" title="Permalink to
 commonly used or to locally log RTG command use for their own analysis.</p>
 <p>A usage record contains the following fields:</p>
 <ul class="simple">
-<li>Time and date</li>
-<li>License serial number</li>
-<li>Unique ID for the run</li>
-<li>Version of RTG software</li>
-<li>RTG command name, without parameters (e.g. map)</li>
-<li>Status (Started / Failed / Succeeded)</li>
-<li>A command-specific field (e.g. number of reads)</li>
+<li><p>Time and date</p></li>
+<li><p>License serial number</p></li>
+<li><p>Unique ID for the run</p></li>
+<li><p>Version of RTG software</p></li>
+<li><p>RTG command name, without parameters (e.g. map)</p></li>
+<li><p>Status (Started / Failed / Succeeded)</p></li>
+<li><p>A command-specific field (e.g. number of reads)</p></li>
 </ul>
 <p>For example:</p>
 <div class="highlight-text notranslate"><div class="highlight"><pre><span></span>2013-02-11 11:38:38007   4f6c2eca-0bfc-4267-be70-b7baa85ebf66    RTG Core v2.7 build d74f45d (2013-02-04)   format  Start   N/A
@@ -311,11 +274,11 @@ <h3>Advanced usage configuration<a class="headerlink" href="#advanced-usage-conf
 the <code class="docutils literal notranslate"><span class="pre">RTG_USAGE_OPTIONAL</span></code> to a comma separated list containing any of
 the following:</p>
 <ul class="simple">
-<li><code class="docutils literal notranslate"><span class="pre">username</span></code> - adds the username of the user running the RTG command.</li>
-<li><code class="docutils literal notranslate"><span class="pre">hostname</span></code> - adds the machine name running the RTG command.</li>
-<li><code class="docutils literal notranslate"><span class="pre">commandline</span></code> - adds the command line, including parameters, of the
+<li><p><code class="docutils literal notranslate"><span class="pre">username</span></code> - adds the username of the user running the RTG command.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">hostname</span></code> - adds the machine name running the RTG command.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">commandline</span></code> - adds the command line, including parameters, of the
 RTG command (this field will be truncated if the length exceeds 1000
-characters).</li>
+characters).</p></li>
 </ul>
 <p>For example:</p>
 <div class="highlight-text notranslate"><div class="highlight"><pre><span></span>RTG_USAGE_OPTIONAL=username,hostname,commandline
@@ -338,20 +301,59 @@ <h2>Command-line color highlighting<a class="headerlink" href="#command-line-col
 </div>
 <p>The possible values for <code class="docutils literal notranslate"><span class="pre">rtg.default-markup</span></code> are:</p>
 <ul class="simple">
-<li><code class="docutils literal notranslate"><span class="pre">auto</span></code> - automatically enable ANSI markup when running on
-non-Windows OS and when I/O is detected to be a console.</li>
-<li><code class="docutils literal notranslate"><span class="pre">none</span></code> - disable ANSI markup.</li>
-<li><code class="docutils literal notranslate"><span class="pre">ansi</span></code> - enable ANSI markup. This may be useful if you are using
+<li><p><code class="docutils literal notranslate"><span class="pre">auto</span></code> - automatically enable ANSI markup when running on
+non-Windows OS and when I/O is detected to be a console.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">none</span></code> - disable ANSI markup.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">ansi</span></code> - enable ANSI markup. This may be useful if you are using
 Windows OS and have installed an ANSI-capable terminal such as
-ANSICON, ConEmu or Console 2.</li>
+ANSICON, ConEmu or Console 2.</p></li>
 </ul>
 </div>
 </div>
 
 
+            <div class="clearer"></div>
           </div>
         </div>
       </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="index.html">
+              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
+            </a></p>
+  <h3><a href="index.html">Table of Contents</a></h3>
+  <ul>
+<li><a class="reference internal" href="#">Administration &amp; Capacity Planning</a><ul>
+<li><a class="reference internal" href="#advanced-installation-configuration">Advanced installation configuration</a></li>
+<li><a class="reference internal" href="#run-time-performance-optimization">Run-time performance optimization</a></li>
+<li><a class="reference internal" href="#alternate-configurations">Alternate configurations</a></li>
+<li><a class="reference internal" href="#exception-management-talkback-and-log-file">Exception management - TalkBack and log file</a></li>
+<li><a class="reference internal" href="#usage-logging">Usage logging</a><ul>
+<li><a class="reference internal" href="#single-user-single-machine">Single-user, single machine</a></li>
+<li><a class="reference internal" href="#multi-user-or-multiple-machines">Multi-user or multiple machines</a></li>
+<li><a class="reference internal" href="#advanced-usage-configuration">Advanced usage configuration</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#command-line-color-highlighting">Command-line color highlighting</a></li>
+</ul>
+</li>
+</ul>
+
+  <h4>Previous topic</h4>
+  <p class="topless"><a href="product_usage.html"
+                        title="previous chapter">RTG product usage - baseline progressions</a></p>
+  <h4>Next topic</h4>
+  <p class="topless"><a href="appendix.html"
+                        title="next chapter">Appendix</a></p>
+  <div role="note" aria-label="source link">
+    <h3>This Page</h3>
+    <ul class="this-page-menu">
+      <li><a href="_sources/administration.rst.txt"
+            rel="nofollow">Show Source</a></li>
+    </ul>
+   </div>
+        </div>
+      </div>
       <div class="clearer"></div>
     </div>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -366,12 +368,13 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="product_usage.html" title="RTG product usage - baseline progressions"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Administration &amp; Capacity Planning</a></li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2017, Real Time Genomics.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.8.5.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.1.2.
     </div>
   </body>
 </html>
\ No newline at end of file
diff --git a/installer/resources/core/RTGOperationsManual/appendix.html b/installer/resources/core/RTGOperationsManual/appendix.html
index bb9c90922..2b5d29010 100644
--- a/installer/resources/core/RTGOperationsManual/appendix.html
+++ b/installer/resources/core/RTGOperationsManual/appendix.html
@@ -2,26 +2,26 @@
 
 <!doctype html>
 
-<html xmlns="http://www.w3.org/1999/xhtml">
+<html>
   <head>
-    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Appendix &#8212; RTG Core Operations Manual v3.11</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Appendix &#8212; RTG Core Operations Manual v3.12</title>
     <link rel="stylesheet" href="_static/bizstyle.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     
-    <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <script type="text/javascript" src="_static/language_data.js"></script>
-    <script type="text/javascript" src="_static/bizstyle.js"></script>
+    <script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+    <script src="_static/jquery.js"></script>
+    <script src="_static/underscore.js"></script>
+    <script src="_static/doctools.js"></script>
+    <script src="_static/language_data.js"></script>
+    <script src="_static/bizstyle.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
     <link rel="prev" title="Administration &amp; Capacity Planning" href="administration.html" />
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
     <!--[if lt IE 9]>
-    <script type="text/javascript" src="_static/css3-mediaqueries.js"></script>
+    <script src="_static/css3-mediaqueries.js"></script>
     <![endif]-->
   </head><body>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -33,89 +33,10 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="administration.html" title="Administration &amp; Capacity Planning"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Appendix</a></li> 
       </ul>
-    </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-            <p class="logo"><a href="index.html">
-              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
-            </a></p>
-  <h3><a href="index.html">Table of Contents</a></h3>
-  <ul>
-<li><a class="reference internal" href="#">Appendix</a><ul>
-<li><a class="reference internal" href="#rtg-gapped-alignment-technical-description">RTG gapped alignment technical description</a><ul>
-<li><a class="reference internal" href="#alignment-computations">Alignment computations</a></li>
-<li><a class="reference internal" href="#alignment-scoring">Alignment scoring</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#using-sam-bam-read-groups-in-rtg-map">Using SAM/BAM Read Groups in RTG map</a></li>
-<li><a class="reference internal" href="#rtg-reference-file-format">RTG reference file format</a></li>
-<li><a class="reference internal" href="#rtg-taxonomic-reference-file-format">RTG taxonomic reference file format</a><ul>
-<li><a class="reference internal" href="#rtg-taxonomy-file-format">RTG taxonomy file format</a></li>
-<li><a class="reference internal" href="#rtg-taxonomy-lookup-file-format">RTG taxonomy lookup file format</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#pedigree-ped-input-file-format">Pedigree PED input file format</a></li>
-<li><a class="reference internal" href="#genetic-map-directory">Genetic map directory</a></li>
-<li><a class="reference internal" href="#rtg-commands-using-indexed-input-files">RTG commands using indexed input files</a></li>
-<li><a class="reference internal" href="#rtg-output-results-file-descriptions">RTG output results file descriptions</a><ul>
-<li><a class="reference internal" href="#sam-bam-file-extensions-rtg-map-command-output">SAM/BAM file extensions (RTG map command output)</a></li>
-<li><a class="reference internal" href="#sam-bam-file-extensions-rtg-cgmap-command-output">SAM/BAM file extensions (RTG cgmap command output)</a></li>
-<li><a class="reference internal" href="#small-variant-vcf-output-file-description">Small-variant VCF output file description</a></li>
-<li><a class="reference internal" href="#regions-bed-output-file-description">Regions BED output file description</a></li>
-<li><a class="reference internal" href="#sv-command-output-file-descriptions">SV command output file descriptions</a></li>
-<li><a class="reference internal" href="#discord-command-output-file-descriptions">Discord command output file descriptions</a></li>
-<li><a class="reference internal" href="#coverage-command-output-file-descriptions">Coverage command output file descriptions</a></li>
-<li><a class="reference internal" href="#mapx-and-mapp-output-file-description">Mapx and mapp output file description</a></li>
-<li><a class="reference internal" href="#species-results-file-description">Species results file description</a></li>
-<li><a class="reference internal" href="#similarity-results-file-descriptions">Similarity results file descriptions</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#rtg-javascript-filtering-api">RTG JavaScript filtering API</a><ul>
-<li><a class="reference internal" href="#vcf-record-field-access">VCF record field access</a><ul>
-<li><a class="reference internal" href="#chrom-pos-id-ref-qual">CHROM, POS, ID, REF, QUAL</a></li>
-<li><a class="reference internal" href="#alt-filter">ALT, FILTER</a></li>
-<li><a class="reference internal" href="#info-info-field">INFO.{INFO_FIELD}</a></li>
-<li><a class="reference internal" href="#sample-name-format-field">{SAMPLE_NAME}.{FORMAT_FIELD}</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#vcf-record-modification">VCF record modification</a></li>
-<li><a class="reference internal" href="#vcf-header-modification">VCF header modification</a><ul>
-<li><a class="reference internal" href="#ensureformatheader-format-header-string">ensureFormatHeader(FORMAT_HEADER_STRING)</a></li>
-<li><a class="reference internal" href="#ensureinfoheader-info-header-string">ensureInfoHeader(INFO_HEADER_STRING)</a></li>
-<li><a class="reference internal" href="#ensurefilterheader-filter-header-string">ensureFilterHeader(FILTER_HEADER_STRING)</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#additional-information-and-functions">Additional information and functions</a><ul>
-<li><a class="reference internal" href="#samples">SAMPLES</a></li>
-<li><a class="reference internal" href="#print-string">print({STRING})</a></li>
-<li><a class="reference internal" href="#error-string">error({STRING})</a></li>
-<li><a class="reference internal" href="#checkminversion-rtg-minimum-version">checkMinVersion(RTG_MINIMUM_VERSION)</a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li><a class="reference internal" href="#parallel-processing-approach">Parallel processing approach</a></li>
-<li><a class="reference internal" href="#distribution-contents">Distribution Contents</a></li>
-<li><a class="reference internal" href="#readme-txt">README.txt</a></li>
-<li><a class="reference internal" href="#notice">Notice</a></li>
-</ul>
-</li>
-</ul>
-
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="administration.html"
-                        title="previous chapter">Administration &amp; Capacity Planning</a></p>
-  <div role="note" aria-label="source link">
-    <h3>This Page</h3>
-    <ul class="this-page-menu">
-      <li><a href="_sources/appendix.rst.txt"
-            rel="nofollow">Show Source</a></li>
-    </ul>
-   </div>
-        </div>
-      </div>
+    </div>  
 
     <div class="document">
       <div class="documentwrapper">
@@ -129,15 +50,15 @@ <h2>RTG gapped alignment technical description<a class="headerlink" href="#rtg-g
 <p>Real Time Genomics utilizes its own DNA sequence alignment tool and
 scoring system for aligned reads. Most methods for sequence comparison
 and alignment use a small set of operations derived from the notion of
-<em>edit distance</em> <a class="footnote-reference" href="#c1" id="id1">[1]</a> to discover differences between two DNA sequences.
+<em>edit distance</em> <a class="footnote-reference brackets" href="#c1" id="id1">1</a> to discover differences between two DNA sequences.
 The edit operations introduce insertions, deletions, and substitutions
 to transform one sequence into another. Alignments are termed global if
 they extend over all residues of both sequences.</p>
 <p>Most programs for finding global alignments are based on the
-Needleman-Wunsch algorithm <a class="footnote-reference" href="#c2" id="id2">[2]</a>. Alternatively, alignments may be local,
+Needleman-Wunsch algorithm <a class="footnote-reference brackets" href="#c2" id="id2">2</a>. Alternatively, alignments may be local,
 in which case reported alignments may contain subsequences of the input
 sequences. The Smith-Waterman variation on the Needleman-Wunsch
-algorithm finds such alignments <a class="footnote-reference" href="#c3" id="id3">[3]</a>. The proprietary RTG algorithm
+algorithm finds such alignments <a class="footnote-reference brackets" href="#c3" id="id3">3</a>. The proprietary RTG algorithm
 employs a further variation of this approach, using a dynamic
 programming edit-distance calculation for alignment of reads to a
 reference sequence. The alignment is <em>semi-global</em> in that it always
@@ -200,28 +121,21 @@ <h3>Alignment scoring<a class="headerlink" href="#alignment-scoring" title="Perm
 <p>In addition to the alignment score, a CIGAR is also reported in SAM
 records.</p>
 <p>References for this section</p>
-<table class="docutils footnote" frame="void" id="c1" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id1">[1]</a></td><td>Levenshtein, V. I.(1966) Binary codes capable of correcting deletions,
-insertions and reversal. Soviet Physics Doklady, 6:707-710.</td></tr>
-</tbody>
-</table>
-<table class="docutils footnote" frame="void" id="c2" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id2">[2]</a></td><td>Needleman, S. B and Wunsch, C. D. (1970) A general method applicable to
+<dl class="footnote brackets">
+<dt class="label" id="c1"><span class="brackets"><a class="fn-backref" href="#id1">1</a></span></dt>
+<dd><p>Levenshtein, V. I.(1966) Binary codes capable of correcting deletions,
+insertions and reversal. Soviet Physics Doklady, 6:707-710.</p>
+</dd>
+<dt class="label" id="c2"><span class="brackets"><a class="fn-backref" href="#id2">2</a></span></dt>
+<dd><p>Needleman, S. B and Wunsch, C. D. (1970) A general method applicable to
 the search for similarities in the amino acid sequence of two
-proteins. Journal of Molecular Biology, 48:443-453</td></tr>
-</tbody>
-</table>
-<table class="docutils footnote" frame="void" id="c3" rules="none">
-<colgroup><col class="label" /><col /></colgroup>
-<tbody valign="top">
-<tr><td class="label"><a class="fn-backref" href="#id3">[3]</a></td><td>Smith, T. F. and Waterman, M. S. (1981) Identification of common molecular
-subsequences. Journal of Molecular Biology. 147:195-197.</td></tr>
-</tbody>
-</table>
+proteins. Journal of Molecular Biology, 48:443-453</p>
+</dd>
+<dt class="label" id="c3"><span class="brackets"><a class="fn-backref" href="#id3">3</a></span></dt>
+<dd><p>Smith, T. F. and Waterman, M. S. (1981) Identification of common molecular
+subsequences. Journal of Molecular Biology. 147:195-197.</p>
+</dd>
+</dl>
 </div>
 </div>
 <div class="section" id="using-sam-bam-read-groups-in-rtg-map">
@@ -373,7 +287,8 @@ <h2>RTG reference file format<a class="headerlink" href="#rtg-reference-file-for
 <div class="highlight-text notranslate"><div class="highlight"><pre><span></span>either        def     &lt;ploidy&gt;        &lt;shape&gt;
 </pre></div>
 </div>
-<p>The <em>ploidy</em> field is one of <code class="docutils literal notranslate"><span class="pre">diploid</span></code>, <code class="docutils literal notranslate"><span class="pre">haploid</span></code>, <code class="docutils literal notranslate"><span class="pre">polyploid</span></code> or
+<p>The <em>ploidy</em> field is one of <code class="docutils literal notranslate"><span class="pre">haploid</span></code>, <code class="docutils literal notranslate"><span class="pre">diploid</span></code>, <code class="docutils literal notranslate"><span class="pre">triploid</span></code>,
+<code class="docutils literal notranslate"><span class="pre">tetraploid</span></code>, <code class="docutils literal notranslate"><span class="pre">pentaploid</span></code>, <code class="docutils literal notranslate"><span class="pre">hexaploid</span></code>, <code class="docutils literal notranslate"><span class="pre">polyploid</span></code> or
 <code class="docutils literal notranslate"><span class="pre">none</span></code>. The <em>shape</em> field is one of <code class="docutils literal notranslate"><span class="pre">circular</span></code> or <code class="docutils literal notranslate"><span class="pre">linear</span></code>.</p>
 <p>The specific chromosome settings lines are similar to the default
 chromosome settings lines. All the sex field options can be used,
@@ -504,14 +419,14 @@ <h3>RTG taxonomy file format<a class="headerlink" href="#rtg-taxonomy-file-forma
 <p>Each data line in the file represents a node in the taxonomy tree and is
 comprised of four tab separated values. The values on each line are:</p>
 <ol class="arabic simple">
-<li>The unique taxon ID of the node in the tree. This must be an integer
-value greater than or equal to 1.</li>
-<li>The taxon ID of the parent of this node. This must be an integer
-value corresponding to another node in the tree.</li>
-<li>The rank of the node in the taxonomy. This is a free format string
-that can contain any character other than a tab.</li>
-<li>The name of the node in the taxonomy. This is a free format string
-that can contain any character other than a tab.</li>
+<li><p>The unique taxon ID of the node in the tree. This must be an integer
+value greater than or equal to 1.</p></li>
+<li><p>The taxon ID of the parent of this node. This must be an integer
+value corresponding to another node in the tree.</p></li>
+<li><p>The rank of the node in the taxonomy. This is a free format string
+that can contain any character other than a tab.</p></li>
+<li><p>The name of the node in the taxonomy. This is a free format string
+that can contain any character other than a tab.</p></li>
 </ol>
 <p>The root of the tree is special and must have a taxon ID of 1. Since the
 root has no parent it can have a parent ID of either 1 (itself) or -1.
@@ -538,11 +453,11 @@ <h3>RTG taxonomy lookup file format<a class="headerlink" href="#rtg-taxonomy-loo
 in the SDF, with each line containing two tab separated values.</p>
 <p>The values on each line are:</p>
 <ol class="arabic simple">
-<li>The taxonomy node ID that the sequence is associated with. This must
+<li><p>The taxonomy node ID that the sequence is associated with. This must
 be an integer value that corresponds to a node ID from the taxonomy
-tree.</li>
-<li>The name of the sequence as it appears in the SDF. (These can be
-discovered using the <code class="docutils literal notranslate"><span class="pre">--lengths</span></code> option of the <code class="docutils literal notranslate"><span class="pre">sdfstats</span></code> command)</li>
+tree.</p></li>
+<li><p>The name of the sequence as it appears in the SDF. (These can be
+discovered using the <code class="docutils literal notranslate"><span class="pre">--lengths</span></code> option of the <code class="docutils literal notranslate"><span class="pre">sdfstats</span></code> command)</p></li>
 </ol>
 <p>A single taxon ID may be associated with multiple sequence names. This
 is a way to group the chromosomes and plasmids belonging to a single
@@ -561,40 +476,40 @@ <h2>Pedigree PED input file format<a class="headerlink" href="#pedigree-ped-inpu
 <p>The PED file format is a white space (tab or space) delimited ASCII
 file. Lines starting with <code class="docutils literal notranslate"><span class="pre">#</span></code> are ignored. It has exactly six required
 columns in the following order.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="10%" />
-<col width="90%" />
+<col style="width: 10%" />
+<col style="width: 90%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Column</th>
-<th class="head">Definition</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Column</p></th>
+<th class="head"><p>Definition</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><em>Family ID</em></td>
-<td>Alphanumeric ID of a family group. This field is ignored by RTG commands.</td>
+<tbody>
+<tr class="row-even"><td><p><em>Family ID</em></p></td>
+<td><p>Alphanumeric ID of a family group. This field is ignored by RTG commands.</p></td>
 </tr>
-<tr class="row-odd"><td><em>Individual ID</em></td>
-<td>Alphanumeric ID of an individual. This corresponds to the Sample ID specified in the read group of the individual (<code class="docutils literal notranslate"><span class="pre">SM</span></code> field).</td>
+<tr class="row-odd"><td><p><em>Individual ID</em></p></td>
+<td><p>Alphanumeric ID of an individual. This corresponds to the Sample ID specified in the read group of the individual (<code class="docutils literal notranslate"><span class="pre">SM</span></code> field).</p></td>
 </tr>
-<tr class="row-even"><td><em>Paternal ID</em></td>
-<td>Alphanumeric ID of the paternal parent for the individual. This corresponds to the Sample ID specified in the read group of the paternal parent (<code class="docutils literal notranslate"><span class="pre">SM</span></code> field).</td>
+<tr class="row-even"><td><p><em>Paternal ID</em></p></td>
+<td><p>Alphanumeric ID of the paternal parent for the individual. This corresponds to the Sample ID specified in the read group of the paternal parent (<code class="docutils literal notranslate"><span class="pre">SM</span></code> field).</p></td>
 </tr>
-<tr class="row-odd"><td><em>Maternal ID</em></td>
-<td>Alphanumeric ID of the maternal parent for the individual. This corresponds to the Sample ID specified in the read group of the maternal parent (<code class="docutils literal notranslate"><span class="pre">SM</span></code> field).</td>
+<tr class="row-odd"><td><p><em>Maternal ID</em></p></td>
+<td><p>Alphanumeric ID of the maternal parent for the individual. This corresponds to the Sample ID specified in the read group of the maternal parent (<code class="docutils literal notranslate"><span class="pre">SM</span></code> field).</p></td>
 </tr>
-<tr class="row-even"><td><em>Sex</em></td>
-<td>The sex of the individual specified as using 1 for male, 2 for female and any other number as unknown.</td>
+<tr class="row-even"><td><p><em>Sex</em></p></td>
+<td><p>The sex of the individual specified as using 1 for male, 2 for female and any other number as unknown.</p></td>
 </tr>
-<tr class="row-odd"><td><em>Phenotype</em></td>
-<td>The phenotype of the individual specified using -9 or 0 for unknown, 1 for unaffected and 2 for affected.</td>
+<tr class="row-odd"><td><p><em>Phenotype</em></p></td>
+<td><p>The phenotype of the individual specified using -9 or 0 for unknown, 1 for unaffected and 2 for affected.</p></td>
 </tr>
 </tbody>
 </table>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">The PED format is based on the PED format defined by
+<p class="admonition-title">Note</p>
+<p>The PED format is based on the PED format defined by
 the PLINK project:
 <a class="reference external" href="http://pngu.mgh.harvard.edu/~purcell/plink/data.shtml#ped">http://pngu.mgh.harvard.edu/~purcell/plink/data.shtml#ped</a></p>
 </div>
@@ -644,10 +559,10 @@ <h2>Genetic map directory<a class="headerlink" href="#genetic-map-directory" tit
 </div>
 <p>The columns in the example are:</p>
 <ol class="arabic simple">
-<li>Chromosome name</li>
-<li>Position in chromosome</li>
-<li>Rate of crossovers in region ending at this position (ignored)</li>
-<li>Total number of centimorgans from start of sequence</li>
+<li><p>Chromosome name</p></li>
+<li><p>Position in chromosome</p></li>
+<li><p>Rate of crossovers in region ending at this position (ignored)</p></li>
+<li><p>Total number of centimorgans from start of sequence</p></li>
 </ol>
 <p>The corresponding map directory should contain a file or files for each sequence
 of interest, using the naming convention
@@ -669,9 +584,9 @@ <h2>Genetic map directory<a class="headerlink" href="#genetic-map-directory" tit
 can be used with RTG.</p>
 <p>Specific sources include:</p>
 <ul class="simple">
-<li><a class="reference external" href="https://github.com/cbherer/Bherer_etal_SexualDimorphismRecombination">https://github.com/cbherer/Bherer_etal_SexualDimorphismRecombination</a></li>
-<li><a class="reference external" href="https://genome.sph.umich.edu/wiki/Polymutt2">https://genome.sph.umich.edu/wiki/Polymutt2</a></li>
-<li><a class="reference external" href="http://bochet.gcc.biostat.washington.edu/beagle/genetic_maps/">http://bochet.gcc.biostat.washington.edu/beagle/genetic_maps/</a></li>
+<li><p><a class="reference external" href="https://github.com/cbherer/Bherer_etal_SexualDimorphismRecombination">https://github.com/cbherer/Bherer_etal_SexualDimorphismRecombination</a></p></li>
+<li><p><a class="reference external" href="https://genome.sph.umich.edu/wiki/Polymutt2">https://genome.sph.umich.edu/wiki/Polymutt2</a></p></li>
+<li><p><a class="reference external" href="http://bochet.gcc.biostat.washington.edu/beagle/genetic_maps/">http://bochet.gcc.biostat.washington.edu/beagle/genetic_maps/</a></p></li>
 </ul>
 <p>A zip file containing the Bherer genetic map files for human build 37,
 with the required header manipulations already applied is available for
@@ -706,8 +621,8 @@ <h3>SAM/BAM file extensions (RTG map command output)<a class="headerlink" href="
 the mapping and alignment data for each read, ordered by chromosome (or
 other DNA reference sequence) location.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">For a thorough description of the SAM format please refer
+<p class="admonition-title">Note</p>
+<p>For a thorough description of the SAM format please refer
 to the specification at
 <a class="reference external" href="https://samtools.github.io/hts-specs/SAMv1.pdf">https://samtools.github.io/hts-specs/SAMv1.pdf</a></p>
 </div>
@@ -760,22 +675,22 @@ <h3>SAM/BAM file extensions (RTG map command output)<a class="headerlink" href="
 <p>The following list describes RTG SAM/BAM file characteristics that may
 depart from or be undescribed in the SAM specification.</p>
 <ul class="simple">
-<li>Paired-end sequencing data</li>
-<li><code class="docutils literal notranslate"><span class="pre">FLAG</span></code> is set to 0x02 in properly paired reads and unset for
-unmated or unmapped reads.</li>
-<li>For all non-uniquely mapped reads <code class="docutils literal notranslate"><span class="pre">FLAG</span></code> 0x100 is set.</li>
-<li>Unmated and unmapped reads will have the <code class="docutils literal notranslate"><span class="pre">FLAG</span></code> 0x08 set to reflect
+<li><p>Paired-end sequencing data</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">FLAG</span></code> is set to 0x02 in properly paired reads and unset for
+unmated or unmapped reads.</p></li>
+<li><p>For all non-uniquely mapped reads <code class="docutils literal notranslate"><span class="pre">FLAG</span></code> 0x100 is set.</p></li>
+<li><p>Unmated and unmapped reads will have the <code class="docutils literal notranslate"><span class="pre">FLAG</span></code> 0x08 set to reflect
 whether the mate has been mapped, however <code class="docutils literal notranslate"><span class="pre">RNEXT</span></code> and <code class="docutils literal notranslate"><span class="pre">PNEXT</span></code>
-will always be “*”.</li>
-<li>For mapped reads, the SAM standard <code class="docutils literal notranslate"><span class="pre">NH</span></code> attribute is used, even for
-uniquely mapped reads (<code class="docutils literal notranslate"><span class="pre">NH:i:1</span></code>).</li>
-<li>Single-end sequencing data</li>
-<li>For all non-uniquely mapped reads <code class="docutils literal notranslate"><span class="pre">FLAG</span></code> 0x100 is set.</li>
-<li>For mapped reads, the SAM standard <code class="docutils literal notranslate"><span class="pre">NH</span></code> attribute is used, even for
-uniquely mapped reads (<code class="docutils literal notranslate"><span class="pre">NH:i:1</span></code>).</li>
-<li>Unmapped reads</li>
-<li><code class="docutils literal notranslate"><span class="pre">RNAME</span></code> and <code class="docutils literal notranslate"><span class="pre">CIGAR</span></code> are set as “*”.</li>
-<li><code class="docutils literal notranslate"><span class="pre">POS</span></code>, and <code class="docutils literal notranslate"><span class="pre">MAPQ</span></code> are set as 0.</li>
+will always be “*”.</p></li>
+<li><p>For mapped reads, the SAM standard <code class="docutils literal notranslate"><span class="pre">NH</span></code> attribute is used, even for
+uniquely mapped reads (<code class="docutils literal notranslate"><span class="pre">NH:i:1</span></code>).</p></li>
+<li><p>Single-end sequencing data</p></li>
+<li><p>For all non-uniquely mapped reads <code class="docutils literal notranslate"><span class="pre">FLAG</span></code> 0x100 is set.</p></li>
+<li><p>For mapped reads, the SAM standard <code class="docutils literal notranslate"><span class="pre">NH</span></code> attribute is used, even for
+uniquely mapped reads (<code class="docutils literal notranslate"><span class="pre">NH:i:1</span></code>).</p></li>
+<li><p>Unmapped reads</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">RNAME</span></code> and <code class="docutils literal notranslate"><span class="pre">CIGAR</span></code> are set as “*”.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">POS</span></code>, and <code class="docutils literal notranslate"><span class="pre">MAPQ</span></code> are set as 0.</p></li>
 </ul>
 <p>For mated records, the <code class="docutils literal notranslate"><span class="pre">XA</span></code> attribute contains the sum of the alignment
 scores for each arm. It is this score that is used to determine the
@@ -787,65 +702,65 @@ <h3>SAM/BAM file extensions (RTG map command output)<a class="headerlink" href="
 or unmapped. If this is reported, it means that the read arm had
 matching hits at one point during the mapping phase.</p>
 <p>Single-end SAM character codes include:</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="92%" />
+<col style="width: 8%" />
+<col style="width: 92%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Character</th>
-<th class="head">Definition</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Character</p></th>
+<th class="head"><p>Definition</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">XC:A:B</span></code></td>
-<td>Indicates that the number of raw index hits for the read exceeded the internal threshold of 65536.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">XC:A:B</span></code></p></td>
+<td><p>Indicates that the number of raw index hits for the read exceeded the internal threshold of 65536.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">XC:A:C</span></code></td>
-<td>Indicates that after initial ranking of hits for the read, too many hits were present (affected by <code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">XC:A:C</span></code></p></td>
+<td><p>Indicates that after initial ranking of hits for the read, too many hits were present (affected by <code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">XC:A:D</span></code></td>
-<td>Indicates that after alignment scores are calculated, the <img class="math" src="_images/math/b4e2012103f1c4a304de5f04d2c95b2fa7ddcd73.png" alt="\leq N"/> remaining hits were discarded because they exceeded the mismatches threshold (affected by
-<code class="docutils literal notranslate"><span class="pre">--max-mismatches</span></code>).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">XC:A:D</span></code></p></td>
+<td><p>Indicates that after alignment scores are calculated, the <img class="math" src="_images/math/593c511ee9aeb89e927882c5cb67418a46da3828.png" alt="\leq N"/> remaining hits were discarded because they exceeded the mismatches threshold (affected by
+<code class="docutils literal notranslate"><span class="pre">--max-mismatches</span></code>).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">XC:A:E</span></code></td>
-<td>Indicates that there were good scoring hits, but the arm was discarded because there were too many of these hits (affected by <code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">XC:A:E</span></code></p></td>
+<td><p>Indicates that there were good scoring hits, but the arm was discarded because there were too many of these hits (affected by <code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</p></td>
 </tr>
 </tbody>
 </table>
 <p>Paired-end SAM character codes include:</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="94%" />
+<col style="width: 6%" />
+<col style="width: 94%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Character</th>
-<th class="head">Definition</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Character</p></th>
+<th class="head"><p>Definition</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">XC:A:B</span></code></td>
-<td>Indicates that the number of raw index hits for the read exceeded the internal threshold of 65536.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">XC:A:B</span></code></p></td>
+<td><p>Indicates that the number of raw index hits for the read exceeded the internal threshold of 65536.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">XC:A:C</span></code></td>
-<td>Indicates that there were index matches for the read arm, but no potential mated hits were found (affected by <code class="docutils literal notranslate"><span class="pre">--min-fragment-size</span></code> and
-<code class="docutils literal notranslate"><span class="pre">--max-fragment-size</span></code>), and after ranking candidate unpaired results there were too many hits (affected by <code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">XC:A:C</span></code></p></td>
+<td><p>Indicates that there were index matches for the read arm, but no potential mated hits were found (affected by <code class="docutils literal notranslate"><span class="pre">--min-fragment-size</span></code> and
+<code class="docutils literal notranslate"><span class="pre">--max-fragment-size</span></code>), and after ranking candidate unpaired results there were too many hits (affected by <code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">XC:A:d</span></code></td>
-<td>Indicates that potential mated hits were found for this read arm with its mate, but were discarded because they exceeded the mismatches threshold (affected by
-<code class="docutils literal notranslate"><span class="pre">--max-mated-mismatches</span></code>).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">XC:A:d</span></code></p></td>
+<td><p>Indicates that potential mated hits were found for this read arm with its mate, but were discarded because they exceeded the mismatches threshold (affected by
+<code class="docutils literal notranslate"><span class="pre">--max-mated-mismatches</span></code>).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">XC:A:D</span></code></td>
-<td>Indicates that no potential mated hits were found, and after alignment scores are calculated, the <img class="math" src="_images/math/66e94f41a0f1e5615bd662691764d652b37d7338.png" alt="(\leq N)"/>
-remaining hits were discarded because they exceeded the mismatches threshold (affected by <code class="docutils literal notranslate"><span class="pre">--max-unmated-mismatches</span></code>).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">XC:A:D</span></code></p></td>
+<td><p>Indicates that no potential mated hits were found, and after alignment scores are calculated, the <img class="math" src="_images/math/92ddcd7319ecbea8436f1b18fbebf544a38e4c69.png" alt="(\leq N)"/>
+remaining hits were discarded because they exceeded the mismatches threshold (affected by <code class="docutils literal notranslate"><span class="pre">--max-unmated-mismatches</span></code>).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">XC:A:e</span></code></td>
-<td>Indicates that good scoring hits were found for this read arm with its mate, but were discarded because there were too many hits at the best score (affected by
-<code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">XC:A:e</span></code></p></td>
+<td><p>Indicates that good scoring hits were found for this read arm with its mate, but were discarded because there were too many hits at the best score (affected by
+<code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">XC:A:E</span></code></td>
-<td>Indicates that no potential mated hits were found, there were good scoring unmated hits, but the arm was discarded because there were too many of these hits (affected by <code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">XC:A:E</span></code></p></td>
+<td><p>Indicates that no potential mated hits were found, there were good scoring unmated hits, but the arm was discarded because there were too many of these hits (affected by <code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</p></td>
 </tr>
 </tbody>
 </table>
@@ -947,8 +862,8 @@ <h3>Small-variant VCF output file description<a class="headerlink" href="#small-
 read alignments. The predictions and accompanying statistics are
 reported in a text-based output file named <code class="docutils literal notranslate"><span class="pre">snps.vcf</span></code>.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">RTG variant calls are stored in VCF format (version
+<p class="admonition-title">Note</p>
+<p>RTG variant calls are stored in VCF format (version
 4.2). For more information about the VCF format, refer to the
 specification online at:
 <a class="reference external" href="https://samtools.github.io/hts-specs/VCFv4.2.pdf">https://samtools.github.io/hts-specs/VCFv4.2.pdf</a></p>
@@ -1001,8 +916,8 @@ <h3>Small-variant VCF output file description<a class="headerlink" href="#small-
 </pre></div>
 </div>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">The VCF specification defines the semantics of the <code class="docutils literal notranslate"><span class="pre">QUAL</span></code>
+<p class="admonition-title">Note</p>
+<p>The VCF specification defines the semantics of the <code class="docutils literal notranslate"><span class="pre">QUAL</span></code>
 column differently for records that contain any <code class="docutils literal notranslate"><span class="pre">ALT</span></code> alleles from
 those which do not, and that the <code class="docutils literal notranslate"><span class="pre">QUAL</span></code> column is also defined as a
 score applying across the set of all samples in the VCF. Thus for
@@ -1015,268 +930,268 @@ <h3>Small-variant VCF output file description<a class="headerlink" href="#small-
 The exact set of fields used depend on the module run, with some fields
 only appropriate and present for family calling, somatic calling, etc.</p>
 <p>Table : RTG VCF file FILTER fields</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="9%" />
-<col width="91%" />
+<col style="width: 9%" />
+<col style="width: 91%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Value</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Value</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">PASS</span></code></td>
-<td>Standard VCF <code class="docutils literal notranslate"><span class="pre">PASS</span></code>, if variant meets all the filtering criteria.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">PASS</span></code></p></td>
+<td><p>Standard VCF <code class="docutils literal notranslate"><span class="pre">PASS</span></code>, if variant meets all the filtering criteria.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">OC</span></code></td>
-<td>A predicted variation that has exceeded the maximum coverage filter threshold.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">OC</span></code></p></td>
+<td><p>A predicted variation that has exceeded the maximum coverage filter threshold.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">a&lt;number&gt;</span></code></td>
-<td>A predicted variation that had greater than the given percentage of ambiguously mapped reads overlapping it. The number in the value is the percentage specified by the <code class="docutils literal notranslate"><span class="pre">--max-ambiguity</span></code> flag.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">a&lt;number&gt;</span></code></p></td>
+<td><p>A predicted variation that had greater than the given percentage of ambiguously mapped reads overlapping it. The number in the value is the percentage specified by the <code class="docutils literal notranslate"><span class="pre">--max-ambiguity</span></code> flag.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">RCEQUIV</span></code></td>
-<td>A predicted variation that is the same as a previous variant within a homopolymer or repeat region.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">RCEQUIV</span></code></p></td>
+<td><p>A predicted variation that is the same as a previous variant within a homopolymer or repeat region.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RC</span></code></td>
-<td>The variant caller encountered a complex looking situation. A typical example would be a long insert. Some complex regions may result in simple calls.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RC</span></code></p></td>
+<td><p>The variant caller encountered a complex looking situation. A typical example would be a long insert. Some complex regions may result in simple calls.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">RX</span></code></td>
-<td>This call was made within a long complex region. Note that no attempt is made to generate complex calls in very long complex regions.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">RX</span></code></p></td>
+<td><p>This call was made within a long complex region. Note that no attempt is made to generate complex calls in very long complex regions.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">IONT</span></code></td>
-<td>A predicted variation that failed to pass homopolymer constraints specific to IonTorrent reads.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">IONT</span></code></p></td>
+<td><p>A predicted variation that failed to pass homopolymer constraints specific to IonTorrent reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">OTHER</span></code></td>
-<td>The variant was filtered for an unknown reason.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">OTHER</span></code></p></td>
+<td><p>The variant was filtered for an unknown reason.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">AVR&lt;number&gt;</span></code></td>
-<td>A predicted variation that had less than the given value for the AVR score. The number in the value is the minimum AVR score specified by the <code class="docutils literal notranslate"><span class="pre">--min-avr-score</span></code> flag.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">AVR&lt;number&gt;</span></code></p></td>
+<td><p>A predicted variation that had less than the given value for the AVR score. The number in the value is the minimum AVR score specified by the <code class="docutils literal notranslate"><span class="pre">--min-avr-score</span></code> flag.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">BED</span></code></td>
-<td>The predicted variant falls outside the BED calling regions defined by the <code class="docutils literal notranslate"><span class="pre">--filter-bed</span></code> flag.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">BED</span></code></p></td>
+<td><p>The predicted variant falls outside the BED calling regions defined by the <code class="docutils literal notranslate"><span class="pre">--filter-bed</span></code> flag.</p></td>
 </tr>
 </tbody>
 </table>
 <p>Table : RTG VCF file INFO fields</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="9%" />
-<col width="91%" />
+<col style="width: 9%" />
+<col style="width: 91%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Value</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Value</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">NCS=&lt;value&gt;</span></code></td>
-<td>The Phred scaled posterior probability that the variant at this site is present in the cancer, output by the <code class="docutils literal notranslate"><span class="pre">somatic</span></code> command.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">NCS=&lt;value&gt;</span></code></p></td>
+<td><p>The Phred scaled posterior probability that the variant at this site is present in the cancer, output by the <code class="docutils literal notranslate"><span class="pre">somatic</span></code> command.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">LOH=&lt;value&gt;</span></code></td>
-<td>The value shows on a scale from -1 to 1 if the evidence of a call would suggest a loss of heterozygosity. A long run of high values is a strong indicator of a loss of heterozygosity event.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">LOH=&lt;value&gt;</span></code></p></td>
+<td><p>The value shows on a scale from -1 to 1 if the evidence of a call would suggest a loss of heterozygosity. A long run of high values is a strong indicator of a loss of heterozygosity event.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">DP=&lt;depth&gt;</span></code></td>
-<td>The combined read depth of multi-sample variant calls.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">DP=&lt;depth&gt;</span></code></p></td>
+<td><p>The combined read depth of multi-sample variant calls.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">DPR=&lt;ratio&gt;</span></code></td>
-<td>The ratio of combined read depth to the expected combined read depth.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">DPR=&lt;ratio&gt;</span></code></p></td>
+<td><p>The ratio of combined read depth to the expected combined read depth.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">XRX</span></code></td>
-<td>Indicates the variant was called using the RTG complex caller. This means that a realignment of the reads relative to the reference and each other was required to make this call.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">XRX</span></code></p></td>
+<td><p>Indicates the variant was called using the RTG complex caller. This means that a realignment of the reads relative to the reference and each other was required to make this call.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">RCE</span></code></td>
-<td>Indicates the variant is the same as one or more other variants within a homopolymer or repeat region.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">RCE</span></code></p></td>
+<td><p>Indicates the variant is the same as one or more other variants within a homopolymer or repeat region.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">NREF</span></code></td>
-<td>Indicates the variant is called at a site where the reference is unknown, and so some other scores that require exact knowledge of the reference may not be produced.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">NREF</span></code></p></td>
+<td><p>Indicates the variant is called at a site where the reference is unknown, and so some other scores that require exact knowledge of the reference may not be produced.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">CT=&lt;value&gt;</span></code></td>
-<td>The maximum coverage threshold that was applied when the given variant has been filtered for being over the coverage threshold.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">CT=&lt;value&gt;</span></code></p></td>
+<td><p>The maximum coverage threshold that was applied when the given variant has been filtered for being over the coverage threshold.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">AC</span></code></td>
-<td>The standard VCF allele count in genotypes field. For each ALT allele, in the same order as listed, the count of the allele in the genotypes.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">AC</span></code></p></td>
+<td><p>The standard VCF allele count in genotypes field. For each ALT allele, in the same order as listed, the count of the allele in the genotypes.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">AN</span></code></td>
-<td>The standard VCF total number of alleles in called genotypes field.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">AN</span></code></p></td>
+<td><p>The standard VCF total number of alleles in called genotypes field.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">STRL</span></code></td>
-<td>The number of adjacent simple tandem repeats on the reference sequence.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">STRL</span></code></p></td>
+<td><p>The number of adjacent simple tandem repeats on the reference sequence.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">STRU</span></code></td>
-<td>The length of the repeating unit in a simple tandem repeat.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">STRU</span></code></p></td>
+<td><p>The length of the repeating unit in a simple tandem repeat.</p></td>
 </tr>
 </tbody>
 </table>
 <p>Table : RTG VCF file FORMAT fields</p>
-<table border="1" class="longtable docutils">
+<table class="longtable docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="97%" />
+<col style="width: 3%" />
+<col style="width: 97%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Value</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Value</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">GT</span></code></td>
-<td>The standard VCF format genotype field.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">GT</span></code></p></td>
+<td><p>The standard VCF format genotype field.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">DP</span></code></td>
-<td>The standard VCF format read depth field.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">DP</span></code></p></td>
+<td><p>The standard VCF format read depth field.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">DPR</span></code></td>
-<td>The ratio of read depth to the expected read depth.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">DPR</span></code></p></td>
+<td><p>The ratio of read depth to the expected read depth.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">VA</span></code></td>
-<td>The allele index (using same numbering as the <code class="docutils literal notranslate"><span class="pre">GT</span></code> field) of the most frequent non-REF allele. This allele may not necessarily be part of the genotype that was actually called.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">VA</span></code></p></td>
+<td><p>The allele index (using same numbering as the <code class="docutils literal notranslate"><span class="pre">GT</span></code> field) of the most frequent non-REF allele. This allele may not necessarily be part of the genotype that was actually called.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RE</span></code></td>
-<td>The total error across bases of the reads at the SNP location. This is a corrective factor calculated from the r and q read mapping quality scores that adjusts the level of confidence higher or lower relative to read depth.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RE</span></code></p></td>
+<td><p>The total error across bases of the reads at the SNP location. This is a corrective factor calculated from the r and q read mapping quality scores that adjusts the level of confidence higher or lower relative to read depth.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">AR</span></code></td>
-<td>The ratio of reads contributing to the variant that are considered to be ambiguous to uniquely mapped reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">AR</span></code></p></td>
+<td><p>The ratio of reads contributing to the variant that are considered to be ambiguous to uniquely mapped reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RQ</span></code></td>
-<td>The Phred scaled posterior probability that the sample is not identical to the reference.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RQ</span></code></p></td>
+<td><p>The Phred scaled posterior probability that the sample is not identical to the reference.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">GQ</span></code></td>
-<td>The standard VCF format genotype quality field. This is the Phred scaled posterior score of the call. It is not necessarily the same as the <code class="docutils literal notranslate"><span class="pre">QUAL</span></code> column score.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">GQ</span></code></p></td>
+<td><p>The standard VCF format genotype quality field. This is the Phred scaled posterior score of the call. It is not necessarily the same as the <code class="docutils literal notranslate"><span class="pre">QUAL</span></code> column score.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">GQD</span></code></td>
-<td>The genotype quality divided by the read depth of the sample.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">GQD</span></code></p></td>
+<td><p>The genotype quality divided by the read depth of the sample.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">QD</span></code></td>
-<td>The quality field divided by the sum of the read depth for all samples.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">QD</span></code></p></td>
+<td><p>The quality field divided by the sum of the read depth for all samples.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">DN</span></code></td>
-<td>Indicates with a value of <code class="docutils literal notranslate"><span class="pre">Y</span></code> if the call for this sample is a putative <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> mutation, or <code class="docutils literal notranslate"><span class="pre">N</span></code> to indicate that the sample is not a <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> mutation. Note that even in cases when the <code class="docutils literal notranslate"><span class="pre">GT</span></code> of the sample and the parents would otherwise seem to indicate a <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> mutation, this field may be set to <code class="docutils literal notranslate"><span class="pre">N</span></code> when the variant caller has assigned a sufficiently low score to the likelihood that a <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> event has occurred.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">DN</span></code></p></td>
+<td><p>Indicates with a value of <code class="docutils literal notranslate"><span class="pre">Y</span></code> if the call for this sample is a putative <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> mutation, or <code class="docutils literal notranslate"><span class="pre">N</span></code> to indicate that the sample is not a <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> mutation. Note that even in cases when the <code class="docutils literal notranslate"><span class="pre">GT</span></code> of the sample and the parents would otherwise seem to indicate a <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> mutation, this field may be set to <code class="docutils literal notranslate"><span class="pre">N</span></code> when the variant caller has assigned a sufficiently low score to the likelihood that a <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> event has occurred.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">DNP</span></code></td>
-<td>The Phred scaled probability that the call for this sample is due to a <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> mutation.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">DNP</span></code></p></td>
+<td><p>The Phred scaled probability that the call for this sample is due to a <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> mutation.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">OCOC</span></code></td>
-<td><p class="first">The count of evidence that is considered contrary to the call made for this sample, observed in the original sample.</p>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">OCOC</span></code></p></td>
+<td><p>The count of evidence that is considered contrary to the call made for this sample, observed in the original sample.</p>
 <p>For example, in a normal-cancer somatic call of 0/0 -&gt; 1/0, the <code class="docutils literal notranslate"><span class="pre">OCOC</span></code> value is the count of the somatic (1) allele in the normal sample.</p>
-<p class="last">Usually a high <code class="docutils literal notranslate"><span class="pre">OCOC</span></code> value indicates an unreliable call.</p>
+<p>Usually a high <code class="docutils literal notranslate"><span class="pre">OCOC</span></code> value indicates an unreliable call.</p>
 </td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">OCOF</span></code></td>
-<td><p class="first">The fraction of evidence that is considered contrary to the call made for this sample, observed in the original sample.</p>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">OCOF</span></code></p></td>
+<td><p>The fraction of evidence that is considered contrary to the call made for this sample, observed in the original sample.</p>
 <p>For example, in a somatic call of 0/0 -&gt; 1/0, the <code class="docutils literal notranslate"><span class="pre">OCOF</span></code> value is the fraction of the somatic (1) allele in the normal sample.</p>
 <p>The <code class="docutils literal notranslate"><span class="pre">OCOF</span></code> and <code class="docutils literal notranslate"><span class="pre">OCOC</span></code> attributes are also applicable to <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> calls, where the evidence in the parents for the <code class="docutils literal notranslate"><span class="pre">de</span> <span class="pre">novo</span></code> allele is considered contrary.</p>
-<p class="last">Usually a high <code class="docutils literal notranslate"><span class="pre">OCOF</span></code> value indicates an unreliable call.</p>
+<p>Usually a high <code class="docutils literal notranslate"><span class="pre">OCOF</span></code> value indicates an unreliable call.</p>
 </td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">DCOC</span></code></td>
-<td><p class="first">The count of evidence that is considered contrary to the call made for this sample, observed in the derived sample.</p>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">DCOC</span></code></p></td>
+<td><p>The count of evidence that is considered contrary to the call made for this sample, observed in the derived sample.</p>
 <p>For example, in a normal-cancer somatic call of 0/1 -&gt; 2/0, the <code class="docutils literal notranslate"><span class="pre">DCOC</span></code> value is the count of the germline (1) allele in the somatic sample.</p>
-<p class="last">In cases of high sample purity, a high <code class="docutils literal notranslate"><span class="pre">DCOC</span></code> value may indicate an unreliable call.</p>
+<p>In cases of high sample purity, a high <code class="docutils literal notranslate"><span class="pre">DCOC</span></code> value may indicate an unreliable call.</p>
 </td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">DCOF</span></code></td>
-<td><p class="first">The fraction of evidence that is considered contrary to the call made for this sample, observed in the derived sample.</p>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">DCOF</span></code></p></td>
+<td><p>The fraction of evidence that is considered contrary to the call made for this sample, observed in the derived sample.</p>
 <p>For example, in a somatic call of 0/1 -&gt; 2/0, the <code class="docutils literal notranslate"><span class="pre">DCOF</span></code> value is the fraction of the germline (1) allele in the somatic sample.</p>
 <p>The <code class="docutils literal notranslate"><span class="pre">DCOF</span></code> and <code class="docutils literal notranslate"><span class="pre">DCOC</span></code> attributes are also applicable to pedigree aware calls, where the evidence of non-inherited parental alleles in the child is considered contrary.</p>
-<p class="last">In cases of high sample purity, a high <code class="docutils literal notranslate"><span class="pre">DCOF</span></code> value may indicate an unreliable call.</p>
+<p>In cases of high sample purity, a high <code class="docutils literal notranslate"><span class="pre">DCOF</span></code> value may indicate an unreliable call.</p>
 </td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">ABP</span></code></td>
-<td>The Phred scaled probability that allele imbalance is present in the call.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">ABP</span></code></p></td>
+<td><p>The Phred scaled probability that allele imbalance is present in the call.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">SBP</span></code></td>
-<td>The Phred scaled probability that strand bias is present in the call.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">SBP</span></code></p></td>
+<td><p>The Phred scaled probability that strand bias is present in the call.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RPB</span></code></td>
-<td>The Phred scaled probability that read position bias is present in the call.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RPB</span></code></p></td>
+<td><p>The Phred scaled probability that read position bias is present in the call.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">PPB</span></code></td>
-<td>The Phred scaled probability that bias in the proportion of alignments that are properly paired is present in the call.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">PPB</span></code></p></td>
+<td><p>The Phred scaled probability that bias in the proportion of alignments that are properly paired is present in the call.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">PUR</span></code></td>
-<td>The ratio of placed unmapped reads to mapped reads.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">PUR</span></code></p></td>
+<td><p>The ratio of placed unmapped reads to mapped reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">RS</span></code></td>
-<td>Statistical information about the evidence for the prediction which consists of a variable number of groups of three fields, each separated by commas. The three fields are allele, count, and the sum of probability error (computed from the Phred quality). The sum of counts should equal DP and the sum of the errors should equal <code class="docutils literal notranslate"><span class="pre">RE</span></code>.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">RS</span></code></p></td>
+<td><p>Statistical information about the evidence for the prediction which consists of a variable number of groups of three fields, each separated by commas. The three fields are allele, count, and the sum of probability error (computed from the Phred quality). The sum of counts should equal DP and the sum of the errors should equal <code class="docutils literal notranslate"><span class="pre">RE</span></code>.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">DH</span></code></td>
-<td>An alternative disagreeing hypothesis in the same format as the genotype field. This can occur when a sample intersects multiple families in a pedigree when doing population calling.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">DH</span></code></p></td>
+<td><p>An alternative disagreeing hypothesis in the same format as the genotype field. This can occur when a sample intersects multiple families in a pedigree when doing population calling.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">AD</span></code></td>
-<td>The allelic depths for the reference and alternate alleles in the order listed.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">AD</span></code></p></td>
+<td><p>The allelic depths for the reference and alternate alleles in the order listed.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">ADE</span></code></td>
-<td>The allelic depths for the reference and alternate alleles in the order listed, after adjusting for poor base quality and mapping quality.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">ADE</span></code></p></td>
+<td><p>The allelic depths for the reference and alternate alleles in the order listed, after adjusting for poor base quality and mapping quality.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">ADF</span></code></td>
-<td>The allelic depths for the reference and alternate alleles in the order listed, for reads on the forward strand.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">ADF</span></code></p></td>
+<td><p>The allelic depths for the reference and alternate alleles in the order listed, for reads on the forward strand.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">ADR</span></code></td>
-<td>The allelic depths for the reference and alternate alleles in the order listed, for reads on the reverse strand.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">ADR</span></code></p></td>
+<td><p>The allelic depths for the reference and alternate alleles in the order listed, for reads on the reverse strand.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">ADF1</span></code></td>
-<td>The allelic depths for the reference and alternate alleles in the order listed, for arm 1 reads on the forward strand.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">ADF1</span></code></p></td>
+<td><p>The allelic depths for the reference and alternate alleles in the order listed, for arm 1 reads on the forward strand.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">ADF2</span></code></td>
-<td>The allelic depths for the reference and alternate alleles in the order listed, for arm 2 reads on the forward strand.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">ADF2</span></code></p></td>
+<td><p>The allelic depths for the reference and alternate alleles in the order listed, for arm 2 reads on the forward strand.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">ADR1</span></code></td>
-<td>The allelic depths for the reference and alternate alleles in the order listed, for arm 1 reads on the reverse strand.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">ADR1</span></code></p></td>
+<td><p>The allelic depths for the reference and alternate alleles in the order listed, for arm 1 reads on the reverse strand.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">ADR2</span></code></td>
-<td>The allelic depths for the reference and alternate alleles in the order listed, for arm 2 reads on the reverse strand.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">ADR2</span></code></p></td>
+<td><p>The allelic depths for the reference and alternate alleles in the order listed, for arm 2 reads on the reverse strand.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">AQ</span></code></td>
-<td>The sum of the quality of evidence (including base quality and mapping quality) for the reference and alternate alleles in the order listed.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">AQ</span></code></p></td>
+<td><p>The sum of the quality of evidence (including base quality and mapping quality) for the reference and alternate alleles in the order listed.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">MEANQAD</span></code></td>
-<td>The difference in the mean <code class="docutils literal notranslate"><span class="pre">AQ</span></code> between the two called alleles.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">MEANQAD</span></code></p></td>
+<td><p>The difference in the mean <code class="docutils literal notranslate"><span class="pre">AQ</span></code> between the two called alleles.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">SSC</span></code></td>
-<td>The score for the somatic mutation specified by the <code class="docutils literal notranslate"><span class="pre">GT</span></code> field.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">SSC</span></code></p></td>
+<td><p>The score for the somatic mutation specified by the <code class="docutils literal notranslate"><span class="pre">GT</span></code> field.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">SS</span></code></td>
-<td>The somatic status of the genotype for this sample. A value of 0 indicates none or wild type, a value of 1 indicates a germline variant, and a value of 2 indicates a somatic variant.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">SS</span></code></p></td>
+<td><p>The somatic status of the genotype for this sample. A value of 0 indicates none or wild type, a value of 1 indicates a germline variant, and a value of 2 indicates a somatic variant.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">GL</span></code></td>
-<td>The log10 scaled likelihoods for all possible genotypes given the set of alleles defined in the <code class="docutils literal notranslate"><span class="pre">REF</span></code> and <code class="docutils literal notranslate"><span class="pre">ALT</span></code> fields as defined in the VCF specifications.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">GL</span></code></p></td>
+<td><p>The log10 scaled likelihoods for all possible genotypes given the set of alleles defined in the <code class="docutils literal notranslate"><span class="pre">REF</span></code> and <code class="docutils literal notranslate"><span class="pre">ALT</span></code> fields as defined in the VCF specifications.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">VAF</span></code></td>
-<td>The <code class="docutils literal notranslate"><span class="pre">VAF</span></code> field contains the estimated variant allelic fraction of each alternate allele, in the order listed.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">VAF</span></code></p></td>
+<td><p>The <code class="docutils literal notranslate"><span class="pre">VAF</span></code> field contains the estimated variant allelic fraction of each alternate allele, in the order listed.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">VAF1</span></code></td>
-<td>The <code class="docutils literal notranslate"><span class="pre">VAF1</span></code> field contains the estimated variant allelic fraction of the most abundant non-reference allele. This attribute may be more suitable for AVR model building and filtering than the multi-valued <code class="docutils literal notranslate"><span class="pre">VAF</span></code> annotation.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">VAF1</span></code></p></td>
+<td><p>The <code class="docutils literal notranslate"><span class="pre">VAF1</span></code> field contains the estimated variant allelic fraction of the most abundant non-reference allele. This attribute may be more suitable for AVR model building and filtering than the multi-valued <code class="docutils literal notranslate"><span class="pre">VAF</span></code> annotation.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">IC</span></code></td>
-<td>The inbreeding coefficient for the site.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">IC</span></code></p></td>
+<td><p>The inbreeding coefficient for the site.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">EP</span></code></td>
-<td>The Phred scaled probability that the site is not in Hardy-Weinberg equilibrium.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">EP</span></code></p></td>
+<td><p>The Phred scaled probability that the site is not in Hardy-Weinberg equilibrium.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">LAL</span></code></td>
-<td>The length of the longest allele for the site.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">LAL</span></code></p></td>
+<td><p>The length of the longest allele for the site.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">NAA</span></code></td>
-<td>The number of alternate alleles for the site.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">NAA</span></code></p></td>
+<td><p>The number of alternate alleles for the site.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">PD</span></code></td>
-<td>The ploidy of the sample.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">PD</span></code></p></td>
+<td><p>The ploidy of the sample.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">ZY</span></code></td>
-<td>The zygosity of the sample.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">ZY</span></code></p></td>
+<td><p>The zygosity of the sample.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">RA</span></code></td>
-<td>Categorizes the call as hom-ref (<code class="docutils literal notranslate"><span class="pre">RR</span></code>), hom-alt (<code class="docutils literal notranslate"><span class="pre">AA</span></code>), het-ref (<code class="docutils literal notranslate"><span class="pre">RA</span></code>), or het-alt (<code class="docutils literal notranslate"><span class="pre">AB</span></code>), independent of phase or ALT allele indices.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">RA</span></code></p></td>
+<td><p>Categorizes the call as hom-ref (<code class="docutils literal notranslate"><span class="pre">RR</span></code>), hom-alt (<code class="docutils literal notranslate"><span class="pre">AA</span></code>), het-ref (<code class="docutils literal notranslate"><span class="pre">RA</span></code>), or het-alt (<code class="docutils literal notranslate"><span class="pre">AB</span></code>), independent of phase or ALT allele indices.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">QA</span></code></td>
-<td>Sum of quality of the alternate observations.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">QA</span></code></p></td>
+<td><p>Sum of quality of the alternate observations.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">CLUS</span></code></td>
-<td>The number of variants in this sample within five bases of the current variant.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">CLUS</span></code></p></td>
+<td><p>The number of variants in this sample within five bases of the current variant.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">AVR</span></code></td>
-<td>The adaptive variant rescoring value. It is a value between 0 and 1 that represents the probability that the variant for the sample is correct.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">AVR</span></code></p></td>
+<td><p>The adaptive variant rescoring value. It is a value between 0 and 1 that represents the probability that the variant for the sample is correct.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1349,43 +1264,43 @@ <h3>Regions BED output file description<a class="headerlink" href="#regions-bed-
 </div>
 <p>The columns in order are:</p>
 <ol class="arabic simple">
-<li>Sequence name</li>
-<li>Region start, counting from 0</li>
-<li>Region end, counting from 0, not inclusive</li>
-<li>Name of the region type</li>
+<li><p>Sequence name</p></li>
+<li><p>Region start, counting from 0</p></li>
+<li><p>Region end, counting from 0, not inclusive</p></li>
+<li><p>Name of the region type</p></li>
 </ol>
 <p>Table : Region type names</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="35%" />
-<col width="65%" />
+<col style="width: 35%" />
+<col style="width: 65%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Value</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Value</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">complex-called</span></code></td>
-<td>Complex regions that were called using complex calling.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">complex-called</span></code></p></td>
+<td><p>Complex regions that were called using complex calling.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">hyper-complex</span></code></td>
-<td>Long complex regions for which no call attempt was made.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">hyper-complex</span></code></p></td>
+<td><p>Long complex regions for which no call attempt was made.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">extreme-coverage</span></code></td>
-<td>No calls made in this region due to extreme coverage.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">extreme-coverage</span></code></p></td>
+<td><p>No calls made in this region due to extreme coverage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">complex-over-coverage</span></code></td>
-<td>Complex region has greater than the maximum coverage allowed.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">complex-over-coverage</span></code></p></td>
+<td><p>Complex region has greater than the maximum coverage allowed.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">complex-no-hypotheses</span></code></td>
-<td>No hypotheses could be created for the complex region.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">complex-no-hypotheses</span></code></p></td>
+<td><p>No hypotheses could be created for the complex region.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">complex-no-variant</span></code></td>
-<td>Complex region evaluation resulted in no variants.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">complex-no-variant</span></code></p></td>
+<td><p>Complex region evaluation resulted in no variants.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">complex-too-many-hypotheses</span></code></td>
-<td>Complex region had too many hypotheses for evaluation.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">complex-too-many-hypotheses</span></code></p></td>
+<td><p>Complex region had too many hypotheses for evaluation.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1404,34 +1319,34 @@ <h3>SV command output file descriptions<a class="headerlink" href="#sv-command-o
 </pre></div>
 </div>
 <p>Table : SV_INTERESTING.BED file output column descriptions</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="20%" />
-<col width="80%" />
+<col style="width: 20%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Column</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Column</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">chr</span></code></td>
-<td>The chromosome name.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">chr</span></code></p></td>
+<td><p>The chromosome name.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">start</span></code></td>
-<td>The start position in the reference chromosome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">start</span></code></p></td>
+<td><p>The start position in the reference chromosome.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">end</span></code></td>
-<td>The end position in the reference chromosome.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">end</span></code></p></td>
+<td><p>The end position in the reference chromosome.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">areas</span></code></td>
-<td>The number of distinct model areas contained in the region.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">areas</span></code></p></td>
+<td><p>The number of distinct model areas contained in the region.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">maxscore</span></code></td>
-<td>The maximum score reached by a model in the given region.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">maxscore</span></code></p></td>
+<td><p>The maximum score reached by a model in the given region.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">average</span></code></td>
-<td>The average score for the model areas covered by this region.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">average</span></code></p></td>
+<td><p>The average score for the model areas covered by this region.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1455,52 +1370,52 @@ <h3>SV command output file descriptions<a class="headerlink" href="#sv-command-o
 </pre></div>
 </div>
 <p>Table : SV_BAYESIAN.TSV file output column descriptions</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="12%" />
-<col width="88%" />
+<col style="width: 12%" />
+<col style="width: 88%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Column</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Column</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">template-name</span></code></td>
-<td>The chromosome name.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">template-name</span></code></p></td>
+<td><p>The chromosome name.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">position</span></code></td>
-<td>The position in the reference chromosome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">position</span></code></p></td>
+<td><p>The position in the reference chromosome.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">normal</span></code></td>
-<td>The prediction strength for the normal model.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">normal</span></code></p></td>
+<td><p>The prediction strength for the normal model.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">duplicate</span></code></td>
-<td>The prediction strength for the duplicate model.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">duplicate</span></code></p></td>
+<td><p>The prediction strength for the duplicate model.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">delete</span></code></td>
-<td>The prediction strength for the delete model.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">delete</span></code></p></td>
+<td><p>The prediction strength for the delete model.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">delete-left</span></code></td>
-<td>The prediction strength for the delete-left model.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">delete-left</span></code></p></td>
+<td><p>The prediction strength for the delete-left model.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">delete-right</span></code></td>
-<td>The prediction strength for the delete-right model.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">delete-right</span></code></p></td>
+<td><p>The prediction strength for the delete-right model.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">duplicate-left</span></code></td>
-<td>The prediction strength for the duplicate-left model.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">duplicate-left</span></code></p></td>
+<td><p>The prediction strength for the duplicate-left model.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">duplicate-right</span></code></td>
-<td>The prediction strength for the duplicate-right model.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">duplicate-right</span></code></p></td>
+<td><p>The prediction strength for the duplicate-right model.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">breakpoint</span></code></td>
-<td>The prediction strength for the breakpoint model.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">breakpoint</span></code></p></td>
+<td><p>The prediction strength for the breakpoint model.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">novel-insertion</span></code></td>
-<td>The prediction strength for the novel-insertion model.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">novel-insertion</span></code></p></td>
+<td><p>The prediction strength for the novel-insertion model.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">max-index</span></code></td>
-<td>The index of the model that has the maximum prediction strength for this line. The index starts from 0 meaning normal and is in the same order as the model columns.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">max-index</span></code></p></td>
+<td><p>The index of the model that has the maximum prediction strength for this line. The index starts from 0 meaning normal and is in the same order as the model columns.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1527,52 +1442,52 @@ <h3>SV command output file descriptions<a class="headerlink" href="#sv-command-o
 </pre></div>
 </div>
 <p>Table : SV_SIMPLE.TSV file output column descriptions</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="26%" />
-<col width="74%" />
+<col style="width: 26%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Column</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Column</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">template-name</span></code></td>
-<td>The chromosome name.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">template-name</span></code></p></td>
+<td><p>The chromosome name.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">position</span></code></td>
-<td>The position in the reference chromosome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">position</span></code></p></td>
+<td><p>The position in the reference chromosome.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">proper-left</span></code></td>
-<td>Count of properly paired left reads mapped in this location.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">proper-left</span></code></p></td>
+<td><p>Count of properly paired left reads mapped in this location.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">discordant-left</span></code></td>
-<td>Count of discordantly paired left reads mapped in this location.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">discordant-left</span></code></p></td>
+<td><p>Count of discordantly paired left reads mapped in this location.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">unmated-left</span></code></td>
-<td>Count of unmated left reads mapped in this location.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">unmated-left</span></code></p></td>
+<td><p>Count of unmated left reads mapped in this location.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">proper-right</span></code></td>
-<td>Count of properly paired right reads mapped in this location.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">proper-right</span></code></p></td>
+<td><p>Count of properly paired right reads mapped in this location.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">discordant-right</span></code></td>
-<td>Count of discordantly paired right reads mapped in this location.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">discordant-right</span></code></p></td>
+<td><p>Count of discordantly paired right reads mapped in this location.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">unmated-right</span></code></td>
-<td>Count of unmated right reads mapped in this location.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">unmated-right</span></code></p></td>
+<td><p>Count of unmated right reads mapped in this location.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">not-paired</span></code></td>
-<td>Count of single end reads mapped in this location.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">not-paired</span></code></p></td>
+<td><p>Count of single end reads mapped in this location.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">unique</span></code></td>
-<td>Count of unique mappings in this location.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">unique</span></code></p></td>
+<td><p>Count of unique mappings in this location.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">ambiguous</span></code></td>
-<td>Count of ambiguous mappings in this location.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">ambiguous</span></code></p></td>
+<td><p>Count of ambiguous mappings in this location.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">n-count</span></code></td>
-<td>The number of unknown bases on the reference for this location.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">n-count</span></code></p></td>
+<td><p>The number of unknown bases on the reference for this location.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1584,8 +1499,8 @@ <h3>Discord command output file descriptions<a class="headerlink" href="#discord
 a VCF file called <code class="docutils literal notranslate"><span class="pre">discord_pairs.vcf.gz</span></code> using the <code class="docutils literal notranslate"><span class="pre">ALT</span></code> and <code class="docutils literal notranslate"><span class="pre">INFO</span></code>
 fields as defined in the VCF specification.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">RTG structural variant calls are stored in VCF format
+<p class="admonition-title">Note</p>
+<p>RTG structural variant calls are stored in VCF format
 (version 4.2). For more information about the VCF format, refer to the
 specification online at:
 <a class="reference external" href="https://samtools.github.io/hts-specs/VCFv4.2.pdf">https://samtools.github.io/hts-specs/VCFv4.2.pdf</a></p>
@@ -1614,39 +1529,39 @@ <h3>Discord command output file descriptions<a class="headerlink" href="#discord
 its unique structural variant calling features, described in the tables
 below.</p>
 <p>Table : RTG VCF file FILTER fields</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="19%" />
-<col width="81%" />
+<col style="width: 19%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Value</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Value</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">PASS</span></code></td>
-<td>Standard VCF “PASS”, if breakend meets all the filtering criteria.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">PASS</span></code></p></td>
+<td><p>Standard VCF “PASS”, if breakend meets all the filtering criteria.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">INCONSISTENT</span></code></td>
-<td>Breakend with discordant read cluster that does not agree on the possible positions.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">INCONSISTENT</span></code></p></td>
+<td><p>Breakend with discordant read cluster that does not agree on the possible positions.</p></td>
 </tr>
 </tbody>
 </table>
 <p>Table : RTG VCF file INFO fields</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="17%" />
-<col width="83%" />
+<col style="width: 17%" />
+<col style="width: 83%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Value</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Value</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">DP=&lt;depth&gt;</span></code></td>
-<td>Indicates the number of discordant reads contributing to the cluster at this breakend.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">DP=&lt;depth&gt;</span></code></p></td>
+<td><p>Indicates the number of discordant reads contributing to the cluster at this breakend.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1667,11 +1582,11 @@ <h3>Discord command output file descriptions<a class="headerlink" href="#discord
 </div>
 <p>The columns in the example are in BED file order:</p>
 <ol class="arabic simple">
-<li>Chromosome name</li>
-<li>Start position in chromosome</li>
-<li>End position in chromosome</li>
-<li>Location of remote break-end matching this one</li>
-<li>Count of discordant reads contributing to the break-end</li>
+<li><p>Chromosome name</p></li>
+<li><p>Start position in chromosome</p></li>
+<li><p>End position in chromosome</p></li>
+<li><p>Location of remote break-end matching this one</p></li>
+<li><p>Count of discordant reads contributing to the break-end</p></li>
 </ol>
 </div>
 <div class="section" id="coverage-command-output-file-descriptions">
@@ -1710,11 +1625,11 @@ <h3>Coverage command output file descriptions<a class="headerlink" href="#covera
 </div>
 <p>The columns in the example are in BED file order:</p>
 <ol class="arabic simple">
-<li>Chromosome name</li>
-<li>Start position in chromosome</li>
-<li>End position in chromosome</li>
-<li>Name or label of the feature, this is generally the name of the chromosome or name of any BED features overlapping the coverage region</li>
-<li>Depth of coverage for the range specified</li>
+<li><p>Chromosome name</p></li>
+<li><p>Start position in chromosome</p></li>
+<li><p>End position in chromosome</p></li>
+<li><p>Name or label of the feature, this is generally the name of the chromosome or name of any BED features overlapping the coverage region</p></li>
+<li><p>Depth of coverage for the range specified</p></li>
 </ol>
 <p>When the <code class="docutils literal notranslate"><span class="pre">--per-region</span></code> flag is set, the <code class="docutils literal notranslate"><span class="pre">coverage</span></code> command will alter
 the criteria for outputting a BED record. Rather than defining regions
@@ -1750,10 +1665,10 @@ <h3>Coverage command output file descriptions<a class="headerlink" href="#covera
 </div>
 <p>The columns in the example are in BEDGRAPH file order:</p>
 <ol class="arabic simple">
-<li>Chromosome name</li>
-<li>Start position in chromosome</li>
-<li>End position in chromosome</li>
-<li>Depth of coverage for the range specified</li>
+<li><p>Chromosome name</p></li>
+<li><p>Start position in chromosome</p></li>
+<li><p>End position in chromosome</p></li>
+<li><p>Depth of coverage for the range specified</p></li>
 </ol>
 <p>When the <code class="docutils literal notranslate"><span class="pre">--per-base</span></code> flag is set when running the <code class="docutils literal notranslate"><span class="pre">coverage</span></code> command
 will produce a tab separated value file with the coverage information
@@ -1776,31 +1691,31 @@ <h3>Coverage command output file descriptions<a class="headerlink" href="#covera
 </pre></div>
 </div>
 <p>Table : COVERAGE.TSV file output column descriptions</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="21%" />
-<col width="79%" />
+<col style="width: 21%" />
+<col style="width: 79%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Column</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Column</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">sequence</span></code></td>
-<td>The chromosome name.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">sequence</span></code></p></td>
+<td><p>The chromosome name.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">position</span></code></td>
-<td>The position in the reference chromosome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">position</span></code></p></td>
+<td><p>The position in the reference chromosome.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">unique-count</span></code></td>
-<td>The count of reads covering this position with <code class="docutils literal notranslate"><span class="pre">IH</span></code> equal to one.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">unique-count</span></code></p></td>
+<td><p>The count of reads covering this position with <code class="docutils literal notranslate"><span class="pre">IH</span></code> equal to one.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">ambiguous-count</span></code></td>
-<td>The count of reads covering this position with <code class="docutils literal notranslate"><span class="pre">IH</span></code> greater than one.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">ambiguous-count</span></code></p></td>
+<td><p>The count of reads covering this position with <code class="docutils literal notranslate"><span class="pre">IH</span></code> greater than one.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">score</span></code></td>
-<td>The sum of one divided by the <code class="docutils literal notranslate"><span class="pre">IH</span></code> value for all the reads covering this position.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">score</span></code></p></td>
+<td><p>The sum of one divided by the <code class="docutils literal notranslate"><span class="pre">IH</span></code> value for all the reads covering this position.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1822,31 +1737,31 @@ <h3>Coverage command output file descriptions<a class="headerlink" href="#covera
 </pre></div>
 </div>
 <p>Table : STATS.TSV column descriptions</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="11%" />
-<col width="89%" />
+<col style="width: 11%" />
+<col style="width: 89%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Column</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Column</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">depth</span></code></td>
-<td>The average depth of coverage for the region where each base position is calculated as the sum of one divided by the IH of each read alignment which covers the position.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">depth</span></code></p></td>
+<td><p>The average depth of coverage for the region where each base position is calculated as the sum of one divided by the IH of each read alignment which covers the position.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">breadth</span></code></td>
-<td>The fraction of the non-N region base positions which have a depth of one or greater.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">breadth</span></code></p></td>
+<td><p>The fraction of the non-N region base positions which have a depth of one or greater.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">covered</span></code></td>
-<td>The number of non-N bases in the region which have a depth of one or greater.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">covered</span></code></p></td>
+<td><p>The number of non-N bases in the region which have a depth of one or greater.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">size</span></code></td>
-<td>The number of non-N bases in the region.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">size</span></code></p></td>
+<td><p>The number of non-N bases in the region.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">name</span></code></td>
-<td>The name of the region, or “all sequences” for the entire reference.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">name</span></code></p></td>
+<td><p>The name of the region, or “all sequences” for the entire reference.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1866,28 +1781,28 @@ <h3>Coverage command output file descriptions<a class="headerlink" href="#covera
 </pre></div>
 </div>
 <p>Table : LEVELS.TSV column descriptions</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="25%" />
-<col width="75%" />
+<col style="width: 25%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Column</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Column</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">coverage_level</span></code></td>
-<td>The coverage level.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">coverage_level</span></code></p></td>
+<td><p>The coverage level.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">count</span></code></td>
-<td>The count of the number of bases at this coverage level.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">count</span></code></p></td>
+<td><p>The count of the number of bases at this coverage level.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">%age</span></code></td>
-<td>The percentage of the reference at this coverage level.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">%age</span></code></p></td>
+<td><p>The percentage of the reference at this coverage level.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">%cumulative</span></code></td>
-<td>The percentage of the reference at this coverage level or higher.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">%cumulative</span></code></p></td>
+<td><p>The percentage of the reference at this coverage level or higher.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1913,83 +1828,83 @@ <h3>Mapx and mapp output file description<a class="headerlink" href="#mapx-and-m
 <p>The following table provides descriptions of each column in this alignment
 output file format, listed from left to right.</p>
 <p>Table : ALIGNMENTS.TSV file output column descriptions</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="92%" />
+<col style="width: 8%" />
+<col style="width: 92%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Column</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Column</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">template-name</span></code></td>
-<td>ID or description of protein (reference) with match.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">template-name</span></code></p></td>
+<td><p>ID or description of protein (reference) with match.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">frame</span></code></td>
-<td>Denotes translation frame on forward (1,2,3) or reverse strand.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">frame</span></code></p></td>
+<td><p>Denotes translation frame on forward (1,2,3) or reverse strand.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">read-id</span></code></td>
-<td>Numeric ID of query sequence from SDF.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">read-id</span></code></p></td>
+<td><p>Numeric ID of query sequence from SDF.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">template-start</span></code></td>
-<td>Start position of alignment on protein subject.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">template-start</span></code></p></td>
+<td><p>Start position of alignment on protein subject.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">template-end</span></code></td>
-<td>End position of alignment on protein subject.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">template-end</span></code></p></td>
+<td><p>End position of alignment on protein subject.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">template-length</span></code></td>
-<td>Amino acid length of protein subject.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">template-length</span></code></p></td>
+<td><p>Amino acid length of protein subject.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">read-start</span></code></td>
-<td>Start position of alignment on query sequence.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">read-start</span></code></p></td>
+<td><p>Start position of alignment on query sequence.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">read-end</span></code></td>
-<td>End position of alignment on query sequence.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">read-end</span></code></p></td>
+<td><p>End position of alignment on query sequence.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">read-length</span></code></td>
-<td>Total length of query (nucleotides for <code class="docutils literal notranslate"><span class="pre">mapx</span></code> / amino acids for <code class="docutils literal notranslate"><span class="pre">mapp</span></code>).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">read-length</span></code></p></td>
+<td><p>Total length of query (nucleotides for <code class="docutils literal notranslate"><span class="pre">mapx</span></code> / amino acids for <code class="docutils literal notranslate"><span class="pre">mapp</span></code>).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">template-protein</span></code></td>
-<td>Amino acid sequence of aligned protein reference.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">template-protein</span></code></p></td>
+<td><p>Amino acid sequence of aligned protein reference.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">read-protein</span></code></td>
-<td>Amino acid sequence of aligned query sequence.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">read-protein</span></code></p></td>
+<td><p>Amino acid sequence of aligned query sequence.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">alignment</span></code></td>
-<td>Amino acid alignment of match.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">alignment</span></code></p></td>
+<td><p>Amino acid alignment of match.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">identical</span></code></td>
-<td>Count of identities in alignment between protein subject and query sequences.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">identical</span></code></p></td>
+<td><p>Count of identities in alignment between protein subject and query sequences.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">%identical</span></code></td>
-<td>Percent identity of match between protein subject and query sequences, for exact matches only (global across query sequence).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">%identical</span></code></p></td>
+<td><p>Percent identity of match between protein subject and query sequences, for exact matches only (global across query sequence).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">positive</span></code></td>
-<td>Count of identical and similar amino acids in alignment between protein subject and query sequences.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">positive</span></code></p></td>
+<td><p>Count of identical and similar amino acids in alignment between protein subject and query sequences.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">%positive</span></code></td>
-<td>Percent similarity between protein subject and query sequences, for exact and similar matches (global across query sequence).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">%positive</span></code></p></td>
+<td><p>Percent similarity between protein subject and query sequences, for exact and similar matches (global across query sequence).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">mismatches</span></code></td>
-<td>Count of mismatches between protein subject and query sequences.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">mismatches</span></code></p></td>
+<td><p>Count of mismatches between protein subject and query sequences.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">raw-score</span></code></td>
-<td>RTG alignment score (S); The alignment score is the negated sum of all single protein raw scores plus its penalties for gaps, which is the edit distance using one of the scoring matrices. Note that the RTG alignment score is the negated raw score of BLAST.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">raw-score</span></code></p></td>
+<td><p>RTG alignment score (S); The alignment score is the negated sum of all single protein raw scores plus its penalties for gaps, which is the edit distance using one of the scoring matrices. Note that the RTG alignment score is the negated raw score of BLAST.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">bit-score</span></code></td>
-<td><p class="first">Bit score is computed from the alignment score using the following formula:
-<img class="math" src="_images/math/4b0ffe0e53244b2c1bff21382be9a5ab326276d1.png" alt="\text{bit-score} = ((\lambda \times -S) - \ln (K)) / \ln (2)"/></p>
-<p class="last">where <img class="math" src="_images/math/76f1d8ace30435987c01a00ca53a71cba1f40e6c.png" alt="\lambda"/> and <img class="math" src="_images/math/684381a21cd73ebbf43b63a087d3f7410ee99ce8.png" alt="K"/> are taken from the matrix defaults [Blast pp.302-304] and <img class="math" src="_images/math/1dbc400fcc213305415872f9f625cd2828f97a00.png" alt="S"/> is the RTG alignment score.</p>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">bit-score</span></code></p></td>
+<td><p>Bit score is computed from the alignment score using the following formula:
+<img class="math" src="_images/math/1dda4b44764a929f5d95a12343b22b3343e7993e.png" alt="\text{bit-score} = ((\lambda \times -S) - \ln (K)) / \ln (2)"/></p>
+<p>where <img class="math" src="_images/math/cefc603e5658facb747581f9567192993f21c7ab.png" alt="\lambda"/> and <img class="math" src="_images/math/52ddc0cde6d632f631533173562fe3ca375b1f32.png" alt="K"/> are taken from the matrix defaults [Blast pp.302-304] and <img class="math" src="_images/math/b988975be41fd13b4d091c10202ba19374643586.png" alt="S"/> is the RTG alignment score.</p>
 </td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">e-score</span></code></td>
-<td><p class="first">e-score is computed from the alignment score using the following formula:
-<img class="math" src="_images/math/60ec5a4e636f260cafc63c490e2da12d8e36b418.png" alt="\text{e-score} = K \times m' \times n \times e ^ {(\lambda \times S)}"/></p>
-<p><img class="math" src="_images/math/e11f2701c4a39c7fe543a6c4150b421d50f1c159.png" alt="n"/> is the total length of the database.</p>
-<p><img class="math" src="_images/math/24a4a3d3565eacdc678ca2e8cda9c27eac9abe6a.png" alt="m'"/> is the effective length of the query (read):</p>
-<p class="last"><img class="math" src="_images/math/28357bd43b973b6fe3b43cd8cb18a02b20d55648.png" alt="m' = \max(1, \text{querylength} + \lambda \times S/H)"/></p>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">e-score</span></code></p></td>
+<td><p>e-score is computed from the alignment score using the following formula:
+<img class="math" src="_images/math/6596b3f1d72eeb3b72dd1cdaaae199a4a3b1a412.png" alt="\text{e-score} = K \times m' \times n \times e ^ {(\lambda \times S)}"/></p>
+<p><img class="math" src="_images/math/5a939c5280da7202ca4531f175a7780ad5e1f80a.png" alt="n"/> is the total length of the database.</p>
+<p><img class="math" src="_images/math/2895eb405a03db49e2217253743e51b83144c2ac.png" alt="m'"/> is the effective length of the query (read):</p>
+<p><img class="math" src="_images/math/00b47fa9220275347363dd17597c6ce4efc96fa5.png" alt="m' = \max(1, \text{querylength} + \lambda \times S/H)"/></p>
 </td>
 </tr>
 </tbody>
@@ -2001,32 +1916,32 @@ <h3>Mapx and mapp output file description<a class="headerlink" href="#mapx-and-m
 reason the query was not mapped, with no code indicating that sequence had
 no matches.</p>
 <p>Character codes for unmapped sequences include:</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="92%" />
+<col style="width: 8%" />
+<col style="width: 92%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Character</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Character</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">d</span></code></td>
-<td>Indicates that after alignment scores are calculated, the remaining hits were discarded because they exceeded the alignment score threshold (affected by
-<code class="docutils literal notranslate"><span class="pre">--max-alignment-score</span></code>).</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">d</span></code></p></td>
+<td><p>Indicates that after alignment scores are calculated, the remaining hits were discarded because they exceeded the alignment score threshold (affected by
+<code class="docutils literal notranslate"><span class="pre">--max-alignment-score</span></code>).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">e</span></code></td>
-<td>Indicates that there were good scoring hits, but the results were discarded because there were too many of these hits (affected by <code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">e</span></code></p></td>
+<td><p>Indicates that there were good scoring hits, but the results were discarded because there were too many of these hits (affected by <code class="docutils literal notranslate"><span class="pre">--max-top-results</span></code>).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">f</span></code></td>
-<td>Indicates that there was a good hit which failed the percent identity threshold (affected by <code class="docutils literal notranslate"><span class="pre">--min-identity</span></code>).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">f</span></code></p></td>
+<td><p>Indicates that there was a good hit which failed the percent identity threshold (affected by <code class="docutils literal notranslate"><span class="pre">--min-identity</span></code>).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">g</span></code></td>
-<td>Indicates that there was a good hit which failed the e-score threshold (affected by <code class="docutils literal notranslate"><span class="pre">--max-e-score</span></code>).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">g</span></code></p></td>
+<td><p>Indicates that there was a good hit which failed the e-score threshold (affected by <code class="docutils literal notranslate"><span class="pre">--max-e-score</span></code>).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">h</span></code></td>
-<td>Indicates that there was a good hit which failed the bit score threshold (affected by <code class="docutils literal notranslate"><span class="pre">--min-bit-score</span></code>).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">h</span></code></p></td>
+<td><p>Indicates that there was a good hit which failed the bit score threshold (affected by <code class="docutils literal notranslate"><span class="pre">--min-bit-score</span></code>).</p></td>
 </tr>
 </tbody>
 </table>
@@ -2064,67 +1979,67 @@ <h3>Species results file description<a class="headerlink" href="#species-results
 <p>The following table provides descriptions of each column in the species
 output file format, listed from left to right.</p>
 <p>Table : SPECIES.TSV file output column descriptions</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="12%" />
-<col width="88%" />
+<col style="width: 12%" />
+<col style="width: 88%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Column</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Column</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">abundance</span></code></td>
-<td>Fraction of the individuals in the sample that belong to this taxon. The output file is sorted on this column.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">abundance</span></code></p></td>
+<td><p>Fraction of the individuals in the sample that belong to this taxon. The output file is sorted on this column.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">abundance-low</span></code></td>
-<td>Lower bound three standard deviations below the abundance.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">abundance-low</span></code></p></td>
+<td><p>Lower bound three standard deviations below the abundance.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">abundance-high</span></code></td>
-<td>Upper bound three standard deviations above the abundance.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">abundance-high</span></code></p></td>
+<td><p>Upper bound three standard deviations above the abundance.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">DNA-fraction</span></code></td>
-<td>Raw fraction of the DNA that maps to this taxon.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">DNA-fraction</span></code></p></td>
+<td><p>Raw fraction of the DNA that maps to this taxon.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">DNA-fraction-low</span></code></td>
-<td>Lower bound three standard deviations below the DNA-fraction.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">DNA-fraction-low</span></code></p></td>
+<td><p>Lower bound three standard deviations below the DNA-fraction.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">DNA-fraction-high</span></code></td>
-<td>Upper bound three standard deviations above the DNA-fraction.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">DNA-fraction-high</span></code></p></td>
+<td><p>Upper bound three standard deviations above the DNA-fraction.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">confidence</span></code></td>
-<td>Confidence that this taxon is present in the sample. (Computed as the number of standard deviations away from the null hypotheses).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">confidence</span></code></p></td>
+<td><p>Confidence that this taxon is present in the sample. (Computed as the number of standard deviations away from the null hypotheses).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">coverage-depth</span></code></td>
-<td>The coverage depth of reads mapped to the taxon sequences, adjusted for the <code class="docutils literal notranslate"><span class="pre">IH</span></code> (number of output alignments) of the individual reads. (Zero if no reference sequences for the taxon).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">coverage-depth</span></code></p></td>
+<td><p>The coverage depth of reads mapped to the taxon sequences, adjusted for the <code class="docutils literal notranslate"><span class="pre">IH</span></code> (number of output alignments) of the individual reads. (Zero if no reference sequences for the taxon).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">coverage-breadth</span></code></td>
-<td>The fraction of the taxon sequences covered by the reads. (Zero if no reference sequences for the taxon).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">coverage-breadth</span></code></p></td>
+<td><p>The fraction of the taxon sequences covered by the reads. (Zero if no reference sequences for the taxon).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">reference-length</span></code></td>
-<td>The total length of the reference sequences, will be 0 if the taxon does not have associated reference sequences.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">reference-length</span></code></p></td>
+<td><p>The total length of the reference sequences, will be 0 if the taxon does not have associated reference sequences.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">mapped-reads</span></code></td>
-<td>The count of the reads which mapped to this taxon, adjusted for the <code class="docutils literal notranslate"><span class="pre">IH</span></code> (number of output alignments) of the individual reads.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">mapped-reads</span></code></p></td>
+<td><p>The count of the reads which mapped to this taxon, adjusted for the <code class="docutils literal notranslate"><span class="pre">IH</span></code> (number of output alignments) of the individual reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">has-reference</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">Y</span></code> if the taxon has associated reference sequences, otherwise <code class="docutils literal notranslate"><span class="pre">N</span></code>.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">has-reference</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">Y</span></code> if the taxon has associated reference sequences, otherwise <code class="docutils literal notranslate"><span class="pre">N</span></code>.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">taxa-count</span></code></td>
-<td>The count of the number of taxa that are descendants of this taxon (including itself) and which are above the minimum confidence threshold.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">taxa-count</span></code></p></td>
+<td><p>The count of the number of taxa that are descendants of this taxon (including itself) and which are above the minimum confidence threshold.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">taxon-id</span></code></td>
-<td>The taxonomic ID for this result.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">taxon-id</span></code></p></td>
+<td><p>The taxonomic ID for this result.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">parent-id</span></code></td>
-<td>The taxonomic ID of this results parent.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">parent-id</span></code></p></td>
+<td><p>The taxonomic ID of this results parent.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">rank</span></code></td>
-<td>The taxonomic rank associated with this result. This can be used to filter results into meaningful sets at different taxonomic ranks.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">rank</span></code></p></td>
+<td><p>The taxonomic rank associated with this result. This can be used to filter results into meaningful sets at different taxonomic ranks.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">taxonomy-name</span></code></td>
-<td>The taxonomic name for this result.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">taxonomy-name</span></code></p></td>
+<td><p>The taxonomic name for this result.</p></td>
 </tr>
 </tbody>
 </table>
@@ -2137,7 +2052,7 @@ <h3>Similarity results file descriptions<a class="headerlink" href="#similarity-
 and two formats for phylogenetic trees showing relationships
 (<code class="docutils literal notranslate"><span class="pre">closest.tre</span></code> and <code class="docutils literal notranslate"><span class="pre">closest.xml</span></code>).</p>
 <p>The similarity matrix file is a tab separated format file containing an
-<img class="math" src="_images/math/0d6ecf115a0fefc045135d4dbfcfe920262c1b81.png" alt="N\times N"/> matrix of the matching <em>k</em>-mer counts, where <em>N</em> is the number of
+<img class="math" src="_images/math/9e32cdd0b4d023c3e9b3e724291a03bdbcbee572.png" alt="N\times N"/> matrix of the matching <em>k</em>-mer counts, where <em>N</em> is the number of
 samples. An example of a <code class="docutils literal notranslate"><span class="pre">similarity.tsv</span></code> file:</p>
 <div class="highlight-text notranslate"><div class="highlight"><pre><span></span>#rtg similarity --unique-words -o similarity-out -I samples.txt -w 20 -s 15
 F1_G_S_1M     F1_N_AN_1M      F1_O_BM_1M      F1_O_SP_1M      F1_O_TD_1M      F1_V_PF_1M
@@ -2191,19 +2106,19 @@ <h4>CHROM, POS, ID, REF, QUAL<a class="headerlink" href="#chrom-pos-id-ref-qual"
 <p>Within the context of a <code class="docutils literal notranslate"><span class="pre">--keep-expr</span></code> or <code class="docutils literal notranslate"><span class="pre">record</span></code> function these
 variables will provide access to the String representation of the VCF
 column of the same name.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>CHROM; // &quot;1&quot;
-POS; // &quot;11259340&quot;
-ID; // &quot;.&quot;
-REF; // &quot;G&quot;
-QUAL; // &quot;.&quot;
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">CHROM</span><span class="p">;</span> <span class="c1">// &quot;1&quot;</span>
+<span class="nx">POS</span><span class="p">;</span> <span class="c1">// &quot;11259340&quot;</span>
+<span class="nx">ID</span><span class="p">;</span> <span class="c1">// &quot;.&quot;</span>
+<span class="nx">REF</span><span class="p">;</span> <span class="c1">// &quot;G&quot;</span>
+<span class="nx">QUAL</span><span class="p">;</span> <span class="c1">// &quot;.&quot;</span>
 </pre></div>
 </div>
 </div>
 <div class="section" id="alt-filter">
 <h4>ALT, FILTER<a class="headerlink" href="#alt-filter" title="Permalink to this headline">¶</a></h4>
 <p>Will retrieve an array of the values in the column.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>ALT; // [&quot;C&quot;, &quot;T&quot;]
-FILTER; // [&quot;PASS&quot;]
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">ALT</span><span class="p">;</span> <span class="c1">// [&quot;C&quot;, &quot;T&quot;]</span>
+<span class="nx">FILTER</span><span class="p">;</span> <span class="c1">// [&quot;PASS&quot;]</span>
 </pre></div>
 </div>
 </div>
@@ -2215,8 +2130,8 @@ <h4>INFO.{INFO_FIELD}<a class="headerlink" href="#info-info-field" title="Permal
 Missing fields will be represented by “<code class="docutils literal notranslate"><span class="pre">.</span></code>”. Assigning to these
 properties will update the VCF record. This will be undefined for fields not
 declared in the header.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>INFO.DP; // &quot;795&quot;
-INFO.ABC; // &quot;4,5&quot;
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">INFO</span><span class="p">.</span><span class="nx">DP</span><span class="p">;</span> <span class="c1">// &quot;795&quot;</span>
+<span class="nx">INFO</span><span class="p">.</span><span class="nx">ABC</span><span class="p">;</span> <span class="c1">// &quot;4,5&quot;</span>
 </pre></div>
 </div>
 </div>
@@ -2226,8 +2141,8 @@ <h4>{SAMPLE_NAME}.{FORMAT_FIELD}<a class="headerlink" href="#sample-name-format-
 format fields for each sample. The string representation of values in
 the sample column are accessible as properties on the string matching
 the sample name named after the <code class="docutils literal notranslate"><span class="pre">FORMAT</span></code> field <code class="docutils literal notranslate"><span class="pre">ID</span></code>.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>&#39;NA12877&#39;.GT; // &quot;1/2&quot;
-&#39;NA12878&#39;.GT; // &quot;1/0&quot;
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="s1">&#39;NA12877&#39;</span><span class="p">.</span><span class="nx">GT</span><span class="p">;</span> <span class="c1">// &quot;1/2&quot;</span>
+<span class="s1">&#39;NA12878&#39;</span><span class="p">.</span><span class="nx">GT</span><span class="p">;</span> <span class="c1">// &quot;1/0&quot;</span>
 </pre></div>
 </div>
 <p>Note that these properties are only defined for fields that are declared
@@ -2241,20 +2156,20 @@ <h3>VCF record modification<a class="headerlink" href="#vcf-record-modification"
 <p>Most components of VCF records can be written or updated in a fairly
 natural manner by direct assignment in order to make modifications. For
 example:</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>CHROM = &quot;chr1&quot;;      // Will change the CHROM value
-POS = 42;            // Will change the POS value
-ID = &quot;rs23987382&quot;;   // Will change the ID value
-QUAL = &quot;50&quot;;         // Will change the QUAL value
-FILTER = &quot;FAIL&quot;;     // Will set the FILTER value
-INFO.DPR = &quot;0.01&quot;;   // Will change the value of the DPR info field
-&#39;NA12877&#39;.DP = &quot;10&quot;; // Will change the DP field of the NA12877 sample
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">CHROM</span> <span class="o">=</span> <span class="s2">&quot;chr1&quot;</span><span class="p">;</span>      <span class="c1">// Will change the CHROM value</span>
+<span class="nx">POS</span> <span class="o">=</span> <span class="mi">42</span><span class="p">;</span>            <span class="c1">// Will change the POS value</span>
+<span class="nx">ID</span> <span class="o">=</span> <span class="s2">&quot;rs23987382&quot;</span><span class="p">;</span>   <span class="c1">// Will change the ID value</span>
+<span class="nx">QUAL</span> <span class="o">=</span> <span class="s2">&quot;50&quot;</span><span class="p">;</span>         <span class="c1">// Will change the QUAL value</span>
+<span class="nx">FILTER</span> <span class="o">=</span> <span class="s2">&quot;FAIL&quot;</span><span class="p">;</span>     <span class="c1">// Will set the FILTER value</span>
+<span class="nx">INFO</span><span class="p">.</span><span class="nx">DPR</span> <span class="o">=</span> <span class="s2">&quot;0.01&quot;</span><span class="p">;</span>   <span class="c1">// Will change the value of the DPR info field</span>
+<span class="s1">&#39;NA12877&#39;</span><span class="p">.</span><span class="nx">DP</span> <span class="o">=</span> <span class="s2">&quot;10&quot;</span><span class="p">;</span> <span class="c1">// Will change the DP field of the NA12877 sample</span>
 </pre></div>
 </div>
 <p>Other components of the VCF record (such as <code class="docutils literal notranslate"><span class="pre">REF</span></code>,
 and <code class="docutils literal notranslate"><span class="pre">ALT</span></code>) are considered immutable and can not currently be altered.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">Modification of <code class="docutils literal notranslate"><span class="pre">CHROM</span></code> and/or <code class="docutils literal notranslate"><span class="pre">POS</span></code> can lead to a VCF file
+<p class="admonition-title">Note</p>
+<p>Modification of <code class="docutils literal notranslate"><span class="pre">CHROM</span></code> and/or <code class="docutils literal notranslate"><span class="pre">POS</span></code> can lead to a VCF file
 which is incorrectly sorted and this will not necessarily be detected
 or reported until the resulting VCF file is used with another module
 or tool.  Depending on the new value assigned to <code class="docutils literal notranslate"><span class="pre">CHROM</span></code> it may
@@ -2263,10 +2178,10 @@ <h3>VCF record modification<a class="headerlink" href="#vcf-record-modification"
 </div>
 <p>Direct assignment to <code class="docutils literal notranslate"><span class="pre">ID</span></code> and <code class="docutils literal notranslate"><span class="pre">FILTER</span></code> fields accept either a string
 containing semicolon separated values, or a list of values. For example:</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>ID = &#39;rs23987382;COSM3805&#39;;
-ID = [&#39;rs23987382&#39;, &#39;COSM3805&#39;];
-FILTER = &#39;BAZ;BANG&#39;;
-FILTER = [&#39;BAZ&#39;, &#39;BANG&#39;];
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">ID</span> <span class="o">=</span> <span class="s1">&#39;rs23987382;COSM3805&#39;</span><span class="p">;</span>
+<span class="nx">ID</span> <span class="o">=</span> <span class="p">[</span><span class="s1">&#39;rs23987382&#39;</span><span class="p">,</span> <span class="s1">&#39;COSM3805&#39;</span><span class="p">];</span>
+<span class="nx">FILTER</span> <span class="o">=</span> <span class="s1">&#39;BAZ;BANG&#39;</span><span class="p">;</span>
+<span class="nx">FILTER</span> <span class="o">=</span> <span class="p">[</span><span class="s1">&#39;BAZ&#39;</span><span class="p">,</span> <span class="s1">&#39;BANG&#39;</span><span class="p">];</span>
 </pre></div>
 </div>
 <p>Note that although the <code class="docutils literal notranslate"><span class="pre">FILTER</span></code> field returns an array when read, any
@@ -2275,16 +2190,16 @@ <h3>VCF record modification<a class="headerlink" href="#vcf-record-modification"
 <p>Adding a filter to existing filters is a common operation and can be
 accomplished by the above assignment methods, for example by adding a
 value to the existing list and then setting the result:</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>var f = FILTER;
-f.push(&#39;BOING&#39;);
-FILTER = f;
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="kd">var</span> <span class="nx">f</span> <span class="o">=</span> <span class="nx">FILTER</span><span class="p">;</span>
+<span class="nx">f</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="s1">&#39;BOING&#39;</span><span class="p">);</span>
+<span class="nx">FILTER</span> <span class="o">=</span> <span class="nx">f</span><span class="p">;</span>
 </pre></div>
 </div>
 <p>However, since this is a little unwieldy, a convenience function called
 <cite>add()</cite> can be used (and may be chained):</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>FILTER.add(&#39;BOING&#39;);
-FILTER.add([&#39;BOING&#39;, &#39;DOING&#39;);
-FILTER.add(&#39;BOING&#39;).add(&#39;DOING&#39;);
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">FILTER</span><span class="p">.</span><span class="nx">add</span><span class="p">(</span><span class="s1">&#39;BOING&#39;</span><span class="p">);</span>
+<span class="nx">FILTER</span><span class="p">.</span><span class="nx">add</span><span class="p">([</span><span class="s1">&#39;BOING&#39;</span><span class="p">,</span> <span class="s1">&#39;DOING&#39;</span><span class="p">);</span>
+<span class="nx">FILTER</span><span class="p">.</span><span class="nx">add</span><span class="p">(</span><span class="s1">&#39;BOING&#39;</span><span class="p">).</span><span class="nx">add</span><span class="p">(</span><span class="s1">&#39;DOING&#39;</span><span class="p">);</span>
 </pre></div>
 </div>
 </div>
@@ -2295,31 +2210,80 @@ <h3>VCF header modification<a class="headerlink" href="#vcf-header-modification"
 recommended that the following functions only be used within the
 run-once portion of <code class="docutils literal notranslate"><span class="pre">--javascript</span></code>.</p>
 <div class="section" id="ensureformatheader-format-header-string">
-<h4>ensureFormatHeader(FORMAT_HEADER_STRING)<a class="headerlink" href="#ensureformatheader-format-header-string" title="Permalink to this headline">¶</a></h4>
+<h4>ensureFormatHeader({FORMAT_HEADER_STRING})<a class="headerlink" href="#ensureformatheader-format-header-string" title="Permalink to this headline">¶</a></h4>
 <p>Add a new <code class="docutils literal notranslate"><span class="pre">FORMAT</span></code> field to the VCF if it is not already present. This
 will add a <code class="docutils literal notranslate"><span class="pre">FORMAT</span></code> declaration line to the header and define the
 corresponding accessor methods for use in record processing.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>ensureFormatHeader(&#39;##FORMAT=&lt;ID=GL,Number=G,Type=Float,&#39; +
-  &#39;Description=&quot;Log_10 scaled genotype likelihoods.&quot;&gt;&#39;);
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">ensureFormatHeader</span><span class="p">(</span><span class="s1">&#39;##FORMAT=&lt;ID=GL,Number=G,Type=Float,&#39;</span> <span class="o">+</span>
+  <span class="s1">&#39;Description=&quot;Log_10 scaled genotype likelihoods.&quot;&gt;&#39;</span><span class="p">);</span>
 </pre></div>
 </div>
 </div>
 <div class="section" id="ensureinfoheader-info-header-string">
-<h4>ensureInfoHeader(INFO_HEADER_STRING)<a class="headerlink" href="#ensureinfoheader-info-header-string" title="Permalink to this headline">¶</a></h4>
+<h4>ensureInfoHeader({INFO_HEADER_STRING})<a class="headerlink" href="#ensureinfoheader-info-header-string" title="Permalink to this headline">¶</a></h4>
 <p>Add a new <code class="docutils literal notranslate"><span class="pre">INFO</span></code> field to the VCF if it is not already present. This
 will add an <code class="docutils literal notranslate"><span class="pre">INFO</span></code> declaration line to the header and define the
 corresponding accessor methods for use in record processing.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>ensureInfoHeader(&#39;##INFO=&lt;ID=CT,Number=1,Type=Integer,&#39; +
-  &#39;Description=&quot;Coverage threshold that was applied&quot;&gt;&#39;);
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">ensureInfoHeader</span><span class="p">(</span><span class="s1">&#39;##INFO=&lt;ID=CT,Number=1,Type=Integer,&#39;</span> <span class="o">+</span>
+  <span class="s1">&#39;Description=&quot;Coverage threshold that was applied&quot;&gt;&#39;</span><span class="p">);</span>
 </pre></div>
 </div>
 </div>
 <div class="section" id="ensurefilterheader-filter-header-string">
-<h4>ensureFilterHeader(FILTER_HEADER_STRING)<a class="headerlink" href="#ensurefilterheader-filter-header-string" title="Permalink to this headline">¶</a></h4>
+<h4>ensureFilterHeader({FILTER_HEADER_STRING})<a class="headerlink" href="#ensurefilterheader-filter-header-string" title="Permalink to this headline">¶</a></h4>
 <p>Add a new <code class="docutils literal notranslate"><span class="pre">FILTER</span></code> field to the VCF header if it is not already
 present. This will add an <code class="docutils literal notranslate"><span class="pre">FILTER</span></code> declaration line to the header.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>ensureFilterHeader(&#39;##INFO=&lt;ID=FAIL_VAL,&#39; +
-  &#39;Description=&quot;Failed validation&quot;&gt;&#39;);
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">ensureFilterHeader</span><span class="p">(</span><span class="s1">&#39;##INFO=&lt;ID=FAIL_VAL,&#39;</span> <span class="o">+</span>
+  <span class="s1">&#39;Description=&quot;Failed validation&quot;&gt;&#39;</span><span class="p">);</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="testing-for-overlap-with-genomic-regions">
+<h3>Testing for overlap with genomic regions<a class="headerlink" href="#testing-for-overlap-with-genomic-regions" title="Permalink to this headline">¶</a></h3>
+<p>One common use case is to test whether any given VCF record overlaps or
+is contained within a set of genomic regions. Regions may be loaded from
+either an external BED file or VCF file in the run-once portion of the
+JavaScript by either of the following:</p>
+<div class="section" id="regions-frombed-filename">
+<h4>Regions.fromBed({FILENAME})<a class="headerlink" href="#regions-frombed-filename" title="Permalink to this headline">¶</a></h4>
+<p>Load the specified BED file into a <cite>regions</cite> object. For example:</p>
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="kd">var</span> <span class="nx">myregions</span> <span class="o">=</span> <span class="nx">Regions</span><span class="p">.</span><span class="nx">fromBed</span><span class="p">(</span><span class="s1">&#39;/path/to/regions.bed&#39;</span><span class="p">);</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="regions-fromvcf-filename">
+<h4>Regions.fromVcf({FILENAME})<a class="headerlink" href="#regions-fromvcf-filename" title="Permalink to this headline">¶</a></h4>
+<p>Load the specified VCF file into a <cite>regions</cite> object. For example:</p>
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="kd">var</span> <span class="nx">myregions</span> <span class="o">=</span> <span class="nx">Regions</span><span class="p">.</span><span class="nx">fromVcf</span><span class="p">(</span><span class="s1">&#39;/path/to/regions.vcf&#39;</span><span class="p">);</span>
+</pre></div>
+</div>
+<p>Having loaded a set of genomic regions, this can be used to test for
+region overlaps using the following methods:</p>
+</div>
+<div class="section" id="regions-object-overlaps-chrom-start-end">
+<h4>{REGIONS_OBJECT}.overlaps({CHROM}, {START}, {END})<a class="headerlink" href="#regions-object-overlaps-chrom-start-end" title="Permalink to this headline">¶</a></h4>
+<p>Return true if the loaded regions overlap the specified interval.  This
+function is typically used within the <code class="docutils literal notranslate"><span class="pre">record</span></code> function to test the
+coordinates of the current VCF record, e.g.:</p>
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="kd">function</span> <span class="nx">record</span><span class="p">()</span> <span class="p">{</span>
+    <span class="k">if</span> <span class="p">(</span><span class="nx">myregions</span><span class="p">.</span><span class="nx">overlaps</span><span class="p">(</span><span class="nx">CHROM</span><span class="p">,</span> <span class="nx">POS</span><span class="p">,</span> <span class="nx">POS</span> <span class="o">+</span> <span class="nx">REF</span><span class="p">.</span><span class="nx">length</span><span class="p">))</span> <span class="p">{</span>
+        <span class="c1">// do something if the record overlaps any region</span>
+    <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="regions-object-encloses-chrom-start-end">
+<h4>{REGIONS_OBJECT}.encloses({CHROM}, {START}, {END})<a class="headerlink" href="#regions-object-encloses-chrom-start-end" title="Permalink to this headline">¶</a></h4>
+<p>Return true if the loaded regions entirely encloses the supplied
+interval.  This function is typically used within the <code class="docutils literal notranslate"><span class="pre">record</span></code>
+function to test the coordinates of the current VCF record, e.g.:</p>
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="kd">function</span> <span class="nx">record</span><span class="p">()</span> <span class="p">{</span>
+    <span class="k">if</span> <span class="p">(</span><span class="nx">myregions</span><span class="p">.</span><span class="nx">encloses</span><span class="p">(</span><span class="nx">CHROM</span><span class="p">,</span> <span class="nx">POS</span><span class="p">,</span> <span class="nx">POS</span> <span class="o">+</span> <span class="nx">REF</span><span class="p">.</span><span class="nx">length</span><span class="p">))</span> <span class="p">{</span>
+        <span class="c1">// do something if the record is fully enclosed by any region</span>
+    <span class="p">}</span>
+<span class="p">}</span>
 </pre></div>
 </div>
 </div>
@@ -2329,36 +2293,36 @@ <h3>Additional information and functions<a class="headerlink" href="#additional-
 <div class="section" id="samples">
 <h4>SAMPLES<a class="headerlink" href="#samples" title="Permalink to this headline">¶</a></h4>
 <p>This variable contains an array of the sample names in the VCF header.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>SAMPLES; // [&#39;NA12877&#39;, &#39;NA12878&#39;]
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">SAMPLES</span><span class="p">;</span> <span class="c1">// [&#39;NA12877&#39;, &#39;NA12878&#39;]</span>
 </pre></div>
 </div>
 </div>
 <div class="section" id="print-string">
 <h4>print({STRING})<a class="headerlink" href="#print-string" title="Permalink to this headline">¶</a></h4>
-<p>Writes the provided string to standard output.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>print(&#39;The samples are: &#39; + SAMPLES);
+<p>Write the provided string to standard output.</p>
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">print</span><span class="p">(</span><span class="s1">&#39;The samples are: &#39;</span> <span class="o">+</span> <span class="nx">SAMPLES</span><span class="p">);</span>
 </pre></div>
 </div>
 </div>
 <div class="section" id="error-string">
 <h4>error({STRING})<a class="headerlink" href="#error-string" title="Permalink to this headline">¶</a></h4>
-<p>Writes the provided string to standard error.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>error(&#39;The samples are: &#39; + SAMPLES);
+<p>Write the provided string to standard error.</p>
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">error</span><span class="p">(</span><span class="s1">&#39;The samples are: &#39;</span> <span class="o">+</span> <span class="nx">SAMPLES</span><span class="p">);</span>
 </pre></div>
 </div>
 </div>
 <div class="section" id="checkminversion-rtg-minimum-version">
 <h4>checkMinVersion(RTG_MINIMUM_VERSION)<a class="headerlink" href="#checkminversion-rtg-minimum-version" title="Permalink to this headline">¶</a></h4>
-<p>Checks the version of RTG that the script is running under, and exits
+<p>Check the version of RTG that the script is running under, and exits
 with an error message if the version of RTG does not meet the minimum
 required version. This is useful when distributing scripts that make use
 of features that are not present in earlier versions of RTG.</p>
-<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>checkMinVersion(&#39;3.9.2&#39;);
+<div class="highlight-javascript notranslate"><div class="highlight"><pre><span></span><span class="nx">checkMinVersion</span><span class="p">(</span><span class="s1">&#39;3.9.2&#39;</span><span class="p">);</span>
 </pre></div>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For javascript filtering usage and examples see <a class="reference internal" href="rtg_command_reference.html#vcffilter"><span class="std std-ref">vcffilter</span></a></p>
+<p class="admonition-title">See also</p>
+<p>For javascript filtering usage and examples see <a class="reference internal" href="rtg_command_reference.html#vcffilter"><span class="std std-ref">vcffilter</span></a></p>
 </div>
 </div>
 </div>
@@ -2409,8 +2373,8 @@ <h2>Parallel processing approach<a class="headerlink" href="#parallel-processing
 have sufficient, dedicated memory. RTG will automatically use the
 available cores of the processor to run multi-threaded tasks.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">The map command does not require specific assignment of
+<p class="admonition-title">Note</p>
+<p>The map command does not require specific assignment of
 input files for left and right mate pair read data sets; this is handled
 automatically by the format command. The result is an SDF directory
 structure, with left and right SDF directories underneath a directory
@@ -2440,11 +2404,11 @@ <h2>Parallel processing approach<a class="headerlink" href="#parallel-processing
 <h2>Distribution Contents<a class="headerlink" href="#distribution-contents" title="Permalink to this headline">¶</a></h2>
 <p>The contents of the RTG distribution zip file should include:</p>
 <ul class="simple">
-<li>The RTG executable JAR file.</li>
-<li>RTG executable wrapper script.</li>
-<li>Example scripts and files.</li>
-<li>This operations manual.</li>
-<li>A release notes file and a readme file.</li>
+<li><p>The RTG executable JAR file.</p></li>
+<li><p>RTG executable wrapper script.</p></li>
+<li><p>Example scripts and files.</p></li>
+<li><p>This operations manual.</p></li>
+<li><p>A release notes file and a readme file.</p></li>
 </ul>
 <p>Some distributions also include an appropriate java runtime environment
 (JRE) for your operating system.</p>
@@ -2733,9 +2697,97 @@ <h2>Notice<a class="headerlink" href="#notice" title="Permalink to this headline
 </div>
 
 
+            <div class="clearer"></div>
           </div>
         </div>
       </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="index.html">
+              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
+            </a></p>
+  <h3><a href="index.html">Table of Contents</a></h3>
+  <ul>
+<li><a class="reference internal" href="#">Appendix</a><ul>
+<li><a class="reference internal" href="#rtg-gapped-alignment-technical-description">RTG gapped alignment technical description</a><ul>
+<li><a class="reference internal" href="#alignment-computations">Alignment computations</a></li>
+<li><a class="reference internal" href="#alignment-scoring">Alignment scoring</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#using-sam-bam-read-groups-in-rtg-map">Using SAM/BAM Read Groups in RTG map</a></li>
+<li><a class="reference internal" href="#rtg-reference-file-format">RTG reference file format</a></li>
+<li><a class="reference internal" href="#rtg-taxonomic-reference-file-format">RTG taxonomic reference file format</a><ul>
+<li><a class="reference internal" href="#rtg-taxonomy-file-format">RTG taxonomy file format</a></li>
+<li><a class="reference internal" href="#rtg-taxonomy-lookup-file-format">RTG taxonomy lookup file format</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#pedigree-ped-input-file-format">Pedigree PED input file format</a></li>
+<li><a class="reference internal" href="#genetic-map-directory">Genetic map directory</a></li>
+<li><a class="reference internal" href="#rtg-commands-using-indexed-input-files">RTG commands using indexed input files</a></li>
+<li><a class="reference internal" href="#rtg-output-results-file-descriptions">RTG output results file descriptions</a><ul>
+<li><a class="reference internal" href="#sam-bam-file-extensions-rtg-map-command-output">SAM/BAM file extensions (RTG map command output)</a></li>
+<li><a class="reference internal" href="#sam-bam-file-extensions-rtg-cgmap-command-output">SAM/BAM file extensions (RTG cgmap command output)</a></li>
+<li><a class="reference internal" href="#small-variant-vcf-output-file-description">Small-variant VCF output file description</a></li>
+<li><a class="reference internal" href="#regions-bed-output-file-description">Regions BED output file description</a></li>
+<li><a class="reference internal" href="#sv-command-output-file-descriptions">SV command output file descriptions</a></li>
+<li><a class="reference internal" href="#discord-command-output-file-descriptions">Discord command output file descriptions</a></li>
+<li><a class="reference internal" href="#coverage-command-output-file-descriptions">Coverage command output file descriptions</a></li>
+<li><a class="reference internal" href="#mapx-and-mapp-output-file-description">Mapx and mapp output file description</a></li>
+<li><a class="reference internal" href="#species-results-file-description">Species results file description</a></li>
+<li><a class="reference internal" href="#similarity-results-file-descriptions">Similarity results file descriptions</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#rtg-javascript-filtering-api">RTG JavaScript filtering API</a><ul>
+<li><a class="reference internal" href="#vcf-record-field-access">VCF record field access</a><ul>
+<li><a class="reference internal" href="#chrom-pos-id-ref-qual">CHROM, POS, ID, REF, QUAL</a></li>
+<li><a class="reference internal" href="#alt-filter">ALT, FILTER</a></li>
+<li><a class="reference internal" href="#info-info-field">INFO.{INFO_FIELD}</a></li>
+<li><a class="reference internal" href="#sample-name-format-field">{SAMPLE_NAME}.{FORMAT_FIELD}</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#vcf-record-modification">VCF record modification</a></li>
+<li><a class="reference internal" href="#vcf-header-modification">VCF header modification</a><ul>
+<li><a class="reference internal" href="#ensureformatheader-format-header-string">ensureFormatHeader({FORMAT_HEADER_STRING})</a></li>
+<li><a class="reference internal" href="#ensureinfoheader-info-header-string">ensureInfoHeader({INFO_HEADER_STRING})</a></li>
+<li><a class="reference internal" href="#ensurefilterheader-filter-header-string">ensureFilterHeader({FILTER_HEADER_STRING})</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#testing-for-overlap-with-genomic-regions">Testing for overlap with genomic regions</a><ul>
+<li><a class="reference internal" href="#regions-frombed-filename">Regions.fromBed({FILENAME})</a></li>
+<li><a class="reference internal" href="#regions-fromvcf-filename">Regions.fromVcf({FILENAME})</a></li>
+<li><a class="reference internal" href="#regions-object-overlaps-chrom-start-end">{REGIONS_OBJECT}.overlaps({CHROM}, {START}, {END})</a></li>
+<li><a class="reference internal" href="#regions-object-encloses-chrom-start-end">{REGIONS_OBJECT}.encloses({CHROM}, {START}, {END})</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#additional-information-and-functions">Additional information and functions</a><ul>
+<li><a class="reference internal" href="#samples">SAMPLES</a></li>
+<li><a class="reference internal" href="#print-string">print({STRING})</a></li>
+<li><a class="reference internal" href="#error-string">error({STRING})</a></li>
+<li><a class="reference internal" href="#checkminversion-rtg-minimum-version">checkMinVersion(RTG_MINIMUM_VERSION)</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li><a class="reference internal" href="#parallel-processing-approach">Parallel processing approach</a></li>
+<li><a class="reference internal" href="#distribution-contents">Distribution Contents</a></li>
+<li><a class="reference internal" href="#readme-txt">README.txt</a></li>
+<li><a class="reference internal" href="#notice">Notice</a></li>
+</ul>
+</li>
+</ul>
+
+  <h4>Previous topic</h4>
+  <p class="topless"><a href="administration.html"
+                        title="previous chapter">Administration &amp; Capacity Planning</a></p>
+  <div role="note" aria-label="source link">
+    <h3>This Page</h3>
+    <ul class="this-page-menu">
+      <li><a href="_sources/appendix.rst.txt"
+            rel="nofollow">Show Source</a></li>
+    </ul>
+   </div>
+        </div>
+      </div>
       <div class="clearer"></div>
     </div>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -2747,12 +2799,13 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="administration.html" title="Administration &amp; Capacity Planning"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Appendix</a></li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2017, Real Time Genomics.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.8.5.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.1.2.
     </div>
   </body>
 </html>
\ No newline at end of file
diff --git a/installer/resources/core/RTGOperationsManual/genindex.html b/installer/resources/core/RTGOperationsManual/genindex.html
index 9342e5989..e37ccc181 100644
--- a/installer/resources/core/RTGOperationsManual/genindex.html
+++ b/installer/resources/core/RTGOperationsManual/genindex.html
@@ -1,27 +1,26 @@
 
 
-
 <!doctype html>
 
-<html xmlns="http://www.w3.org/1999/xhtml">
+<html>
   <head>
-    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Index &#8212; RTG Core Operations Manual v3.11</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Index &#8212; RTG Core Operations Manual v3.12</title>
     <link rel="stylesheet" href="_static/bizstyle.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     
-    <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <script type="text/javascript" src="_static/language_data.js"></script>
-    <script type="text/javascript" src="_static/bizstyle.js"></script>
+    <script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+    <script src="_static/jquery.js"></script>
+    <script src="_static/underscore.js"></script>
+    <script src="_static/doctools.js"></script>
+    <script src="_static/language_data.js"></script>
+    <script src="_static/bizstyle.js"></script>
     <link rel="index" title="Index" href="#" />
     <link rel="search" title="Search" href="search.html" />
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
     <!--[if lt IE 9]>
-    <script type="text/javascript" src="_static/css3-mediaqueries.js"></script>
+    <script src="_static/css3-mediaqueries.js"></script>
     <![endif]-->
   </head><body>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -30,16 +29,10 @@ <h3>Navigation</h3>
         <li class="right" style="margin-right: 10px">
           <a href="#" title="General Index"
              accesskey="I">index</a></li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Index</a></li> 
       </ul>
-    </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-            <p class="logo"><a href="index.html">
-              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
-            </a></p>
-        </div>
-      </div>
+    </div>  
 
     <div class="document">
       <div class="documentwrapper">
@@ -54,9 +47,17 @@ <h1 id="index">Index</h1>
 </div>
 
 
+            <div class="clearer"></div>
           </div>
         </div>
       </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="index.html">
+              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
+            </a></p>
+        </div>
+      </div>
       <div class="clearer"></div>
     </div>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -65,12 +66,13 @@ <h3>Navigation</h3>
         <li class="right" style="margin-right: 10px">
           <a href="#" title="General Index"
              >index</a></li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Index</a></li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2017, Real Time Genomics.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.8.5.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.1.2.
     </div>
   </body>
 </html>
\ No newline at end of file
diff --git a/installer/resources/core/RTGOperationsManual/index.html b/installer/resources/core/RTGOperationsManual/index.html
index fa9e4f947..3aa235bfe 100644
--- a/installer/resources/core/RTGOperationsManual/index.html
+++ b/installer/resources/core/RTGOperationsManual/index.html
@@ -2,26 +2,26 @@
 
 <!doctype html>
 
-<html xmlns="http://www.w3.org/1999/xhtml">
+<html>
   <head>
-    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Table Of Contents &#8212; RTG Core Operations Manual v3.11</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Table Of Contents &#8212; RTG Core Operations Manual v3.12</title>
     <link rel="stylesheet" href="_static/bizstyle.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     
-    <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <script type="text/javascript" src="_static/language_data.js"></script>
-    <script type="text/javascript" src="_static/bizstyle.js"></script>
+    <script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+    <script src="_static/jquery.js"></script>
+    <script src="_static/underscore.js"></script>
+    <script src="_static/doctools.js"></script>
+    <script src="_static/language_data.js"></script>
+    <script src="_static/bizstyle.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
     <link rel="next" title="Overview" href="overview.html" />
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
     <!--[if lt IE 9]>
-    <script type="text/javascript" src="_static/css3-mediaqueries.js"></script>
+    <script src="_static/css3-mediaqueries.js"></script>
     <![endif]-->
   </head><body>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -33,26 +33,10 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="overview.html" title="Overview"
              accesskey="N">next</a> |</li>
-        <li class="nav-item nav-item-0"><a href="#">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="#">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Table Of Contents</a></li> 
       </ul>
-    </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-            <p class="logo"><a href="#">
-              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
-            </a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="overview.html"
-                        title="next chapter">Overview</a></p>
-  <div role="note" aria-label="source link">
-    <h3>This Page</h3>
-    <ul class="this-page-menu">
-      <li><a href="_sources/index.rst.txt"
-            rel="nofollow">Show Source</a></li>
-    </ul>
-   </div>
-        </div>
-      </div>
+    </div>  
 
     <div class="document">
       <div class="documentwrapper">
@@ -202,6 +186,7 @@ <h1>Table Of Contents<a class="headerlink" href="#table-of-contents" title="Perm
 <li class="toctree-l3"><a class="reference internal" href="rtg_command_reference.html#vcfsplit">vcfsplit</a></li>
 <li class="toctree-l3"><a class="reference internal" href="rtg_command_reference.html#vcfstats">vcfstats</a></li>
 <li class="toctree-l3"><a class="reference internal" href="rtg_command_reference.html#vcfsubset">vcfsubset</a></li>
+<li class="toctree-l3"><a class="reference internal" href="rtg_command_reference.html#vcf2rocplot">vcf2rocplot</a></li>
 <li class="toctree-l3"><a class="reference internal" href="rtg_command_reference.html#svdecompose">svdecompose</a></li>
 <li class="toctree-l3"><a class="reference internal" href="rtg_command_reference.html#bndeval">bndeval</a></li>
 <li class="toctree-l3"><a class="reference internal" href="rtg_command_reference.html#pedfilter">pedfilter</a></li>
@@ -343,6 +328,7 @@ <h1>Table Of Contents<a class="headerlink" href="#table-of-contents" title="Perm
 <li class="toctree-l3"><a class="reference internal" href="appendix.html#vcf-record-field-access">VCF record field access</a></li>
 <li class="toctree-l3"><a class="reference internal" href="appendix.html#vcf-record-modification">VCF record modification</a></li>
 <li class="toctree-l3"><a class="reference internal" href="appendix.html#vcf-header-modification">VCF header modification</a></li>
+<li class="toctree-l3"><a class="reference internal" href="appendix.html#testing-for-overlap-with-genomic-regions">Testing for overlap with genomic regions</a></li>
 <li class="toctree-l3"><a class="reference internal" href="appendix.html#additional-information-and-functions">Additional information and functions</a></li>
 </ul>
 </li>
@@ -357,9 +343,27 @@ <h1>Table Of Contents<a class="headerlink" href="#table-of-contents" title="Perm
 </div>
 
 
+            <div class="clearer"></div>
           </div>
         </div>
       </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="#">
+              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
+            </a></p>
+  <h4>Next topic</h4>
+  <p class="topless"><a href="overview.html"
+                        title="next chapter">Overview</a></p>
+  <div role="note" aria-label="source link">
+    <h3>This Page</h3>
+    <ul class="this-page-menu">
+      <li><a href="_sources/index.rst.txt"
+            rel="nofollow">Show Source</a></li>
+    </ul>
+   </div>
+        </div>
+      </div>
       <div class="clearer"></div>
     </div>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -371,12 +375,13 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="overview.html" title="Overview"
              >next</a> |</li>
-        <li class="nav-item nav-item-0"><a href="#">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="#">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Table Of Contents</a></li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2017, Real Time Genomics.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.8.5.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.1.2.
     </div>
   </body>
 </html>
\ No newline at end of file
diff --git a/installer/resources/core/RTGOperationsManual/objects.inv b/installer/resources/core/RTGOperationsManual/objects.inv
index 75a7108d7..81a152b11 100644
Binary files a/installer/resources/core/RTGOperationsManual/objects.inv and b/installer/resources/core/RTGOperationsManual/objects.inv differ
diff --git a/installer/resources/core/RTGOperationsManual/overview.html b/installer/resources/core/RTGOperationsManual/overview.html
index f8831bb30..185425e67 100644
--- a/installer/resources/core/RTGOperationsManual/overview.html
+++ b/installer/resources/core/RTGOperationsManual/overview.html
@@ -2,27 +2,27 @@
 
 <!doctype html>
 
-<html xmlns="http://www.w3.org/1999/xhtml">
+<html>
   <head>
-    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Overview &#8212; RTG Core Operations Manual v3.11</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Overview &#8212; RTG Core Operations Manual v3.12</title>
     <link rel="stylesheet" href="_static/bizstyle.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     
-    <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <script type="text/javascript" src="_static/language_data.js"></script>
-    <script type="text/javascript" src="_static/bizstyle.js"></script>
+    <script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+    <script src="_static/jquery.js"></script>
+    <script src="_static/underscore.js"></script>
+    <script src="_static/doctools.js"></script>
+    <script src="_static/language_data.js"></script>
+    <script src="_static/bizstyle.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
     <link rel="next" title="RTG Command Reference" href="rtg_command_reference.html" />
     <link rel="prev" title="Table Of Contents" href="index.html" />
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
     <!--[if lt IE 9]>
-    <script type="text/javascript" src="_static/css3-mediaqueries.js"></script>
+    <script src="_static/css3-mediaqueries.js"></script>
     <![endif]-->
   </head><body>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -37,77 +37,10 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="index.html" title="Table Of Contents"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Overview</a></li> 
       </ul>
-    </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-            <p class="logo"><a href="index.html">
-              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
-            </a></p>
-  <h3><a href="index.html">Table of Contents</a></h3>
-  <ul>
-<li><a class="reference internal" href="#">Overview</a><ul>
-<li><a class="reference internal" href="#introduction">Introduction</a></li>
-<li><a class="reference internal" href="#rtg-software-description">RTG software description</a></li>
-<li><a class="reference internal" href="#sequence-search-and-alignment">Sequence search and alignment</a><ul>
-<li><a class="reference internal" href="#data-formatting">Data formatting</a></li>
-<li><a class="reference internal" href="#read-mapping-and-alignment">Read mapping and alignment</a></li>
-<li><a class="reference internal" href="#read-mapping-output-files">Read mapping output files</a></li>
-<li><a class="reference internal" href="#read-mapping-sensitivity-tuning">Read mapping sensitivity tuning</a></li>
-<li><a class="reference internal" href="#protein-search">Protein search</a></li>
-<li><a class="reference internal" href="#protein-search-output-files">Protein search output files</a></li>
-<li><a class="reference internal" href="#protein-search-sensitivity-tuning">Protein search sensitivity tuning</a></li>
-<li><a class="reference internal" href="#benchmarking-and-optimization-utilities">Benchmarking and optimization utilities</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#variant-detection-functions">Variant detection functions</a><ul>
-<li><a class="reference internal" href="#sequence-variation-snps-indels-and-complex-variants">Sequence variation (SNPs, indels and complex variants)</a></li>
-<li><a class="reference internal" href="#sequence-variation-with-mendelian-pedigree">Sequence variation with Mendelian pedigree</a></li>
-<li><a class="reference internal" href="#somatic-sequence-variation">Somatic sequence variation</a></li>
-<li><a class="reference internal" href="#coverage-analysis">Coverage analysis</a></li>
-<li><a class="reference internal" href="#copy-number-variation-cnv-analysis">Copy number variation (CNV) analysis</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#standard-input-and-output-file-formats">Standard input and output file formats</a><ul>
-<li><a class="reference internal" href="#sam-bam-files-created-by-the-rtg-map-command">SAM/BAM files created by the RTG map command</a></li>
-<li><a class="reference internal" href="#variant-caller-output-files">Variant caller output files</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#metagenomic-analysis-functions">Metagenomic analysis functions</a><ul>
-<li><a class="reference internal" href="#contamination-filtering">Contamination filtering</a></li>
-<li><a class="reference internal" href="#taxon-abundance-breakdown">Taxon abundance breakdown</a></li>
-<li><a class="reference internal" href="#sample-relationships">Sample relationships</a></li>
-<li><a class="reference internal" href="#functional-protein-analysis">Functional protein analysis</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#pipelines">Pipelines</a></li>
-<li><a class="reference internal" href="#parallel-processing">Parallel processing</a></li>
-<li><a class="reference internal" href="#installation-and-deployment">Installation and deployment</a><ul>
-<li><a class="reference internal" href="#quick-start-instructions">Quick start instructions</a></li>
-<li><a class="reference internal" href="#license-management">License Management</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#technical-assistance-and-support">Technical assistance and support</a></li>
-</ul>
-</li>
-</ul>
-
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="index.html"
-                        title="previous chapter">Table Of Contents</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="rtg_command_reference.html"
-                        title="next chapter">RTG Command Reference</a></p>
-  <div role="note" aria-label="source link">
-    <h3>This Page</h3>
-    <ul class="this-page-menu">
-      <li><a href="_sources/overview.rst.txt"
-            rel="nofollow">Show Source</a></li>
-    </ul>
-   </div>
-        </div>
-      </div>
+    </div>  
 
     <div class="document">
       <div class="documentwrapper">
@@ -138,27 +71,27 @@ <h2>Introduction<a class="headerlink" href="#introduction" title="Permalink to t
 <p>RTG software supports a variety of research and medical genomics
 applications, such as:</p>
 <ul class="simple">
-<li><strong>Medical Genomic Research</strong> – Compare sequence variants and
+<li><p><strong>Medical Genomic Research</strong> – Compare sequence variants and
 structural variation between normal and disease genomes, or over a
-disease progression in the same individual to identity causal loci.</li>
-<li><strong>Personalized Medicine</strong> – Establish reliable, high-throughput
+disease progression in the same individual to identity causal loci.</p></li>
+<li><p><strong>Personalized Medicine</strong> – Establish reliable, high-throughput
 processing pipelines that analyze individual human genomes compared
 to one or more reference genomes. Use RTG software for detection of
 sequence variants (SNP and indel calling, intersection scripting), as
 well as structural variation (coverage depth, and copy number
-variation).</li>
-<li><strong>Model Organisms and Basic Research</strong> – Utilize RTG mapping and
+variation).</p></li>
+<li><p><strong>Model Organisms and Basic Research</strong> – Utilize RTG mapping and
 variant detection commands for focused research applications such as
 metagenomic species identification and frequency, and metabolic
 pathway analysis. Map microbial communities to generate gapped
-alignments of both DNA and protein sequence data.</li>
-<li><strong>Plant Genomics</strong> – Enable investigations of new crop species and
+alignments of both DNA and protein sequence data.</p></li>
+<li><p><strong>Plant Genomics</strong> – Enable investigations of new crop species and
 variant detection in genetically diverse strains by leveraging RTG’s
 highly sensitive sequence search capabilities for strain and
 cross-species mapping applications. Flexible sensitivity tuning
 controls allow investigators to accommodate very high error rates
 associated with unique combinations of sequencing system error,
-genome-specific mutation, and aggressive cross-species comparisons.</li>
+genome-specific mutation, and aggressive cross-species comparisons.</p></li>
 </ul>
 </div>
 <div class="section" id="rtg-software-description">
@@ -173,33 +106,33 @@ <h2>RTG software description<a class="headerlink" href="#rtg-software-descriptio
 </div>
 <p>RTG software delivers features in four areas:</p>
 <ul class="simple">
-<li><strong>Sequence Search and Alignment</strong> – RTG software uses patented
+<li><p><strong>Sequence Search and Alignment</strong> – RTG software uses patented
 sequence search technology for the rapid production of genomic
 sequence data. The <code class="docutils literal notranslate"><span class="pre">map</span></code> command implements read mapping and gapped
 alignment of sequence data against a reference. The <code class="docutils literal notranslate"><span class="pre">mapx</span></code> command
-searches translated sequence data against a protein database.</li>
-<li><strong>Data Analysis</strong> – RTG software supports two pipelines for data
+searches translated sequence data against a protein database.</p></li>
+<li><p><strong>Data Analysis</strong> – RTG software supports two pipelines for data
 analysis - variant detection and metagenomics. Purpose-built variant
 detection pipeline functions include several commands to identify
 small sequence variants, a <code class="docutils literal notranslate"><span class="pre">cnv</span></code> command to report copy number
 variation statistics for structural variation, and a <code class="docutils literal notranslate"><span class="pre">coverage</span></code>
-command to report read depth across a reference.</li>
-<li><strong>Reporting Options</strong> – Standard result formats and utility commands
+command to report read depth across a reference.</p></li>
+<li><p><strong>Reporting Options</strong> – Standard result formats and utility commands
 report results for validation, and ease development of custom scripts
 for analysis. Scripts that produce publication quality graphics for
 visualization of data analysis results are available through Real
-Time Genomics technical support.</li>
-<li><strong>Data Center Deployment</strong> – RTG software supports typical data
+Time Genomics technical support.</p></li>
+<li><p><strong>Data Center Deployment</strong> – RTG software supports typical data
 center standards for enterprise deployment. RTG provides automated
 installation and supports industry standard operating environments
 and data processing systems to help maintain total cost of ownership
 objectives in enterprise data centers. The RTG software can be run in
 compute clusters of varying sizes, and commands take advantage of
-multi-core processors by default.</li>
+multi-core processors by default.</p></li>
 </ul>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For detailed information about RTG command syntax and
+<p class="admonition-title">See also</p>
+<p>For detailed information about RTG command syntax and
 usage of individual commands, refer to <a class="reference internal" href="rtg_command_reference.html#rtg-command-reference"><span class="std std-ref">RTG Command Reference</span></a>.</p>
 </div>
 </div>
@@ -215,32 +148,32 @@ <h2>Sequence search and alignment<a class="headerlink" href="#sequence-search-an
 downstream analysis functions.</p>
 <p>Key functionality of RTG sequence search and alignment includes:</p>
 <ul class="simple">
-<li>Read mapping by nucleotide sequence alignment to a reference genome</li>
-<li>Protein database searching by translated nucleotide sequence searches
-against protein databases</li>
-<li>Sensitivity tuning using parameter options for substitutions, indels,
-indel lengths, word or step sizes, and alignment scores</li>
-<li>Filtering and reporting ambiguous reads that map to multiple
-locations</li>
-<li>Benchmarking and optimization using simulation and evaluation
-commands</li>
+<li><p>Read mapping by nucleotide sequence alignment to a reference genome</p></li>
+<li><p>Protein database searching by translated nucleotide sequence searches
+against protein databases</p></li>
+<li><p>Sensitivity tuning using parameter options for substitutions, indels,
+indel lengths, word or step sizes, and alignment scores</p></li>
+<li><p>Filtering and reporting ambiguous reads that map to multiple
+locations</p></li>
+<li><p>Benchmarking and optimization using simulation and evaluation
+commands</p></li>
 </ul>
 <p>RTG mapping commands have the following characteristics:</p>
 <ul class="simple">
-<li>Eliminates need for genome indexing</li>
-<li>Aligns sequence reads of any length</li>
-<li>Allows high mismatch levels for increased sensitivity in longer reads</li>
-<li>Allows detection of short indels with single end (SE) or paired end
-(PE) data</li>
-<li>Can optionally guarantee the mapping of reads with at least a
-specified number of substitutions and indels</li>
-<li>Supports a wide range of alignment scores</li>
+<li><p>Eliminates need for genome indexing</p></li>
+<li><p>Aligns sequence reads of any length</p></li>
+<li><p>Allows high mismatch levels for increased sensitivity in longer reads</p></li>
+<li><p>Allows detection of short indels with single end (SE) or paired end
+(PE) data</p></li>
+<li><p>Can optionally guarantee the mapping of reads with at least a
+specified number of substitutions and indels</p></li>
+<li><p>Supports a wide range of alignment scores</p></li>
 </ul>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
+<p class="admonition-title">See also</p>
 <p>For detailed information about sequence search and
 alignment functionality, refer to <a class="reference internal" href="rtg_command_reference.html#map"><span class="std std-ref">Command Reference, map</span></a>.</p>
-<p class="last">For more information about the RTG integrated software pipeline, refer to <a class="reference internal" href="product_usage.html#baseline-product-usage"><span class="std std-ref">RTG product usage - baseline progressions</span></a></p>
+<p>For more information about the RTG integrated software pipeline, refer to <a class="reference internal" href="product_usage.html#baseline-product-usage"><span class="std std-ref">RTG product usage - baseline progressions</span></a></p>
 </div>
 <div class="section" id="data-formatting">
 <h3>Data formatting<a class="headerlink" href="#data-formatting" title="Permalink to this headline">¶</a></h3>
@@ -276,8 +209,8 @@ <h3>Data formatting<a class="headerlink" href="#data-formatting" title="Permalin
 </pre></div>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For detailed information about formatting sequencing
+<p class="admonition-title">See also</p>
+<p>For detailed information about formatting sequencing
 system reads to RTG SDF, refer to <a class="reference internal" href="rtg_command_reference.html#data-formatting-commands"><span class="std std-ref">Data Formatting Commands</span></a></p>
 </div>
 </div>
@@ -336,10 +269,10 @@ <h3>Read mapping output files<a class="headerlink" href="#read-mapping-output-fi
 that did not align to the reference will include <code class="docutils literal notranslate"><span class="pre">XC</span></code> attributes in the
 BAM file that describe why a read did not map.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
+<p class="admonition-title">See also</p>
 <p>For more information about the RTG <code class="docutils literal notranslate"><span class="pre">map</span></code> command, refer
 to <a class="reference internal" href="rtg_command_reference.html#map"><span class="std std-ref">Command Reference, map</span></a>.</p>
-<p class="last">For details on RTG extensions to the BAM file format, refer to <a class="reference internal" href="appendix.html#sam-bam-file-extensions-rtg-map-command-output"><span class="std std-ref">SAM/BAM file extensions (RTG map command output)</span></a></p>
+<p>For details on RTG extensions to the BAM file format, refer to <a class="reference internal" href="appendix.html#sam-bam-file-extensions-rtg-map-command-output"><span class="std std-ref">SAM/BAM file extensions (RTG map command output)</span></a></p>
 </div>
 </div>
 <div class="section" id="read-mapping-sensitivity-tuning">
@@ -370,8 +303,8 @@ <h3>Read mapping sensitivity tuning<a class="headerlink" href="#read-mapping-sen
 parameter for example, an investigator might limit reported alignments
 to only those at or lower than the given threshold value.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For more information about the RTG <code class="docutils literal notranslate"><span class="pre">map</span></code> command’s
+<p class="admonition-title">See also</p>
+<p>For more information about the RTG <code class="docutils literal notranslate"><span class="pre">map</span></code> command’s
 sensitivity and tuning parameters, refer to <a class="reference internal" href="rtg_command_reference.html#map"><span class="std std-ref">Command Reference, map</span></a></p>
 </div>
 </div>
@@ -398,8 +331,8 @@ <h3>Protein search<a class="headerlink" href="#protein-search" title="Permalink
 score. The output results file is similar in construct to that reported
 by BLASTX.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For more information about the RTG protein mapping commands
+<p class="admonition-title">See also</p>
+<p>For more information about the RTG protein mapping commands
 please refer to <a class="reference internal" href="rtg_command_reference.html#mapx"><span class="std std-ref">Command Reference, mapx</span></a> and
 <a class="reference internal" href="rtg_command_reference.html#mapp"><span class="std std-ref">Command Reference, mapp</span></a></p>
 </div>
@@ -417,8 +350,8 @@ <h3>Protein search output files<a class="headerlink" href="#protein-search-outpu
 valid search result, is written as tab-separated fields on a single
 line. The output fields are very similar to those reported by BLASTX.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For detailed information about the RTG <code class="docutils literal notranslate"><span class="pre">mapx</span></code> and
+<p class="admonition-title">See also</p>
+<p>For detailed information about the RTG <code class="docutils literal notranslate"><span class="pre">mapx</span></code> and
 <code class="docutils literal notranslate"><span class="pre">mapp</span></code> command results file format refer to <a class="reference internal" href="appendix.html#mapx-and-mapp-output-file-description"><span class="std std-ref">Mapx and mapp output file description</span></a></p>
 </div>
 </div>
@@ -435,8 +368,8 @@ <h3>Protein search sensitivity tuning<a class="headerlink" href="#protein-search
 for example, an investigator might limit reported alignments to only
 those at or lower than the given threshold value.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For more information about the RTG <code class="docutils literal notranslate"><span class="pre">mapx</span></code> command’s
+<p class="admonition-title">See also</p>
+<p>For more information about the RTG <code class="docutils literal notranslate"><span class="pre">mapx</span></code> command’s
 sensitivity and tuning parameters, refer to <a class="reference internal" href="appendix.html#mapx-and-mapp-output-file-description"><span class="std std-ref">Mapx and mapp output file description</span></a></p>
 </div>
 </div>
@@ -449,28 +382,28 @@ <h3>Benchmarking and optimization utilities<a class="headerlink" href="#benchmar
 software in various read mapping and data analysis scenarios.</p>
 <p>RTG provides several simulators:</p>
 <ul class="simple">
-<li><code class="docutils literal notranslate"><span class="pre">genomesim</span></code>
+<li><p><code class="docutils literal notranslate"><span class="pre">genomesim</span></code>
 The <code class="docutils literal notranslate"><span class="pre">genomesim</span></code> command generates a reference genome with one or more
 segments of varying length and a percentage mix of nucleotide values.
 Use the command to create simulated genomes for benchmarking and
-evaluation.</li>
-<li><code class="docutils literal notranslate"><span class="pre">readsim</span></code> / <code class="docutils literal notranslate"><span class="pre">cgsim</span></code>
+evaluation.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">readsim</span></code> / <code class="docutils literal notranslate"><span class="pre">cgsim</span></code>
 The <code class="docutils literal notranslate"><span class="pre">readsim</span></code> / <code class="docutils literal notranslate"><span class="pre">cgsim</span></code> commands generate synthetic read sequence
 data from an input reference genome, introducing errors at a
 specified rate. Use the commands to create simulated read sets for
-benchmarking and evaluation.</li>
-<li><code class="docutils literal notranslate"><span class="pre">popsim</span></code>, <code class="docutils literal notranslate"><span class="pre">samplesim</span></code>, <code class="docutils literal notranslate"><span class="pre">childsim</span></code>, <code class="docutils literal notranslate"><span class="pre">samplereplay</span></code>, <code class="docutils literal notranslate"><span class="pre">denovosim</span></code>
+benchmarking and evaluation.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">popsim</span></code>, <code class="docutils literal notranslate"><span class="pre">samplesim</span></code>, <code class="docutils literal notranslate"><span class="pre">childsim</span></code>, <code class="docutils literal notranslate"><span class="pre">samplereplay</span></code>, <code class="docutils literal notranslate"><span class="pre">denovosim</span></code>
 These variant simulation commands are used to create mutated genomes
 from a known reference by adding variants. Use these commands to
 verify accuracy of variant detection analysis software for a
-particular experiment using different pipeline settings.</li>
+particular experiment using different pipeline settings.</p></li>
 </ul>
 <p>Simulated data that is produced in SDF format can be converted into
 FASTA and FASTQ format sequence files for use with other tools using the
 <code class="docutils literal notranslate"><span class="pre">sdf2fasta</span></code> and <code class="docutils literal notranslate"><span class="pre">sdf2fastq</span></code> commands respectively.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For more information about the RTG simulation commands,
+<p class="admonition-title">See also</p>
+<p>For more information about the RTG simulation commands,
 refer to <a class="reference internal" href="rtg_command_reference.html#simulation-commands"><span class="std std-ref">Simulation Commands</span></a>. Advice is
 available to ensure best results. Please contact RTG technical support
 for assistance.</p>
@@ -517,8 +450,8 @@ <h3>Sequence variation (SNPs, indels and complex variants)<a class="headerlink"
 scores, coverage depth, or indels, and filtered report results may be
 integrated with the SNP calls themselves.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For more information about the SNP output data, refer to
+<p class="admonition-title">See also</p>
+<p>For more information about the SNP output data, refer to
 <a class="reference internal" href="rtg_command_reference.html#map"><span class="std std-ref">Command Reference, map</span></a>, <a class="reference internal" href="rtg_command_reference.html#snp"><span class="std std-ref">Command Reference, snp</span></a> for syntax, parameters,
 and usage of the <code class="docutils literal notranslate"><span class="pre">map</span></code> and <code class="docutils literal notranslate"><span class="pre">snp</span></code> commands.</p>
 </div>
@@ -593,8 +526,8 @@ <h3>Coverage analysis<a class="headerlink" href="#coverage-analysis" title="Perm
 <p>Customizable scripts are available for enabling graphical plotting of
 the coverage results using <code class="docutils literal notranslate"><span class="pre">gnuplot</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For more information about the RTG coverage analysis, refer
+<p class="admonition-title">See also</p>
+<p>For more information about the RTG coverage analysis, refer
 to <a class="reference internal" href="rtg_command_reference.html#coverage"><span class="std std-ref">Command reference, coverage</span></a></p>
 </div>
 </div>
@@ -609,8 +542,8 @@ <h3>Copy number variation (CNV) analysis<a class="headerlink" href="#copy-number
 Customizable scripts are available for enabling graphical plotting of
 the CNV results using tools such as <code class="docutils literal notranslate"><span class="pre">gnuplot</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For more information about the CNV output data, refer to
+<p class="admonition-title">See also</p>
+<p>For more information about the CNV output data, refer to
 <a class="reference internal" href="rtg_command_reference.html#cnv"><span class="std std-ref">Command Reference, cnv</span></a></p>
 </div>
 </div>
@@ -620,40 +553,40 @@ <h2>Standard input and output file formats<a class="headerlink" href="#standard-
 <p>RTG software produces alignment and data analysis results in standard
 formats to allow pipeline validation and downstream analysis.</p>
 <p>Table : Result file formats for validation and downstream analysis</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="96%" />
+<col style="width: 4%" />
+<col style="width: 96%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">File type</th>
-<th class="head">Description and Usage</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>File type</p></th>
+<th class="head"><p>Description and Usage</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>BAM, SAM</td>
-<td>The RTG <code class="docutils literal notranslate"><span class="pre">map</span></code> and <code class="docutils literal notranslate"><span class="pre">cgmap</span></code> commands produces alignment results in the Binary Sequence Alignment/Map (BAM) format: <code class="docutils literal notranslate"><span class="pre">alignments.bam</span></code> or optionally the compressed ASCII (SAM format) equivalent <code class="docutils literal notranslate"><span class="pre">alignments.sam.gz</span></code>. This allows use of familiar pileup viewers for quick visual inspection of alignment results.</td>
+<tbody>
+<tr class="row-even"><td><p>BAM, SAM</p></td>
+<td><p>The RTG <code class="docutils literal notranslate"><span class="pre">map</span></code> and <code class="docutils literal notranslate"><span class="pre">cgmap</span></code> commands produces alignment results in the Binary Sequence Alignment/Map (BAM) format: <code class="docutils literal notranslate"><span class="pre">alignments.bam</span></code> or optionally the compressed ASCII (SAM format) equivalent <code class="docutils literal notranslate"><span class="pre">alignments.sam.gz</span></code>. This allows use of familiar pileup viewers for quick visual inspection of alignment results.</p></td>
 </tr>
-<tr class="row-odd"><td>TXT</td>
-<td>Many RTG commands output summary statistics as ASCII text files.</td>
+<tr class="row-odd"><td><p>TXT</p></td>
+<td><p>Many RTG commands output summary statistics as ASCII text files.</p></td>
 </tr>
-<tr class="row-even"><td>TSV</td>
-<td>Many RTG commands output results in tab separated ASCII text files. These files can typically be loaded directly into a spreadsheet viewing program like Microsoft Excel or Open Office.</td>
+<tr class="row-even"><td><p>TSV</p></td>
+<td><p>Many RTG commands output results in tab separated ASCII text files. These files can typically be loaded directly into a spreadsheet viewing program like Microsoft Excel or Open Office.</p></td>
 </tr>
-<tr class="row-odd"><td>BED</td>
-<td>Some RTG commands output results in standard BED formats for further analysis and reporting.</td>
+<tr class="row-odd"><td><p>BED</p></td>
+<td><p>Some RTG commands output results in standard BED formats for further analysis and reporting.</p></td>
 </tr>
-<tr class="row-even"><td>PED</td>
-<td>Some RTG commands utilize standard PED format text files for supplying sample pedigree and sex information.</td>
+<tr class="row-even"><td><p>PED</p></td>
+<td><p>Some RTG commands utilize standard PED format text files for supplying sample pedigree and sex information.</p></td>
 </tr>
-<tr class="row-odd"><td>VCF</td>
-<td>The <code class="docutils literal notranslate"><span class="pre">snp</span></code>, <code class="docutils literal notranslate"><span class="pre">family</span></code>, <code class="docutils literal notranslate"><span class="pre">population</span></code> and <code class="docutils literal notranslate"><span class="pre">somatic</span></code> commands output results in Variant Call Format (VCF) version 4.1.</td>
+<tr class="row-odd"><td><p>VCF</p></td>
+<td><p>The <code class="docutils literal notranslate"><span class="pre">snp</span></code>, <code class="docutils literal notranslate"><span class="pre">family</span></code>, <code class="docutils literal notranslate"><span class="pre">population</span></code> and <code class="docutils literal notranslate"><span class="pre">somatic</span></code> commands output results in Variant Call Format (VCF) version 4.1.</p></td>
 </tr>
 </tbody>
 </table>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For more information about file format extensions, refer
+<p class="admonition-title">See also</p>
+<p>For more information about file format extensions, refer
 to Appendix <a class="reference internal" href="appendix.html#rtg-output-results-file-descriptions"><span class="std std-ref">RTG output results file descriptions</span></a></p>
 </div>
 <div class="section" id="sam-bam-files-created-by-the-rtg-map-command">
@@ -668,8 +601,8 @@ <h3>SAM/BAM files created by the RTG map command<a class="headerlink" href="#sam
 mismatches, insertions and deletions (indels) as determined by the RTG
 <code class="docutils literal notranslate"><span class="pre">map</span></code> aligner.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">RTG mapped alignments are stored in BAM format with RTG
+<p class="admonition-title">Note</p>
+<p>RTG mapped alignments are stored in BAM format with RTG
 read IDs by default. This default can be overridden using the
 <code class="docutils literal notranslate"><span class="pre">--read-names</span></code> flag or changed after processing using the RTG
 <code class="docutils literal notranslate"><span class="pre">samrename</span></code> utility to label the reads with the sequence identifiers
@@ -694,8 +627,8 @@ <h3>Variant caller output files<a class="headerlink" href="#variant-caller-outpu
 <code class="docutils literal notranslate"><span class="pre">snps.vcf</span></code> output has tab-separated fields and represents a SNP
 variation calculated from the mapped reads against the reference genome.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">RTG variant calls are stored in VCF format (version
+<p class="admonition-title">Note</p>
+<p>RTG variant calls are stored in VCF format (version
 4.2). For more information about the VCF format, refer to the
 specification online at:
 <a class="reference external" href="https://samtools.github.io/hts-specs/VCFv4.2.pdf">https://samtools.github.io/hts-specs/VCFv4.2.pdf</a></p>
@@ -705,8 +638,8 @@ <h3>Variant caller output files<a class="headerlink" href="#variant-caller-outpu
 of the <em>Appendix</em> to this guide for a complete list of all extensions
 and differences.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For more information about file formats, refer to the
+<p class="admonition-title">See also</p>
+<p>For more information about file formats, refer to the
 <em>Appendix,</em> <a class="reference internal" href="appendix.html#rtg-output-results-file-descriptions"><span class="std std-ref">RTG output results file descriptions</span></a></p>
 </div>
 </div>
@@ -758,10 +691,10 @@ <h2>Pipelines<a class="headerlink" href="#pipelines" title="Permalink to this he
 as a guideline to building more complex end-to-end pipelines using our
 tools. The metagenomic pipeline commands are:</p>
 <ul class="simple">
-<li>species composition (<code class="docutils literal notranslate"><span class="pre">composition-meta-pipeline</span></code>)</li>
-<li>functional protein analysis (<code class="docutils literal notranslate"><span class="pre">functional-meta-pipeline</span></code>)</li>
-<li>species composition and functional protein analysis
-(<code class="docutils literal notranslate"><span class="pre">composition-functional-meta-pipeline</span></code>).</li>
+<li><p>species composition (<code class="docutils literal notranslate"><span class="pre">composition-meta-pipeline</span></code>)</p></li>
+<li><p>functional protein analysis (<code class="docutils literal notranslate"><span class="pre">functional-meta-pipeline</span></code>)</p></li>
+<li><p>species composition and functional protein analysis
+(<code class="docutils literal notranslate"><span class="pre">composition-functional-meta-pipeline</span></code>).</p></li>
 </ul>
 <p>For detailed information about individual pipeline commands see
 <a class="reference internal" href="rtg_command_reference.html#pipeline-commands"><span class="std std-ref">Pipeline Commands</span></a></p>
@@ -782,8 +715,8 @@ <h2>Parallel processing<a class="headerlink" href="#parallel-processing" title="
 <code class="docutils literal notranslate"><span class="pre">--region</span></code> or <code class="docutils literal notranslate"><span class="pre">--bed-regions</span></code> parameter to allow breaking up tasks into
 pieces across the reference genome.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">See <a class="reference internal" href="rtg_command_reference.html#rtg-command-reference"><span class="std std-ref">RTG Command Reference</span></a>
+<p class="admonition-title">See also</p>
+<p>See <a class="reference internal" href="rtg_command_reference.html#rtg-command-reference"><span class="std std-ref">RTG Command Reference</span></a>
 for command-specific details, <a class="reference internal" href="administration.html#administration-capacity-planning"><span class="std std-ref">Administration &amp; Capacity Planning</span></a>
 for detailed information about estimating the number of
 multi-core servers needed (capacity planning), and <a class="reference internal" href="appendix.html#parallel-processing-approach"><span class="std std-ref">Parallel processing approach</span></a> for a
@@ -804,20 +737,20 @@ <h2>Installation and deployment<a class="headerlink" href="#installation-and-dep
 analysis benchmarks suggest the use of six server nodes of the
 configuration shown in below.</p>
 <p>Table : Recommended system requirements</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="23%" />
-<col width="77%" />
+<col style="width: 23%" />
+<col style="width: 77%" />
 </colgroup>
-<tbody valign="top">
-<tr class="row-odd"><td>Processor</td>
-<td>Intel Core i7-2600</td>
+<tbody>
+<tr class="row-odd"><td><p>Processor</p></td>
+<td><p>Intel Core i7-2600</p></td>
 </tr>
-<tr class="row-even"><td>Memory</td>
-<td>48 GB RAM DDR3</td>
+<tr class="row-even"><td><p>Memory</p></td>
+<td><p>48 GB RAM DDR3</p></td>
 </tr>
-<tr class="row-odd"><td>Disk</td>
-<td>5 TB, 7200 RPM (prefer SAS disk)</td>
+<tr class="row-odd"><td><p>Disk</p></td>
+<td><p>5 TB, 7200 RPM (prefer SAS disk)</p></td>
 </tr>
 </tbody>
 </table>
@@ -847,19 +780,16 @@ <h3>Quick start instructions<a class="headerlink" href="#quick-start-instruction
 <p>Here are platform-specific instructions for RTG deployment.</p>
 <p>Linux/MacOS X:</p>
 <ul>
-<li><p class="first">Unzip the RTG distribution to the desired location.</p>
-</li>
-<li><p class="first">If your installation requires a license file (<code class="docutils literal notranslate"><span class="pre">rtg-license.txt</span></code>),
+<li><p>Unzip the RTG distribution to the desired location.</p></li>
+<li><p>If your installation requires a license file (<code class="docutils literal notranslate"><span class="pre">rtg-license.txt</span></code>),
 copy the license file provided by Real Time Genomics into the RTG
-distribution directory.</p>
-</li>
-<li><dl class="first docutils">
-<dt>In a terminal, cd to the installation directory and test for success</dt>
-<dd><p class="first last">by entering <code class="docutils literal notranslate"><span class="pre">./rtg</span> <span class="pre">version</span></code></p>
+distribution directory.</p></li>
+<li><dl class="simple">
+<dt>In a terminal, cd to the installation directory and test for success</dt><dd><p>by entering <code class="docutils literal notranslate"><span class="pre">./rtg</span> <span class="pre">version</span></code></p>
 </dd>
 </dl>
 </li>
-<li><p class="first">On MacOS X, depending on your operating system version and
+<li><p>On MacOS X, depending on your operating system version and
 configuration regarding unsigned applications, you may encounter the
 error message:</p>
 <div class="highlight-text notranslate"><div class="highlight"><pre><span></span>-bash: rtg: /usr/bin/env: bad interpreter: Operation not permitted
@@ -871,44 +801,40 @@ <h3>Quick start instructions<a class="headerlink" href="#quick-start-instruction
 </pre></div>
 </div>
 </li>
-<li><p class="first">The first time rtg is executed you will be prompted with some
-questions to customize your installation. Follow the prompts.</p>
-</li>
-<li><p class="first">Enter <code class="docutils literal notranslate"><span class="pre">./rtg</span> <span class="pre">help</span></code> for a list of rtg commands. Help for any
+<li><p>The first time rtg is executed you will be prompted with some
+questions to customize your installation. Follow the prompts.</p></li>
+<li><p>Enter <code class="docutils literal notranslate"><span class="pre">./rtg</span> <span class="pre">help</span></code> for a list of rtg commands. Help for any
 individual command is available using the <code class="docutils literal notranslate"><span class="pre">--help</span></code> flag, e.g.:
-<code class="docutils literal notranslate"><span class="pre">./rtg</span> <span class="pre">format</span> <span class="pre">--help</span></code></p>
-</li>
-<li><p class="first">By default, RTG software scripts establish a memory space of 90% of
+<code class="docutils literal notranslate"><span class="pre">./rtg</span> <span class="pre">format</span> <span class="pre">--help</span></code></p></li>
+<li><p>By default, RTG software scripts establish a memory space of 90% of
 the available RAM - this is automatically calculated. One may
 override this limit in the <code class="docutils literal notranslate"><span class="pre">rtg.cfg</span></code> settings file or on a per-run
 basis by supplying <code class="docutils literal notranslate"><span class="pre">RTG_MEM</span></code> as an environment variable or as the
-first program argument, e.g.: <code class="docutils literal notranslate"><span class="pre">./rtg</span> <span class="pre">RTG_MEM=48g</span> <span class="pre">map</span></code></p>
-</li>
-<li><p class="first">[OPTIONAL] If you will be running RTG on multiple machines and would
+first program argument, e.g.: <code class="docutils literal notranslate"><span class="pre">./rtg</span> <span class="pre">RTG_MEM=48g</span> <span class="pre">map</span></code></p></li>
+<li><p>[OPTIONAL] If you will be running RTG on multiple machines and would
 like to customize settings on a per-machine basis, copy <code class="docutils literal notranslate"><span class="pre">rtg.cfg</span></code> to
 <code class="docutils literal notranslate"><span class="pre">/etc/rtg.cfg</span></code>, editing per-machine settings appropriately (requires
 root privileges).  An alternative that does not require root
 privileges is to copy <code class="docutils literal notranslate"><span class="pre">rtg.cfg</span></code> to <code class="docutils literal notranslate"><span class="pre">rtg.HOSTNAME.cfg</span></code>, editing
 per-machine settings appropriately, where <code class="docutils literal notranslate"><span class="pre">HOSTNAME</span></code> is the short host
-name output by the command <code class="docutils literal notranslate"><span class="pre">hostname</span> <span class="pre">-s</span></code></p>
-</li>
+name output by the command <code class="docutils literal notranslate"><span class="pre">hostname</span> <span class="pre">-s</span></code></p></li>
 </ul>
 <p>Windows:</p>
 <ul class="simple">
-<li>Unzip the RTG distribution to the desired location.</li>
-<li>If your installation requires a license, copy the license file
+<li><p>Unzip the RTG distribution to the desired location.</p></li>
+<li><p>If your installation requires a license, copy the license file
 provided by Real Time Genomics (<code class="docutils literal notranslate"><span class="pre">rtg-license.txt</span></code>) into the RTG
-distribution directory.</li>
-<li>Test for success by entering <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">version</span></code> at the command line. The
+distribution directory.</p></li>
+<li><p>Test for success by entering <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">version</span></code> at the command line. The
 first time RTG is executed you will be prompted with some questions
-to customize your installation. Follow the prompts.</li>
-<li>Enter <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">help</span></code> for a list of rtg commands. Help for any
+to customize your installation. Follow the prompts.</p></li>
+<li><p>Enter <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">help</span></code> for a list of rtg commands. Help for any
 individual command is available using the <code class="docutils literal notranslate"><span class="pre">--help</span></code> flag, e.g.:
-<code class="docutils literal notranslate"><span class="pre">./rtg</span> <span class="pre">format</span> <span class="pre">--help</span></code></li>
-<li>By default, RTG software scripts establish a memory space of 90% of
+<code class="docutils literal notranslate"><span class="pre">./rtg</span> <span class="pre">format</span> <span class="pre">--help</span></code></p></li>
+<li><p>By default, RTG software scripts establish a memory space of 90% of
 the available RAM - this is automatically calculated. One may
 override this limit by setting the <code class="docutils literal notranslate"><span class="pre">RTG_MEM</span></code> variable in the
-<code class="docutils literal notranslate"><span class="pre">rtg.bat</span></code> script or as an environment variable.</li>
+<code class="docutils literal notranslate"><span class="pre">rtg.bat</span></code> script or as an environment variable.</p></li>
 </ul>
 </div>
 <div class="section" id="license-management">
@@ -925,8 +851,8 @@ <h3>License Management<a class="headerlink" href="#license-management" title="Pe
 </pre></div>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For more data center deployment and instructions for
+<p class="admonition-title">See also</p>
+<p>For more data center deployment and instructions for
 editing scripts, see <a class="reference internal" href="administration.html#administration-capacity-planning"><span class="std std-ref">Administration &amp; Capacity Planning</span></a>.</p>
 </div>
 </div>
@@ -944,9 +870,78 @@ <h2>Technical assistance and support<a class="headerlink" href="#technical-assis
 </div>
 
 
+            <div class="clearer"></div>
           </div>
         </div>
       </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="index.html">
+              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
+            </a></p>
+  <h3><a href="index.html">Table of Contents</a></h3>
+  <ul>
+<li><a class="reference internal" href="#">Overview</a><ul>
+<li><a class="reference internal" href="#introduction">Introduction</a></li>
+<li><a class="reference internal" href="#rtg-software-description">RTG software description</a></li>
+<li><a class="reference internal" href="#sequence-search-and-alignment">Sequence search and alignment</a><ul>
+<li><a class="reference internal" href="#data-formatting">Data formatting</a></li>
+<li><a class="reference internal" href="#read-mapping-and-alignment">Read mapping and alignment</a></li>
+<li><a class="reference internal" href="#read-mapping-output-files">Read mapping output files</a></li>
+<li><a class="reference internal" href="#read-mapping-sensitivity-tuning">Read mapping sensitivity tuning</a></li>
+<li><a class="reference internal" href="#protein-search">Protein search</a></li>
+<li><a class="reference internal" href="#protein-search-output-files">Protein search output files</a></li>
+<li><a class="reference internal" href="#protein-search-sensitivity-tuning">Protein search sensitivity tuning</a></li>
+<li><a class="reference internal" href="#benchmarking-and-optimization-utilities">Benchmarking and optimization utilities</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#variant-detection-functions">Variant detection functions</a><ul>
+<li><a class="reference internal" href="#sequence-variation-snps-indels-and-complex-variants">Sequence variation (SNPs, indels and complex variants)</a></li>
+<li><a class="reference internal" href="#sequence-variation-with-mendelian-pedigree">Sequence variation with Mendelian pedigree</a></li>
+<li><a class="reference internal" href="#somatic-sequence-variation">Somatic sequence variation</a></li>
+<li><a class="reference internal" href="#coverage-analysis">Coverage analysis</a></li>
+<li><a class="reference internal" href="#copy-number-variation-cnv-analysis">Copy number variation (CNV) analysis</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#standard-input-and-output-file-formats">Standard input and output file formats</a><ul>
+<li><a class="reference internal" href="#sam-bam-files-created-by-the-rtg-map-command">SAM/BAM files created by the RTG map command</a></li>
+<li><a class="reference internal" href="#variant-caller-output-files">Variant caller output files</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#metagenomic-analysis-functions">Metagenomic analysis functions</a><ul>
+<li><a class="reference internal" href="#contamination-filtering">Contamination filtering</a></li>
+<li><a class="reference internal" href="#taxon-abundance-breakdown">Taxon abundance breakdown</a></li>
+<li><a class="reference internal" href="#sample-relationships">Sample relationships</a></li>
+<li><a class="reference internal" href="#functional-protein-analysis">Functional protein analysis</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#pipelines">Pipelines</a></li>
+<li><a class="reference internal" href="#parallel-processing">Parallel processing</a></li>
+<li><a class="reference internal" href="#installation-and-deployment">Installation and deployment</a><ul>
+<li><a class="reference internal" href="#quick-start-instructions">Quick start instructions</a></li>
+<li><a class="reference internal" href="#license-management">License Management</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#technical-assistance-and-support">Technical assistance and support</a></li>
+</ul>
+</li>
+</ul>
+
+  <h4>Previous topic</h4>
+  <p class="topless"><a href="index.html"
+                        title="previous chapter">Table Of Contents</a></p>
+  <h4>Next topic</h4>
+  <p class="topless"><a href="rtg_command_reference.html"
+                        title="next chapter">RTG Command Reference</a></p>
+  <div role="note" aria-label="source link">
+    <h3>This Page</h3>
+    <ul class="this-page-menu">
+      <li><a href="_sources/overview.rst.txt"
+            rel="nofollow">Show Source</a></li>
+    </ul>
+   </div>
+        </div>
+      </div>
       <div class="clearer"></div>
     </div>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -961,12 +956,13 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="index.html" title="Table Of Contents"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Overview</a></li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2017, Real Time Genomics.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.8.5.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.1.2.
     </div>
   </body>
 </html>
\ No newline at end of file
diff --git a/installer/resources/core/RTGOperationsManual/product_usage.html b/installer/resources/core/RTGOperationsManual/product_usage.html
index c9c8f238f..ad425fd92 100644
--- a/installer/resources/core/RTGOperationsManual/product_usage.html
+++ b/installer/resources/core/RTGOperationsManual/product_usage.html
@@ -2,27 +2,27 @@
 
 <!doctype html>
 
-<html xmlns="http://www.w3.org/1999/xhtml">
+<html>
   <head>
-    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>RTG product usage - baseline progressions &#8212; RTG Core Operations Manual v3.11</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RTG product usage - baseline progressions &#8212; RTG Core Operations Manual v3.12</title>
     <link rel="stylesheet" href="_static/bizstyle.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     
-    <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <script type="text/javascript" src="_static/language_data.js"></script>
-    <script type="text/javascript" src="_static/bizstyle.js"></script>
+    <script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+    <script src="_static/jquery.js"></script>
+    <script src="_static/underscore.js"></script>
+    <script src="_static/doctools.js"></script>
+    <script src="_static/language_data.js"></script>
+    <script src="_static/bizstyle.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
     <link rel="next" title="Administration &amp; Capacity Planning" href="administration.html" />
     <link rel="prev" title="RTG Command Reference" href="rtg_command_reference.html" />
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
     <!--[if lt IE 9]>
-    <script type="text/javascript" src="_static/css3-mediaqueries.js"></script>
+    <script src="_static/css3-mediaqueries.js"></script>
     <![endif]-->
   </head><body>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -37,109 +37,10 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="rtg_command_reference.html" title="RTG Command Reference"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">RTG product usage - baseline progressions</a></li> 
       </ul>
-    </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-            <p class="logo"><a href="index.html">
-              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
-            </a></p>
-  <h3><a href="index.html">Table of Contents</a></h3>
-  <ul>
-<li><a class="reference internal" href="#">RTG product usage - baseline progressions</a><ul>
-<li><a class="reference internal" href="#human-read-mapping-and-sequence-variant-detection">Human read mapping and sequence variant detection</a><ul>
-<li><a class="reference internal" href="#task-1-format-reference-data">Task 1 - Format reference data</a></li>
-<li><a class="reference internal" href="#task-2-prepare-sex-pedigree-information">Task 2 - Prepare sex/pedigree information</a></li>
-<li><a class="reference internal" href="#task-3-format-read-data">Task 3 - Format read data</a></li>
-<li><a class="reference internal" href="#task-4-map-reads-to-the-reference-genome">Task 4 - Map reads to the reference genome</a></li>
-<li><a class="reference internal" href="#task-5-view-and-evaluate-mapping-performance">Task 5 - View and evaluate mapping performance</a></li>
-<li><a class="reference internal" href="#task-6-generate-and-review-coverage-information">Task 6 - Generate and review coverage information</a></li>
-<li><a class="reference internal" href="#task-7-call-sequence-variants-single-sample">Task 7 - Call sequence variants (single sample)</a></li>
-<li><a class="reference internal" href="#task-8-call-sequence-variants-single-family">Task 8 - Call sequence variants (single family)</a></li>
-<li><a class="reference internal" href="#task-9-call-population-sequence-variants">Task 9 - Call population sequence variants</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#create-and-use-population-priors-in-variant-calling">Create and use population priors in variant calling</a><ul>
-<li><a class="reference internal" href="#task-1-produce-population-priors-file">Task 1 - Produce population priors file</a></li>
-<li><a class="reference internal" href="#task-2-run-variant-calling-using-population-priors">Task 2 - Run variant calling using population priors</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#somatic-variant-detection-in-cancer">Somatic variant detection in cancer</a><ul>
-<li><a class="reference internal" href="#task-1-format-reference-data-somatic">Task 1 - Format reference data (Somatic)</a></li>
-<li><a class="reference internal" href="#task-2-format-read-data-somatic">Task 2 - Format read data (Somatic)</a></li>
-<li><a class="reference internal" href="#task-3-map-tumor-and-normal-sample-reads-against-the-reference-genome">Task 3 - Map tumor and normal sample reads against the reference genome</a></li>
-<li><a class="reference internal" href="#task-4-call-somatic-variants">Task 4 - Call somatic variants</a></li>
-<li><a class="reference internal" href="#using-site-specific-somatic-priors">Using site-specific somatic priors</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#avr-scoring-using-hapmap-for-model-building">AVR scoring using HAPMAP for model building</a><ul>
-<li><a class="reference internal" href="#task-1-create-training-data">Task 1 - Create training data</a></li>
-<li><a class="reference internal" href="#task-2-build-and-check-avr-model">Task 2 - Build and check AVR model</a></li>
-<li><a class="reference internal" href="#task-3-use-avr-model">Task 3 - Use AVR model</a></li>
-<li><a class="reference internal" href="#task-4-install-avr-model">Task 4 - Install AVR model</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#rtg-structural-variant-detection">RTG structural variant detection</a><ul>
-<li><a class="reference internal" href="#task-1-prepare-read-group-statistics-files">Task 1 - Prepare Read-group statistics files</a></li>
-<li><a class="reference internal" href="#task-2-find-structural-variants-with-sv">Task 2 - Find structural variants with sv</a></li>
-<li><a class="reference internal" href="#task-3-find-structural-variants-with-discord">Task 3 - Find structural variants with discord</a></li>
-<li><a class="reference internal" href="#task-4-report-copy-number-variation-statistics">Task 4 - Report copy number variation statistics</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#ion-torrent-bacterial-mapping-and-sequence-variant-detection">Ion Torrent bacterial mapping and sequence variant detection</a><ul>
-<li><a class="reference internal" href="#task-1-format-bacterial-reference-data-ion-torrent">Task 1 - Format bacterial reference data (Ion Torrent)</a></li>
-<li><a class="reference internal" href="#task-2-format-read-data-ion-torrent">Task 2 - Format read data (Ion Torrent)</a></li>
-<li><a class="reference internal" href="#task-3-map-ion-torrent-reads-to-the-reference-genome">Task 3 - Map Ion Torrent reads to the reference genome</a></li>
-<li><a class="reference internal" href="#task-4-call-sequence-variants-in-haploid-mode">Task 4 - Call sequence variants in haploid mode</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#rtg-contaminant-filtering">RTG contaminant filtering</a><ul>
-<li><a class="reference internal" href="#task-1-format-reference-data-contaminant-filtering">Task 1 - Format reference data (contaminant filtering)</a></li>
-<li><a class="reference internal" href="#task-2-format-read-data-contaminant-filtering">Task 2 - Format read data (contaminant filtering)</a></li>
-<li><a class="reference internal" href="#task-3-run-contamination-filter">Task 3 - Run contamination filter</a></li>
-<li><a class="reference internal" href="#task-4-manage-filtered-reads">Task 4 - Manage filtered reads</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#rtg-translated-protein-searching">RTG translated protein searching</a><ul>
-<li><a class="reference internal" href="#task-1-format-protein-data-set">Task 1 - Format protein data set</a></li>
-<li><a class="reference internal" href="#task-2-format-dna-read-set">Task 2 - Format DNA read set</a></li>
-<li><a class="reference internal" href="#task-3-search-against-protein-data-set">Task 3 - Search against protein data set</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#rtg-species-frequency-estimation">RTG species frequency estimation</a><ul>
-<li><a class="reference internal" href="#task-1-format-reference-data-species">Task 1 - Format reference data (species)</a></li>
-<li><a class="reference internal" href="#task-2-format-read-data-species">Task 2 - Format read data (species)</a></li>
-<li><a class="reference internal" href="#task-3-run-contamination-filter-optional">Task 3 - Run contamination filter (optional)</a></li>
-<li><a class="reference internal" href="#task-4-map-metagenomic-reads-against-bacterial-database">Task 4 - Map metagenomic reads against bacterial database</a></li>
-<li><a class="reference internal" href="#task-5-run-species-estimator">Task 5 - Run species estimator</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#rtg-sample-similarity">RTG sample similarity</a><ul>
-<li><a class="reference internal" href="#task-1-prepare-read-sets">Task 1 - Prepare read sets</a></li>
-<li><a class="reference internal" href="#task-2-generate-read-set-name-map">Task 2 - Generate read set name map</a></li>
-<li><a class="reference internal" href="#task-3-run-similarity-tool">Task 3 - Run similarity tool</a></li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="rtg_command_reference.html"
-                        title="previous chapter">RTG Command Reference</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="administration.html"
-                        title="next chapter">Administration &amp; Capacity Planning</a></p>
-  <div role="note" aria-label="source link">
-    <h3>This Page</h3>
-    <ul class="this-page-menu">
-      <li><a href="_sources/product_usage.rst.txt"
-            rel="nofollow">Show Source</a></li>
-    </ul>
-   </div>
-        </div>
-      </div>
+    </div>  
 
     <div class="document">
       <div class="documentwrapper">
@@ -191,64 +92,64 @@ <h2>Human read mapping and sequence variant detection<a class="headerlink" href=
 sequencing data for these samples is available via
 <a class="reference external" href="http://www.completegenomics.com/public-data/69-Genomes/">http://www.completegenomics.com/public-data/69-Genomes/</a></p>
 <p>Table : Overview of basic pipeline stages</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="20%" />
-<col width="15%" />
-<col width="61%" />
+<col style="width: 4%" />
+<col style="width: 20%" />
+<col style="width: 15%" />
+<col style="width: 61%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="2">Task</th>
-<th class="head">Command &amp; Utilities</th>
-<th class="head">Purpose</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="2"><p>Task</p></th>
+<th class="head"><p>Command &amp; Utilities</p></th>
+<th class="head"><p>Purpose</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>1</td>
-<td>Format reference data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert reference sequence from FASTA files to RTG Sequence Data Format (SDF)</td>
+<tbody>
+<tr class="row-even"><td><p>1</p></td>
+<td><p>Format reference data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert reference sequence from FASTA files to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-odd"><td>2</td>
-<td>Prepare pedigree/sex information</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">pedstats</span></code></td>
-<td>Configure per-sample sex and pedigree relationship information in a PED file</td>
+<tr class="row-odd"><td><p>2</p></td>
+<td><p>Prepare pedigree/sex information</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">pedstats</span></code></p></td>
+<td><p>Configure per-sample sex and pedigree relationship information in a PED file</p></td>
 </tr>
-<tr class="row-even"><td>3</td>
-<td>Format read data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code>, <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">cg2sdf</span></code></td>
-<td>Convert read sequence from FASTA or FASTQ files to RTG Sequence Data Format (SDF)</td>
+<tr class="row-even"><td><p>3</p></td>
+<td><p>Format read data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code>, <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">cg2sdf</span></code></p></td>
+<td><p>Convert read sequence from FASTA or FASTQ files to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-odd"><td>4</td>
-<td>Map reads against a reference genome</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">map</span></code>, <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">cgmap</span></code></td>
-<td>Generate read alignments against a given reference, and report in a BAM file for downstream analysis</td>
+<tr class="row-odd"><td><p>4</p></td>
+<td><p>Map reads against a reference genome</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">map</span></code>, <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">cgmap</span></code></p></td>
+<td><p>Generate read alignments against a given reference, and report in a BAM file for downstream analysis</p></td>
 </tr>
-<tr class="row-even"><td>5</td>
-<td>View alignment results</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">samstats</span></code></td>
-<td>Evaluate alignments and determine if the mapping should be repeated with different settings</td>
+<tr class="row-even"><td><p>5</p></td>
+<td><p>View alignment results</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">samstats</span></code></p></td>
+<td><p>Evaluate alignments and determine if the mapping should be repeated with different settings</p></td>
 </tr>
-<tr class="row-odd"><td>6</td>
-<td>Generate coverage information</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">coverage</span></code></td>
-<td>Run the coverage command to generate coverage breadth and depth statistics</td>
+<tr class="row-odd"><td><p>6</p></td>
+<td><p>Generate coverage information</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">coverage</span></code></p></td>
+<td><p>Run the coverage command to generate coverage breadth and depth statistics</p></td>
 </tr>
-<tr class="row-even"><td>7</td>
-<td>Call sequence variants (single sample)</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">snp</span></code></td>
-<td>Detect SNPs, MNPs, and indels in a sample relative to a reference genome</td>
+<tr class="row-even"><td><p>7</p></td>
+<td><p>Call sequence variants (single sample)</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">snp</span></code></p></td>
+<td><p>Detect SNPs, MNPs, and indels in a sample relative to a reference genome</p></td>
 </tr>
-<tr class="row-odd"><td>8</td>
-<td>Call sequence variants (single family)</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">family</span></code></td>
-<td>Perform sex-aware joint variant calls relative to the reference on a Mendelian family</td>
+<tr class="row-odd"><td><p>8</p></td>
+<td><p>Call sequence variants (single family)</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">family</span></code></p></td>
+<td><p>Perform sex-aware joint variant calls relative to the reference on a Mendelian family</p></td>
 </tr>
-<tr class="row-even"><td>9</td>
-<td>Call sequence variants (population)</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">population</span></code></td>
-<td>Perform sex-aware joint variant calls relative to the reference on a population</td>
+<tr class="row-even"><td><p>9</p></td>
+<td><p>Call sequence variants (population)</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">population</span></code></p></td>
+<td><p>Perform sex-aware joint variant calls relative to the reference on a population</p></td>
 </tr>
 </tbody>
 </table>
@@ -309,8 +210,8 @@ <h3>Task 1 - Format reference data<a class="headerlink" href="#task-1-format-ref
 help identify potential pipeline issues that arise from incorrectly
 using different human reference builds at different pipeline stages.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">When formatting a reference genome, the <code class="docutils literal notranslate"><span class="pre">format</span></code> command
+<p class="admonition-title">Note</p>
+<p>When formatting a reference genome, the <code class="docutils literal notranslate"><span class="pre">format</span></code> command
 will automatically recognize several common human reference genomes
 and install a <code class="docutils literal notranslate"><span class="pre">reference.txt</span></code> configuration file.  For reference
 genomes which are not recognized, you should copy or create an
@@ -509,21 +410,21 @@ <h3>Task 3 - Format read data<a class="headerlink" href="#task-3-format-read-dat
 SAM/BAM. There are pros and cons as to whether to perform an initial
 format of the read sequence data to RTG SDF:</p>
 <ul class="simple">
-<li>Pre-formatting requires an extra one-off workflow step (the <code class="docutils literal notranslate"><span class="pre">format</span></code>
+<li><p>Pre-formatting requires an extra one-off workflow step (the <code class="docutils literal notranslate"><span class="pre">format</span></code>
 command), whereas native input file formats are directly accepted by
-many RTG commands.</li>
-<li>Pre-formatting requires extra disk space for the SDF (although these
-can be deleted after processing if required).</li>
-<li>With pre-formatting, decompression, parsing and error checking raw
+many RTG commands.</p></li>
+<li><p>Pre-formatting requires extra disk space for the SDF (although these
+can be deleted after processing if required).</p></li>
+<li><p>With pre-formatting, decompression, parsing and error checking raw
 files is carried out only once, whereas native formats require this
-processing each time.</li>
-<li>Pre-formatting permits random access to individual sequences or
+processing each time.</p></li>
+<li><p>Pre-formatting permits random access to individual sequences or
 blocks of sequences, whereas with native formats, the whole file
 leading up to the region of interest must also be decompressed, and
-parsed.</li>
-<li>Pre-formatting permits loading of sequence data, sequence names, and
+parsed.</p></li>
+<li><p>Pre-formatting permits loading of sequence data, sequence names, and
 sequence quality values independently, allowing reduced RAM use
-during mapping</li>
+during mapping</p></li>
 </ul>
 <p>Thus, pre-formatting read sequence data can result in lower overall
 resource requirements (and faster throughput) than processing native
@@ -676,8 +577,8 @@ <h3>Task 4 - Map reads to the reference genome<a class="headerlink" href="#task-
 <p>Note that supplying a BED file does restrict the locations to which reads are
 mapped, it is only used to ensure calibration information is correctly calculated.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">The exome capture BED file must correspond to the correct
+<p class="admonition-title">Note</p>
+<p>The exome capture BED file must correspond to the correct
 reference you are mapping and calling against. You may need to
 run the BED file supplied by your sequencing vendor through a
 lift-over tool if the reference genome versions differ.</p>
@@ -935,8 +836,8 @@ <h3>Task 7 - Call sequence variants (single sample)<a class="headerlink" href="#
 done by specifying the corresponding sample ID used during mapping to the
 command line flags <code class="docutils literal notranslate"><span class="pre">--mother</span></code>, <code class="docutils literal notranslate"><span class="pre">--father</span></code>, <code class="docutils literal notranslate"><span class="pre">--daughter</span></code> and <code class="docutils literal notranslate"><span class="pre">--son</span></code>.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">The RTG <code class="docutils literal notranslate"><span class="pre">family</span></code> command only supports a basic
+<p class="admonition-title">Note</p>
+<p>The RTG <code class="docutils literal notranslate"><span class="pre">family</span></code> command only supports a basic
 family relationship of a mother, father and one or more children, either
 daughters or sons. For other pedigrees, use the <code class="docutils literal notranslate"><span class="pre">population</span></code> command.</p>
 </div>
@@ -958,8 +859,8 @@ <h3>Task 7 - Call sequence variants (single sample)<a class="headerlink" href="#
 individual columns for the variants of each family member. For more
 details about the VCF output file see <a class="reference internal" href="appendix.html#small-variant-vcf-output-file-description"><span class="std std-ref">Small-variant VCF output file description</span></a></p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">Per-family relationship information can also be specified
+<p class="admonition-title">Note</p>
+<p>Per-family relationship information can also be specified
 using a pedigree PED file with the <code class="docutils literal notranslate"><span class="pre">--pedigree</span></code> flag. In this case,
 the pedigree file should contain a single family only.</p>
 </div>
@@ -1004,39 +905,39 @@ <h2>Create and use population priors in variant calling<a class="headerlink" hre
 <p><strong>Data</strong></p>
 <p>For this use case it is assumed that the following data is available:</p>
 <ul class="simple">
-<li><code class="docutils literal notranslate"><span class="pre">/data/runs/20humans.vcf.gz</span></code> - output from a previous population
-command run on 20 humans from a population.</li>
-<li><code class="docutils literal notranslate"><span class="pre">/data/reference/human_reference</span></code> - SDF containing the human
-reference sequences.</li>
-<li><code class="docutils literal notranslate"><span class="pre">/data/mappings/new_human.txt</span></code> - text file containing a list of BAM
+<li><p><code class="docutils literal notranslate"><span class="pre">/data/runs/20humans.vcf.gz</span></code> - output from a previous population
+command run on 20 humans from a population.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">/data/reference/human_reference</span></code> - SDF containing the human
+reference sequences.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">/data/mappings/new_human.txt</span></code> - text file containing a list of BAM
 files with the sequence alignments for the new member of the
-population.</li>
+population.</p></li>
 </ul>
 <p>Table : Overview of pipeline tasks.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="24%" />
-<col width="13%" />
-<col width="58%" />
+<col style="width: 4%" />
+<col style="width: 24%" />
+<col style="width: 13%" />
+<col style="width: 58%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="2">Task</th>
-<th class="head">Command &amp; Utilities</th>
-<th class="head">Purpose</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="2"><p>Task</p></th>
+<th class="head"><p>Command &amp; Utilities</p></th>
+<th class="head"><p>Purpose</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>1</td>
-<td>Produce population priors file</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">vcfannotate</span></code>,
-<code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">vcfsubset</span></code></td>
-<td>Produce a reusable set of population priors from an existing VCF file</td>
+<tbody>
+<tr class="row-even"><td><p>1</p></td>
+<td><p>Produce population priors file</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">vcfannotate</span></code>,
+<code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">vcfsubset</span></code></p></td>
+<td><p>Produce a reusable set of population priors from an existing VCF file</p></td>
 </tr>
-<tr class="row-odd"><td>2</td>
-<td>Run variant calling using population priors</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">snp</span></code></td>
-<td>Perform variant calling on the new member of the population using the new population priors to improve results</td>
+<tr class="row-odd"><td><p>2</p></td>
+<td><p>Run variant calling using population priors</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">snp</span></code></p></td>
+<td><p>Perform variant calling on the new member of the population using the new population priors to improve results</p></td>
 </tr>
 </tbody>
 </table>
@@ -1092,39 +993,39 @@ <h2>Somatic variant detection in cancer<a class="headerlink" href="#somatic-vari
 there is no matched normal sample.</p>
 <p>Follow the steps below to obtain somatic variant calls.</p>
 <p>Table : Overview of somatic pipeline tasks.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="23%" />
-<col width="11%" />
-<col width="61%" />
+<col style="width: 4%" />
+<col style="width: 23%" />
+<col style="width: 11%" />
+<col style="width: 61%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="2">Task</th>
-<th class="head">Command &amp; Utilities</th>
-<th class="head">Purpose</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="2"><p>Task</p></th>
+<th class="head"><p>Command &amp; Utilities</p></th>
+<th class="head"><p>Purpose</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>1</td>
-<td>Format reference data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert reference sequence from FASTA file to RTG Sequence Data Format (SDF)</td>
+<tbody>
+<tr class="row-even"><td><p>1</p></td>
+<td><p>Format reference data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert reference sequence from FASTA file to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-odd"><td>2</td>
-<td>Format read data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert read sequence from FASTA and FASTQ files to RTG Sequence Data Format (SDF)</td>
+<tr class="row-odd"><td><p>2</p></td>
+<td><p>Format read data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert read sequence from FASTA and FASTQ files to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-even"><td>3</td>
-<td>Map reads against the reference genome</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">map</span></code></td>
-<td>Generate read alignments for the sample(s), and report in a BAM file for downstream analysis</td>
+<tr class="row-even"><td><p>3</p></td>
+<td><p>Map reads against the reference genome</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">map</span></code></p></td>
+<td><p>Generate read alignments for the sample(s), and report in a BAM file for downstream analysis</p></td>
 </tr>
-<tr class="row-odd"><td>4</td>
-<td>Call somatic variants</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">somatic</span></code></td>
-<td>Detect somatic variants in the tumor sample</td>
+<tr class="row-odd"><td><p>4</p></td>
+<td><p>Call somatic variants</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">somatic</span></code></p></td>
+<td><p>Detect somatic variants in the tumor sample</p></td>
 </tr>
 </tbody>
 </table>
@@ -1194,9 +1095,9 @@ <h3>Task 4 - Call somatic variants<a class="headerlink" href="#task-4-call-somat
 to specify the sample IDs corresponding to the normal and cancer
 samples, with the <code class="docutils literal notranslate"><span class="pre">--original</span></code> and <code class="docutils literal notranslate"><span class="pre">--derived</span></code> flags respectively.</p>
 <blockquote>
-<div><dl class="docutils">
-<dt>$ rtg somatic -t grch38 -o somatic_out –contamination 0.3 </dt>
-<dd>–derived sm_tumor –original sm_normal normal_map_*/alignments.bam tumor_map_*/alignments.bam</dd>
+<div><dl class="simple">
+<dt>$ rtg somatic -t grch38 -o somatic_out –contamination 0.3 </dt><dd><p>–derived sm_tumor –original sm_normal normal_map_*/alignments.bam tumor_map_*/alignments.bam</p>
+</dd>
 </dl>
 </div></blockquote>
 <p>Examining the <code class="docutils literal notranslate"><span class="pre">snps.vcf.gz</span></code> file in the output directory will show a
@@ -1372,43 +1273,43 @@ <h2>AVR scoring using HAPMAP for model building<a class="headerlink" href="#avr-
 command for the 1000 genomes CEU trio NA12878, NA12891 and NA12892. For
 this example this will be called <code class="docutils literal notranslate"><span class="pre">/data/runs/NA12878trio/family.vcf.gz</span></code>.</p>
 <p>Table : Overview of basic pipeline tasks.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="19%" />
-<col width="14%" />
-<col width="61%" />
+<col style="width: 5%" />
+<col style="width: 19%" />
+<col style="width: 14%" />
+<col style="width: 61%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="2">Task</th>
-<th class="head">Command &amp; Utilities</th>
-<th class="head">Purpose</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="2"><p>Task</p></th>
+<th class="head"><p>Command &amp; Utilities</p></th>
+<th class="head"><p>Purpose</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>1</td>
-<td>Create training data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">vcffilter</span></code></td>
-<td>To generate positive and negative examples for the AVR machine learning model to train on</td>
+<tbody>
+<tr class="row-even"><td><p>1</p></td>
+<td><p>Create training data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">vcffilter</span></code></p></td>
+<td><p>To generate positive and negative examples for the AVR machine learning model to train on</p></td>
 </tr>
-<tr class="row-odd"><td>2</td>
-<td>Build and check AVR model</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">avrbuild</span></code>,
-<code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">avrstats</span></code></td>
-<td>To create and check an AVR model</td>
+<tr class="row-odd"><td><p>2</p></td>
+<td><p>Build and check AVR model</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">avrbuild</span></code>,
+<code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">avrstats</span></code></p></td>
+<td><p>To create and check an AVR model</p></td>
 </tr>
-<tr class="row-even"><td>3</td>
-<td>Use AVR model</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">avrpredict</span></code>,
+<tr class="row-even"><td><p>3</p></td>
+<td><p>Use AVR model</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">avrpredict</span></code>,
 <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">snp</span></code>,
 <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">family</span></code>,
-<code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">population</span></code></td>
-<td>To apply the AVR model to the existing output or to use it directly during variant calling</td>
+<code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">population</span></code></p></td>
+<td><p>To apply the AVR model to the existing output or to use it directly during variant calling</p></td>
 </tr>
-<tr class="row-odd"><td>4</td>
-<td>Install AVR model</td>
-<td><code class="docutils literal notranslate"><span class="pre">cp</span></code></td>
-<td>Install model in standard RTG model location for later reuse</td>
+<tr class="row-odd"><td><p>4</p></td>
+<td><p>Install AVR model</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">cp</span></code></p></td>
+<td><p>Install model in standard RTG model location for later reuse</p></td>
 </tr>
 </tbody>
 </table>
@@ -1554,30 +1455,30 @@ <h3>Task 4 - Install AVR model<a class="headerlink" href="#task-4-install-avr-mo
 </div>
 <p>The AVR model directory will already contain the models prebuilt by RTG:</p>
 <ul class="simple">
-<li><code class="docutils literal notranslate"><span class="pre">illumina-exome.avr</span></code> - model built from Illumina exome sequencing
+<li><p><code class="docutils literal notranslate"><span class="pre">illumina-exome.avr</span></code> - model built from Illumina exome sequencing
 data. If you are running variant calling Illumina exome data you
 may want to use this model instead of the default, although the
-default should still be effective.</li>
-<li><code class="docutils literal notranslate"><span class="pre">illumina-wgs.avr</span></code> - model built from Illumina whole genome
+default should still be effective.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">illumina-wgs.avr</span></code> - model built from Illumina whole genome
 sequencing data. This model is the default model when running normal
-variant calling.</li>
-<li><dl class="first docutils">
-<dt><code class="docutils literal notranslate"><span class="pre">illumina-somatic.avr</span></code> - model built from somatic samples using</dt>
-<dd>Illumina sequencing. It is applicable to somatic variant calling,
+variant calling.</p></li>
+<li><dl class="simple">
+<dt><code class="docutils literal notranslate"><span class="pre">illumina-somatic.avr</span></code> - model built from somatic samples using</dt><dd><p>Illumina sequencing. It is applicable to somatic variant calling,
 where a variety of allelic fractions are to be expected in somatic
 variants. The <code class="docutils literal notranslate"><span class="pre">somatic</span></code> command defaults to this AVR model.  If
 you want to score germline variants in a somatic run, it is
 preferable to use <code class="docutils literal notranslate"><span class="pre">illumina-wgs.avr</span></code> or <code class="docutils literal notranslate"><span class="pre">illumina-exome.wgs</span></code>
-instead.</dd>
+instead.</p>
+</dd>
 </dl>
 </li>
-<li><code class="docutils literal notranslate"><span class="pre">alternate.avr</span></code> - model built using <code class="docutils literal notranslate"><span class="pre">XRX</span></code>, <code class="docutils literal notranslate"><span class="pre">ZY</span></code> and <code class="docutils literal notranslate"><span class="pre">GQD</span></code> attributes.
+<li><p><code class="docutils literal notranslate"><span class="pre">alternate.avr</span></code> - model built using <code class="docutils literal notranslate"><span class="pre">XRX</span></code>, <code class="docutils literal notranslate"><span class="pre">ZY</span></code> and <code class="docutils literal notranslate"><span class="pre">GQD</span></code> attributes.
 This should be platform independent and may be a better choice if a
 more specific model for your data is unavailable. In particular, this
 model may be more appropriate for scoring the results of variant
 calling in situations where unusual allele-balance is expected (for
 example somatic calling with contamination, or calling high
-amplification data where allele drop out is expected)</li>
+amplification data where allele drop out is expected)</p></li>
 </ul>
 <p>It is possible to score a sample with more than one AVR model, by running
 <code class="docutils literal notranslate"><span class="pre">avrpredict</span></code> with another model and using a different field name
@@ -1601,39 +1502,39 @@ <h2>RTG structural variant detection<a class="headerlink" href="#rtg-structural-
 attribute to be either <code class="docutils literal notranslate"><span class="pre">ILLUMINA</span></code> (for Illumina reads) or <code class="docutils literal notranslate"><span class="pre">COMPLETE</span></code>
 (for Complete Genomics reads).</p>
 <p>Table : Overview of structural variants analysis pipeline tasks.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="24%" />
-<col width="12%" />
-<col width="60%" />
+<col style="width: 5%" />
+<col style="width: 24%" />
+<col style="width: 12%" />
+<col style="width: 60%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="2">Task</th>
-<th class="head">Command &amp; Utilities</th>
-<th class="head">Purpose</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="2"><p>Task</p></th>
+<th class="head"><p>Command &amp; Utilities</p></th>
+<th class="head"><p>Purpose</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>1</td>
-<td>Prepare read group statistics file</td>
-<td><code class="docutils literal notranslate"><span class="pre">find</span></code></td>
-<td>Identify read group statistics files created during mapping</td>
+<tbody>
+<tr class="row-even"><td><p>1</p></td>
+<td><p>Prepare read group statistics file</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">find</span></code></p></td>
+<td><p>Identify read group statistics files created during mapping</p></td>
 </tr>
-<tr class="row-odd"><td>2</td>
-<td>Find structural variants with sv</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">sv</span></code></td>
-<td>Process prepared mapping results to identify likely structural variants</td>
+<tr class="row-odd"><td><p>2</p></td>
+<td><p>Find structural variants with sv</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">sv</span></code></p></td>
+<td><p>Process prepared mapping results to identify likely structural variants</p></td>
 </tr>
-<tr class="row-even"><td>3</td>
-<td>Find structural variants with discord</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">discord</span></code></td>
-<td>Process prepared mapping results to identify likely structural variant breakends</td>
+<tr class="row-even"><td><p>3</p></td>
+<td><p>Find structural variants with discord</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">discord</span></code></p></td>
+<td><p>Process prepared mapping results to identify likely structural variant breakends</p></td>
 </tr>
-<tr class="row-odd"><td>4</td>
-<td>Find copy number variants</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">cnv</span></code></td>
-<td>Detect copy number variants between a pair of samples</td>
+<tr class="row-odd"><td><p>4</p></td>
+<td><p>Find copy number variants</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">cnv</span></code></p></td>
+<td><p>Detect copy number variants between a pair of samples</p></td>
 </tr>
 </tbody>
 </table>
@@ -1673,43 +1574,43 @@ <h3>Task 2 - Find structural variants with sv<a class="headerlink" href="#task-2
 alternative bayesian hypothesis at points along the reference genome.
 The currently supported hypotheses are shown in the following table.</p>
 <p>Table : Structural variant hypotheses.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="18%" />
-<col width="82%" />
+<col style="width: 18%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Hypothesis</th>
-<th class="head">Semantics</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Hypothesis</p></th>
+<th class="head"><p>Semantics</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">normal</span></code></td>
-<td>Normal mappings, no structural variants</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">normal</span></code></p></td>
+<td><p>Normal mappings, no structural variants</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">duplicate</span></code></td>
-<td>Above normal mappings, potential duplication region</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">duplicate</span></code></p></td>
+<td><p>Above normal mappings, potential duplication region</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">delete</span></code></td>
-<td>Below normal mappings, potential deletion region</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">delete</span></code></p></td>
+<td><p>Below normal mappings, potential deletion region</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">delete-left</span></code></td>
-<td>Mapping data suggest the left breakpoint of a deletion</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">delete-left</span></code></p></td>
+<td><p>Mapping data suggest the left breakpoint of a deletion</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">delete-right</span></code></td>
-<td>Mapping data suggest the right breakpoint of a deletion</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">delete-right</span></code></p></td>
+<td><p>Mapping data suggest the right breakpoint of a deletion</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">duplicate-left</span></code></td>
-<td>Mapping data suggest the left boundary of a region that has been copied elsewhere</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">duplicate-left</span></code></p></td>
+<td><p>Mapping data suggest the left boundary of a region that has been copied elsewhere</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">duplicate-right</span></code></td>
-<td>Mapping data suggest the right boundary of a region that has been copied elsewhere</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">duplicate-right</span></code></p></td>
+<td><p>Mapping data suggest the right boundary of a region that has been copied elsewhere</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">breakpoint</span></code></td>
-<td>Mapping data suggest this location has received an insertion of copied genome</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">breakpoint</span></code></p></td>
+<td><p>Mapping data suggest this location has received an insertion of copied genome</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">novel-insertion</span></code></td>
-<td>Mapping data suggests this location has received an insertion of material not present in the reference</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">novel-insertion</span></code></p></td>
+<td><p>Mapping data suggests this location has received an insertion of material not present in the reference</p></td>
 </tr>
 </tbody>
 </table>
@@ -1788,39 +1689,39 @@ <h2>Ion Torrent bacterial mapping and sequence variant detection<a class="header
 community (<a class="reference external" href="http://lifetech-it.hosted.jivesoftware.com">http://lifetech-it.hosted.jivesoftware.com</a>, requires
 registration).</p>
 <p>Table : Overview of basic pipeline tasks.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="23%" />
-<col width="11%" />
-<col width="61%" />
+<col style="width: 4%" />
+<col style="width: 23%" />
+<col style="width: 11%" />
+<col style="width: 61%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="2">Task</th>
-<th class="head">Command &amp; Utilities</th>
-<th class="head">Purpose</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="2"><p>Task</p></th>
+<th class="head"><p>Command &amp; Utilities</p></th>
+<th class="head"><p>Purpose</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>1</td>
-<td>Format reference data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert reference sequence from FASTA file to RTG Sequence Data Format (SDF)</td>
+<tbody>
+<tr class="row-even"><td><p>1</p></td>
+<td><p>Format reference data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert reference sequence from FASTA file to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-odd"><td>2</td>
-<td>Format read data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert read sequence from FASTA and FASTQ files to RTG Sequence Data Format (SDF)</td>
+<tr class="row-odd"><td><p>2</p></td>
+<td><p>Format read data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert read sequence from FASTA and FASTQ files to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-even"><td>3</td>
-<td>Map reads against the reference genome</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">map</span></code></td>
-<td>Generate read alignments for the normal and cancer samples, and report in a BAM file for downstream analysis</td>
+<tr class="row-even"><td><p>3</p></td>
+<td><p>Map reads against the reference genome</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">map</span></code></p></td>
+<td><p>Generate read alignments for the normal and cancer samples, and report in a BAM file for downstream analysis</p></td>
 </tr>
-<tr class="row-odd"><td>4</td>
-<td>Call sequence variants in haploid mode</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">snp</span></code></td>
-<td>Detect SNPs, MNPs, and indels in haploid sample relative to the reference genome</td>
+<tr class="row-odd"><td><p>4</p></td>
+<td><p>Call sequence variants in haploid mode</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">snp</span></code></p></td>
+<td><p>Detect SNPs, MNPs, and indels in haploid sample relative to the reference genome</p></td>
 </tr>
 </tbody>
 </table>
@@ -1900,39 +1801,39 @@ <h2>RTG contaminant filtering<a class="headerlink" href="#rtg-contaminant-filter
 sequence contaminating it. The following process removes any human reads
 leaving only bacteria reads.</p>
 <p>Table : Overview of contaminant filtering tasks.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="18%" />
-<col width="14%" />
-<col width="63%" />
+<col style="width: 5%" />
+<col style="width: 18%" />
+<col style="width: 14%" />
+<col style="width: 63%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="2">Task</th>
-<th class="head">Command &amp; Utilities</th>
-<th class="head">Purpose</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="2"><p>Task</p></th>
+<th class="head"><p>Command &amp; Utilities</p></th>
+<th class="head"><p>Purpose</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>1</td>
-<td>Format reference data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert reference sequence from FASTA file to RTG Sequence Data Format (SDF)</td>
+<tbody>
+<tr class="row-even"><td><p>1</p></td>
+<td><p>Format reference data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert reference sequence from FASTA file to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-odd"><td>2</td>
-<td>Format read data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert read sequence from FASTA and FASTQ files to RTG Sequence Data Format (SDF)</td>
+<tr class="row-odd"><td><p>2</p></td>
+<td><p>Format read data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert read sequence from FASTA and FASTQ files to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-even"><td>3</td>
-<td>Run contamination filter</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">mapf</span></code></td>
-<td>Produce the SDF file of reads which map to the contaminant and the SDF file of those that do not</td>
+<tr class="row-even"><td><p>3</p></td>
+<td><p>Run contamination filter</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">mapf</span></code></p></td>
+<td><p>Produce the SDF file of reads which map to the contaminant and the SDF file of those that do not</p></td>
 </tr>
-<tr class="row-odd"><td>4</td>
-<td>Manage filtered reads</td>
-<td><code class="docutils literal notranslate"><span class="pre">mv</span></code></td>
-<td>Set up the results for use in further processing</td>
+<tr class="row-odd"><td><p>4</p></td>
+<td><p>Manage filtered reads</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">mv</span></code></p></td>
+<td><p>Set up the results for use in further processing</p></td>
 </tr>
 </tbody>
 </table>
@@ -2105,34 +2006,34 @@ <h2>RTG translated protein searching<a class="headerlink" href="#rtg-translated-
 assumed non-redundant protein data set is called <code class="docutils literal notranslate"><span class="pre">nr.fasta</span></code> and the
 human gut sample is called <code class="docutils literal notranslate"><span class="pre">human-gut.fastq</span></code>.</p>
 <p>Table : Overview of translated protein searching tasks.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="23%" />
-<col width="14%" />
-<col width="57%" />
+<col style="width: 5%" />
+<col style="width: 23%" />
+<col style="width: 14%" />
+<col style="width: 57%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="2">Task</th>
-<th class="head">Command &amp; Utilities</th>
-<th class="head">Purpose</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="2"><p>Task</p></th>
+<th class="head"><p>Command &amp; Utilities</p></th>
+<th class="head"><p>Purpose</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>1</td>
-<td>Format protein data set</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert protein data set from FASTA to RTG sequence data format (SDF)</td>
+<tbody>
+<tr class="row-even"><td><p>1</p></td>
+<td><p>Format protein data set</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert protein data set from FASTA to RTG sequence data format (SDF)</p></td>
 </tr>
-<tr class="row-odd"><td>2</td>
-<td>Format DNA read set</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert read sequence from FASTA and FASTQ files to RTG Sequence Data Format (SDF)</td>
+<tr class="row-odd"><td><p>2</p></td>
+<td><p>Format DNA read set</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert read sequence from FASTA and FASTQ files to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-even"><td>3</td>
-<td>Search against protein data set</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">mapx</span></code></td>
-<td>Generate search results with alignments in tabular format</td>
+<tr class="row-even"><td><p>3</p></td>
+<td><p>Search against protein data set</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">mapx</span></code></p></td>
+<td><p>Generate search results with alignments in tabular format</p></td>
 </tr>
 </tbody>
 </table>
@@ -2187,44 +2088,44 @@ <h2>RTG species frequency estimation<a class="headerlink" href="#rtg-species-fre
 and from this estimates the relative frequency of each species in the
 database.</p>
 <p>Table : Overview of species frequency estimation tasks.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="25%" />
-<col width="10%" />
-<col width="61%" />
+<col style="width: 4%" />
+<col style="width: 25%" />
+<col style="width: 10%" />
+<col style="width: 61%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="2">Task</th>
-<th class="head">Command &amp; Utilities</th>
-<th class="head">Purpose</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="2"><p>Task</p></th>
+<th class="head"><p>Command &amp; Utilities</p></th>
+<th class="head"><p>Purpose</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>1</td>
-<td>Format reference data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert reference sequence from FASTA file to RTG Sequence Data Format (SDF)</td>
+<tbody>
+<tr class="row-even"><td><p>1</p></td>
+<td><p>Format reference data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert reference sequence from FASTA file to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-odd"><td>2</td>
-<td>Format read data</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert read sequence from FASTA and FASTQ files to RTG Sequence Data Format (SDF)</td>
+<tr class="row-odd"><td><p>2</p></td>
+<td><p>Format read data</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert read sequence from FASTA and FASTQ files to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-even"><td>3</td>
-<td>Run contamination filter (optional)</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">mapf</span></code></td>
-<td>Produce the SDF file of reads which map to the contaminant and the SDF file of those that do not</td>
+<tr class="row-even"><td><p>3</p></td>
+<td><p>Run contamination filter (optional)</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">mapf</span></code></p></td>
+<td><p>Produce the SDF file of reads which map to the contaminant and the SDF file of those that do not</p></td>
 </tr>
-<tr class="row-odd"><td>4</td>
-<td>Map metagenomic reads against bacterial database</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">map</span></code></td>
-<td>Generate read alignments against a given reference, and report in a BAM file for downstream analysis</td>
+<tr class="row-odd"><td><p>4</p></td>
+<td><p>Map metagenomic reads against bacterial database</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">map</span></code></p></td>
+<td><p>Generate read alignments against a given reference, and report in a BAM file for downstream analysis</p></td>
 </tr>
-<tr class="row-even"><td>5</td>
-<td>Run species estimator</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">species</span></code></td>
-<td>Produce a text file which contains a list of species, one per line, with an estimate of the relative frequency in the sample</td>
+<tr class="row-even"><td><p>5</p></td>
+<td><p>Run species estimator</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">species</span></code></p></td>
+<td><p>Produce a text file which contains a list of species, one per line, with an estimate of the relative frequency in the sample</p></td>
 </tr>
 </tbody>
 </table>
@@ -2340,35 +2241,35 @@ <h2>RTG sample similarity<a class="headerlink" href="#rtg-sample-similarity" tit
 sets independent of any reference genome. It does this by examining
 <em>k</em>-mer word frequencies and the intersections between sets of reads.</p>
 <p>Table : Overview of sample similarity tasks.</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="22%" />
-<col width="16%" />
-<col width="58%" />
+<col style="width: 5%" />
+<col style="width: 22%" />
+<col style="width: 16%" />
+<col style="width: 58%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Task</th>
-<th class="head">&#160;</th>
-<th class="head">Command &amp; Utilities</th>
-<th class="head">Purpose</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Task</p></th>
+<th class="head"></th>
+<th class="head"><p>Command &amp; Utilities</p></th>
+<th class="head"><p>Purpose</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>1</td>
-<td>Prepare read sets</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></td>
-<td>Convert reference sequence from FASTA file to RTG Sequence Data Format (SDF)</td>
+<tbody>
+<tr class="row-even"><td><p>1</p></td>
+<td><p>Prepare read sets</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span></code></p></td>
+<td><p>Convert reference sequence from FASTA file to RTG Sequence Data Format (SDF)</p></td>
 </tr>
-<tr class="row-odd"><td>2</td>
-<td>Generate read set name map</td>
-<td><code class="docutils literal notranslate"><span class="pre">text-editor</span></code></td>
-<td>Produce the map of names to read set SDF locations</td>
+<tr class="row-odd"><td><p>2</p></td>
+<td><p>Generate read set name map</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">text-editor</span></code></p></td>
+<td><p>Produce the map of names to read set SDF locations</p></td>
 </tr>
-<tr class="row-even"><td>3</td>
-<td>Run similarity tool</td>
-<td><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">similarity</span></code></td>
-<td>Process the read sets for similarity</td>
+<tr class="row-even"><td><p>3</p></td>
+<td><p>Run similarity tool</p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">similarity</span></code></p></td>
+<td><p>Process the read sets for similarity</p></td>
 </tr>
 </tbody>
 </table>
@@ -2456,9 +2357,110 @@ <h3>Task 3 - Run similarity tool<a class="headerlink" href="#task-3-run-similari
 </div>
 
 
+            <div class="clearer"></div>
           </div>
         </div>
       </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="index.html">
+              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
+            </a></p>
+  <h3><a href="index.html">Table of Contents</a></h3>
+  <ul>
+<li><a class="reference internal" href="#">RTG product usage - baseline progressions</a><ul>
+<li><a class="reference internal" href="#human-read-mapping-and-sequence-variant-detection">Human read mapping and sequence variant detection</a><ul>
+<li><a class="reference internal" href="#task-1-format-reference-data">Task 1 - Format reference data</a></li>
+<li><a class="reference internal" href="#task-2-prepare-sex-pedigree-information">Task 2 - Prepare sex/pedigree information</a></li>
+<li><a class="reference internal" href="#task-3-format-read-data">Task 3 - Format read data</a></li>
+<li><a class="reference internal" href="#task-4-map-reads-to-the-reference-genome">Task 4 - Map reads to the reference genome</a></li>
+<li><a class="reference internal" href="#task-5-view-and-evaluate-mapping-performance">Task 5 - View and evaluate mapping performance</a></li>
+<li><a class="reference internal" href="#task-6-generate-and-review-coverage-information">Task 6 - Generate and review coverage information</a></li>
+<li><a class="reference internal" href="#task-7-call-sequence-variants-single-sample">Task 7 - Call sequence variants (single sample)</a></li>
+<li><a class="reference internal" href="#task-8-call-sequence-variants-single-family">Task 8 - Call sequence variants (single family)</a></li>
+<li><a class="reference internal" href="#task-9-call-population-sequence-variants">Task 9 - Call population sequence variants</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#create-and-use-population-priors-in-variant-calling">Create and use population priors in variant calling</a><ul>
+<li><a class="reference internal" href="#task-1-produce-population-priors-file">Task 1 - Produce population priors file</a></li>
+<li><a class="reference internal" href="#task-2-run-variant-calling-using-population-priors">Task 2 - Run variant calling using population priors</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#somatic-variant-detection-in-cancer">Somatic variant detection in cancer</a><ul>
+<li><a class="reference internal" href="#task-1-format-reference-data-somatic">Task 1 - Format reference data (Somatic)</a></li>
+<li><a class="reference internal" href="#task-2-format-read-data-somatic">Task 2 - Format read data (Somatic)</a></li>
+<li><a class="reference internal" href="#task-3-map-tumor-and-normal-sample-reads-against-the-reference-genome">Task 3 - Map tumor and normal sample reads against the reference genome</a></li>
+<li><a class="reference internal" href="#task-4-call-somatic-variants">Task 4 - Call somatic variants</a></li>
+<li><a class="reference internal" href="#using-site-specific-somatic-priors">Using site-specific somatic priors</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#avr-scoring-using-hapmap-for-model-building">AVR scoring using HAPMAP for model building</a><ul>
+<li><a class="reference internal" href="#task-1-create-training-data">Task 1 - Create training data</a></li>
+<li><a class="reference internal" href="#task-2-build-and-check-avr-model">Task 2 - Build and check AVR model</a></li>
+<li><a class="reference internal" href="#task-3-use-avr-model">Task 3 - Use AVR model</a></li>
+<li><a class="reference internal" href="#task-4-install-avr-model">Task 4 - Install AVR model</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#rtg-structural-variant-detection">RTG structural variant detection</a><ul>
+<li><a class="reference internal" href="#task-1-prepare-read-group-statistics-files">Task 1 - Prepare Read-group statistics files</a></li>
+<li><a class="reference internal" href="#task-2-find-structural-variants-with-sv">Task 2 - Find structural variants with sv</a></li>
+<li><a class="reference internal" href="#task-3-find-structural-variants-with-discord">Task 3 - Find structural variants with discord</a></li>
+<li><a class="reference internal" href="#task-4-report-copy-number-variation-statistics">Task 4 - Report copy number variation statistics</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#ion-torrent-bacterial-mapping-and-sequence-variant-detection">Ion Torrent bacterial mapping and sequence variant detection</a><ul>
+<li><a class="reference internal" href="#task-1-format-bacterial-reference-data-ion-torrent">Task 1 - Format bacterial reference data (Ion Torrent)</a></li>
+<li><a class="reference internal" href="#task-2-format-read-data-ion-torrent">Task 2 - Format read data (Ion Torrent)</a></li>
+<li><a class="reference internal" href="#task-3-map-ion-torrent-reads-to-the-reference-genome">Task 3 - Map Ion Torrent reads to the reference genome</a></li>
+<li><a class="reference internal" href="#task-4-call-sequence-variants-in-haploid-mode">Task 4 - Call sequence variants in haploid mode</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#rtg-contaminant-filtering">RTG contaminant filtering</a><ul>
+<li><a class="reference internal" href="#task-1-format-reference-data-contaminant-filtering">Task 1 - Format reference data (contaminant filtering)</a></li>
+<li><a class="reference internal" href="#task-2-format-read-data-contaminant-filtering">Task 2 - Format read data (contaminant filtering)</a></li>
+<li><a class="reference internal" href="#task-3-run-contamination-filter">Task 3 - Run contamination filter</a></li>
+<li><a class="reference internal" href="#task-4-manage-filtered-reads">Task 4 - Manage filtered reads</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#rtg-translated-protein-searching">RTG translated protein searching</a><ul>
+<li><a class="reference internal" href="#task-1-format-protein-data-set">Task 1 - Format protein data set</a></li>
+<li><a class="reference internal" href="#task-2-format-dna-read-set">Task 2 - Format DNA read set</a></li>
+<li><a class="reference internal" href="#task-3-search-against-protein-data-set">Task 3 - Search against protein data set</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#rtg-species-frequency-estimation">RTG species frequency estimation</a><ul>
+<li><a class="reference internal" href="#task-1-format-reference-data-species">Task 1 - Format reference data (species)</a></li>
+<li><a class="reference internal" href="#task-2-format-read-data-species">Task 2 - Format read data (species)</a></li>
+<li><a class="reference internal" href="#task-3-run-contamination-filter-optional">Task 3 - Run contamination filter (optional)</a></li>
+<li><a class="reference internal" href="#task-4-map-metagenomic-reads-against-bacterial-database">Task 4 - Map metagenomic reads against bacterial database</a></li>
+<li><a class="reference internal" href="#task-5-run-species-estimator">Task 5 - Run species estimator</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#rtg-sample-similarity">RTG sample similarity</a><ul>
+<li><a class="reference internal" href="#task-1-prepare-read-sets">Task 1 - Prepare read sets</a></li>
+<li><a class="reference internal" href="#task-2-generate-read-set-name-map">Task 2 - Generate read set name map</a></li>
+<li><a class="reference internal" href="#task-3-run-similarity-tool">Task 3 - Run similarity tool</a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+
+  <h4>Previous topic</h4>
+  <p class="topless"><a href="rtg_command_reference.html"
+                        title="previous chapter">RTG Command Reference</a></p>
+  <h4>Next topic</h4>
+  <p class="topless"><a href="administration.html"
+                        title="next chapter">Administration &amp; Capacity Planning</a></p>
+  <div role="note" aria-label="source link">
+    <h3>This Page</h3>
+    <ul class="this-page-menu">
+      <li><a href="_sources/product_usage.rst.txt"
+            rel="nofollow">Show Source</a></li>
+    </ul>
+   </div>
+        </div>
+      </div>
       <div class="clearer"></div>
     </div>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -2473,12 +2475,13 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="rtg_command_reference.html" title="RTG Command Reference"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">RTG product usage - baseline progressions</a></li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2017, Real Time Genomics.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.8.5.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.1.2.
     </div>
   </body>
 </html>
\ No newline at end of file
diff --git a/installer/resources/core/RTGOperationsManual/rtg_command_reference.html b/installer/resources/core/RTGOperationsManual/rtg_command_reference.html
index 6afb8b628..633b960ad 100644
--- a/installer/resources/core/RTGOperationsManual/rtg_command_reference.html
+++ b/installer/resources/core/RTGOperationsManual/rtg_command_reference.html
@@ -2,27 +2,27 @@
 
 <!doctype html>
 
-<html xmlns="http://www.w3.org/1999/xhtml">
+<html>
   <head>
-    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>RTG Command Reference &#8212; RTG Core Operations Manual v3.11</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RTG Command Reference &#8212; RTG Core Operations Manual v3.12</title>
     <link rel="stylesheet" href="_static/bizstyle.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     
-    <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <script type="text/javascript" src="_static/language_data.js"></script>
-    <script type="text/javascript" src="_static/bizstyle.js"></script>
+    <script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+    <script src="_static/jquery.js"></script>
+    <script src="_static/underscore.js"></script>
+    <script src="_static/doctools.js"></script>
+    <script src="_static/language_data.js"></script>
+    <script src="_static/bizstyle.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
     <link rel="next" title="RTG product usage - baseline progressions" href="product_usage.html" />
     <link rel="prev" title="Overview" href="overview.html" />
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
     <!--[if lt IE 9]>
-    <script type="text/javascript" src="_static/css3-mediaqueries.js"></script>
+    <script src="_static/css3-mediaqueries.js"></script>
     <![endif]-->
   </head><body>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -37,159 +37,10 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="overview.html" title="Overview"
              accesskey="P">previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">RTG Command Reference</a></li> 
       </ul>
-    </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-            <p class="logo"><a href="index.html">
-              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
-            </a></p>
-  <h3><a href="index.html">Table of Contents</a></h3>
-  <ul>
-<li><a class="reference internal" href="#">RTG Command Reference</a><ul>
-<li><a class="reference internal" href="#command-line-interface-cli">Command line interface (CLI)</a></li>
-<li><a class="reference internal" href="#rtg-command-syntax">RTG command syntax</a></li>
-<li><a class="reference internal" href="#data-formatting-commands">Data Formatting Commands</a><ul>
-<li><a class="reference internal" href="#format">format</a></li>
-<li><a class="reference internal" href="#cg2sdf">cg2sdf</a></li>
-<li><a class="reference internal" href="#sdf2cg">sdf2cg</a></li>
-<li><a class="reference internal" href="#sdf2fasta">sdf2fasta</a></li>
-<li><a class="reference internal" href="#sdf2fastq">sdf2fastq</a></li>
-<li><a class="reference internal" href="#sdf2sam">sdf2sam</a></li>
-<li><a class="reference internal" href="#fastqtrim">fastqtrim</a></li>
-<li><a class="reference internal" href="#petrim">petrim</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#read-mapping-commands">Read Mapping Commands</a><ul>
-<li><a class="reference internal" href="#map">map</a></li>
-<li><a class="reference internal" href="#mapf">mapf</a></li>
-<li><a class="reference internal" href="#cgmap">cgmap</a></li>
-<li><a class="reference internal" href="#coverage">coverage</a></li>
-<li><a class="reference internal" href="#calibrate">calibrate</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#protein-search-commands">Protein Search Commands</a><ul>
-<li><a class="reference internal" href="#mapx">mapx</a></li>
-<li><a class="reference internal" href="#mapp">mapp</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#assembly-commands">Assembly Commands</a><ul>
-<li><a class="reference internal" href="#assemble">assemble</a><ul>
-<li><a class="reference internal" href="#output">Output</a></li>
-<li><a class="reference internal" href="#graph-construction">Graph Construction</a></li>
-<li><a class="reference internal" href="#read-mapping">Read Mapping</a></li>
-<li><a class="reference internal" href="#filtering">Filtering</a></li>
-<li><a class="reference internal" href="#consensus">Consensus</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#addpacbio">addpacbio</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#variant-detection-commands">Variant Detection Commands</a><ul>
-<li><a class="reference internal" href="#snp">snp</a><ul>
-<li><a class="reference internal" href="#quality-calibration">Quality calibration</a></li>
-<li><a class="reference internal" href="#coverage-filtering">Coverage filtering</a></li>
-<li><a class="reference internal" href="#prior-distributions">Prior distributions</a></li>
-<li><a class="reference internal" href="#adaptive-variant-rescoring">Adaptive Variant Rescoring</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#family">family</a></li>
-<li><a class="reference internal" href="#somatic">somatic</a></li>
-<li><a class="reference internal" href="#tumoronly">tumoronly</a></li>
-<li><a class="reference internal" href="#population">population</a></li>
-<li><a class="reference internal" href="#lineage">lineage</a></li>
-<li><a class="reference internal" href="#avrpredict">avrpredict</a></li>
-<li><a class="reference internal" href="#avrbuild">avrbuild</a></li>
-<li><a class="reference internal" href="#svprep">svprep</a></li>
-<li><a class="reference internal" href="#discord">discord</a></li>
-<li><a class="reference internal" href="#sv">sv</a></li>
-<li><a class="reference internal" href="#cnv">cnv</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#metagenomics-commands">Metagenomics Commands</a><ul>
-<li><a class="reference internal" href="#species">species</a></li>
-<li><a class="reference internal" href="#similarity">similarity</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#pipeline-commands">Pipeline Commands</a><ul>
-<li><a class="reference internal" href="#composition-meta-pipeline">composition-meta-pipeline</a></li>
-<li><a class="reference internal" href="#functional-meta-pipeline">functional-meta-pipeline</a></li>
-<li><a class="reference internal" href="#composition-functional-meta-pipeline">composition-functional-meta-pipeline</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#simulation-commands">Simulation Commands</a><ul>
-<li><a class="reference internal" href="#genomesim">genomesim</a></li>
-<li><a class="reference internal" href="#cgsim">cgsim</a></li>
-<li><a class="reference internal" href="#readsim">readsim</a></li>
-<li><a class="reference internal" href="#readsimeval">readsimeval</a></li>
-<li><a class="reference internal" href="#popsim">popsim</a></li>
-<li><a class="reference internal" href="#samplesim">samplesim</a></li>
-<li><a class="reference internal" href="#denovosim">denovosim</a></li>
-<li><a class="reference internal" href="#childsim">childsim</a></li>
-<li><a class="reference internal" href="#pedsamplesim">pedsamplesim</a></li>
-<li><a class="reference internal" href="#samplereplay">samplereplay</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#utility-commands">Utility Commands</a><ul>
-<li><a class="reference internal" href="#bgzip">bgzip</a></li>
-<li><a class="reference internal" href="#index">index</a></li>
-<li><a class="reference internal" href="#extract">extract</a></li>
-<li><a class="reference internal" href="#aview">aview</a></li>
-<li><a class="reference internal" href="#sdfstats">sdfstats</a></li>
-<li><a class="reference internal" href="#sdfsplit">sdfsplit</a></li>
-<li><a class="reference internal" href="#sdfsubset">sdfsubset</a></li>
-<li><a class="reference internal" href="#sdfsubseq">sdfsubseq</a></li>
-<li><a class="reference internal" href="#sam2bam">sam2bam</a></li>
-<li><a class="reference internal" href="#sammerge">sammerge</a></li>
-<li><a class="reference internal" href="#samstats">samstats</a></li>
-<li><a class="reference internal" href="#samrename">samrename</a></li>
-<li><a class="reference internal" href="#mapxrename">mapxrename</a></li>
-<li><a class="reference internal" href="#chrstats">chrstats</a></li>
-<li><a class="reference internal" href="#mendelian">mendelian</a></li>
-<li><a class="reference internal" href="#vcfannotate">vcfannotate</a></li>
-<li><a class="reference internal" href="#vcfdecompose">vcfdecompose</a></li>
-<li><a class="reference internal" href="#vcfeval">vcfeval</a></li>
-<li><a class="reference internal" href="#vcffilter">vcffilter</a></li>
-<li><a class="reference internal" href="#vcfmerge">vcfmerge</a></li>
-<li><a class="reference internal" href="#vcfsplit">vcfsplit</a></li>
-<li><a class="reference internal" href="#vcfstats">vcfstats</a></li>
-<li><a class="reference internal" href="#vcfsubset">vcfsubset</a></li>
-<li><a class="reference internal" href="#svdecompose">svdecompose</a></li>
-<li><a class="reference internal" href="#bndeval">bndeval</a></li>
-<li><a class="reference internal" href="#pedfilter">pedfilter</a></li>
-<li><a class="reference internal" href="#pedstats">pedstats</a></li>
-<li><a class="reference internal" href="#avrstats">avrstats</a></li>
-<li><a class="reference internal" href="#rocplot">rocplot</a></li>
-<li><a class="reference internal" href="#hashdist">hashdist</a></li>
-<li><a class="reference internal" href="#ncbi2tax">ncbi2tax</a></li>
-<li><a class="reference internal" href="#taxfilter">taxfilter</a></li>
-<li><a class="reference internal" href="#taxstats">taxstats</a></li>
-<li><a class="reference internal" href="#usageserver">usageserver</a></li>
-<li><a class="reference internal" href="#version">version</a></li>
-<li><a class="reference internal" href="#license">license</a></li>
-<li><a class="reference internal" href="#help">help</a></li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-
-  <h4>Previous topic</h4>
-  <p class="topless"><a href="overview.html"
-                        title="previous chapter">Overview</a></p>
-  <h4>Next topic</h4>
-  <p class="topless"><a href="product_usage.html"
-                        title="next chapter">RTG product usage - baseline progressions</a></p>
-  <div role="note" aria-label="source link">
-    <h3>This Page</h3>
-    <ul class="this-page-menu">
-      <li><a href="_sources/rtg_command_reference.rst.txt"
-            rel="nofollow">Show Source</a></li>
-    </ul>
-   </div>
-        </div>
-      </div>
+    </div>  
 
     <div class="document">
       <div class="documentwrapper">
@@ -238,52 +89,52 @@ <h2>RTG command syntax<a class="headerlink" href="#rtg-command-syntax" title="Pe
 is issued with the command.</p>
 <p>Many command parameters require user-supplied information of various
 types, as shown in the following:</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="17%" />
-<col width="83%" />
+<col style="width: 17%" />
+<col style="width: 83%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Type</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Type</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>DIR, FILE</td>
-<td>File or directory name(s)</td>
+<tbody>
+<tr class="row-even"><td><p>DIR, FILE</p></td>
+<td><p>File or directory name(s)</p></td>
 </tr>
-<tr class="row-odd"><td>SDF</td>
-<td>Sequence data that has been formatted to SDF</td>
+<tr class="row-odd"><td><p>SDF</p></td>
+<td><p>Sequence data that has been formatted to SDF</p></td>
 </tr>
-<tr class="row-even"><td>INT</td>
-<td>Integer value</td>
+<tr class="row-even"><td><p>INT</p></td>
+<td><p>Integer value</p></td>
 </tr>
-<tr class="row-odd"><td>FLOAT</td>
-<td>Floating point decimal value</td>
+<tr class="row-odd"><td><p>FLOAT</p></td>
+<td><p>Floating point decimal value</p></td>
 </tr>
-<tr class="row-even"><td>STRING</td>
-<td>A sequence of characters for comments, filenames, or labels</td>
+<tr class="row-even"><td><p>STRING</p></td>
+<td><p>A sequence of characters for comments, filenames, or labels</p></td>
 </tr>
-<tr class="row-odd"><td>REGION</td>
-<td>A genomic region specification (see below)</td>
+<tr class="row-odd"><td><p>REGION</p></td>
+<td><p>A genomic region specification (see below)</p></td>
 </tr>
 </tbody>
 </table>
 <p>Genomic region parameters take one of the following forms:</p>
 <ul class="simple">
-<li>sequence_name (e.g.: <code class="docutils literal notranslate"><span class="pre">chr21</span></code>) corresponds to the entirety of the
-named sequence.</li>
-<li>sequence_name:start (e.g.: <code class="docutils literal notranslate"><span class="pre">chr21:100000</span></code>) corresponds to a single
-position on the named sequence.</li>
-<li>sequence_name:start-end (e.g.: <code class="docutils literal notranslate"><span class="pre">chr21:100000-110000</span></code>) corresponds to a
+<li><p>sequence_name (e.g.: <code class="docutils literal notranslate"><span class="pre">chr21</span></code>) corresponds to the entirety of the
+named sequence.</p></li>
+<li><p>sequence_name:start (e.g.: <code class="docutils literal notranslate"><span class="pre">chr21:100000</span></code>) corresponds to a single
+position on the named sequence.</p></li>
+<li><p>sequence_name:start-end (e.g.: <code class="docutils literal notranslate"><span class="pre">chr21:100000-110000</span></code>) corresponds to a
 range that extends from the specified start position to the specified
-end position (inclusive). The positions are 1-based.</li>
-<li>sequence_name:position+length (e.g.: <code class="docutils literal notranslate"><span class="pre">chr21:100000+10000</span></code>) corresponds
+end position (inclusive). The positions are 1-based.</p></li>
+<li><p>sequence_name:position+length (e.g.: <code class="docutils literal notranslate"><span class="pre">chr21:100000+10000</span></code>) corresponds
 to a range that extends from the specified start position that
-includes the specified number of nucleotides.</li>
-<li>sequence_name:position~padding (e.g.: <code class="docutils literal notranslate"><span class="pre">chr21:100000~10000</span></code>)
+includes the specified number of nucleotides.</p></li>
+<li><p>sequence_name:position~padding (e.g.: <code class="docutils literal notranslate"><span class="pre">chr21:100000~10000</span></code>)
 corresponds to a range that spans the specified position by the
-specified amount of padding on either side.</li>
+specified amount of padding on either side.</p></li>
 </ul>
 <p>To display all parameters and syntax associated with an RTG command,
 enter the command and type <code class="docutils literal notranslate"><span class="pre">--help</span></code>. For example: all parameters
@@ -513,13 +364,13 @@ <h2>RTG command syntax<a class="headerlink" href="#rtg-command-syntax" title="Pe
 </pre></div>
 </div>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">The following commands are synonymous:
+<p class="admonition-title">Note</p>
+<p>The following commands are synonymous:
 <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">help</span> <span class="pre">format</span></code> and <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">format</span> <span class="pre">--help</span></code></p>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">Refer to <a class="reference internal" href="overview.html#installation-and-deployment"><span class="std std-ref">Installation and deployment</span></a> for information
+<p class="admonition-title">See also</p>
+<p>Refer to <a class="reference internal" href="overview.html#installation-and-deployment"><span class="std std-ref">Installation and deployment</span></a> for information
 about installing the RTG product executable.</p>
 </div>
 </div>
@@ -557,111 +408,111 @@ <h3>format<a class="headerlink" href="#format" title="Permalink to this headline
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="18%" />
-<col width="77%" />
+<col style="width: 6%" />
+<col style="width: 18%" />
+<col style="width: 77%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></td>
-<td>The format of the input file(s). Allowed values are [fasta, fastq, fastq-interleaved, sam-se, sam-pe] (Default is fasta).</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></p></td>
+<td><p>The format of the input file(s). Allowed values are [fasta, fastq, fastq-interleaved, sam-se, sam-pe] (Default is fasta).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>Specifies a file containing a list of sequence data files (one per line) to be converted into an SDF.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>Specifies a file containing a list of sequence data files (one per line) to be converted into an SDF.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-l</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--left=FILE</span></code></td>
-<td>The left input file for FASTA/FASTQ paired end data.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-l</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--left=FILE</span></code></p></td>
+<td><p>The left input file for FASTA/FASTQ paired end data.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></td>
-<td>The name of the output SDF.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></p></td>
+<td><p>The name of the output SDF.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--protein</span></code></td>
-<td>Set if the input consists of protein. If this option is not specified, then the input is assumed to consist of nucleotides.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--protein</span></code></p></td>
+<td><p>Set if the input consists of protein. If this option is not specified, then the input is assumed to consist of nucleotides.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--quality-format=FORMAT</span></code></td>
-<td>The format of the quality data for fastq format files. (Use sanger for Illumina1.8+). Allowed values are [sanger, solexa, illumina].</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--quality-format=FORMAT</span></code></p></td>
+<td><p>The format of the quality data for fastq format files. (Use sanger for Illumina1.8+). Allowed values are [sanger, solexa, illumina].</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--right=FILE</span></code></td>
-<td>The right input file for FASTA/FASTQ paired end data.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--right=FILE</span></code></p></td>
+<td><p>The right input file for FASTA/FASTQ paired end data.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>Specifies a sequence data file to be converted into an SDF. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>Specifies a sequence data file to be converted into an SDF. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="2%" />
-<col width="18%" />
-<col width="80%" />
+<col style="width: 2%" />
+<col style="width: 18%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--duster</span></code></td>
-<td>Treat lower case residues as unknowns.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--duster</span></code></p></td>
+<td><p>Treat lower case residues as unknowns.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude=STRING</span></code></td>
-<td>Exclude individual input sequences based on their name. If the input sequence name contains the specified string then that sequence is excluded from the
-SDF. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude=STRING</span></code></p></td>
+<td><p>Exclude individual input sequences based on their name. If the input sequence name contains the specified string then that sequence is excluded from the
+SDF. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--select-read-group=STRING</span></code></td>
-<td>Set to only include only reads with this read group ID when formatting from SAM/BAM files.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--select-read-group=STRING</span></code></p></td>
+<td><p>Set to only include only reads with this read group ID when formatting from SAM/BAM files.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--trim-threshold=INT</span></code></td>
-<td>Set to trim the read ends to maximise the base quality above the given threshold.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--trim-threshold=INT</span></code></p></td>
+<td><p>Set to trim the read ends to maximise the base quality above the given threshold.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="16%" />
-<col width="79%" />
+<col style="width: 5%" />
+<col style="width: 16%" />
+<col style="width: 79%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--allow-duplicate-names</span></code></td>
-<td>Set to disable duplicate name detection.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--allow-duplicate-names</span></code></p></td>
+<td><p>Set to disable duplicate name detection.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-names</span></code></td>
-<td>Do not include sequence names in the resulting SDF.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-names</span></code></p></td>
+<td><p>Do not include sequence names in the resulting SDF.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-quality</span></code></td>
-<td>Do not include sequence quality data in the resulting SDF.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-quality</span></code></p></td>
+<td><p>Do not include sequence quality data in the resulting SDF.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></td>
-<td>Specifies a file containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:RG1\tSM:G1_SAMP\tPL:ILLUMINA</span></code>.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></p></td>
+<td><p>Specifies a file containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:RG1\tSM:G1_SAMP\tPL:ILLUMINA</span></code>.</p></td>
 </tr>
 </tbody>
 </table>
@@ -731,17 +582,17 @@ <h3>format<a class="headerlink" href="#format" title="Permalink to this headline
 threshold given, a new read length is found which maximizes the overall
 quality of the retained bases using the following formula.</p>
 <div class="math">
-<p><img src="_images/math/d87c941fdcf46735e757ab196fe03da2ea08ec45.png" alt="\arg \max x\left({\sum_{i=x+1}^l (T - q(i))}\right) \text{ if } q(l) &lt; T"/></p>
+<p><img src="_images/math/6c754ae3fc49dc56e236eb95ef00cfdcad3df594.png" alt="\arg \max x\left({\sum_{i=x+1}^l (T - q(i))}\right) \text{ if } q(l) &lt; T"/></p>
 </div><p>Where <em>l</em> is the original read length, <em>x</em> is the new read length, <em>T</em>
 is the given threshold quality and <em>q(n)</em> is the quality of the base at
 the position n of the read.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
+<p class="admonition-title">Note</p>
 <p>Sequencing system read files and reference genome files
 often have the same extension and it may not always be obvious which
 file is a read set and which is a genome. Before formatting a sequencing
 system file, open it to see which type of file it is. For example:</p>
-<div class="last highlight-text notranslate"><div class="highlight"><pre><span></span>$ less pf3.fa
+<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>$ less pf3.fa
 </pre></div>
 </div>
 </div>
@@ -754,8 +605,8 @@ <h3>format<a class="headerlink" href="#format" title="Permalink to this headline
 names can cause problems with other commands, especially for reference data
 since the output many commands identifies sequences by their names.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#sdf2fasta"><span class="std std-ref">sdf2fasta</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#sdf2fasta"><span class="std std-ref">sdf2fasta</span></a>,
 <a class="reference internal" href="#sdf2fastq"><span class="std std-ref">sdf2fastq</span></a>,
 <a class="reference internal" href="#sdfstats"><span class="std std-ref">sdfstats</span></a></p>
 </div>
@@ -778,70 +629,70 @@ <h3>cg2sdf<a class="headerlink" href="#cg2sdf" title="Permalink to this headline
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of Complete Genomics TSV files (1 per line)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of Complete Genomics TSV files (1 per line)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></td>
-<td>Name of output SDF.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></p></td>
+<td><p>Name of output SDF.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>File in Complete Genomics TSV format. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>File in Complete Genomics TSV format. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-unknowns=INT</span></code></td>
-<td>Maximum number of Ns allowed in either side for a read (Default is 5)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-unknowns=INT</span></code></p></td>
+<td><p>Maximum number of Ns allowed in either side for a read (Default is 5)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="15%" />
-<col width="80%" />
+<col style="width: 5%" />
+<col style="width: 15%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-quality</span></code></td>
-<td>Does not include quality data in the resulting SDF.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-quality</span></code></p></td>
+<td><p>Does not include quality data in the resulting SDF.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></td>
-<td>File containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:RG1\tSM:G1_SAMP\tPL:COMPLETE</span></code>.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></p></td>
+<td><p>File containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:RG1\tSM:G1_SAMP\tPL:COMPLETE</span></code>.</p></td>
 </tr>
 </tbody>
 </table>
@@ -871,8 +722,8 @@ <h3>cg2sdf<a class="headerlink" href="#cg2sdf" title="Permalink to this headline
 during conversion.  If there are more than the specified number of Ns in
 one arm of the read, they read will not be added to the SDF.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
 <a class="reference internal" href="#sdf2cg"><span class="std std-ref">sdf2cg</span></a>,
 <a class="reference internal" href="#cgmap"><span class="std std-ref">cgmap</span></a>,
 <a class="reference internal" href="#sdf2fasta"><span class="std std-ref">sdf2fasta</span></a>,
@@ -899,82 +750,82 @@ <h3>sdf2cg<a class="headerlink" href="#sdf2cg" title="Permalink to this headline
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="17%" />
-<col width="76%" />
+<col style="width: 7%" />
+<col style="width: 17%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></td>
-<td>SDF containing sequences</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></p></td>
+<td><p>SDF containing sequences</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output filename (extension added if not present). Use ‘-‘ to write to standard output</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output filename (extension added if not present). Use ‘-‘ to write to standard output</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="15%" />
-<col width="78%" />
+<col style="width: 6%" />
+<col style="width: 15%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-id=INT</span></code></td>
-<td>Exclusive upper bound on sequence id</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-id=INT</span></code></p></td>
+<td><p>Exclusive upper bound on sequence id</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--id-file=FILE</span></code></td>
-<td>File containing sequence ids, or sequence names if –names flag is set, one per line</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--id-file=FILE</span></code></p></td>
+<td><p>File containing sequence ids, or sequence names if –names flag is set, one per line</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--names</span></code></td>
-<td>Interpret supplied sequence as names instead of numeric ids</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--names</span></code></p></td>
+<td><p>Interpret supplied sequence as names instead of numeric ids</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-id=INT</span></code></td>
-<td>Inclusive lower bound on sequence id</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-id=INT</span></code></p></td>
+<td><p>Inclusive lower bound on sequence id</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">STRING+</span></code></td>
-<td>ID of sequence to extract, or sequence name if –names flag is set. May be specified 0 or more times</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">STRING+</span></code></p></td>
+<td><p>ID of sequence to extract, or sequence name if –names flag is set. May be specified 0 or more times</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="17%" />
-<col width="78%" />
+<col style="width: 6%" />
+<col style="width: 17%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-l</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--line-length=INT</span></code></td>
-<td>Maximum number of nucleotides to print on a line of output. A value of 0 indicates no limit (Default is 0)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-l</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--line-length=INT</span></code></p></td>
+<td><p>Maximum number of nucleotides to print on a line of output. A value of 0 indicates no limit (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output</p></td>
 </tr>
 </tbody>
 </table>
@@ -988,8 +839,8 @@ <h3>sdf2cg<a class="headerlink" href="#sdf2cg" title="Permalink to this headline
 this command can be used to turn SDF formatted CG data back into TSV
 close to its original form.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#cg2sdf"><span class="std std-ref">cg2sdf</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#cg2sdf"><span class="std std-ref">cg2sdf</span></a></p>
 </div>
 </div>
 <div class="section" id="sdf2fasta">
@@ -1005,91 +856,91 @@ <h3>sdf2fasta<a class="headerlink" href="#sdf2fasta" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="19%" />
-<col width="74%" />
+<col style="width: 7%" />
+<col style="width: 19%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></td>
-<td>SDF containing sequences.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></p></td>
+<td><p>SDF containing sequences.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output filename (extension added if not present). Use ‘-‘ to write to standard output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output filename (extension added if not present). Use ‘-‘ to write to standard output.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="12%" />
-<col width="82%" />
+<col style="width: 6%" />
+<col style="width: 12%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-id=INT</span></code></td>
-<td>Only output sequences with sequence id less than the given number. (Sequence ids start at 0).</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-id=INT</span></code></p></td>
+<td><p>Only output sequences with sequence id less than the given number. (Sequence ids start at 0).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-id=INT</span></code></td>
-<td>Only output sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-id=INT</span></code></p></td>
+<td><p>Only output sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--id-file=FILE</span></code></td>
-<td>Name of a file containing a list of sequences to extract, one per line.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--id-file=FILE</span></code></p></td>
+<td><p>Name of a file containing a list of sequences to extract, one per line.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--names</span></code></td>
-<td>Interpret any specified sequence as names instead of numeric sequence ids.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--names</span></code></p></td>
+<td><p>Interpret any specified sequence as names instead of numeric sequence ids.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--taxons</span></code></td>
-<td>Interpret any specified sequence as taxon ids instead of numeric sequence ids. This option only applies to a metagenomic reference species SDF.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--taxons</span></code></p></td>
+<td><p>Interpret any specified sequence as taxon ids instead of numeric sequence ids. This option only applies to a metagenomic reference species SDF.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">STRING+</span></code></td>
-<td>Specify one or more explicit sequences to extract, as sequence id, or sequence name if –names flag is set.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">STRING+</span></code></p></td>
+<td><p>Specify one or more explicit sequences to extract, as sequence id, or sequence name if –names flag is set.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="13%" />
-<col width="82%" />
+<col style="width: 5%" />
+<col style="width: 13%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--interleave</span></code></td>
-<td>Interleave paired data into a single output file. Default is to split to separate output files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--interleave</span></code></p></td>
+<td><p>Interleave paired data into a single output file. Default is to split to separate output files.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-l</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--line-length=INT</span></code></td>
-<td>Set the maximum number of nucleotides or amino acids to print on a line of FASTA output. Should be nonnegative, with a value of 0 indicating that the line
-length is not capped. (Default is 0).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-l</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--line-length=INT</span></code></p></td>
+<td><p>Set the maximum number of nucleotides or amino acids to print on a line of FASTA output. Should be nonnegative, with a value of 0 indicating that the line
+length is not capped. (Default is 0).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Set this flag to create the FASTA output file without compression. By default the output file is compressed with blocked gzip.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Set this flag to create the FASTA output file without compression. By default the output file is compressed with blocked gzip.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1124,8 +975,8 @@ <h3>sdf2fasta<a class="headerlink" href="#sdf2fasta" title="Permalink to this he
 </div>
 <p>will extract sequences with id 2 and 3.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
 <a class="reference internal" href="#sdf2fastq"><span class="std std-ref">sdf2fastq</span></a>,
 <a class="reference internal" href="#sdfstats"><span class="std std-ref">sdfstats</span></a></p>
 </div>
@@ -1143,91 +994,91 @@ <h3>sdf2fastq<a class="headerlink" href="#sdf2fastq" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="10%" />
-<col width="21%" />
-<col width="69%" />
+<col style="width: 10%" />
+<col style="width: 21%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></td>
-<td>Specifies the SDF data to be converted.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></p></td>
+<td><p>Specifies the SDF data to be converted.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Specifies the file name used to write the resulting FASTQ output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Specifies the file name used to write the resulting FASTQ output.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="15%" />
-<col width="78%" />
+<col style="width: 7%" />
+<col style="width: 15%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-id=INT</span></code></td>
-<td>Only output sequences with sequence id less than the given number. (Sequence ids start at 0).</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-id=INT</span></code></p></td>
+<td><p>Only output sequences with sequence id less than the given number. (Sequence ids start at 0).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-id=INT</span></code></td>
-<td>Only output sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-id=INT</span></code></p></td>
+<td><p>Only output sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--id-file=FILE</span></code></td>
-<td>Name of a file containing a list of sequences to extract, one per line.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--id-file=FILE</span></code></p></td>
+<td><p>Name of a file containing a list of sequences to extract, one per line.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--names</span></code></td>
-<td>Interpret any specified sequence as names instead of numeric sequence ids.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--names</span></code></p></td>
+<td><p>Interpret any specified sequence as names instead of numeric sequence ids.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">STRING+</span></code></td>
-<td>Specify one or more explicit sequences to extract, as sequence id, or sequence name if –names flag is set.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">STRING+</span></code></p></td>
+<td><p>Specify one or more explicit sequences to extract, as sequence id, or sequence name if –names flag is set.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="14%" />
-<col width="80%" />
+<col style="width: 5%" />
+<col style="width: 14%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--default-qualty=INT</span></code></td>
-<td>Set the default quality to use if the SDF does not contain sequence quality data (0-63).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--default-qualty=INT</span></code></p></td>
+<td><p>Set the default quality to use if the SDF does not contain sequence quality data (0-63).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--interleave</span></code></td>
-<td>Interleave paired data into a single output file. Default is to split to separate output files.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--interleave</span></code></p></td>
+<td><p>Interleave paired data into a single output file. Default is to split to separate output files.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-l</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--line-length=INT</span></code></td>
-<td>Set the maximum number of nucleotides or amino acids to print on a line of FASTQ output. Should be nonnegative, with a value of 0 indicating that the line
-length is not capped. (Default is 0).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-l</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--line-length=INT</span></code></p></td>
+<td><p>Set the maximum number of nucleotides or amino acids to print on a line of FASTQ output. Should be nonnegative, with a value of 0 indicating that the line
+length is not capped. (Default is 0).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Set this flag to create the FASTQ output file without compression. By default the output file is compressed with blocked gzip.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Set this flag to create the FASTQ output file without compression. By default the output file is compressed with blocked gzip.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1247,8 +1098,8 @@ <h3>sdf2fastq<a class="headerlink" href="#sdf2fastq" title="Permalink to this he
 and may also be more convenient when dealing with paired-end data.</p>
 <p>The <code class="docutils literal notranslate"><span class="pre">--start-id</span></code> and <code class="docutils literal notranslate"><span class="pre">--end-id</span></code> flags behave as in <code class="docutils literal notranslate"><span class="pre">sdf2fasta</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
 <a class="reference internal" href="#sdf2fasta"><span class="std std-ref">sdf2fasta</span></a>,
 <a class="reference internal" href="#sdf2sam"><span class="std std-ref">sdf2sam</span></a>,
 <a class="reference internal" href="#sdfstats"><span class="std std-ref">sdfstats</span></a></p>
@@ -1267,79 +1118,79 @@ <h3>sdf2sam<a class="headerlink" href="#sdf2sam" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="13%" />
-<col width="80%" />
+<col style="width: 6%" />
+<col style="width: 13%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></td>
-<td>Specifies the SDF data to be converted.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></p></td>
+<td><p>Specifies the SDF data to be converted.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Specifies the file name used to write the resulting SAM/BAM to. The output format is automatically determined based on the
-filename specified. If ‘-‘ is given, the data is written as uncompressed SAM to standard output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Specifies the file name used to write the resulting SAM/BAM to. The output format is automatically determined based on the
+filename specified. If ‘-‘ is given, the data is written as uncompressed SAM to standard output.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="15%" />
-<col width="78%" />
+<col style="width: 7%" />
+<col style="width: 15%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-id=INT</span></code></td>
-<td>Only output sequences with sequence id less than the given number. (Sequence ids start at 0).</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-id=INT</span></code></p></td>
+<td><p>Only output sequences with sequence id less than the given number. (Sequence ids start at 0).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-id=INT</span></code></td>
-<td>Only output sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-id=INT</span></code></p></td>
+<td><p>Only output sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--id-file=FILE</span></code></td>
-<td>Name of a file containing a list of sequences to extract, one per line.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--id-file=FILE</span></code></p></td>
+<td><p>Name of a file containing a list of sequences to extract, one per line.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--names</span></code></td>
-<td>Interpret any specified sequence as names instead of numeric sequence ids.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--names</span></code></p></td>
+<td><p>Interpret any specified sequence as names instead of numeric sequence ids.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">STRING+</span></code></td>
-<td>Specify one or more explicit sequences to extract, as sequence id, or sequence name if –names flag is set.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">STRING+</span></code></p></td>
+<td><p>Specify one or more explicit sequences to extract, as sequence id, or sequence name if –names flag is set.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="10%" />
-<col width="85%" />
+<col style="width: 6%" />
+<col style="width: 10%" />
+<col style="width: 85%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Set this flag when creating SAM format output to disable compression. By default SAM is compressed with blocked gzip, and BAM is always compressed.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Set this flag when creating SAM format output to disable compression. By default SAM is compressed with blocked gzip, and BAM is always compressed.</p></td>
 </tr>
 </tbody>
 </table>
@@ -1360,8 +1211,8 @@ <h3>sdf2sam<a class="headerlink" href="#sdf2sam" title="Permalink to this headli
 format.</p>
 <p>The <code class="docutils literal notranslate"><span class="pre">--start-id</span></code> and <code class="docutils literal notranslate"><span class="pre">--end-if</span></code> behave as in <code class="docutils literal notranslate"><span class="pre">sdf2fasta</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
 <a class="reference internal" href="#sdf2fasta"><span class="std std-ref">sdf2fasta</span></a>,
 <a class="reference internal" href="#sdf2fastq"><span class="std std-ref">sdf2fastq</span></a>,
 <a class="reference internal" href="#sdfstats"><span class="std std-ref">sdfstats</span></a>,
@@ -1383,102 +1234,102 @@ <h3>fastqtrim<a class="headerlink" href="#fastqtrim" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>Input FASTQ file, Use ‘-‘ to read from standard input.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>Input FASTQ file, Use ‘-‘ to read from standard input.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output filename. Use ‘-‘ to write to standard output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output filename. Use ‘-‘ to write to standard output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--quality-format=FORMAT</span></code></td>
-<td>Quality data encoding method used in FASTQ input files (Illumina 1.8+ uses sanger). Allowed values are [sanger, solexa, illumina] (Default is sanger)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--quality-format=FORMAT</span></code></p></td>
+<td><p>Quality data encoding method used in FASTQ input files (Illumina 1.8+ uses sanger). Allowed values are [sanger, solexa, illumina] (Default is sanger)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="24%" />
-<col width="70%" />
+<col style="width: 6%" />
+<col style="width: 24%" />
+<col style="width: 70%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--discard-empty-reads</span></code></td>
-<td>Discard reads that have zero length after trimming. Should not be used with paired-end data.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--discard-empty-reads</span></code></p></td>
+<td><p>Discard reads that have zero length after trimming. Should not be used with paired-end data.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-E</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-quality-threshold=INT</span></code></td>
-<td>Trim read ends to maximise base quality above the given threshold (Default is 0)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-E</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-quality-threshold=INT</span></code></p></td>
+<td><p>Trim read ends to maximise base quality above the given threshold (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-read-length=INT</span></code></td>
-<td>If a read ends up shorter than this threshold it will be trimmed to zero length (Default is 0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-read-length=INT</span></code></p></td>
+<td><p>If a read ends up shorter than this threshold it will be trimmed to zero length (Default is 0)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-S</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-quality-threshold=INT</span></code></td>
-<td>Trim read starts to maximise base quality above the given threshold (Default is 0)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-S</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-quality-threshold=INT</span></code></p></td>
+<td><p>Trim read starts to maximise base quality above the given threshold (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-e</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--trim-end-bases=INT</span></code></td>
-<td>Always trim the specified number of bases from read end (Default is 0)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-e</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--trim-end-bases=INT</span></code></p></td>
+<td><p>Always trim the specified number of bases from read end (Default is 0)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--trim-start-bases=INT</span></code></td>
-<td>Always trim the specified number of bases from read start (Default is 0)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--trim-start-bases=INT</span></code></p></td>
+<td><p>Always trim the specified number of bases from read start (Default is 0)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="24%" />
-<col width="70%" />
+<col style="width: 6%" />
+<col style="width: 24%" />
+<col style="width: 70%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reverse-complement</span></code></td>
-<td>If set, output in reverse complement.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reverse-complement</span></code></p></td>
+<td><p>If set, output in reverse complement.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Seed used during subsampling.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Seed used during subsampling.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--subsample=FLOAT</span></code></td>
-<td>If set, subsample the input to retain this fraction of reads.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--subsample=FLOAT</span></code></p></td>
+<td><p>If set, subsample the input to retain this fraction of reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -1497,7 +1348,7 @@ <h3>fastqtrim<a class="headerlink" href="#fastqtrim" title="Permalink to this he
 than the threshold given, a new read length is found which maximizes the
 overall quality of the retained bases using the following formula:</p>
 <div class="math">
-<p><img src="_images/math/d87c941fdcf46735e757ab196fe03da2ea08ec45.png" alt="\arg \max x\left({\sum_{i=x+1}^l (T - q(i))}\right) \text{ if } q(l) &lt; T"/></p>
+<p><img src="_images/math/6c754ae3fc49dc56e236eb95ef00cfdcad3df594.png" alt="\arg \max x\left({\sum_{i=x+1}^l (T - q(i))}\right) \text{ if } q(l) &lt; T"/></p>
 </div><p>where <em>l</em> is the original read length, <em>x</em> is the new read length, <em>T</em>
 is the given threshold quality and <em>q(n)</em> is the quality of the base at
 the position <em>n</em> of the read.  Similarly, <code class="docutils literal notranslate"><span class="pre">--start-quality-threshold</span></code>
@@ -1528,8 +1379,8 @@ <h4>Formatting with filtering on the fly<a class="headerlink" href="#formatting-
 </pre></div>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a></p>
 </div>
 </div>
 </div>
@@ -1542,159 +1393,159 @@ <h3>petrim<a class="headerlink" href="#petrim" title="Permalink to this headline
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="17%" />
-<col width="79%" />
+<col style="width: 4%" />
+<col style="width: 17%" />
+<col style="width: 79%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-l</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--left=FILE</span></code></td>
-<td>Left input FASTQ file (AKA R1)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-l</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--left=FILE</span></code></p></td>
+<td><p>Left input FASTQ file (AKA R1)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output filename prefix. Use ‘-‘ to write to standard output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output filename prefix. Use ‘-‘ to write to standard output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--quality-format=FORMAT</span></code></td>
-<td>Quality data encoding method used in FASTQ input files (Illumina 1.8+ uses sanger). Allowed values are [sanger, solexa, illumina] (Default is sanger)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--quality-format=FORMAT</span></code></p></td>
+<td><p>Quality data encoding method used in FASTQ input files (Illumina 1.8+ uses sanger). Allowed values are [sanger, solexa, illumina] (Default is sanger)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--right=FILE</span></code></td>
-<td>Right input FASTQ file (AKA R2)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--right=FILE</span></code></p></td>
+<td><p>Right input FASTQ file (AKA R2)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="22%" />
-<col width="72%" />
+<col style="width: 6%" />
+<col style="width: 22%" />
+<col style="width: 72%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--aligner-band-width=FLOAT</span></code></td>
-<td>Aligner indel band width scaling factor, fraction of read length allowed as an indel (Default is 0.5)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--aligner-band-width=FLOAT</span></code></p></td>
+<td><p>Aligner indel band width scaling factor, fraction of read length allowed as an indel (Default is 0.5)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--gap-extend-penalty=INT</span></code></td>
-<td>Penalty for a gap extension during alignment (Default is 1)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--gap-extend-penalty=INT</span></code></p></td>
+<td><p>Penalty for a gap extension during alignment (Default is 1)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--gap-open-penalty=INT</span></code></td>
-<td>Penalty for a gap open during alignment (Default is 19)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--gap-open-penalty=INT</span></code></p></td>
+<td><p>Penalty for a gap open during alignment (Default is 19)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-P</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-identity=INT</span></code></td>
-<td>Minimum percent identity in overlap to trigger overlap trimming (Default is 90)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-P</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-identity=INT</span></code></p></td>
+<td><p>Minimum percent identity in overlap to trigger overlap trimming (Default is 90)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-L</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-overlap-length=INT</span></code></td>
-<td>Minimum number of bases in overlap to trigger overlap trimming (Default is 25)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-L</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-overlap-length=INT</span></code></p></td>
+<td><p>Minimum number of bases in overlap to trigger overlap trimming (Default is 25)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--mismatch-penalty=INT</span></code></td>
-<td>Penalty for a mismatch during alignment (Default is 9)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mismatch-penalty=INT</span></code></p></td>
+<td><p>Penalty for a mismatch during alignment (Default is 9)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--soft-clip-distance=INT</span></code></td>
-<td>Soft clip alignments if indels occur INT bp from either end (Default is 5)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--soft-clip-distance=INT</span></code></p></td>
+<td><p>Soft clip alignments if indels occur INT bp from either end (Default is 5)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--unknowns-penalty=INT</span></code></td>
-<td>Penalty for unknown nucleotides during alignment (Default is 5)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--unknowns-penalty=INT</span></code></p></td>
+<td><p>Penalty for unknown nucleotides during alignment (Default is 5)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="77%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 77%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--discard-empty-pairs</span></code></td>
-<td>If set, discard pairs where both reads have zero length (after any trimming)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--discard-empty-pairs</span></code></p></td>
+<td><p>If set, discard pairs where both reads have zero length (after any trimming)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--discard-empty-reads</span></code></td>
-<td>If set, discard pairs where either read has zero length (after any trimming)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--discard-empty-reads</span></code></p></td>
+<td><p>If set, discard pairs where either read has zero length (after any trimming)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--left-probe-length=INT</span></code></td>
-<td>Assume R1 starts with probes this long, and trim R2 bases that overlap into this (Default is 0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--left-probe-length=INT</span></code></p></td>
+<td><p>Assume R1 starts with probes this long, and trim R2 bases that overlap into this (Default is 0)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-M</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--midpoint-merge</span></code></td>
-<td>If set, merge overlapping reads at midpoint of overlap region. Result is in R1 (R2 will be empty)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-M</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--midpoint-merge</span></code></p></td>
+<td><p>If set, merge overlapping reads at midpoint of overlap region. Result is in R1 (R2 will be empty)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--midpoint-trim</span></code></td>
-<td>If set, trim overlapping reads to midpoint of overlap region.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--midpoint-trim</span></code></p></td>
+<td><p>If set, trim overlapping reads to midpoint of overlap region.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-read-length=INT</span></code></td>
-<td>If a read ends up shorter than this threshold it will be trimmed to zero length (Default is 0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-read-length=INT</span></code></p></td>
+<td><p>If a read ends up shorter than this threshold it will be trimmed to zero length (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--mismatch-adjustment=STRING</span></code></td>
-<td>Method used to alter bases/qualities at mismatches within overlap region. Allowed values are [none, zero-phred, pick-best] (Default is none)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mismatch-adjustment=STRING</span></code></p></td>
+<td><p>Method used to alter bases/qualities at mismatches within overlap region. Allowed values are [none, zero-phred, pick-best] (Default is none)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--right-probe-length=INT</span></code></td>
-<td>Assume R2 starts with probes this long, and trim R1 bases that overlap into this (Default is 0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--right-probe-length=INT</span></code></p></td>
+<td><p>Assume R2 starts with probes this long, and trim R1 bases that overlap into this (Default is 0)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="23%" />
-<col width="71%" />
+<col style="width: 6%" />
+<col style="width: 23%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--interleave</span></code></td>
-<td>Interleave paired data into a single output file. Default is to split to separate output files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--interleave</span></code></p></td>
+<td><p>Interleave paired data into a single output file. Default is to split to separate output files.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Seed used during subsampling.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Seed used during subsampling.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--subsample=FLOAT</span></code></td>
-<td>If set, subsample the input to retain this fraction of reads.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--subsample=FLOAT</span></code></p></td>
+<td><p>If set, subsample the input to retain this fraction of reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -1722,29 +1573,29 @@ <h3>petrim<a class="headerlink" href="#petrim" title="Permalink to this headline
 possible to adjust the penalties used during alignment.</p>
 <p>The following types of trimming or merging may be applied.</p>
 <ul class="simple">
-<li>Removal of non-genomic bases due to complete read-through. This
-removal is always applied.</li>
-<li>Removal of overlap bases impinging into regions occupied by probe
+<li><p>Removal of non-genomic bases due to complete read-through. This
+removal is always applied.</p></li>
+<li><p>Removal of overlap bases impinging into regions occupied by probe
 bases. For example, if the left arms contain 11-mer probes, using
 <code class="docutils literal notranslate"><span class="pre">--left-probe-length=11</span></code> will result in the removal of any right arm
 bases that overlap into the first 11 bases of the left arm. Similar
 trimming is available for situations where probes are ligated to the
-right arm by using <code class="docutils literal notranslate"><span class="pre">--right-probe-length</span></code>.</li>
-<li>Adjustment of mismatching read bases inside areas of overlap. Such
+right arm by using <code class="docutils literal notranslate"><span class="pre">--right-probe-length</span></code>.</p></li>
+<li><p>Adjustment of mismatching read bases inside areas of overlap. Such
 mismatches indicate that one or other of the bases has been
 incorrectly sequenced. Alteration of these bases is selected by
 supplying the <code class="docutils literal notranslate"><span class="pre">--mismatch-adjustment</span></code> flag with a value of
 <code class="docutils literal notranslate"><span class="pre">zero-phred</span></code> to alter the phred quality score of both bases to zero,
 or <code class="docutils literal notranslate"><span class="pre">pick-best</span></code> to choose whichever base had the higher reported
-quality score.</li>
-<li>Removal of overlap regions by trimming both arms back to a point where
+quality score.</p></li>
+<li><p>Removal of overlap regions by trimming both arms back to a point where
 no overlap is present. An equal number of bases are removed from each
 arm. This trimming is enabled by specifying <code class="docutils literal notranslate"><span class="pre">--midpoint-trim</span></code> and
-takes place after any read-through or probe related trimming.</li>
-<li>Merging non-redundant sequence from both reads to create a single
+takes place after any read-through or probe related trimming.</p></li>
+<li><p>Merging non-redundant sequence from both reads to create a single
 read, enabled via <code class="docutils literal notranslate"><span class="pre">--midpoint-merge</span></code>. This is like
 <code class="docutils literal notranslate"><span class="pre">--midpoint-trim</span></code> with a subsequent moving of the R2 read onto the
-end of the the R1 read (thus the R2 read becomes empty).</li>
+end of the the R1 read (thus the R2 read becomes empty).</p></li>
 </ul>
 <p>After trimming or merging it is possible that one or both of the arms of
 the pair have no bases remaining, and a strategy is needed to handle
@@ -1777,8 +1628,8 @@ <h4>Formatting with paired-end trimming on the fly<a class="headerlink" href="#f
 </pre></div>
 </div>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last"><code class="docutils literal notranslate"><span class="pre">petrim</span></code> currently assumes Illumina paired-end sequencing,
+<p class="admonition-title">Note</p>
+<p><code class="docutils literal notranslate"><span class="pre">petrim</span></code> currently assumes Illumina paired-end sequencing,
 and aligns the reads in FR orientation. Sequencing methods which
 produce arms in a different orientation can be processed by first
 converting the input files using <code class="docutils literal notranslate"><span class="pre">fastqtrim</span> <span class="pre">--reverse-complement</span></code>,
@@ -1787,8 +1638,8 @@ <h4>Formatting with paired-end trimming on the fly<a class="headerlink" href="#f
 orientation.</p>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#fastqtrim"><span class="std std-ref">fastqtrim</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#fastqtrim"><span class="std std-ref">fastqtrim</span></a>,
 <a class="reference internal" href="#format"><span class="std std-ref">format</span></a></p>
 </div>
 </div>
@@ -1817,269 +1668,269 @@ <h3>map<a class="headerlink" href="#map" title="Permalink to this headline">¶</
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-F</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></td>
-<td>Input format for reads. Allowed values are [sdf, fasta, fastq, fastq-interleaved, sam-se, sam-pe] (Default is sdf)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-F</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></p></td>
+<td><p>Input format for reads. Allowed values are [sdf, fasta, fastq, fastq-interleaved, sam-se, sam-pe] (Default is sdf)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></td>
-<td>Input read set.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></p></td>
+<td><p>Input read set.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-l</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--left=FILE</span></code></td>
-<td>Left input file for FASTA/FASTQ paired end reads.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-l</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--left=FILE</span></code></p></td>
+<td><p>Left input file for FASTA/FASTQ paired end reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--quality-format=FORMAT</span></code></td>
-<td>Quality data encoding method used in FASTQ input files (Illumina 1.8+ uses sanger). Allowed values are [sanger, solexa, illumina] (Default is sanger)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--quality-format=FORMAT</span></code></p></td>
+<td><p>Quality data encoding method used in FASTQ input files (Illumina 1.8+ uses sanger). Allowed values are [sanger, solexa, illumina] (Default is sanger)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--right=FILE</span></code></td>
-<td>Right input file for FASTA/FASTQ paired end reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--right=FILE</span></code></p></td>
+<td><p>Right input file for FASTA/FASTQ paired end reads.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sam</span></code></td>
-<td>Output the alignment files in SAM format.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sam</span></code></p></td>
+<td><p>Output the alignment files in SAM format.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing template to map against.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing template to map against.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="17%" />
-<col width="77%" />
+<col style="width: 5%" />
+<col style="width: 17%" />
+<col style="width: 77%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--aligner-band-width=FLOAT</span></code></td>
-<td>Set the fraction of the read length that is allowed to be an indel. Decreasing this factor will allow faster processing, at the expense of only
-allowing shorter indels to be aligned. (Default is 0.5).</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--aligner-band-width=FLOAT</span></code></p></td>
+<td><p>Set the fraction of the read length that is allowed to be an indel. Decreasing this factor will allow faster processing, at the expense of only
+allowing shorter indels to be aligned. (Default is 0.5).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--aligner-mode=STRING</span></code></td>
-<td>Set the aligner mode to be used. Allowed values are [auto, table, general] (Default is auto).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--aligner-mode=STRING</span></code></p></td>
+<td><p>Set the aligner mode to be used. Allowed values are [auto, table, general] (Default is auto).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>Restrict calibration to mappings falling within the regions in the supplied BED file.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>Restrict calibration to mappings falling within the regions in the supplied BED file.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--blacklist-threshold=INT</span></code></td>
-<td>filter k-mers that occur more than this many times in the reference using a blacklist</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--blacklist-threshold=INT</span></code></p></td>
+<td><p>filter k-mers that occur more than this many times in the reference using a blacklist</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--gap-extend-penalty=INT</span></code></td>
-<td>Set the penalty for extending a gap during alignment. (Default is 1).</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--gap-extend-penalty=INT</span></code></p></td>
+<td><p>Set the penalty for extending a gap during alignment. (Default is 1).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--gap-open-penalty=INT</span></code></td>
-<td>Set the penalty for a gap open during alignment. (Default is 19).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--gap-open-penalty=INT</span></code></p></td>
+<td><p>Set the penalty for a gap open during alignment. (Default is 19).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--indel-length=INT</span></code></td>
-<td>Guarantees number of positions that will be detected in a single indel. For example, -c 3 specifies 3 nucleotide insertions or deletions. (Default is
-1).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--indel-length=INT</span></code></p></td>
+<td><p>Guarantees number of positions that will be detected in a single indel. For example, -c 3 specifies 3 nucleotide insertions or deletions. (Default is
+1).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-b</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--indels=INT</span></code></td>
-<td>Guarantees minimum number of indels which will be detected when used with read less than 64 bp long. For example -b 1 specifies 1 insertion or
-deletion. (Default is 1).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-b</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--indels=INT</span></code></p></td>
+<td><p>Guarantees minimum number of indels which will be detected when used with read less than 64 bp long. For example -b 1 specifies 1 insertion or
+deletion. (Default is 1).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-M</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-fragment-size=INT</span></code></td>
-<td>The maximum permitted fragment size when mating paired reads. (Default is 1000).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-M</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-fragment-size=INT</span></code></p></td>
+<td><p>The maximum permitted fragment size when mating paired reads. (Default is 1000).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-fragment-size=INT</span></code></td>
-<td>The minimum permitted fragment size when mating paired reads. (Default is 0).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-fragment-size=INT</span></code></p></td>
+<td><p>The minimum permitted fragment size when mating paired reads. (Default is 0).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--mismatch-penalty=INT</span></code></td>
-<td>Set the penalty for a mismatch during alignment. (Default is 9).</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mismatch-penalty=INT</span></code></p></td>
+<td><p>Set the penalty for a mismatch during alignment. (Default is 9).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-d</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--orientation=STRING</span></code></td>
-<td>Set the orientation required for proper pairs. Allowed values are [fr, rf, tandem, any] (Default is any).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-d</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--orientation=STRING</span></code></p></td>
+<td><p>Set the orientation required for proper pairs. Allowed values are [fr, rf, tandem, any] (Default is any).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></td>
-<td>Genome relationships pedigree containing sex of sample.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></p></td>
+<td><p>Genome relationships pedigree containing sex of sample.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--repeat-freq=INT%</span></code></td>
-<td>Where INT specifies the percentage of all hashes to keep, discarding the remaining percentage of the most frequent hashes. Increasing this value will
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--repeat-freq=INT%</span></code></p></td>
+<td><p>Where INT specifies the percentage of all hashes to keep, discarding the remaining percentage of the most frequent hashes. Increasing this value will
 improve the ability to map sequences in repetitive regions at a cost of run time. It is also possible to specify the option as an absolute count (by
-omitting the percent symbol) where any hash exceeding the threshold will be discarded from the index. (Default is 90%).</td>
+omitting the percent symbol) where any hash exceeding the threshold will be discarded from the index. (Default is 90%).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></td>
-<td>Specifies the sex of the individual. Allowed values are [male, female, either].</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></p></td>
+<td><p>Specifies the sex of the individual. Allowed values are [male, female, either].</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--soft-clip-distance=INT</span></code></td>
-<td>Set to soft clip alignments when an indel occurs within that many nucleotides from either end of the read. (Default is 5).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--soft-clip-distance=INT</span></code></p></td>
+<td><p>Set to soft clip alignments when an indel occurs within that many nucleotides from either end of the read. (Default is 5).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></td>
-<td>Set the step size. (Default is word size).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></p></td>
+<td><p>Set the step size. (Default is word size).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--substitutions=INT</span></code></td>
-<td>Guarantees minimum number of substitutions to be detected when used with read data less than 64 bp long. (Default is 1).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--substitutions=INT</span></code></p></td>
+<td><p>Guarantees minimum number of substitutions to be detected when used with read data less than 64 bp long. (Default is 1).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--unknowns-penalty=INT</span></code></td>
-<td>Set the penalty for unknown nucleotides during alignment. (Default is 5).</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--unknowns-penalty=INT</span></code></p></td>
+<td><p>Set the penalty for unknown nucleotides during alignment. (Default is 5).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-w</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></td>
-<td>Specifies an internal minimum word size used during the initial matching phase. Word size selection optimizes the number of reads for a desired level
-of sensitivity (allowed mismatches and indels) given an acceptable alignment speed. (Default is 22, or read length / 2, whichever is smaller).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-w</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></p></td>
+<td><p>Specifies an internal minimum word size used during the initial matching phase. Word size selection optimizes the number of reads for a desired level
+of sensitivity (allowed mismatches and indels) given an acceptable alignment speed. (Default is 22, or read length / 2, whichever is smaller).</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="17%" />
-<col width="80%" />
+<col style="width: 3%" />
+<col style="width: 17%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></td>
-<td>Only map sequences with sequence id less than the given number. (Sequence ids start at 0).</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></p></td>
+<td><p>Only map sequences with sequence id less than the given number. (Sequence ids start at 0).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></td>
-<td>Only map sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></p></td>
+<td><p>Only map sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="18%" />
-<col width="77%" />
+<col style="width: 5%" />
+<col style="width: 18%" />
+<col style="width: 77%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--all-hits</span></code></td>
-<td>Output all alignments meeting thresholds instead of applying mating and N limits.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all-hits</span></code></p></td>
+<td><p>Output all alignments meeting thresholds instead of applying mating and N limits.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-mated-mismatches=INT</span></code></td>
-<td>The maximum mismatches for mappings across mated results, alias for <code class="docutils literal notranslate"><span class="pre">--max-mismatches</span></code> (as absolute value or percentage of read length). (Default
-is 10%).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-mated-mismatches=INT</span></code></p></td>
+<td><p>The maximum mismatches for mappings across mated results, alias for <code class="docutils literal notranslate"><span class="pre">--max-mismatches</span></code> (as absolute value or percentage of read length). (Default
+is 10%).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-e</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-mismatches=INT</span></code></td>
-<td>The maximum mismatches for mappings in single-end mode (as absolute value or percentage of read length). (Default is 10%).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-e</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-mismatches=INT</span></code></p></td>
+<td><p>The maximum mismatches for mappings in single-end mode (as absolute value or percentage of read length). (Default is 10%).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-top-results=INT</span></code></td>
-<td>Sets the maximum number of reported mapping results (locations) per read when it maps to multiple locations with the same alignment score
-(AS). Allowed values are between 1 and 255. (Default is 5).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-top-results=INT</span></code></p></td>
+<td><p>Sets the maximum number of reported mapping results (locations) per read when it maps to multiple locations with the same alignment score
+(AS). Allowed values are between 1 and 255. (Default is 5).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-E</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-unmated-mismatches=INT</span></code></td>
-<td>The maximum mismatches for mappings of unmated results (as absolute value or percentage of read length). (Default is 10%).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-E</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-unmated-mismatches=INT</span></code></p></td>
+<td><p>The maximum mismatches for mappings of unmated results (as absolute value or percentage of read length). (Default is 10%).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></td>
-<td>Specifies a file containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:RG1\tSM:BACT\tPL:ILLUMINA</span></code>.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></p></td>
+<td><p>Specifies a file containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:RG1\tSM:BACT\tPL:ILLUMINA</span></code>.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--top-random</span></code></td>
-<td>If set, will only output a single random top hit for each read.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--top-random</span></code></p></td>
+<td><p>If set, will only output a single random top hit for each read.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="12%" />
-<col width="83%" />
+<col style="width: 5%" />
+<col style="width: 12%" />
+<col style="width: 83%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--legacy-cigars</span></code></td>
-<td>Produce cigars in legacy format (using M instead of X or =) in SAM/BAM output. When set will also produce the MD field.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--legacy-cigars</span></code></p></td>
+<td><p>Produce cigars in legacy format (using M instead of X or =) in SAM/BAM output. When set will also produce the MD field.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></td>
-<td>Set this flag to not produce the calibration output files.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></p></td>
+<td><p>Set this flag to not produce the calibration output files.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Set this flag to create the SAM output files without compression. By default the output files are compressed with tabix compatible blocked gzip.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Set this flag to create the SAM output files without compression. By default the output files are compressed with tabix compatible blocked gzip.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-merge</span></code></td>
-<td>Set to output mated, unmated and unmapped alignment records into separate SAM/BAM files.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-merge</span></code></p></td>
+<td><p>Set to output mated, unmated and unmapped alignment records into separate SAM/BAM files.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-svprep</span></code></td>
-<td>Do not perform structural variant processing.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-svprep</span></code></p></td>
+<td><p>Do not perform structural variant processing.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-unmapped</span></code></td>
-<td>Do not output unmapped reads. Some reads that map multiple times will not be aligned, and are reported as unmapped. These reads are reported with XC attributes that
-indicate the reason they were not mapped.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-unmapped</span></code></p></td>
+<td><p>Do not output unmapped reads. Some reads that map multiple times will not be aligned, and are reported as unmapped. These reads are reported with XC attributes that
+indicate the reason they were not mapped.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-unmated</span></code></td>
-<td>Do not output unmated reads when in paired-end mode.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-unmated</span></code></p></td>
+<td><p>Do not output unmated reads when in paired-end mode.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--read-names</span></code></td>
-<td>Output read names instead of sequence ids in SAM/BAM files. (Uses more RAM).</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--read-names</span></code></p></td>
+<td><p>Output read names instead of sequence ids in SAM/BAM files. (Uses more RAM).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--tempdir=DIR</span></code></td>
-<td>Set the directory to use for temporary files during processing. (Defaults to output directory).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--tempdir=DIR</span></code></p></td>
+<td><p>Set the directory to use for temporary files during processing. (Defaults to output directory).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</p></td>
 </tr>
 </tbody>
 </table>
@@ -2250,8 +2101,8 @@ <h3>map<a class="headerlink" href="#map" title="Permalink to this headline">¶</
 inputs and outputs to reside on separate disk partitions where possible.
 For more details see <a class="reference internal" href="product_usage.html#task-4-map-reads-to-the-reference-genome"><span class="std std-ref">Task 4 - Map reads to the reference genome</span></a>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
 <a class="reference internal" href="#calibrate"><span class="std std-ref">calibrate</span></a>,
 <a class="reference internal" href="#cgmap"><span class="std std-ref">cgmap</span></a>,
 <a class="reference internal" href="#mapf"><span class="std std-ref">mapf</span></a>,
@@ -2280,240 +2131,240 @@ <h3>mapf<a class="headerlink" href="#mapf" title="Permalink to this headline">¶
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bam</span></code></td>
-<td>Output the alignment files in BAM format.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bam</span></code></p></td>
+<td><p>Output the alignment files in BAM format.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-F</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></td>
-<td>Input format for reads. Allowed values are [sdf, fasta, fastq, fastq-interleaved, sam-se, sam-pe] (Default is sdf)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-F</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></p></td>
+<td><p>Input format for reads. Allowed values are [sdf, fasta, fastq, fastq-interleaved, sam-se, sam-pe] (Default is sdf)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></td>
-<td>Input read set.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></p></td>
+<td><p>Input read set.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-l</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--left=FILE</span></code></td>
-<td>Left input file for FASTA/FASTQ paired end reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-l</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--left=FILE</span></code></p></td>
+<td><p>Left input file for FASTA/FASTQ paired end reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--quality-format=FORMAT</span></code></td>
-<td>Quality data encoding method used in FASTQ input files (Illumina 1.8+ uses sanger). Allowed values are [sanger, solexa, illumina] (Default is sanger)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--quality-format=FORMAT</span></code></p></td>
+<td><p>Quality data encoding method used in FASTQ input files (Illumina 1.8+ uses sanger). Allowed values are [sanger, solexa, illumina] (Default is sanger)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--right=FILE</span></code></td>
-<td>Right input file for FASTA/FASTQ paired end reads.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--right=FILE</span></code></p></td>
+<td><p>Right input file for FASTA/FASTQ paired end reads.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sam</span></code></td>
-<td>Output the alignment files in SAM format.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sam</span></code></p></td>
+<td><p>Output the alignment files in SAM format.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing template to map against.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing template to map against.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--aligner-band-width=FLOAT</span></code></td>
-<td>Set the fraction of the read length that is allowed to be an indel. Decreasing this factor will allow faster processing,
-at the expense of only allowing shorter indels to be aligned. (Default is 0.5).</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--aligner-band-width=FLOAT</span></code></p></td>
+<td><p>Set the fraction of the read length that is allowed to be an indel. Decreasing this factor will allow faster processing,
+at the expense of only allowing shorter indels to be aligned. (Default is 0.5).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--aligner-mode=STRING</span></code></td>
-<td>Set the aligner mode to be used. Allowed values are [auto, table, general] (Default is auto).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--aligner-mode=STRING</span></code></p></td>
+<td><p>Set the aligner mode to be used. Allowed values are [auto, table, general] (Default is auto).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--blacklist-threshold=INT</span></code></td>
-<td>filter k-mers that occur more than this many times in the reference using a blacklist</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--blacklist-threshold=INT</span></code></p></td>
+<td><p>filter k-mers that occur more than this many times in the reference using a blacklist</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--gap-extend-penalty=INT</span></code></td>
-<td>Set the penalty for extending a gap during alignment. (Default is 1).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--gap-extend-penalty=INT</span></code></p></td>
+<td><p>Set the penalty for extending a gap during alignment. (Default is 1).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--gap-open-penalty=INT</span></code></td>
-<td>Set the penalty for a gap open during alignment. (Default is 19).</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--gap-open-penalty=INT</span></code></p></td>
+<td><p>Set the penalty for a gap open during alignment. (Default is 19).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--indel-length=INT</span></code></td>
-<td>Guarantees number of positions that will be detected in a single indel. For example, -c 3 specifies 3 nucleotide
-insertions or deletions. (Default is 1).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--indel-length=INT</span></code></p></td>
+<td><p>Guarantees number of positions that will be detected in a single indel. For example, -c 3 specifies 3 nucleotide
+insertions or deletions. (Default is 1).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-b</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--indels=INT</span></code></td>
-<td>Guarantees minimum number of indels which will be detected when used with read less than 64 bp long. For example -b 1
-specifies 1 insertion or deletion. (Default is 1).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-b</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--indels=INT</span></code></p></td>
+<td><p>Guarantees minimum number of indels which will be detected when used with read less than 64 bp long. For example -b 1
+specifies 1 insertion or deletion. (Default is 1).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-M</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-fragment-size=INT</span></code></td>
-<td>The maximum permitted fragment size when mating paired reads. (Default is 1000).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-M</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-fragment-size=INT</span></code></p></td>
+<td><p>The maximum permitted fragment size when mating paired reads. (Default is 1000).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-fragment-size=INT</span></code></td>
-<td>The minimum permitted fragment size when mating paired reads. (Default is 0).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-fragment-size=INT</span></code></p></td>
+<td><p>The minimum permitted fragment size when mating paired reads. (Default is 0).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--mismatch-penalty=INT</span></code></td>
-<td>Set the penalty for a mismatch during alignment. (Default is 9).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mismatch-penalty=INT</span></code></p></td>
+<td><p>Set the penalty for a mismatch during alignment. (Default is 9).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-d</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--orientation=STRING</span></code></td>
-<td>Set the orientation required for proper pairs. Allowed values are [fr, rf, tandem, any] (Default is any).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-d</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--orientation=STRING</span></code></p></td>
+<td><p>Set the orientation required for proper pairs. Allowed values are [fr, rf, tandem, any] (Default is any).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></td>
-<td>Genome relationships pedigree containing sex of sample.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></p></td>
+<td><p>Genome relationships pedigree containing sex of sample.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--repeat-freq=INT%</span></code></td>
-<td>Where INT specifies the percentage of all hashes to keep, discarding the remaining percentage of the most frequent
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--repeat-freq=INT%</span></code></p></td>
+<td><p>Where INT specifies the percentage of all hashes to keep, discarding the remaining percentage of the most frequent
 hashes. Increasing this value will improve the ability to map sequences in repetitive regions at a cost of run time. It is
 also possible to specify the option as an absolute count (by omitting the percent symbol) where any hash exceeding the
-threshold will be discarded from the index. (Default is 90%).</td>
+threshold will be discarded from the index. (Default is 90%).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></td>
-<td>Specifies the sex of the individual. Allowed values are [male, female, either].</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></p></td>
+<td><p>Specifies the sex of the individual. Allowed values are [male, female, either].</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--soft-clip-distance=INT</span></code></td>
-<td>Set to soft clip alignments when an indel occurs within that many nucleotides from either end of the read. (Default is 5).</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--soft-clip-distance=INT</span></code></p></td>
+<td><p>Set to soft clip alignments when an indel occurs within that many nucleotides from either end of the read. (Default is 5).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></td>
-<td>Set the step size. (Default is half word size).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></p></td>
+<td><p>Set the step size. (Default is half word size).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--substitutions=INT</span></code></td>
-<td>Guarantees minimum number of substitutions to be detected when used with read data less than 64 bp long. (Default is 1).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--substitutions=INT</span></code></p></td>
+<td><p>Guarantees minimum number of substitutions to be detected when used with read data less than 64 bp long. (Default is 1).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--unknowns-penalty=INT</span></code></td>
-<td>Set the penalty for unknown nucleotides during alignment. (Default is 5).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--unknowns-penalty=INT</span></code></p></td>
+<td><p>Set the penalty for unknown nucleotides during alignment. (Default is 5).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-w</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></td>
-<td>Specifies an internal minimum word size used during the initial matching phase. Word size selection optimizes the number
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-w</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></p></td>
+<td><p>Specifies an internal minimum word size used during the initial matching phase. Word size selection optimizes the number
 of reads for a desired level of sensitivity (allowed mismatches and indels) given an acceptable alignment speed. (Default
-is 22).</td>
+is 22).</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="24%" />
-<col width="71%" />
+<col style="width: 6%" />
+<col style="width: 24%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></td>
-<td>Exclusive upper bound on read id.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></p></td>
+<td><p>Exclusive upper bound on read id.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></td>
-<td>Inclusive lower bound on read id.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></p></td>
+<td><p>Inclusive lower bound on read id.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-mated-mismatches=INT</span></code></td>
-<td>Maximum mismatches for mappings across mated results, alias for –max-mismatches (as absolute value or percentage of read length) (Default is 10%)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-mated-mismatches=INT</span></code></p></td>
+<td><p>Maximum mismatches for mappings across mated results, alias for –max-mismatches (as absolute value or percentage of read length) (Default is 10%)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-e</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-mismatches=INT</span></code></td>
-<td>Maximum mismatches for mappings in single-end mode (as absolute value or percentage of read length) (Default is 10%)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-e</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-mismatches=INT</span></code></p></td>
+<td><p>Maximum mismatches for mappings in single-end mode (as absolute value or percentage of read length) (Default is 10%)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-E</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-unmated-mismatches=INT</span></code></td>
-<td>Maximum mismatches for mappings of unmated results (as absolute value or percentage of read length) (Default is 10%)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-E</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-unmated-mismatches=INT</span></code></p></td>
+<td><p>Maximum mismatches for mappings of unmated results (as absolute value or percentage of read length) (Default is 10%)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></td>
-<td>File containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:READGROUP1\tSM:BACT_SAMPLE\tPL:ILLUMINA</span></code></td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></p></td>
+<td><p>File containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:READGROUP1\tSM:BACT_SAMPLE\tPL:ILLUMINA</span></code></p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="24%" />
-<col width="71%" />
+<col style="width: 6%" />
+<col style="width: 24%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--legacy-cigars</span></code></td>
-<td>Use legacy cigars in output.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--legacy-cigars</span></code></p></td>
+<td><p>Use legacy cigars in output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-merge</span></code></td>
-<td>Output mated/unmated/unmapped alignments into separate SAM/BAM files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-merge</span></code></p></td>
+<td><p>Output mated/unmated/unmapped alignments into separate SAM/BAM files.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--read-names</span></code></td>
-<td>Use read name in output instead of read id (Uses more RAM)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--read-names</span></code></p></td>
+<td><p>Use read name in output instead of read id (Uses more RAM)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--tempdir=DIR</span></code></td>
-<td>Directory used for temporary files (Defaults to output directory)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--tempdir=DIR</span></code></p></td>
+<td><p>Directory used for temporary files (Defaults to output directory)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -2531,15 +2382,15 @@ <h3>mapf<a class="headerlink" href="#mapf" title="Permalink to this headline">¶
 and the other did not. Thus, with <code class="docutils literal notranslate"><span class="pre">mapf</span></code>, if either end of the read maps
 to the contaminant database, both arms of the read are filtered.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">The <code class="docutils literal notranslate"><span class="pre">--sam-rg</span></code> flag specifies the read group information
+<p class="admonition-title">Note</p>
+<p>The <code class="docutils literal notranslate"><span class="pre">--sam-rg</span></code> flag specifies the read group information
 when outputting to SAM/BAM and also adjusts the internal aligner
 configuration based on the platform given. Recognized platforms are
 <code class="docutils literal notranslate"><span class="pre">ILLUMINA,</span></code> <code class="docutils literal notranslate"><span class="pre">LS454</span></code>, and <code class="docutils literal notranslate"><span class="pre">IONTORRENT</span></code>.</p>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#cgmap"><span class="std std-ref">cgmap</span></a>,
 <a class="reference internal" href="#mapx"><span class="std std-ref">mapx</span></a></p>
 </div>
@@ -2557,196 +2408,196 @@ <h3>cgmap<a class="headerlink" href="#cgmap" title="Permalink to this headline">
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="20%" />
-<col width="72%" />
+<col style="width: 8%" />
+<col style="width: 20%" />
+<col style="width: 72%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-F</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></td>
-<td>Format of read data. Allowed values are [sdf, tsv] (Default is sdf)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-F</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></p></td>
+<td><p>Format of read data. Allowed values are [sdf, tsv] (Default is sdf)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></td>
-<td>Specifies the Complete Genomics reads to be mapped.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></p></td>
+<td><p>Specifies the Complete Genomics reads to be mapped.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Specifies the directory where results are reported.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Specifies the directory where results are reported.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sam</span></code></td>
-<td>Set to output results in SAM format instead of BAM format.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sam</span></code></p></td>
+<td><p>Set to output results in SAM format instead of BAM format.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>Specifies the SDF containing the reference genome to map against.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing the reference genome to map against.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="19%" />
-<col width="75%" />
+<col style="width: 6%" />
+<col style="width: 19%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--blacklist-threshold=INT</span></code></td>
-<td>filter k-mers that occur more than this many times in the reference using a blacklist</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--blacklist-threshold=INT</span></code></p></td>
+<td><p>filter k-mers that occur more than this many times in the reference using a blacklist</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--mask=STRING</span></code></td>
-<td>Read indexing method. Allowed values are [cg1, cg1-fast, cg2]</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mask=STRING</span></code></p></td>
+<td><p>Read indexing method. Allowed values are [cg1, cg1-fast, cg2]</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-M</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-fragment-size=INT</span></code></td>
-<td>The maximum permitted fragment size when mating paired reads. (Default is 1000).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-M</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-fragment-size=INT</span></code></p></td>
+<td><p>The maximum permitted fragment size when mating paired reads. (Default is 1000).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-fragment-size=INT</span></code></td>
-<td>The minimum permitted fragment size when mating paired reads. (Default is 0).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-fragment-size=INT</span></code></p></td>
+<td><p>The minimum permitted fragment size when mating paired reads. (Default is 0).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-d</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--orientation=STRING</span></code></td>
-<td>Orientation for proper pairs. Allowed values are [fr, rf, tandem, any] (Default is any)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-d</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--orientation=STRING</span></code></p></td>
+<td><p>Orientation for proper pairs. Allowed values are [fr, rf, tandem, any] (Default is any)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree</span></code></td>
-<td>Genome relationships pedigree containing sex of sample.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree</span></code></p></td>
+<td><p>Genome relationships pedigree containing sex of sample.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--penalize-unknowns</span></code></td>
-<td>If set, will treat unknown bases as mismatches.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--penalize-unknowns</span></code></p></td>
+<td><p>If set, will treat unknown bases as mismatches.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--repeat-freq=INT%</span></code></td>
-<td>Where INT specifies the percentage of all hashes to keep, discarding the remaining percentage of the most frequent
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--repeat-freq=INT%</span></code></p></td>
+<td><p>Where INT specifies the percentage of all hashes to keep, discarding the remaining percentage of the most frequent
 hashes. Increasing this value will improve the ability to map sequences in repetitive regions at a cost of run time. It is
 also possible to specify the option as an absolute count (by omitting the percent symbol) where any hash exceeding the
-threshold will be discarded from the index. (Default is 95%).</td>
+threshold will be discarded from the index. (Default is 95%).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></td>
-<td>Sex of individual. Allowed values are [male, female, either]</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></p></td>
+<td><p>Sex of individual. Allowed values are [male, female, either]</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="18%" />
-<col width="80%" />
+<col style="width: 3%" />
+<col style="width: 18%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></td>
-<td>Only map sequences with sequence id less than the given number. (Sequence ids start at 0).</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></p></td>
+<td><p>Only map sequences with sequence id less than the given number. (Sequence ids start at 0).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></td>
-<td>Only map sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></p></td>
+<td><p>Only map sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="17%" />
-<col width="79%" />
+<col style="width: 5%" />
+<col style="width: 17%" />
+<col style="width: 79%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--all-hits</span></code></td>
-<td>Output all alignments meeting thresholds instead of applying mating and N limits.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all-hits</span></code></p></td>
+<td><p>Output all alignments meeting thresholds instead of applying mating and N limits.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-e</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-mated-mismatches=INT</span></code></td>
-<td>The maximum mismatches allowed for mated results (as absolute value or percentage of read length). (Default is 10%).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-e</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-mated-mismatches=INT</span></code></p></td>
+<td><p>The maximum mismatches allowed for mated results (as absolute value or percentage of read length). (Default is 10%).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-top-results=INT</span></code></td>
-<td>Sets the maximum number of reported mapping results (locations) with the same alignment score (AS). Allowed values are between 1 and 255. (Default is 5).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-top-results=INT</span></code></p></td>
+<td><p>Sets the maximum number of reported mapping results (locations) with the same alignment score (AS). Allowed values are between 1 and 255. (Default is 5).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-E</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-unmated-mismatches=INT</span></code></td>
-<td>The maximum mismatches allowed for unmated results (as absolute value or percentage of read length). (Default is 10%).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-E</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-unmated-mismatches=INT</span></code></p></td>
+<td><p>The maximum mismatches allowed for unmated results (as absolute value or percentage of read length). (Default is 10%).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></td>
-<td>Specifies a file containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:RG1\tSM:BACT\tPL:COMPLETE</span></code>.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></p></td>
+<td><p>Specifies a file containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:RG1\tSM:BACT\tPL:COMPLETE</span></code>.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="11%" />
-<col width="84%" />
+<col style="width: 5%" />
+<col style="width: 11%" />
+<col style="width: 84%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--legacy-cigars</span></code></td>
-<td>Produce cigars in legacy format (using M instead of X or =) in SAM/BAM output. When set will also produce the MD field.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--legacy-cigars</span></code></p></td>
+<td><p>Produce cigars in legacy format (using M instead of X or =) in SAM/BAM output. When set will also produce the MD field.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></td>
-<td>Set this flag to not produce the calibration output files.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></p></td>
+<td><p>Set this flag to not produce the calibration output files.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Set this flag to create the SAM output files without compression. By default the output files are compressed with tabix compatible blocked gzip.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Set this flag to create the SAM output files without compression. By default the output files are compressed with tabix compatible blocked gzip.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-merge</span></code></td>
-<td>Set to output mated, unmated and unmapped alignment records into separate SAM/BAM files.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-merge</span></code></p></td>
+<td><p>Set to output mated, unmated and unmapped alignment records into separate SAM/BAM files.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-svprep</span></code></td>
-<td>Do not perform structural variant processing.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-svprep</span></code></p></td>
+<td><p>Do not perform structural variant processing.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-unmapped</span></code></td>
-<td>Do not output unmapped reads. Some reads that map multiple times will not be aligned, and are reported as unmapped. These reads are reported with XC attributes that indicate the
-reason they were not mapped.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-unmapped</span></code></p></td>
+<td><p>Do not output unmapped reads. Some reads that map multiple times will not be aligned, and are reported as unmapped. These reads are reported with XC attributes that indicate the
+reason they were not mapped.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-unmated</span></code></td>
-<td>Do not output unmated reads when in paired-end mode.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-unmated</span></code></p></td>
+<td><p>Do not output unmated reads when in paired-end mode.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--tempdir=DIR</span></code></td>
-<td>Set the directory to use for temporary files during processing. (Defaults to output directory).</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--tempdir=DIR</span></code></p></td>
+<td><p>Set the directory to use for temporary files during processing. (Defaults to output directory).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</p></td>
 </tr>
 </tbody>
 </table>
@@ -2774,8 +2625,8 @@ <h3>cgmap<a class="headerlink" href="#cgmap" title="Permalink to this headline">
 (somewhere between 1 and 2). For version 2 the mask <code class="docutils literal notranslate"><span class="pre">cg2</span></code> is
 approximately equivalent to the mask <code class="docutils literal notranslate"><span class="pre">cg1</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#mapf"><span class="std std-ref">mapf</span></a>,
 <a class="reference internal" href="#mapx"><span class="std std-ref">mapx</span></a></p>
 </div>
@@ -2799,123 +2650,123 @@ <h3>coverage<a class="headerlink" href="#coverage" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="14%" />
-<col width="82%" />
+<col style="width: 4%" />
+<col style="width: 14%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read SAM records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read SAM records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bedgraph</span></code></td>
-<td>If set, output in BEDGRAPH format (suppresses BED file output)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bedgraph</span></code></p></td>
+<td><p>If set, output in BEDGRAPH format (suppresses BED file output)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--per-base</span></code></td>
-<td>If set, output per-base counts in TSV format (suppresses BED file output)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--per-base</span></code></p></td>
+<td><p>If set, output per-base counts in TSV format (suppresses BED file output)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--per-region</span></code></td>
-<td>If set, output BED/BEDGRAPH entries per-region rather than every coverage level change.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--per-region</span></code></p></td>
+<td><p>If set, output BED/BEDGRAPH entries per-region rather than every coverage level change.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
-or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
+or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></td>
-<td>Exclude all mated SAM records.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></p></td>
+<td><p>Exclude all mated SAM records.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></td>
-<td>Exclude all unmated SAM records.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></p></td>
+<td><p>Exclude all unmated SAM records.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></td>
-<td>Don’t detect and filter duplicate reads based on mapping position.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></p></td>
+<td><p>Don’t detect and filter duplicate reads based on mapping position.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></td>
-<td>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></p></td>
+<td><p>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-u</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></td>
-<td>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-u</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></p></td>
+<td><p>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-hits=INT</span></code></td>
-<td>If set, ignore SAM records with an alignment count that exceeds this value.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-hits=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with an alignment count that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></td>
-<td>If set, ignore SAM records with MAPQ less than this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with MAPQ less than this value.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--smoothing=INT</span></code></td>
-<td>Smooth with this number of neighboring values (0 means no smoothing) (Default is 50)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--smoothing=INT</span></code></p></td>
+<td><p>Smooth with this number of neighboring values (0 means no smoothing) (Default is 50)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -2945,8 +2796,8 @@ <h3>coverage<a class="headerlink" href="#coverage" title="Permalink to this head
 output files can be very large, so this is of most use when focusing on
 particular regions..</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#cnv"><span class="std std-ref">cnv</span></a></p>
 </div>
@@ -2969,82 +2820,82 @@ <h3>calibrate<a class="headerlink" href="#calibrate" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--merge=FILE</span></code></td>
-<td>If set, merge records and calibration files to this output file.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--merge=FILE</span></code></p></td>
+<td><p>If set, merge records and calibration files to this output file.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>Restrict calibration to mappings falling within the supplied BED regions.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>Restrict calibration to mappings falling within the supplied BED regions.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-bed=FILE</span></code></td>
-<td>BED containing regions to exclude from calibration.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-bed=FILE</span></code></p></td>
+<td><p>BED containing regions to exclude from calibration.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-vcf=FILE</span></code></td>
-<td>VCF containing sites of known variants to exclude from calibration.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-vcf=FILE</span></code></p></td>
+<td><p>VCF containing sites of known variants to exclude from calibration.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--force</span></code></td>
-<td>Force overwriting of calibration files.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--force</span></code></p></td>
+<td><p>Force overwriting of calibration files.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -3055,8 +2906,8 @@ <h3>calibrate<a class="headerlink" href="#calibrate" title="Permalink to this he
 name. If the <code class="docutils literal notranslate"><span class="pre">--merge</span></code> option is used, this command can be used to
 simultaneously merge input files to a single, calibrated output file.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#cgmap"><span class="std std-ref">cgmap</span></a></p>
 </div>
@@ -3083,177 +2934,177 @@ <h3>mapx<a class="headerlink" href="#mapx" title="Permalink to this headline">¶
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="24%" />
-<col width="70%" />
+<col style="width: 6%" />
+<col style="width: 24%" />
+<col style="width: 70%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-F</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></td>
-<td>Input format for reads. Allowed values are [sdf, fasta, fastq, sam-se] (Default is sdf)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-F</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></p></td>
+<td><p>Input format for reads. Allowed values are [sdf, fasta, fastq, sam-se] (Default is sdf)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></td>
-<td>Query sequences.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></p></td>
+<td><p>Query sequences.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing protein database to search.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing protein database to search.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="15%" />
-<col width="81%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--gap-length=INT</span></code></td>
-<td>Guaranteed number of positions that will be detected in a single gap (Default is 1)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--gap-length=INT</span></code></p></td>
+<td><p>Guaranteed number of positions that will be detected in a single gap (Default is 1)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-b</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--gaps=INT</span></code></td>
-<td>Guaranteed minimum number of gaps which will be detected (if this is larger than the minimum number of mismatches then the minimum number of mismatches is
-increased to the same value) (Default is 0)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-b</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--gaps=INT</span></code></p></td>
+<td><p>Guaranteed minimum number of gaps which will be detected (if this is larger than the minimum number of mismatches then the minimum number of mismatches is
+increased to the same value) (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--matrix=STRING</span></code></td>
-<td>Name of the scoring matrix used during alignment. Allowed values are [blosum45, blosum62, blosum80] (Default is blosum62)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--matrix=STRING</span></code></p></td>
+<td><p>Name of the scoring matrix used during alignment. Allowed values are [blosum45, blosum62, blosum80] (Default is blosum62)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-read-length=INT</span></code></td>
-<td>Minimum read length. Shorter reads will be ignored (Default is protein space length of (w + a + 1))</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-read-length=INT</span></code></p></td>
+<td><p>Minimum read length. Shorter reads will be ignored (Default is protein space length of (w + a + 1))</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--mismatches=INT</span></code></td>
-<td>Guaranteed minimum number of identical mismatches which will be detected (Default is 1)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mismatches=INT</span></code></p></td>
+<td><p>Guaranteed minimum number of identical mismatches which will be detected (Default is 1)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--repeat-freq=INT</span></code></td>
-<td>Maximum repeat frequency (Default is 95%)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--repeat-freq=INT</span></code></p></td>
+<td><p>Maximum repeat frequency (Default is 95%)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-w</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></td>
-<td>Word size (Default is 7)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-w</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></p></td>
+<td><p>Word size (Default is 7)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="26%" />
-<col width="68%" />
+<col style="width: 7%" />
+<col style="width: 26%" />
+<col style="width: 68%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></td>
-<td>Exclusive upper bound on read id.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></p></td>
+<td><p>Exclusive upper bound on read id.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></td>
-<td>Inclusive lower bound on read id.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></p></td>
+<td><p>Inclusive lower bound on read id.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="20%" />
-<col width="75%" />
+<col style="width: 5%" />
+<col style="width: 20%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--all-hits</span></code></td>
-<td>Output all alignments meeting thresholds instead of applying topn/topequals N limits.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all-hits</span></code></p></td>
+<td><p>Output all alignments meeting thresholds instead of applying topn/topequals N limits.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-e</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-alignment-score=INT</span></code></td>
-<td>Maximum alignment score at output (as absolute value or percentage of query length in protein space) (Default is 30%)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-e</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-alignment-score=INT</span></code></p></td>
+<td><p>Maximum alignment score at output (as absolute value or percentage of query length in protein space) (Default is 30%)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-E</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-e-score=FLOAT</span></code></td>
-<td>Maximum e-score at output (Default is 10.0)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-E</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-e-score=FLOAT</span></code></p></td>
+<td><p>Maximum e-score at output (Default is 10.0)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-top-results=INT</span></code></td>
-<td>Maximum number of topn/topequals results output per read (Default is 10)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-top-results=INT</span></code></p></td>
+<td><p>Maximum number of topn/topequals results output per read (Default is 10)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-B</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-bit-score=FLOAT</span></code></td>
-<td>Minimum bit score at output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-B</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-bit-score=FLOAT</span></code></p></td>
+<td><p>Minimum bit score at output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-P</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-identity=INT</span></code></td>
-<td>Minimum percent identity at output (Default is 60)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-P</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-identity=INT</span></code></p></td>
+<td><p>Minimum percent identity at output (Default is 60)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-filter=STRING</span></code></td>
-<td>Output filter. Allowed values are [topequal, topn] (Default is topn)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-filter=STRING</span></code></p></td>
+<td><p>Output filter. Allowed values are [topequal, topn] (Default is topn)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="26%" />
-<col width="68%" />
+<col style="width: 7%" />
+<col style="width: 26%" />
+<col style="width: 68%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-unmapped</span></code></td>
-<td>Do not output unmapped reads.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-unmapped</span></code></p></td>
+<td><p>Do not output unmapped reads.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--read-names</span></code></td>
-<td>Use read name in output instead of read id (Uses more RAM)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--read-names</span></code></p></td>
+<td><p>Use read name in output instead of read id (Uses more RAM)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--suppress-protein</span></code></td>
-<td>Do not include protein sequence in output files.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--suppress-protein</span></code></p></td>
+<td><p>Do not include protein sequence in output files.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--tempdir=DIR</span></code></td>
-<td>Directory used for temporary files (Defaults to output directory)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--tempdir=DIR</span></code></p></td>
+<td><p>Directory used for temporary files (Defaults to output directory)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -3290,8 +3141,8 @@ <h3>mapx<a class="headerlink" href="#mapx" title="Permalink to this headline">¶
 <code class="docutils literal notranslate"><span class="pre">alignments.tsv</span></code> in the output directory. This ASCII file contains
 columns of reported data in a format similar to that produced by BLASTX.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#cgmap"><span class="std std-ref">cgmap</span></a>,
 <a class="reference internal" href="#mapf"><span class="std std-ref">mapf</span></a>,
 <a class="reference internal" href="#mapp"><span class="std std-ref">mapp</span></a></p>
@@ -3316,177 +3167,177 @@ <h3>mapp<a class="headerlink" href="#mapp" title="Permalink to this headline">¶
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="22%" />
-<col width="72%" />
+<col style="width: 6%" />
+<col style="width: 22%" />
+<col style="width: 72%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-F</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></td>
-<td>Input format for query sequences. Allowed values are [sdf, fasta, fastq, sam-se] (Default is sdf)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-F</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></p></td>
+<td><p>Input format for query sequences. Allowed values are [sdf, fasta, fastq, sam-se] (Default is sdf)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></td>
-<td>Query sequences.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></p></td>
+<td><p>Query sequences.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing protein database to search.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing protein database to search.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="15%" />
-<col width="81%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--gap-length=INT</span></code></td>
-<td>Guaranteed number of positions that will be detected in a single gap (Default is 1)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--gap-length=INT</span></code></p></td>
+<td><p>Guaranteed number of positions that will be detected in a single gap (Default is 1)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-b</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--gaps=INT</span></code></td>
-<td>Guaranteed minimum number of gaps which will be detected (if this is larger than the minimum number of mismatches then the minimum number of mismatches is
-increased to the same value) (Default is 0)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-b</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--gaps=INT</span></code></p></td>
+<td><p>Guaranteed minimum number of gaps which will be detected (if this is larger than the minimum number of mismatches then the minimum number of mismatches is
+increased to the same value) (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--matrix=STRING</span></code></td>
-<td>Name of the scoring matrix used during alignment. Allowed values are [blosum45, blosum62, blosum80] (Default is blosum62)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--matrix=STRING</span></code></p></td>
+<td><p>Name of the scoring matrix used during alignment. Allowed values are [blosum45, blosum62, blosum80] (Default is blosum62)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-read-length=INT</span></code></td>
-<td>Minimum query sequence length. Shorter query sequences will be ignored (Default is protein space length of (w + a + 1))</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-read-length=INT</span></code></p></td>
+<td><p>Minimum query sequence length. Shorter query sequences will be ignored (Default is protein space length of (w + a + 1))</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--mismatches=INT</span></code></td>
-<td>Guaranteed minimum number of identical mismatches which will be detected (Default is 1)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mismatches=INT</span></code></p></td>
+<td><p>Guaranteed minimum number of identical mismatches which will be detected (Default is 1)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--repeat-freq=INT</span></code></td>
-<td>Maximum repeat frequency (Default is 95%)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--repeat-freq=INT</span></code></p></td>
+<td><p>Maximum repeat frequency (Default is 95%)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-w</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></td>
-<td>Word size (Default is 7)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-w</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></p></td>
+<td><p>Word size (Default is 7)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="26%" />
-<col width="68%" />
+<col style="width: 7%" />
+<col style="width: 26%" />
+<col style="width: 68%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></td>
-<td>Exclusive upper bound on query sequence id.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></p></td>
+<td><p>Exclusive upper bound on query sequence id.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></td>
-<td>Inclusive lower bound on query sequence id.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></p></td>
+<td><p>Inclusive lower bound on query sequence id.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="20%" />
-<col width="75%" />
+<col style="width: 5%" />
+<col style="width: 20%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--all-hits</span></code></td>
-<td>Output all alignments meeting thresholds instead of applying topn/topequals N limits.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all-hits</span></code></p></td>
+<td><p>Output all alignments meeting thresholds instead of applying topn/topequals N limits.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-e</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-alignment-score=INT</span></code></td>
-<td>Maximum alignment score at output (as absolute value or percentage of query length in protein space) (Default is 30%)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-e</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-alignment-score=INT</span></code></p></td>
+<td><p>Maximum alignment score at output (as absolute value or percentage of query length in protein space) (Default is 30%)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-E</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-e-score=FLOAT</span></code></td>
-<td>Maximum e-score at output (Default is 10.0)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-E</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-e-score=FLOAT</span></code></p></td>
+<td><p>Maximum e-score at output (Default is 10.0)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-top-results=INT</span></code></td>
-<td>Maximum number of topn/topequals results output per query sequence (Default is 10)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-top-results=INT</span></code></p></td>
+<td><p>Maximum number of topn/topequals results output per query sequence (Default is 10)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-B</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-bit-score=FLOAT</span></code></td>
-<td>Minimum bit score at output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-B</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-bit-score=FLOAT</span></code></p></td>
+<td><p>Minimum bit score at output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-P</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-identity=INT</span></code></td>
-<td>Minimum percent identity at output (Default is 60)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-P</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-identity=INT</span></code></p></td>
+<td><p>Minimum percent identity at output (Default is 60)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-filter=STRING</span></code></td>
-<td>Output filter. Allowed values are [topequal, topn] (Default is topn)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-filter=STRING</span></code></p></td>
+<td><p>Output filter. Allowed values are [topequal, topn] (Default is topn)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="26%" />
-<col width="68%" />
+<col style="width: 7%" />
+<col style="width: 26%" />
+<col style="width: 68%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-unmapped</span></code></td>
-<td>Do not output unmapped query sequences.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-unmapped</span></code></p></td>
+<td><p>Do not output unmapped query sequences.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--read-names</span></code></td>
-<td>Use query sequence name in output instead of query sequence id (Uses more RAM)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--read-names</span></code></p></td>
+<td><p>Use query sequence name in output instead of query sequence id (Uses more RAM)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--suppress-protein</span></code></td>
-<td>Do not include protein sequence in output files.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--suppress-protein</span></code></p></td>
+<td><p>Do not include protein sequence in output files.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--tempdir=DIR</span></code></td>
-<td>Directory used for temporary files (Defaults to output directory)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--tempdir=DIR</span></code></p></td>
+<td><p>Directory used for temporary files (Defaults to output directory)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -3524,8 +3375,8 @@ <h3>mapp<a class="headerlink" href="#mapp" title="Permalink to this headline">¶
 <code class="docutils literal notranslate"><span class="pre">alignments.tsv</span></code> in the output directory. This ASCII file contains
 columns of reported data in a format similar to that produced by BLASTX.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#cgmap"><span class="std std-ref">cgmap</span></a>,
 <a class="reference internal" href="#mapf"><span class="std std-ref">mapf</span></a>,
 <a class="reference internal" href="#mapx"><span class="std std-ref">mapx</span></a></p>
@@ -3572,130 +3423,130 @@ <h3>assemble<a class="headerlink" href="#assemble" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="16%" />
-<col width="80%" />
+<col style="width: 4%" />
+<col style="width: 16%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--454=DIR</span></code></td>
-<td>SDF containing 454 sequences to assemble. May be specified 0 or more times.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--454=DIR</span></code></p></td>
+<td><p>SDF containing 454 sequences to assemble. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-g</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--graph=DIR</span></code></td>
-<td>If you have already constructed an assembly and would like to map additional reads to it or apply some alternate filters you can use this flag to specify the existing graph
-directory. You will still need to supply a kmer size to indicate the amount of overlap between contigs.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-g</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--graph=DIR</span></code></p></td>
+<td><p>If you have already constructed an assembly and would like to map additional reads to it or apply some alternate filters you can use this flag to specify the existing graph
+directory. You will still need to supply a kmer size to indicate the amount of overlap between contigs.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-F</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-454=FILE</span></code></td>
-<td>File containing a list of SDF directories (1 per line) containing 454 sequences to assemble.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-F</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-454=FILE</span></code></p></td>
+<td><p>File containing a list of SDF directories (1 per line) containing 454 sequences to assemble.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SDF directories (1 per line) containing Illumina sequences to assemble.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SDF directories (1 per line) containing Illumina sequences to assemble.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-J</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-mate-pair=FILE</span></code></td>
-<td>File containing a list of SDF directories (1 per line) containing mate pair sequences to assemble.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-J</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-mate-pair=FILE</span></code></p></td>
+<td><p>File containing a list of SDF directories (1 per line) containing mate pair sequences to assemble.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-j</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--mate-pair</span></code></td>
-<td>SDF containing mate pair reads. May be specified 0 or more times.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-j</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mate-pair</span></code></p></td>
+<td><p>SDF containing mate pair reads. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Specifies the directory where results are reported.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Specifies the directory where results are reported.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">SDF+</span></code></td>
-<td>SDF directories containing Illumina sequences to assemble. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">SDF+</span></code></p></td>
+<td><p>SDF directories containing Illumina sequences to assemble. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="18%" />
-<col width="77%" />
+<col style="width: 5%" />
+<col style="width: 18%" />
+<col style="width: 77%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--consensus-reads=INT</span></code></td>
-<td>When using read mappings to disambiguate a graph, paths that are supported by fewer reads than the threshold supplied here will not be collapsed (Default
-is 0).</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--consensus-reads=INT</span></code></p></td>
+<td><p>When using read mappings to disambiguate a graph, paths that are supported by fewer reads than the threshold supplied here will not be collapsed (Default
+is 0).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-k</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--kmer-size=INT</span></code></td>
-<td>K-mer length to use when constructing a de Bruijn graph.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-k</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--kmer-size=INT</span></code></p></td>
+<td><p>K-mer length to use when constructing a de Bruijn graph.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-M</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-insert=INT</span></code></td>
-<td>Maximum insert size between fragments. (Default is automatically calculated.)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-M</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-insert=INT</span></code></p></td>
+<td><p>Maximum insert size between fragments. (Default is automatically calculated.)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-insert=INT</span></code></td>
-<td>Minimum insert size between fragments. (Default is automatically calculated.)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-insert=INT</span></code></p></td>
+<td><p>Minimum insert size between fragments. (Default is automatically calculated.)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-path=INT</span></code></td>
-<td>Prior to generating a consensus, long paths will be deleted if they are supported by fewer than
-<code class="docutils literal notranslate"><span class="pre">--min-path</span></code> reads.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-path=INT</span></code></p></td>
+<td><p>Prior to generating a consensus, long paths will be deleted if they are supported by fewer than
+<code class="docutils literal notranslate"><span class="pre">--min-path</span></code> reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--minimum-kmer-frequency=INT</span></code></td>
-<td>Set minimum k-mer frequency to retain, or -1 for automatic threshold (Default is -1).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--minimum-kmer-frequency=INT</span></code></p></td>
+<td><p>Set minimum k-mer frequency to retain, or -1 for automatic threshold (Default is -1).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--mismatches=INT</span></code></td>
-<td>Number of bases that may mismatch in an alignment or percentage of read that may mismatch (Default is 0).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mismatches=INT</span></code></p></td>
+<td><p>Number of bases that may mismatch in an alignment or percentage of read that may mismatch (Default is 0).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--preserve-bubbles=FLOAT</span></code></td>
-<td>Avoid merging bubbles where the ratio of k-mers on the branches is below this (Default is 0.0). This can be used if you wish to preserve diploid
-information or some near repeats in graph construction.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--preserve-bubbles=FLOAT</span></code></p></td>
+<td><p>Avoid merging bubbles where the ratio of k-mers on the branches is below this (Default is 0.0). This can be used if you wish to preserve diploid
+information or some near repeats in graph construction.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--read-count=INT</span></code></td>
-<td>Prior to generating a consensus delete links in the graph that are supported by fewer reads than this threshold.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--read-count=INT</span></code></p></td>
+<td><p>Prior to generating a consensus delete links in the graph that are supported by fewer reads than this threshold.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></td>
-<td>Step size for mapping (Default is 18).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></p></td>
+<td><p>Step size for mapping (Default is 18).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-w</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></td>
-<td>Word size for mapping (Default is 18).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-w</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></p></td>
+<td><p>Word size for mapping (Default is 18).</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="16%" />
-<col width="77%" />
+<col style="width: 8%" />
+<col style="width: 16%" />
+<col style="width: 77%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</p></td>
 </tr>
 </tbody>
 </table>
@@ -3775,8 +3626,8 @@ <h4>Consensus<a class="headerlink" href="#consensus" title="Permalink to this he
 mapped will potentially be merged into a single contig. Increasing this
 may help to reduce mis-assemblies.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a></p>
 </div>
 </div>
 </div>
@@ -3795,53 +3646,53 @@ <h3>addpacbio<a class="headerlink" href="#addpacbio" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-g</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--graph=DIR</span></code></td>
-<td>Graph of the assembly to map against.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-g</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--graph=DIR</span></code></p></td>
+<td><p>Graph of the assembly to map against.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SDF directories (1 per line) containing sequences to assemble.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SDF directories (1 per line) containing sequences to assemble.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--trim</span></code></td>
-<td>Before mapping remove any short disconnected sequences from the graph.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--trim</span></code></p></td>
+<td><p>Before mapping remove any short disconnected sequences from the graph.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">SDF+</span></code></td>
-<td>SDF directories containing reads to map. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">SDF+</span></code></p></td>
+<td><p>SDF directories containing reads to map. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -3856,8 +3707,8 @@ <h3>addpacbio<a class="headerlink" href="#addpacbio" title="Permalink to this he
 work for the mapper. Setting this option will often result in much
 faster execution.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#assemble"><span class="std std-ref">assemble</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#assemble"><span class="std std-ref">assemble</span></a>,
 <a class="reference internal" href="#format"><span class="std std-ref">format</span></a></p>
 </div>
 </div>
@@ -3888,209 +3739,209 @@ <h3>snp<a class="headerlink" href="#snp" title="Permalink to this headline">¶</
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="20%" />
-<col width="76%" />
+<col style="width: 4%" />
+<col style="width: 20%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read SAM records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read SAM records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
-or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
+or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="22%" />
-<col width="73%" />
+<col style="width: 4%" />
+<col style="width: 22%" />
+<col style="width: 73%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></td>
-<td>If set, incorporate the expected allelic fraction in scoring.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></p></td>
+<td><p>If set, incorporate the expected allelic fraction in scoring.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></td>
-<td>Exclude all mated SAM records.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></p></td>
+<td><p>Exclude all mated SAM records.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></td>
-<td>Exclude all unmated SAM records.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></p></td>
+<td><p>Exclude all unmated SAM records.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></td>
-<td>Don’t detect and filter duplicate reads based on mapping position.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></p></td>
+<td><p>Don’t detect and filter duplicate reads based on mapping position.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></td>
-<td>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></p></td>
+<td><p>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></td>
-<td>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></p></td>
+<td><p>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></td>
-<td>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></p></td>
+<td><p>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></td>
-<td>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></p></td>
+<td><p>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></td>
-<td>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 5.0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></p></td>
+<td><p>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 5.0)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-hits=INT</span></code></td>
-<td>If set, ignore SAM records with an alignment count that exceeds this value.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-hits=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with an alignment count that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></td>
-<td>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></p></td>
+<td><p>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></td>
-<td>If set, ignore SAM records with MAPQ less than this value.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with MAPQ less than this value.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-depth=FLOAT</span></code></td>
-<td>If set, also output sites that meet this minimum quality-adjusted alternate allelic depth.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-depth=FLOAT</span></code></p></td>
+<td><p>If set, also output sites that meet this minimum quality-adjusted alternate allelic depth.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-fraction=FLOAT</span></code></td>
-<td>If set, also output sites that meet this minimum quality-adjusted alternate allelic fraction.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-fraction=FLOAT</span></code></p></td>
+<td><p>If set, also output sites that meet this minimum quality-adjusted alternate allelic fraction.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></td>
-<td>Genome relationships PED file containing sex of individual.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></p></td>
+<td><p>Genome relationships PED file containing sex of individual.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--ploidy=STRING</span></code></td>
-<td>Ploidy to use. Allowed values are [auto, diploid, haploid] (Default is auto)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--ploidy=STRING</span></code></p></td>
+<td><p>Ploidy to use. Allowed values are [auto, diploid, haploid] (Default is auto)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></td>
-<td>If set, use the VCF file to generate population based site-specific priors.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></p></td>
+<td><p>If set, use the VCF file to generate population based site-specific priors.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></td>
-<td>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></p></td>
+<td><p>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></td>
-<td>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></p></td>
+<td><p>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></td>
-<td>Sex of individual. Allowed values are [male, female, either] (Default is either)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></p></td>
+<td><p>Sex of individual. Allowed values are [male, female, either] (Default is either)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="20%" />
-<col width="76%" />
+<col style="width: 4%" />
+<col style="width: 20%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--all</span></code></td>
-<td>Write variant calls covering every position irrespective of thresholds.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all</span></code></p></td>
+<td><p>Write variant calls covering every position irrespective of thresholds.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></td>
-<td>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path
-to a model file (Default is illumina-wgs.avr)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></p></td>
+<td><p>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path
+to a model file (Default is illumina-wgs.avr)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></td>
-<td>Threshold for ambiguity filter applied to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></p></td>
+<td><p>Threshold for ambiguity filter applied to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></td>
-<td>Apply a position based filter, retaining only variants that fall in these BED regions.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></p></td>
+<td><p>Apply a position based filter, retaining only variants that fall in these BED regions.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></td>
-<td>Apply a fixed depth of coverage filter to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></p></td>
+<td><p>Apply a fixed depth of coverage filter to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></td>
-<td>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></p></td>
+<td><p>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></td>
-<td>If set, fail variants with AVR scores below this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></p></td>
+<td><p>If set, fail variants with AVR scores below this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></td>
-<td>If set, will output simple SNPs only.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></p></td>
+<td><p>If set, will output simple SNPs only.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="32%" />
-<col width="62%" />
+<col style="width: 6%" />
+<col style="width: 32%" />
+<col style="width: 62%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></td>
-<td>If set, ignore mapping calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></p></td>
+<td><p>If set, ignore mapping calibration files.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -4124,8 +3975,8 @@ <h3>snp<a class="headerlink" href="#snp" title="Permalink to this headline">¶</
 output line per base pair in the reference), which takes longer to
 process and requires considerably more space to store.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">For more information about the <code class="docutils literal notranslate"><span class="pre">snps.vcf</span></code> output file
+<p class="admonition-title">Note</p>
+<p>For more information about the <code class="docutils literal notranslate"><span class="pre">snps.vcf</span></code> output file
 column definitions, see <a class="reference internal" href="appendix.html#small-variant-vcf-output-file-description"><span class="std std-ref">Small-variant VCF output file description</span></a>.</p>
 </div>
 <div class="section" id="quality-calibration">
@@ -4195,8 +4046,8 @@ <h4>Adaptive Variant Rescoring<a class="headerlink" href="#adaptive-variant-resc
 correct. This can then be used to filter your results to remove calls
 unlikely to be correct.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#vcffilter"><span class="std std-ref">vcffilter</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#vcffilter"><span class="std std-ref">vcffilter</span></a>,
 <a class="reference internal" href="#vcfannotate"><span class="std std-ref">vcfannotate</span></a>,
 <a class="reference internal" href="#coverage"><span class="std std-ref">coverage</span></a>,
 <a class="reference internal" href="#cnv"><span class="std std-ref">cnv</span></a>,
@@ -4237,188 +4088,188 @@ <h3>family<a class="headerlink" href="#family" title="Permalink to this headline
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read SAM records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read SAM records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--daughter=STRING</span></code></td>
-<td>Sample identifier used in read groups for a daughter sample. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--daughter=STRING</span></code></p></td>
+<td><p>Sample identifier used in read groups for a daughter sample. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--father=STRING</span></code></td>
-<td>Sample identifier used in read groups for father sample.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--father=STRING</span></code></p></td>
+<td><p>Sample identifier used in read groups for father sample.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--mother=STRING</span></code></td>
-<td>Sample identifier used in read groups for for mother sample.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mother=STRING</span></code></p></td>
+<td><p>Sample identifier used in read groups for for mother sample.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></td>
-<td>Genome relationships PED file, if not specifying family via –father, –mother, etc.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></p></td>
+<td><p>Genome relationships PED file, if not specifying family via –father, –mother, etc.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
-or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
+or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--son=STRING</span></code></td>
-<td>Sample identifier used in read groups for a son sample. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--son=STRING</span></code></p></td>
+<td><p>Sample identifier used in read groups for a son sample. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="20%" />
-<col width="75%" />
+<col style="width: 4%" />
+<col style="width: 20%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></td>
-<td>If set, incorporate the expected allelic fraction in scoring.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></p></td>
+<td><p>If set, incorporate the expected allelic fraction in scoring.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></td>
-<td>Don’t detect and filter duplicate reads based on mapping position.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></p></td>
+<td><p>Don’t detect and filter duplicate reads based on mapping position.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></td>
-<td>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></p></td>
+<td><p>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></td>
-<td>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></p></td>
+<td><p>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></td>
-<td>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 5.0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></p></td>
+<td><p>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 5.0)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></td>
-<td>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></p></td>
+<td><p>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></td>
-<td>If set, ignore SAM records with MAPQ less than this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with MAPQ less than this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></td>
-<td>If set, use the VCF file to generate population based site-specific priors.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></p></td>
+<td><p>If set, use the VCF file to generate population based site-specific priors.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></td>
-<td>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></p></td>
+<td><p>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></td>
-<td>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></p></td>
+<td><p>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="15%" />
-<col width="82%" />
+<col style="width: 3%" />
+<col style="width: 15%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--all</span></code></td>
-<td>Write variant calls covering every position irrespective of thresholds.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all</span></code></p></td>
+<td><p>Write variant calls covering every position irrespective of thresholds.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></td>
-<td>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path to a model file (Default is illumina-wgs.avr)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></p></td>
+<td><p>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path to a model file (Default is illumina-wgs.avr)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></td>
-<td>Threshold for ambiguity filter applied to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></p></td>
+<td><p>Threshold for ambiguity filter applied to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></td>
-<td>Apply a position based filter, retaining only variants that fall in these BED regions.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></p></td>
+<td><p>Apply a position based filter, retaining only variants that fall in these BED regions.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></td>
-<td>Apply a fixed depth of coverage filter to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></p></td>
+<td><p>Apply a fixed depth of coverage filter to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></td>
-<td>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></p></td>
+<td><p>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></td>
-<td>If set, fail variants with AVR scores below this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></p></td>
+<td><p>If set, fail variants with AVR scores below this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></td>
-<td>If set, will output simple SNPs only.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></p></td>
+<td><p>If set, will output simple SNPs only.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="25%" />
-<col width="69%" />
+<col style="width: 5%" />
+<col style="width: 25%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></td>
-<td>If set, ignore mapping calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></p></td>
+<td><p>If set, ignore mapping calibration files.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -4462,8 +4313,8 @@ <h3>family<a class="headerlink" href="#family" title="Permalink to this headline
 adaptive variant rescoring refer to the information for the <code class="docutils literal notranslate"><span class="pre">snp</span></code>
 command in <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#somatic"><span class="std std-ref">somatic</span></a>,
 <a class="reference internal" href="#population"><span class="std std-ref">population</span></a>,
 <a class="reference internal" href="#calibrate"><span class="std std-ref">calibrate</span></a></p>
@@ -4472,7 +4323,9 @@ <h3>family<a class="headerlink" href="#family" title="Permalink to this headline
 <div class="section" id="somatic">
 <h3>somatic<a class="headerlink" href="#somatic" title="Permalink to this headline">¶</a></h3>
 <p><strong>Synopsis:</strong></p>
-<p>The <code class="docutils literal notranslate"><span class="pre">somatic</span></code> command calls sequence variants on an original and derived sample set.</p>
+<p>The <code class="docutils literal notranslate"><span class="pre">somatic</span></code> command calls sequence variants on an original and
+derived sample set.  If no normal sample is available, it is possible
+to use the <code class="docutils literal notranslate"><span class="pre">tumoronly</span></code> command instead.</p>
 <p><strong>Syntax:</strong></p>
 <p>Multi-file input specified from command line:</p>
 <div class="highlight-text notranslate"><div class="highlight"><pre><span></span>$ rtg somatic [OPTION]... -o DIR -t SDF --contamination FLOAT --derived STRING \
@@ -4490,217 +4343,217 @@ <h3>somatic<a class="headerlink" href="#somatic" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="20%" />
-<col width="76%" />
+<col style="width: 4%" />
+<col style="width: 20%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read SAM records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read SAM records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--derived=STRING</span></code></td>
-<td>Sample identifier used in read groups for derived sample.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--derived=STRING</span></code></p></td>
+<td><p>Sample identifier used in read groups for derived sample.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--original=STRING</span></code></td>
-<td>Sample identifier used in read groups for original sample.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--original=STRING</span></code></p></td>
+<td><p>Sample identifier used in read groups for original sample.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
-or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
+or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="22%" />
-<col width="74%" />
+<col style="width: 4%" />
+<col style="width: 22%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--contamination=FLOAT</span></code></td>
-<td>Estimated fraction of contamination in derived sample.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--contamination=FLOAT</span></code></p></td>
+<td><p>Estimated fraction of contamination in derived sample.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></td>
-<td>If set, incorporate the expected allelic fraction in scoring.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></p></td>
+<td><p>If set, incorporate the expected allelic fraction in scoring.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--enable-somatic-allelic-fraction</span></code></td>
-<td>If set, incorporate the expected somatic allelic fraction in scoring.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--enable-somatic-allelic-fraction</span></code></p></td>
+<td><p>If set, incorporate the expected somatic allelic fraction in scoring.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-G</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--include-gain-of-reference</span></code></td>
-<td>Include gain of reference somatic calls in output VCF.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-G</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--include-gain-of-reference</span></code></p></td>
+<td><p>Include gain of reference somatic calls in output VCF.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--include-germline</span></code></td>
-<td>Include germline variants in output VCF.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--include-germline</span></code></p></td>
+<td><p>Include germline variants in output VCF.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></td>
-<td>Don’t detect and filter duplicate reads based on mapping position.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></p></td>
+<td><p>Don’t detect and filter duplicate reads based on mapping position.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--loh=FLOAT</span></code></td>
-<td>Prior probability that a loss of heterozygosity event has occurred (Default is 0.0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--loh=FLOAT</span></code></p></td>
+<td><p>Prior probability that a loss of heterozygosity event has occurred (Default is 0.0)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></td>
-<td>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></p></td>
+<td><p>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></td>
-<td>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></p></td>
+<td><p>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></td>
-<td>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 25.0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></p></td>
+<td><p>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 25.0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></td>
-<td>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></p></td>
+<td><p>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></td>
-<td>If set, ignore SAM records with MAPQ less than this value.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with MAPQ less than this value.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-depth=FLOAT</span></code></td>
-<td>If set, also output sites that meet this minimum quality-adjusted alternate allelic depth.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-depth=FLOAT</span></code></p></td>
+<td><p>If set, also output sites that meet this minimum quality-adjusted alternate allelic depth.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-fraction=FLOAT</span></code></td>
-<td>If set, also output sites that meet this minimum quality-adjusted alternate allelic fraction.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-fraction=FLOAT</span></code></p></td>
+<td><p>If set, also output sites that meet this minimum quality-adjusted alternate allelic fraction.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></td>
-<td>If set, use the VCF file to generate population based site-specific priors.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></p></td>
+<td><p>If set, use the VCF file to generate population based site-specific priors.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></td>
-<td>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></p></td>
+<td><p>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></td>
-<td>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></p></td>
+<td><p>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></td>
-<td>Sex of individual. Allowed values are [male, female, either] (Default is either)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></p></td>
+<td><p>Sex of individual. Allowed values are [male, female, either] (Default is either)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--somatic=FLOAT</span></code></td>
-<td>Default prior probability of a somatic SNP mutation in the derived sample (Default is 0.000001)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--somatic=FLOAT</span></code></p></td>
+<td><p>Default prior probability of a somatic SNP mutation in the derived sample (Default is 0.000001)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--somatic-priors=FILE</span></code></td>
-<td>If set, use the BED file to generate site specific somatic priors.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--somatic-priors=FILE</span></code></p></td>
+<td><p>If set, use the BED file to generate site specific somatic priors.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="20%" />
-<col width="76%" />
+<col style="width: 4%" />
+<col style="width: 20%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--all</span></code></td>
-<td>Write variant calls covering every position irrespective of thresholds.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all</span></code></p></td>
+<td><p>Write variant calls covering every position irrespective of thresholds.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></td>
-<td>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path
-to a model file (Default is illumina-somatic.avr)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></p></td>
+<td><p>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path
+to a model file (Default is illumina-somatic.avr)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></td>
-<td>Threshold for ambiguity filter applied to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></p></td>
+<td><p>Threshold for ambiguity filter applied to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></td>
-<td>Apply a position based filter, retaining only variants that fall in these BED regions.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></p></td>
+<td><p>Apply a position based filter, retaining only variants that fall in these BED regions.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></td>
-<td>Apply a fixed depth of coverage filter to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></p></td>
+<td><p>Apply a fixed depth of coverage filter to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></td>
-<td>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></p></td>
+<td><p>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></td>
-<td>If set, fail variants with AVR scores below this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></p></td>
+<td><p>If set, fail variants with AVR scores below this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></td>
-<td>If set, will output simple SNPs only.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></p></td>
+<td><p>If set, will output simple SNPs only.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="32%" />
-<col width="62%" />
+<col style="width: 6%" />
+<col style="width: 32%" />
+<col style="width: 62%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></td>
-<td>If set, ignore mapping calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></p></td>
+<td><p>If set, ignore mapping calibration files.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -4750,9 +4603,9 @@ <h3>somatic<a class="headerlink" href="#somatic" title="Permalink to this headli
 after the run has completed to rescore according to a different model.</p>
 <p>The <code class="docutils literal notranslate"><span class="pre">--loh</span></code> parameter is used to control the sensitivity to variants
 occurring in regions of loss of heterozygosity. In heterozygous
-regions, a somatic mutation of the form <img class="math" src="_images/math/ba8123ebfe56a852560851932a86adaef704bbb7.png" alt="XY \rightarrow ZZ"/>
-(with <img class="math" src="_images/math/61e31c976978a6cea362a491cd9d463454c1e0fb.png" alt="X \neq Z"/> and <img class="math" src="_images/math/5cef678b81febf5ec6b208c557e607eed45b9e2a.png" alt="Y \neq Z"/> ) is extremely unlikely;
-however, in a loss of heterozygosity region, <img class="math" src="_images/math/2483bfc119f473931364741eadb1b413b84e3dff.png" alt="XY \rightarrow Z"/>
+regions, a somatic mutation of the form <img class="math" src="_images/math/c61adab5a368b41156d78099e64eaef7d3a9fb30.png" alt="XY \rightarrow ZZ"/>
+(with <img class="math" src="_images/math/af517d52259b23914a79dc82c765d702ec5cf7b1.png" alt="X \neq Z"/> and <img class="math" src="_images/math/57540cfddc027fe046444894db8bb84952eaff1f.png" alt="Y \neq Z"/> ) is extremely unlikely;
+however, in a loss of heterozygosity region, <img class="math" src="_images/math/0118ce53bf328bf7fa4d2751f727ce6ed1a759fd.png" alt="XY \rightarrow Z"/>
 is plausible. As the loss of heterozygosity prior is increased, the
 barrier to detecting and reporting such variants is reduced. If a
 region is known or suspected to have a loss of heterozygosity, then a
@@ -4763,8 +4616,8 @@ <h3>somatic<a class="headerlink" href="#somatic" title="Permalink to this headli
 <p>For details concerning quality calibration prior distributions refer to
 the information for the <code class="docutils literal notranslate"><span class="pre">snp</span></code> command in <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#population"><span class="std std-ref">population</span></a>,
 <a class="reference internal" href="#calibrate"><span class="std std-ref">calibrate</span></a>,
@@ -4789,211 +4642,211 @@ <h3>tumoronly<a class="headerlink" href="#tumoronly" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="20%" />
-<col width="76%" />
+<col style="width: 4%" />
+<col style="width: 20%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read SAM records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read SAM records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=STRING</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:start-end or &lt;sequence_name&gt;:start+length.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=STRING</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:start-end or &lt;sequence_name&gt;:start+length.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>Sample identifier used in read groups for tumor sample.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>Sample identifier used in read groups for tumor sample.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF of the reference genome the reads have been mapped against.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF of the reference genome the reads have been mapped against.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="22%" />
-<col width="74%" />
+<col style="width: 4%" />
+<col style="width: 22%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--contamination=FLOAT</span></code></td>
-<td>Estimated fraction of contamination in derived sample (Default is 0.75)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--contamination=FLOAT</span></code></p></td>
+<td><p>Estimated fraction of contamination in derived sample (Default is 0.75)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></td>
-<td>If set, incorporate the expected allelic fraction in scoring.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></p></td>
+<td><p>If set, incorporate the expected allelic fraction in scoring.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--enable-somatic-allelic-fraction</span></code></td>
-<td>If set, incorporate the expected somatic allelic fraction in scoring.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--enable-somatic-allelic-fraction</span></code></p></td>
+<td><p>If set, incorporate the expected somatic allelic fraction in scoring.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-G</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--include-gain-of-reference</span></code></td>
-<td>Include gain of reference somatic calls in output VCF.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-G</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--include-gain-of-reference</span></code></p></td>
+<td><p>Include gain of reference somatic calls in output VCF.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></td>
-<td>Don’t detect and filter duplicate reads based on mapping position.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></p></td>
+<td><p>Don’t detect and filter duplicate reads based on mapping position.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--loh=FLOAT</span></code></td>
-<td>Prior probability that a loss of heterozygosity event has occurred (Default is 0.0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--loh=FLOAT</span></code></p></td>
+<td><p>Prior probability that a loss of heterozygosity event has occurred (Default is 0.0)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></td>
-<td>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></p></td>
+<td><p>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></td>
-<td>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></p></td>
+<td><p>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></td>
-<td>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 25.0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></p></td>
+<td><p>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 25.0)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></td>
-<td>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></p></td>
+<td><p>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></td>
-<td>If set, ignore SAM records with MAPQ less than this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with MAPQ less than this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-depth=FLOAT</span></code></td>
-<td>If set, also output sites that meet this minimum quality-adjusted alternate allelic depth.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-depth=FLOAT</span></code></p></td>
+<td><p>If set, also output sites that meet this minimum quality-adjusted alternate allelic depth.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-fraction=FLOAT</span></code></td>
-<td>If set, also output sites that meet this minimum quality-adjusted alternate allelic fraction.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-variant-allelic-fraction=FLOAT</span></code></p></td>
+<td><p>If set, also output sites that meet this minimum quality-adjusted alternate allelic fraction.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></td>
-<td>If set, use the VCF file to generate population based site-specific priors.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></p></td>
+<td><p>If set, use the VCF file to generate population based site-specific priors.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></td>
-<td>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></p></td>
+<td><p>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></td>
-<td>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></p></td>
+<td><p>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></td>
-<td>Sex of individual. Allowed values are [male, female, either] (Default is either)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></p></td>
+<td><p>Sex of individual. Allowed values are [male, female, either] (Default is either)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--somatic=FLOAT</span></code></td>
-<td>Default prior probability of a somatic SNP mutation in the derived sample (Default is 0.000001)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--somatic=FLOAT</span></code></p></td>
+<td><p>Default prior probability of a somatic SNP mutation in the derived sample (Default is 0.000001)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--somatic-priors=FILE</span></code></td>
-<td>If set, use the BED file to generate site specific somatic priors.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--somatic-priors=FILE</span></code></p></td>
+<td><p>If set, use the BED file to generate site specific somatic priors.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="16%" />
-<col width="81%" />
+<col style="width: 3%" />
+<col style="width: 16%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--all</span></code></td>
-<td>Write variant calls covering every position irrespective of thresholds.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all</span></code></p></td>
+<td><p>Write variant calls covering every position irrespective of thresholds.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></td>
-<td>Name of AVR model to use when scoring variants.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></p></td>
+<td><p>Name of AVR model to use when scoring variants.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></td>
-<td>Threshold for ambiguity filter applied to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></p></td>
+<td><p>Threshold for ambiguity filter applied to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></td>
-<td>Apply a position based filter, retaining only variants that fall in these BED regions.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></p></td>
+<td><p>Apply a position based filter, retaining only variants that fall in these BED regions.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></td>
-<td>Apply a fixed depth of coverage filter to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></p></td>
+<td><p>Apply a fixed depth of coverage filter to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></td>
-<td>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></p></td>
+<td><p>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></td>
-<td>If set, fail variants with AVR scores below this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></p></td>
+<td><p>If set, fail variants with AVR scores below this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></td>
-<td>If set, will output simple SNPs only.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></p></td>
+<td><p>If set, will output simple SNPs only.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="28%" />
-<col width="67%" />
+<col style="width: 5%" />
+<col style="width: 28%" />
+<col style="width: 67%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></td>
-<td>If set, ignore mapping calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></p></td>
+<td><p>If set, ignore mapping calibration files.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-index</span></code></td>
-<td>Do not produce indexes for output files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-index</span></code></p></td>
+<td><p>Do not produce indexes for output files.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -5022,8 +4875,8 @@ <h3>tumoronly<a class="headerlink" href="#tumoronly" title="Permalink to this he
 <p>For more details regarding flag usage, refer to the information for the
 <code class="docutils literal notranslate"><span class="pre">somatic</span></code> command in <a class="reference internal" href="#somatic"><span class="std std-ref">somatic</span></a>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#somatic"><span class="std std-ref">somatic</span></a></p>
 </div>
 </div>
@@ -5046,181 +4899,181 @@ <h3>population<a class="headerlink" href="#population" title="Permalink to this
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read SAM records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read SAM records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></td>
-<td>Genome relationships PED file.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></p></td>
+<td><p>Genome relationships PED file.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
-or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
+or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="20%" />
-<col width="75%" />
+<col style="width: 4%" />
+<col style="width: 20%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></td>
-<td>If set, incorporate the expected allelic fraction in scoring.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></p></td>
+<td><p>If set, incorporate the expected allelic fraction in scoring.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></td>
-<td>Don’t detect and filter duplicate reads based on mapping position.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></p></td>
+<td><p>Don’t detect and filter duplicate reads based on mapping position.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></td>
-<td>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></p></td>
+<td><p>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></td>
-<td>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></p></td>
+<td><p>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></td>
-<td>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 5.0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></p></td>
+<td><p>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 5.0)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></td>
-<td>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></p></td>
+<td><p>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></td>
-<td>If set, ignore SAM records with MAPQ less than this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with MAPQ less than this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree-connectivity=STRING</span></code></td>
-<td>Sets mode of operation based on how well connected the pedigree is. Allowed values are [auto, sparse, dense] (Default is auto)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree-connectivity=STRING</span></code></p></td>
+<td><p>Sets mode of operation based on how well connected the pedigree is. Allowed values are [auto, sparse, dense] (Default is auto)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></td>
-<td>If set, use the VCF file to generate population based site-specific priors.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></p></td>
+<td><p>If set, use the VCF file to generate population based site-specific priors.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></td>
-<td>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></p></td>
+<td><p>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></td>
-<td>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></p></td>
+<td><p>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--all</span></code></td>
-<td>Write variant calls covering every position irrespective of thresholds.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all</span></code></p></td>
+<td><p>Write variant calls covering every position irrespective of thresholds.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></td>
-<td>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path
-to a model file (Default is illumina-wgs.avr)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></p></td>
+<td><p>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path
+to a model file (Default is illumina-wgs.avr)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></td>
-<td>Threshold for ambiguity filter applied to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></p></td>
+<td><p>Threshold for ambiguity filter applied to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></td>
-<td>Apply a position based filter, retaining only variants that fall in these BED regions.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></p></td>
+<td><p>Apply a position based filter, retaining only variants that fall in these BED regions.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></td>
-<td>Apply a fixed depth of coverage filter to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></p></td>
+<td><p>Apply a fixed depth of coverage filter to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></td>
-<td>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></p></td>
+<td><p>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--impute=STRING</span></code></td>
-<td>Name of sample absent from mappings to impute genotype for. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--impute=STRING</span></code></p></td>
+<td><p>Name of sample absent from mappings to impute genotype for. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></td>
-<td>If set, fail variants with AVR scores below this value.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></p></td>
+<td><p>If set, fail variants with AVR scores below this value.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></td>
-<td>If set, will output simple SNPs only.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></p></td>
+<td><p>If set, will output simple SNPs only.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="29%" />
-<col width="65%" />
+<col style="width: 6%" />
+<col style="width: 29%" />
+<col style="width: 65%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></td>
-<td>If set, ignore mapping calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></p></td>
+<td><p>If set, ignore mapping calibration files.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -5293,8 +5146,8 @@ <h3>population<a class="headerlink" href="#population" title="Permalink to this
 adaptive variant rescoring refer to the information for the <code class="docutils literal notranslate"><span class="pre">snp</span></code>
 command in <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#somatic"><span class="std std-ref">somatic</span></a>,
 <a class="reference internal" href="#calibrate"><span class="std std-ref">calibrate</span></a></p>
@@ -5319,172 +5172,172 @@ <h3>lineage<a class="headerlink" href="#lineage" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read SAM records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read SAM records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></td>
-<td>Genome relationships PED file.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></p></td>
+<td><p>Genome relationships PED file.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
-or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
+or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="20%" />
-<col width="75%" />
+<col style="width: 4%" />
+<col style="width: 20%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></td>
-<td>If set, incorporate the expected allelic fraction in scoring.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--enable-allelic-fraction</span></code></p></td>
+<td><p>If set, incorporate the expected allelic fraction in scoring.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></td>
-<td>Don’t detect and filter duplicate reads based on mapping position.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-duplicates</span></code></p></td>
+<td><p>Don’t detect and filter duplicate reads based on mapping position.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></td>
-<td>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--machine-errors=STRING</span></code></p></td>
+<td><p>If set, force sequencer machine settings. Allowed values are [default, illumina, ls454_se, ls454_pe, complete, iontorrent]</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></td>
-<td>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage=INT</span></code></p></td>
+<td><p>Skip calling in sites with per sample read depth exceeding this value (Default is 200)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></td>
-<td>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 5.0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-coverage-multiplier=FLOAT</span></code></p></td>
+<td><p>Skip calling in sites with combined depth exceeding multiplier * average combined coverage determined from calibration (Default is 5.0)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></td>
-<td>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-base-quality=INT</span></code></p></td>
+<td><p>Phred scaled quality score, read bases below this quality will be treated as unknowns (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></td>
-<td>If set, ignore SAM records with MAPQ less than this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with MAPQ less than this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></td>
-<td>If set, use the VCF file to generate population based site-specific priors.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--population-priors=FILE</span></code></p></td>
+<td><p>If set, use the VCF file to generate population based site-specific priors.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></td>
-<td>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-mated=INT</span></code></p></td>
+<td><p>For mated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></td>
-<td>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rdefault-unmated=INT</span></code></p></td>
+<td><p>For unmated reads that have no mapping quality supplied use this as the default quality (in Phred format from 0 to 63) (Default is 20)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="15%" />
-<col width="82%" />
+<col style="width: 3%" />
+<col style="width: 15%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--all</span></code></td>
-<td>Write variant calls covering every position irrespective of thresholds.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all</span></code></p></td>
+<td><p>Write variant calls covering every position irrespective of thresholds.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></td>
-<td>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path to a model file (Default is illumina-wgs.avr)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></p></td>
+<td><p>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path to a model file (Default is illumina-wgs.avr)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></td>
-<td>Threshold for ambiguity filter applied to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-ambiguity=INT</span></code></p></td>
+<td><p>Threshold for ambiguity filter applied to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></td>
-<td>Apply a position based filter, retaining only variants that fall in these BED regions.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-bed=FILE</span></code></p></td>
+<td><p>Apply a position based filter, retaining only variants that fall in these BED regions.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></td>
-<td>Apply a fixed depth of coverage filter to output variants.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth=INT</span></code></p></td>
+<td><p>Apply a fixed depth of coverage filter to output variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></td>
-<td>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-depth-multiplier=FLOAT</span></code></p></td>
+<td><p>Apply a ratio based depth filter. The filter will be multiplier * average coverage determined from calibration files.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></td>
-<td>If set, fail variants with AVR scores below this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></p></td>
+<td><p>If set, fail variants with AVR scores below this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></td>
-<td>If set, will output simple SNPs only.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></p></td>
+<td><p>If set, will output simple SNPs only.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="25%" />
-<col width="69%" />
+<col style="width: 5%" />
+<col style="width: 25%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></td>
-<td>If set, ignore mapping calibration files.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-calibration</span></code></p></td>
+<td><p>If set, ignore mapping calibration files.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -5515,8 +5368,8 @@ <h3>lineage<a class="headerlink" href="#lineage" title="Permalink to this headli
 adaptive variant rescoring refer to the information for the <code class="docutils literal notranslate"><span class="pre">snp</span></code>
 command in <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#somatic"><span class="std std-ref">somatic</span></a>,
 <a class="reference internal" href="#population"><span class="std std-ref">population</span></a>,
@@ -5537,74 +5390,74 @@ <h3>avrpredict<a class="headerlink" href="#avrpredict" title="Permalink to this
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="21%" />
-<col width="73%" />
+<col style="width: 6%" />
+<col style="width: 21%" />
+<col style="width: 73%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>Input VCF file containing variants to score. Use ‘-‘ to read from standard input.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>Input VCF file containing variants to score. Use ‘-‘ to read from standard input.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output VCF file. Use ‘-‘ to write to standard output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output VCF file. Use ‘-‘ to write to standard output.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="12%" />
-<col width="85%" />
+<col style="width: 3%" />
+<col style="width: 12%" />
+<col style="width: 85%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></td>
-<td>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path to a model file (Default is illumina-wgs.avr)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--avr-model=MODEL</span></code></p></td>
+<td><p>Name of AVR model to use when scoring variants. Allowed values are [alternate.avr, illumina-exome.avr, illumina-somatic.avr, illumina-wgs.avr, none] or a path to a model file (Default is illumina-wgs.avr)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></td>
-<td>If set, fail variants with AVR scores below this value.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></p></td>
+<td><p>If set, fail variants with AVR scores below this value.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>If set, only re-score the specified samples (Default is to re-score all samples). May be specified 0 or more times.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>If set, only re-score the specified samples (Default is to re-score all samples). May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--vcf-score-field=STRING</span></code></td>
-<td>The name of the VCF FORMAT field in which to store the computed score (Default is AVR)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--vcf-score-field=STRING</span></code></p></td>
+<td><p>The name of the VCF FORMAT field in which to store the computed score (Default is AVR)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="21%" />
-<col width="73%" />
+<col style="width: 6%" />
+<col style="width: 21%" />
+<col style="width: 73%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
 </tbody>
 </table>
@@ -5621,8 +5474,8 @@ <h3>avrpredict<a class="headerlink" href="#avrpredict" title="Permalink to this
 be useful when there are multiple applicable AVR models (e.g. scoring
 using both somatic and germline models).</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#avrbuild"><span class="std std-ref">avrbuild</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#avrbuild"><span class="std std-ref">avrbuild</span></a>,
 <a class="reference internal" href="#avrstats"><span class="std std-ref">avrstats</span></a>,
 <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
@@ -5643,91 +5496,91 @@ <h3>avrbuild<a class="headerlink" href="#avrbuild" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="24%" />
-<col width="70%" />
+<col style="width: 6%" />
+<col style="width: 24%" />
+<col style="width: 70%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--annotated=FILE</span></code></td>
-<td>VCF file containing training examples annotated with CALL=TP/FP. May be specified 0 or more times.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--annotated=FILE</span></code></p></td>
+<td><p>VCF file containing training examples annotated with CALL=TP/FP. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read VCF records that overlap the ranges contained in the specified BED file.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read VCF records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--negative=FILE</span></code></td>
-<td>VCF file containing negative training examples. May be specified 0 or more times.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--negative=FILE</span></code></p></td>
+<td><p>VCF file containing negative training examples. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output AVR model.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output AVR model.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--positive=FILE</span></code></td>
-<td>VCF file containing positive training examples. May be specified 0 or more times.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--positive=FILE</span></code></p></td>
+<td><p>VCF file containing positive training examples. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="17%" />
-<col width="79%" />
+<col style="width: 4%" />
+<col style="width: 17%" />
+<col style="width: 79%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--derived-annotations=STRING</span></code></td>
-<td>Derived fields to use in model. Allowed values are [IC, EP, LAL, QD, NAA, AN, GQD, VAF1, ZY, PD, MEANQAD, QA, RA]. May be specified 0 or more times, or as a
-comma separated list.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--derived-annotations=STRING</span></code></p></td>
+<td><p>Derived fields to use in model. Allowed values are [IC, EP, LAL, QD, NAA, AN, GQD, VAF1, ZY, PD, MEANQAD, QA, RA]. May be specified 0 or more times, or as a
+comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--format-annotations=STRING</span></code></td>
-<td>FORMAT fields to use in model. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--format-annotations=STRING</span></code></p></td>
+<td><p>FORMAT fields to use in model. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--info-annotations=STRING</span></code></td>
-<td>INFO fields to use in model. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--info-annotations=STRING</span></code></p></td>
+<td><p>INFO fields to use in model. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--qual-annotation</span></code></td>
-<td>If set, use QUAL annotation in model.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--qual-annotation</span></code></p></td>
+<td><p>If set, use QUAL annotation in model.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>The name of the sample to select (required when using multi-sample VCF files)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>The name of the sample to select (required when using multi-sample VCF files)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="24%" />
-<col width="71%" />
+<col style="width: 6%" />
+<col style="width: 24%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -5753,8 +5606,8 @@ <h3>avrbuild<a class="headerlink" href="#avrbuild" title="Permalink to this head
 The derived annotations are those which can either be present in the
 VCF record or computed from other fields in the VCF record.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#avrpredict"><span class="std std-ref">avrpredict</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#avrpredict"><span class="std std-ref">avrpredict</span></a>,
 <a class="reference internal" href="#avrstats"><span class="std std-ref">avrstats</span></a>,
 <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
@@ -5777,41 +5630,41 @@ <h3>svprep<a class="headerlink" href="#svprep" title="Permalink to this headline
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="12%" />
-<col width="84%" />
+<col style="width: 4%" />
+<col style="width: 12%" />
+<col style="width: 84%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">DIR</span></code></td>
-<td>Specifies the directory containing SAM/BAM format files for preparation.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">DIR</span></code></p></td>
+<td><p>Specifies the directory containing SAM/BAM format files for preparation.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="17%" />
-<col width="76%" />
+<col style="width: 7%" />
+<col style="width: 17%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-augment</span></code></td>
-<td>If set, only compute read group statistics.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-augment</span></code></p></td>
+<td><p>If set, only compute read group statistics.</p></td>
 </tr>
 </tbody>
 </table>
@@ -5819,17 +5672,17 @@ <h3>svprep<a class="headerlink" href="#svprep" title="Permalink to this headline
 <p>Use the <code class="docutils literal notranslate"><span class="pre">svprep</span></code> command to prepare mappings for structural variant
 analysis. The <code class="docutils literal notranslate"><span class="pre">svprep</span></code> command performs three functions:</p>
 <ul class="simple">
-<li>First, it identifies discordant reads (those were there exists a
+<li><p>First, it identifies discordant reads (those were there exists a
 unique unmated mapping for each arm of a paired-end) and fills in the
 RNEXT/PNEXT/TLEN fields for these records. The augmented unmated
-SAM/BAM file will replace the original.</li>
-<li>Secondly it identifies unmapped reads for which there exists a unique
+SAM/BAM file will replace the original.</p></li>
+<li><p>Secondly it identifies unmapped reads for which there exists a unique
 unmated mapping for the other arm and fills in an estimated position
 for the unmapped read. The augmented unmapped SAM/BAM file will
-replace the original.</li>
-<li>Thirdly it generates per read-group statistics on observed length
+replace the original.</p></li>
+<li><p>Thirdly it generates per read-group statistics on observed length
 distributions used by subsequent structural variant analysis
-tools.</li>
+tools.</p></li>
 </ul>
 <p><code class="docutils literal notranslate"><span class="pre">svprep</span></code> may be instructed to perform only the last of these functions
 via the <code class="docutils literal notranslate"><span class="pre">--no-augment</span></code> flag.</p>
@@ -5837,8 +5690,8 @@ <h3>svprep<a class="headerlink" href="#svprep" title="Permalink to this headline
 commands by default, so does not normally need to be executed as a
 separate stage.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#sv"><span class="std std-ref">sv</span></a>,
 <a class="reference internal" href="#discord"><span class="std std-ref">discord</span></a></p>
 </div>
@@ -5862,111 +5715,111 @@ <h3>discord<a class="headerlink" href="#discord" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed</span></code></td>
-<td>Produce output in BED format in addition to VCF.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed</span></code></p></td>
+<td><p>Produce output in BED format in addition to VCF.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--readgroup-stats=FILE</span></code></td>
-<td>Text file containing read group stats. May be specified 0 or more times.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--readgroup-stats=FILE</span></code></p></td>
+<td><p>Text file containing read group stats. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-R</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--readgroup-stats-list-file=FILE</span></code></td>
-<td>File containing list of read group stats files (1 per line)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-R</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--readgroup-stats-list-file=FILE</span></code></p></td>
+<td><p>File containing list of read group stats files (1 per line)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
-or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
+or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="26%" />
-<col width="69%" />
+<col style="width: 5%" />
+<col style="width: 26%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--consistent-only</span></code></td>
-<td>Only include breakends with internally consistent supporting reads.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--consistent-only</span></code></p></td>
+<td><p>Only include breakends with internally consistent supporting reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></td>
-<td>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></p></td>
+<td><p>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-u</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></td>
-<td>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-u</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></p></td>
+<td><p>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-hits=INT</span></code></td>
-<td>If set, ignore SAM records with an alignment count that exceeds this value.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-hits=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with an alignment count that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-support=INT</span></code></td>
-<td>Minimum number of supporting reads for a breakend (Default is 3)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-support=INT</span></code></p></td>
+<td><p>Minimum number of supporting reads for a breakend (Default is 3)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--overlap-fraction=FLOAT</span></code></td>
-<td>Assume this fraction of an aligned ready may may overlap a breakend (Default is 0.01)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--overlap-fraction=FLOAT</span></code></p></td>
+<td><p>Assume this fraction of an aligned ready may may overlap a breakend (Default is 0.01)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="12%" />
-<col width="82%" />
+<col style="width: 6%" />
+<col style="width: 12%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Set this flag to create the output files without compression. By default the output files are compressed with tabix compatible blocked gzip.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Set this flag to create the output files without compression. By default the output files are compressed with tabix compatible blocked gzip.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</p></td>
 </tr>
 </tbody>
 </table>
@@ -5991,8 +5844,8 @@ <h3>discord<a class="headerlink" href="#discord" title="Permalink to this headli
 <p>For additional information about the <code class="docutils literal notranslate"><span class="pre">discord</span></code> command output files see
 <a class="reference internal" href="appendix.html#discord-command-output-file-descriptions"><span class="std std-ref">Discord command output file descriptions</span></a>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#svprep"><span class="std std-ref">svprep</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#svprep"><span class="std std-ref">svprep</span></a>,
 <a class="reference internal" href="#sv"><span class="std std-ref">sv</span></a></p>
 </div>
 </div>
@@ -6014,107 +5867,107 @@ <h3>sv<a class="headerlink" href="#sv" title="Permalink to this headline">¶</a>
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--readgroup-labels=FILE</span></code></td>
-<td>File containing read group relabel mappings (1 per line with the format: [input_readgroup_id][tab][output_readgroup_id]).</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--readgroup-labels=FILE</span></code></p></td>
+<td><p>File containing read group relabel mappings (1 per line with the format: [input_readgroup_id][tab][output_readgroup_id]).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--readgroup-stats=FILE</span></code></td>
-<td>Text file containing read group stats. May be specified 0 or more times.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--readgroup-stats=FILE</span></code></p></td>
+<td><p>Text file containing read group stats. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-R</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--readgroup-stats-list-file=FILE</span></code></td>
-<td>File containing list of read group stats files (1 per line)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-R</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--readgroup-stats-list-file=FILE</span></code></p></td>
+<td><p>File containing list of read group stats files (1 per line)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
-or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
+or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--simple-signals</span></code></td>
-<td>If set, also output simple signals.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--simple-signals</span></code></p></td>
+<td><p>If set, also output simple signals.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="14%" />
-<col width="81%" />
+<col style="width: 5%" />
+<col style="width: 14%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--fine-step=INT</span></code></td>
-<td>Set the step size in interesting regions. (Default is 10).</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--fine-step=INT</span></code></p></td>
+<td><p>Set the step size in interesting regions. (Default is 10).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></td>
-<td>Set to ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></p></td>
+<td><p>Set to ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-u</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></td>
-<td>Set to ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-u</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></p></td>
+<td><p>Set to ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></td>
-<td>Set the step size. (Default is 100).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></p></td>
+<td><p>Set the step size. (Default is 100).</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="12%" />
-<col width="82%" />
+<col style="width: 6%" />
+<col style="width: 12%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Set this flag to create the output files without compression. By default the output files are compressed with tabix compatible blocked gzip.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Set this flag to create the output files without compression. By default the output files are compressed with tabix compatible blocked gzip.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</p></td>
 </tr>
 </tbody>
 </table>
@@ -6128,43 +5981,43 @@ <h3>sv<a class="headerlink" href="#sv" title="Permalink to this headline">¶</a>
 <code class="docutils literal notranslate"><span class="pre">sv_bayesian.tsv.gz</span></code> is a tab separated format that contains the
 prediction strengths of each event model.</p>
 <p>Table : Bayesian SV indicators</p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="22%" />
-<col width="78%" />
+<col style="width: 22%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head">Indicator</th>
-<th class="head">Description</th>
+<thead>
+<tr class="row-odd"><th class="head"><p>Indicator</p></th>
+<th class="head"><p>Description</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><em>normal</em></td>
-<td>No structural variant.</td>
+<tbody>
+<tr class="row-even"><td><p><em>normal</em></p></td>
+<td><p>No structural variant.</p></td>
 </tr>
-<tr class="row-odd"><td><em>duplicate-left</em></td>
-<td>The left border of a duplication.</td>
+<tr class="row-odd"><td><p><em>duplicate-left</em></p></td>
+<td><p>The left border of a duplication.</p></td>
 </tr>
-<tr class="row-even"><td><em>duplicate</em></td>
-<td>Position within a duplicated region.</td>
+<tr class="row-even"><td><p><em>duplicate</em></p></td>
+<td><p>Position within a duplicated region.</p></td>
 </tr>
-<tr class="row-odd"><td><em>duplicate-right</em></td>
-<td>The right border of a duplication.</td>
+<tr class="row-odd"><td><p><em>duplicate-right</em></p></td>
+<td><p>The right border of a duplication.</p></td>
 </tr>
-<tr class="row-even"><td><em>delete-left</em></td>
-<td>The left border of a deletion.</td>
+<tr class="row-even"><td><p><em>delete-left</em></p></td>
+<td><p>The left border of a deletion.</p></td>
 </tr>
-<tr class="row-odd"><td><em>delete</em></td>
-<td>Position within a deletion.</td>
+<tr class="row-odd"><td><p><em>delete</em></p></td>
+<td><p>Position within a deletion.</p></td>
 </tr>
-<tr class="row-even"><td><em>delete-right</em></td>
-<td>The right border of a deletion.</td>
+<tr class="row-even"><td><p><em>delete-right</em></p></td>
+<td><p>The right border of a deletion.</p></td>
 </tr>
-<tr class="row-odd"><td><em>breakpoint</em></td>
-<td>A breakpoint such as at the site where a duplicated section is inserted.</td>
+<tr class="row-odd"><td><p><em>breakpoint</em></p></td>
+<td><p>A breakpoint such as at the site where a duplicated section is inserted.</p></td>
 </tr>
-<tr class="row-even"><td><em>novel-insertion</em></td>
-<td>A site receiving a novel insertion.</td>
+<tr class="row-even"><td><p><em>novel-insertion</em></p></td>
+<td><p>A site receiving a novel insertion.</p></td>
 </tr>
 </tbody>
 </table>
@@ -6184,8 +6037,8 @@ <h3>sv<a class="headerlink" href="#sv" title="Permalink to this headline">¶</a>
 <p>For additional information about the <code class="docutils literal notranslate"><span class="pre">sv</span></code> command output files see
 <a class="reference internal" href="appendix.html#sv-command-output-file-descriptions"><span class="std std-ref">SV command output file descriptions</span></a>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#svprep"><span class="std std-ref">svprep</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#svprep"><span class="std std-ref">svprep</span></a>,
 <a class="reference internal" href="#discord"><span class="std std-ref">discord</span></a></p>
 </div>
 </div>
@@ -6210,113 +6063,113 @@ <h3>cnv<a class="headerlink" href="#cnv" title="Permalink to this headline">¶</
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="14%" />
-<col width="82%" />
+<col style="width: 4%" />
+<col style="width: 14%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--base-file=FILE</span></code></td>
-<td>SAM/BAM format files containing mapped reads for baseline. May be specified 0 or more times.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--base-file=FILE</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads for baseline. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--base-list-file=FILE</span></code></td>
-<td>File containing list of SAM/BAM format files (1 per line) containing mapped reads for baseline.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--base-list-file=FILE</span></code></p></td>
+<td><p>File containing list of SAM/BAM format files (1 per line) containing mapped reads for baseline.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
-or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
+or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-j</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--test-file=FILE</span></code></td>
-<td>SAM/BAM format files containing mapped reads for test. May be specified 0 or more times.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-j</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--test-file=FILE</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads for test. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-J</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--test-list-file=FILE</span></code></td>
-<td>File containing list of SAM/BAM format files (1 per line) containing mapped reads for test.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-J</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--test-list-file=FILE</span></code></p></td>
+<td><p>File containing list of SAM/BAM format files (1 per line) containing mapped reads for test.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="15%" />
-<col width="80%" />
+<col style="width: 5%" />
+<col style="width: 15%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-b</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--bucket-size=INT</span></code></td>
-<td>Set size of the buckets in the genome. Use the bucket size to determine CNV coverage, bucket size defines the number of nucleotides to average the
-coverage for in a region. (Default is 100)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-b</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bucket-size=INT</span></code></p></td>
+<td><p>Set size of the buckets in the genome. Use the bucket size to determine CNV coverage, bucket size defines the number of nucleotides to average the
+coverage for in a region. (Default is 100)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></td>
-<td>Set to exclude all mated SAM records.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></p></td>
+<td><p>Set to exclude all mated SAM records.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></td>
-<td>Set to exclude all unmated SAM records.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></p></td>
+<td><p>Set to exclude all unmated SAM records.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></td>
-<td>Set to ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></p></td>
+<td><p>Set to ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-u</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></td>
-<td>Set to ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-u</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></p></td>
+<td><p>Set to ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-hits=INT</span></code></td>
-<td>Set to ignore SAM records with an alignment count that exceeds this value. This flag is usually set to 1 because an alignment count of 1 represents
-uniquely mapped reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-hits=INT</span></code></p></td>
+<td><p>Set to ignore SAM records with an alignment count that exceeds this value. This flag is usually set to 1 because an alignment count of 1 represents
+uniquely mapped reads.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></td>
-<td>Set to ignore SAM records with MAPQ less than this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></p></td>
+<td><p>Set to ignore SAM records with MAPQ less than this value.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="23%" />
-<col width="70%" />
+<col style="width: 7%" />
+<col style="width: 23%" />
+<col style="width: 70%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -6329,8 +6182,8 @@ <h3>cnv<a class="headerlink" href="#cnv" title="Permalink to this headline">¶</
 which CNV ratios are calculated (for data smoothing). Filter settings
 allow different analytical comparisons with the same alignments.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#coverage"><span class="std std-ref">coverage</span></a></p>
 </div>
 </div>
@@ -6355,107 +6208,107 @@ <h3>species<a class="headerlink" href="#species" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="19%" />
-<col width="76%" />
+<col style="width: 5%" />
+<col style="width: 19%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--genomes=SDF</span></code></td>
-<td>SDF containing the genomes.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--genomes=SDF</span></code></p></td>
+<td><p>SDF containing the genomes.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--relabel-species-file=FILE</span></code></td>
-<td>File containing list of species name to reference name mappings (1 mapping per line format: [reference short name][tab][species])</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--relabel-species-file=FILE</span></code></p></td>
+<td><p>File containing list of species name to reference name mappings (1 mapping per line format: [reference short name][tab][species])</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="23%" />
-<col width="71%" />
+<col style="width: 6%" />
+<col style="width: 23%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></td>
-<td>Exclude all mated SAM records.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></p></td>
+<td><p>Exclude all mated SAM records.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></td>
-<td>Exclude all unmated SAM records.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></p></td>
+<td><p>Exclude all unmated SAM records.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></td>
-<td>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></p></td>
+<td><p>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-u</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></td>
-<td>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-u</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></p></td>
+<td><p>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="27%" />
-<col width="67%" />
+<col style="width: 7%" />
+<col style="width: 27%" />
+<col style="width: 67%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-confidence=FLOAT</span></code></td>
-<td>Species below this confidence value will not be reported (Default is 10.0)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-confidence=FLOAT</span></code></p></td>
+<td><p>Species below this confidence value will not be reported (Default is 10.0)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--print-all</span></code></td>
-<td>Print non present species in the output file.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--print-all</span></code></p></td>
+<td><p>Print non present species in the output file.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="27%" />
-<col width="67%" />
+<col style="width: 7%" />
+<col style="width: 27%" />
+<col style="width: 67%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -6495,11 +6348,11 @@ <h3>species<a class="headerlink" href="#species" title="Permalink to this headli
 confidence is calculated as a log likelihood ratio between two
 posteriors. Internally, the species tool computes a posterior, ,
 connected to the abundance estimate for a species, corresponding to the
-null hypothesis “species present at level <img class="math" src="_images/math/9dcbbef8e0f76051d388013b90a95bec3069e484.png" alt="P"/> “. For an alternative
-hypothesis, corresponding to “species not present”, another posterior, <img class="math" src="_images/math/2cfe4bba60af0396a6d88125e6619fa19cc59310.png" alt="P'"/> ,
+null hypothesis “species present at level <img class="math" src="_images/math/c2aa3dff9bffb099e9dff196fd36aed56ec16baf.png" alt="P"/> “. For an alternative
+hypothesis, corresponding to “species not present”, another posterior, <img class="math" src="_images/math/23991ec1fa444bd42d05816c69d1ba02c12a264e.png" alt="P'"/> ,
 is computed by forcing the estimated abundance for that species to 0.
-Confidence is then the log ratio of the two values, <img class="math" src="_images/math/5698fa961e23bd31116fc14bcc700c3c82564201.png" alt="C=ln({ \frac {P'} {P} })"/> . The number
-reported in the <em>confidence</em> column is <img class="math" src="_images/math/567fdf012fd3643c1df136a2e28f66591b626323.png" alt="\sqrt{C}"/> . Taking the square root makes
+Confidence is then the log ratio of the two values, <img class="math" src="_images/math/4370f8a24787d16b6631cfde4d5e7bc06d8d42c7.png" alt="C=ln({ \frac {P'} {P} })"/> . The number
+reported in the <em>confidence</em> column is <img class="math" src="_images/math/3e33daea0596958aba9bd9cf28865a39b7e48b25.png" alt="\sqrt{C}"/> . Taking the square root makes
 the units of confidence standard deviations and reduces the spread of
 values. By adjusting the <code class="docutils literal notranslate"><span class="pre">--min-confidence</span></code> parameter you can allow only
 results with a higher confidence to be output.</p>
@@ -6508,8 +6361,8 @@ <h3>species<a class="headerlink" href="#species" title="Permalink to this headli
 interactive pie chart, with wedge sizes defined by either the abundance
 or DNA fraction (user selectable in the report).</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#similarity"><span class="std std-ref">similarity</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#similarity"><span class="std std-ref">similarity</span></a></p>
 </div>
 </div>
 <div class="section" id="similarity">
@@ -6531,74 +6384,74 @@ <h3>similarity<a class="headerlink" href="#similarity" title="Permalink to this
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 7%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>Specifies a file containing a labeled list of SDFs (one label and SDF per line format: [label][space][SDF])</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>Specifies a file containing a labeled list of SDFs (one label and SDF per line format: [label][space][SDF])</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></td>
-<td>Specifies the SDF containing a subject data set.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing a subject data set.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Specifies the directory where results are reported.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Specifies the directory where results are reported.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="14%" />
-<col width="31%" />
-<col width="55%" />
+<col style="width: 14%" />
+<col style="width: 31%" />
+<col style="width: 55%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></td>
-<td>Set the step size. (Default is 1).</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></p></td>
+<td><p>Set the step size. (Default is 1).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--unique-words</span></code></td>
-<td>Set to count only unique words.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--unique-words</span></code></p></td>
+<td><p>Set to count only unique words.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-w</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></td>
-<td>Set the word size. (Default is 25).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-w</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></p></td>
+<td><p>Set the word size. (Default is 25).</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="15%" />
-<col width="78%" />
+<col style="width: 7%" />
+<col style="width: 15%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-reads=INT</span></code></td>
-<td>Set the maximum number of reads to use from each input SDF. Use to reduce memory requirements in multi-file mode.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-reads=INT</span></code></p></td>
+<td><p>Set the maximum number of reads to use from each input SDF. Use to reduce memory requirements in multi-file mode.</p></td>
 </tr>
 </tbody>
 </table>
@@ -6624,8 +6477,8 @@ <h3>similarity<a class="headerlink" href="#similarity" title="Permalink to this
 file and a principal component analysis file. For more detail about the
 output files see <a class="reference internal" href="appendix.html#species-results-file-description"><span class="std std-ref">Species results file description</span></a>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#species"><span class="std std-ref">species</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#species"><span class="std std-ref">species</span></a></p>
 </div>
 </div>
 </div>
@@ -6654,61 +6507,61 @@ <h3>composition-meta-pipeline<a class="headerlink" href="#composition-meta-pipel
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="19%" />
-<col width="78%" />
+<col style="width: 3%" />
+<col style="width: 19%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter=SDF</span></code></td>
-<td>Specifies the SDF containing the filter reference sequences.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing the filter reference sequences.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></td>
-<td>Specifies the path to the reads to be processed.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></p></td>
+<td><p>Specifies the path to the reads to be processed.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-left=FILE</span></code></td>
-<td>The left input file for FASTQ paired end reads.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-left=FILE</span></code></p></td>
+<td><p>The left input file for FASTQ paired end reads.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-right=FILE</span></code></td>
-<td>The right input file for FASTQ paired end reads.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-right=FILE</span></code></p></td>
+<td><p>The right input file for FASTQ paired end reads.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Specifies the directory where results are reported.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Specifies the directory where results are reported.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--platform</span></code></td>
-<td>Specifies the platform of the input data. (Must be one of [illumina, iontorrent]) (Default is illumina).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--platform</span></code></p></td>
+<td><p>Specifies the platform of the input data. (Must be one of [illumina, iontorrent]) (Default is illumina).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--species=SDF</span></code></td>
-<td>Specifies the SDF containing species reference sequences.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--species=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing species reference sequences.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -6755,8 +6608,8 @@ <h3>composition-meta-pipeline<a class="headerlink" href="#composition-meta-pipel
 Reference SDFs for use with the pipeline are available for download from
 our website (<a class="reference external" href="http://www.realtimegenomics.com">http://www.realtimegenomics.com</a>).</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#mapf"><span class="std std-ref">mapf</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#mapf"><span class="std std-ref">mapf</span></a>,
 <a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#species"><span class="std std-ref">species</span></a>,
 <a class="reference internal" href="#composition-functional-meta-pipeline"><span class="std std-ref">composition-functional-meta-pipeline</span></a></p>
@@ -6783,61 +6636,61 @@ <h3>functional-meta-pipeline<a class="headerlink" href="#functional-meta-pipelin
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="19%" />
-<col width="78%" />
+<col style="width: 3%" />
+<col style="width: 19%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter=SDF</span></code></td>
-<td>Specifies the SDF containing the filter reference sequences.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing the filter reference sequences.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></td>
-<td>Specifies the path to the reads to be processed.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></p></td>
+<td><p>Specifies the path to the reads to be processed.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-left=FILE</span></code></td>
-<td>The left input file for FASTQ paired end reads.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-left=FILE</span></code></p></td>
+<td><p>The left input file for FASTQ paired end reads.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-right=FILE</span></code></td>
-<td>The right input file for FASTQ paired end reads.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-right=FILE</span></code></p></td>
+<td><p>The right input file for FASTQ paired end reads.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Specifies the directory where results are reported.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Specifies the directory where results are reported.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--platform</span></code></td>
-<td>Specifies the platform of the input data. Allowed values are [illumina, iontorrent] (Default is illumina)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--platform</span></code></p></td>
+<td><p>Specifies the platform of the input data. Allowed values are [illumina, iontorrent] (Default is illumina)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--protein=SDF</span></code></td>
-<td>Specifies the SDF containing protein reference sequences.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--protein=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing protein reference sequences.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -6882,8 +6735,8 @@ <h3>functional-meta-pipeline<a class="headerlink" href="#functional-meta-pipelin
 Reference SDFs for use with the pipeline are available for download from
 our website (<a class="reference external" href="http://www.realtimegenomics.com">http://www.realtimegenomics.com</a>).</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#mapf"><span class="std std-ref">mapf</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#mapf"><span class="std std-ref">mapf</span></a>,
 <a class="reference internal" href="#mapx"><span class="std std-ref">mapx</span></a>,
 <a class="reference internal" href="#composition-functional-meta-pipeline"><span class="std std-ref">composition-functional-meta-pipeline</span></a></p>
 </div>
@@ -6911,65 +6764,65 @@ <h3>composition-functional-meta-pipeline<a class="headerlink" href="#composition
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="19%" />
-<col width="78%" />
+<col style="width: 3%" />
+<col style="width: 19%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter=SDF</span></code></td>
-<td>Specifies the SDF containing the filter reference sequences.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing the filter reference sequences.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></td>
-<td>Specifies the path to the reads to be processed.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF|FILE</span></code></p></td>
+<td><p>Specifies the path to the reads to be processed.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-left=FILE</span></code></td>
-<td>The left input file for FASTQ paired end reads.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-left=FILE</span></code></p></td>
+<td><p>The left input file for FASTQ paired end reads.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-right=FILE</span></code></td>
-<td>The right input file for FASTQ paired end reads.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-right=FILE</span></code></p></td>
+<td><p>The right input file for FASTQ paired end reads.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Specifies the directory where results are reported.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Specifies the directory where results are reported.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--platform</span></code></td>
-<td>Specifies the platform of the input data. Allowed values are [illumina, iontorrent] (Default is illumina).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--platform</span></code></p></td>
+<td><p>Specifies the platform of the input data. Allowed values are [illumina, iontorrent] (Default is illumina).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--species=SDF</span></code></td>
-<td>Specifies the SDF containing species reference sequences.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--species=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing species reference sequences.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--protein=SDF</span></code></td>
-<td>Specifies the SDF containing protein reference sequences.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--protein=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing protein reference sequences.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -7026,8 +6879,8 @@ <h3>composition-functional-meta-pipeline<a class="headerlink" href="#composition
 Reference SDFs for use with the pipeline are available for download from
 our website (<a class="reference external" href="http://www.realtimegenomics.com">http://www.realtimegenomics.com</a>).</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#mapf"><span class="std std-ref">mapf</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#mapf"><span class="std std-ref">mapf</span></a>,
 <a class="reference internal" href="#mapx"><span class="std std-ref">mapx</span></a>,
 <a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#species"><span class="std std-ref">species</span></a></p>
@@ -7072,70 +6925,70 @@ <h3>genomesim<a class="headerlink" href="#genomesim" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="16%" />
-<col width="33%" />
-<col width="51%" />
+<col style="width: 16%" />
+<col style="width: 33%" />
+<col style="width: 51%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></td>
-<td>The name of the output SDF.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></p></td>
+<td><p>The name of the output SDF.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="17%" />
-<col width="77%" />
+<col style="width: 6%" />
+<col style="width: 17%" />
+<col style="width: 77%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--comment=STRING</span></code></td>
-<td>Specify a comment to include in the generated SDF.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--comment=STRING</span></code></p></td>
+<td><p>Specify a comment to include in the generated SDF.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--freq=STRING</span></code></td>
-<td>Set the relative frequencies of A,C,G,T in the generated sequence. (Default is 1,1,1,1).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--freq=STRING</span></code></p></td>
+<td><p>Set the relative frequencies of A,C,G,T in the generated sequence. (Default is 1,1,1,1).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-l</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--length=INT</span></code></td>
-<td>Specify the length of generated sequence. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-l</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--length=INT</span></code></p></td>
+<td><p>Specify the length of generated sequence. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-length=INT</span></code></td>
-<td>Specify the maximum sequence length.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-length=INT</span></code></p></td>
+<td><p>Specify the maximum sequence length.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-length=INT</span></code></td>
-<td>Specify the minimum sequence length.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-length=INT</span></code></p></td>
+<td><p>Specify the minimum sequence length.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--num-contigs=INT</span></code></td>
-<td>Specify the number of sequences to generate.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--num-contigs=INT</span></code></p></td>
+<td><p>Specify the number of sequences to generate.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--prefix=STRING</span></code></td>
-<td>Specify a sequence name prefix to be used for the generated sequences. The default is to name the output sequences
-‘simulatedSequenceN’, where N is increasing for each sequence.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--prefix=STRING</span></code></p></td>
+<td><p>Specify a sequence name prefix to be used for the generated sequences. The default is to name the output sequences
+‘simulatedSequenceN’, where N is increasing for each sequence.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Specify seed for the random number generator.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Specify seed for the random number generator.</p></td>
 </tr>
 </tbody>
 </table>
@@ -7151,8 +7004,8 @@ <h3>genomesim<a class="headerlink" href="#genomesim" title="Permalink to this he
 to the specified prefix. For example <code class="docutils literal notranslate"><span class="pre">--prefix=chr</span> <span class="pre">--num-contigs=10</span></code>
 would yield contigs named <code class="docutils literal notranslate"><span class="pre">chr1</span></code> through <code class="docutils literal notranslate"><span class="pre">chr10</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#cgsim"><span class="std std-ref">cgsim</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#cgsim"><span class="std std-ref">cgsim</span></a>,
 <a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
 <a class="reference internal" href="#popsim"><span class="std std-ref">popsim</span></a>,
 <a class="reference internal" href="#samplesim"><span class="std std-ref">samplesim</span></a></p>
@@ -7176,135 +7029,135 @@ <h3>cgsim<a class="headerlink" href="#cgsim" title="Permalink to this headline">
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="24%" />
-<col width="71%" />
+<col style="width: 6%" />
+<col style="width: 24%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></td>
-<td>SDF containing input genome.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></p></td>
+<td><p>SDF containing input genome.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></td>
-<td>Name for reads output SDF.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></p></td>
+<td><p>Name for reads output SDF.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="24%" />
-<col width="71%" />
+<col style="width: 6%" />
+<col style="width: 24%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Fragment Generation</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Fragment Generation</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--abundance</span></code></td>
-<td>If set, the user-supplied distribution represents desired abundance.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--abundance</span></code></p></td>
+<td><p>If set, the user-supplied distribution represents desired abundance.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-N</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--allow-unknowns</span></code></td>
-<td>Allow reads to be drawn from template fragments containing unknown nucleotides.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-N</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--allow-unknowns</span></code></p></td>
+<td><p>Allow reads to be drawn from template fragments containing unknown nucleotides.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--coverage=FLOAT</span></code></td>
-<td>Coverage, must be positive.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--coverage=FLOAT</span></code></p></td>
+<td><p>Coverage, must be positive.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-D</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--distribution=FILE</span></code></td>
-<td>File containing probability distribution for sequence selection.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-D</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--distribution=FILE</span></code></p></td>
+<td><p>File containing probability distribution for sequence selection.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--dna-fraction</span></code></td>
-<td>If set, the user-supplied distribution represents desired DNA fraction.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--dna-fraction</span></code></p></td>
+<td><p>If set, the user-supplied distribution represents desired DNA fraction.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-M</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-fragment-size=INT</span></code></td>
-<td>Maximum fragment size (Default is 500)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-M</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-fragment-size=INT</span></code></p></td>
+<td><p>Maximum fragment size (Default is 500)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-fragment-size=INT</span></code></td>
-<td>Minimum fragment size (Default is 350)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-fragment-size=INT</span></code></p></td>
+<td><p>Minimum fragment size (Default is 350)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--n-rate=FLOAT</span></code></td>
-<td>Rate that the machine will generate new unknowns in the read (Default is 0.0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--n-rate=FLOAT</span></code></p></td>
+<td><p>Rate that the machine will generate new unknowns in the read (Default is 0.0)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--num-reads=INT</span></code></td>
-<td>Number of reads to be generated.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--num-reads=INT</span></code></p></td>
+<td><p>Number of reads to be generated.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--taxonomy-distribution=FILE</span></code></td>
-<td>File containing probability distribution for sequence selection expressed by taxonomy id.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--taxonomy-distribution=FILE</span></code></p></td>
+<td><p>File containing probability distribution for sequence selection expressed by taxonomy id.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="9%" />
-<col width="25%" />
-<col width="66%" />
+<col style="width: 9%" />
+<col style="width: 25%" />
+<col style="width: 66%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Complete Genomics</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Complete Genomics</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-V</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--cg-read-version=INT</span></code></td>
-<td>Select Complete Genomics read structure version, 1 (35 bp) or 2 (29 bp)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-V</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--cg-read-version=INT</span></code></p></td>
+<td><p>Select Complete Genomics read structure version, 1 (35 bp) or 2 (29 bp)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="19%" />
-<col width="77%" />
+<col style="width: 4%" />
+<col style="width: 19%" />
+<col style="width: 77%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--comment=STRING</span></code></td>
-<td>Comment to include in the generated SDF.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--comment=STRING</span></code></p></td>
+<td><p>Comment to include in the generated SDF.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-names</span></code></td>
-<td>Do not create read names in the output SDF.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-names</span></code></p></td>
+<td><p>Do not create read names in the output SDF.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-qualities</span></code></td>
-<td>Do not create read qualities in the output SDF.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-qualities</span></code></p></td>
+<td><p>Do not create read qualities in the output SDF.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--qual-range=STRING</span></code></td>
-<td>Set the range of base quality values permitted e.g.: 3-40 (Default is fixed qualities corresponding to overall machine base error rate)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--qual-range=STRING</span></code></p></td>
+<td><p>Set the range of base quality values permitted e.g.: 3-40 (Default is fixed qualities corresponding to overall machine base error rate)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></td>
-<td>File containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:READGROUP1\tSM:BACT_SAMPLE\tPL:ILLUMINA</span></code></td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></p></td>
+<td><p>File containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:READGROUP1\tSM:BACT_SAMPLE\tPL:ILLUMINA</span></code></p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Seed for random number generator.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Seed for random number generator.</p></td>
 </tr>
 </tbody>
 </table>
@@ -7322,8 +7175,8 @@ <h3>cgsim<a class="headerlink" href="#cgsim" title="Permalink to this headline">
 metagenomic databases. Probabilities are numbers between zero and one
 and must sum to one in the file.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#genomesim"><span class="std std-ref">genomesim</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#genomesim"><span class="std std-ref">genomesim</span></a>,
 <a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
 <a class="reference internal" href="#popsim"><span class="std std-ref">popsim</span></a>,
 <a class="reference internal" href="#samplesim"><span class="std std-ref">samplesim</span></a></p>
@@ -7349,202 +7202,202 @@ <h3>readsim<a class="headerlink" href="#readsim" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="17%" />
-<col width="79%" />
+<col style="width: 4%" />
+<col style="width: 17%" />
+<col style="width: 79%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></td>
-<td>SDF containing input genome.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></p></td>
+<td><p>SDF containing input genome.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--machine=STRING</span></code></td>
-<td>Select the sequencing technology to model. Allowed values are [illumina_se, illumina_pe, complete_genomics, complete_genomics_2, 454_pe, 454_se, iontorrent]</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--machine=STRING</span></code></p></td>
+<td><p>Select the sequencing technology to model. Allowed values are [illumina_se, illumina_pe, complete_genomics, complete_genomics_2, 454_pe, 454_se, iontorrent]</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></td>
-<td>Name for reads output SDF.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></p></td>
+<td><p>Name for reads output SDF.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="26%" />
-<col width="68%" />
+<col style="width: 6%" />
+<col style="width: 26%" />
+<col style="width: 68%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Fragment Generation</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Fragment Generation</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--abundance</span></code></td>
-<td>If set, the user-supplied distribution represents desired abundance.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--abundance</span></code></p></td>
+<td><p>If set, the user-supplied distribution represents desired abundance.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-N</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--allow-unknowns</span></code></td>
-<td>Allow reads to be drawn from template fragments containing unknown nucleotides.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-N</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--allow-unknowns</span></code></p></td>
+<td><p>Allow reads to be drawn from template fragments containing unknown nucleotides.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--coverage=FLOAT</span></code></td>
-<td>Coverage, must be positive.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--coverage=FLOAT</span></code></p></td>
+<td><p>Coverage, must be positive.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-D</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--distribution=FILE</span></code></td>
-<td>File containing probability distribution for sequence selection.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-D</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--distribution=FILE</span></code></p></td>
+<td><p>File containing probability distribution for sequence selection.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--dna-fraction</span></code></td>
-<td>If set, the user-supplied distribution represents desired DNA fraction.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--dna-fraction</span></code></p></td>
+<td><p>If set, the user-supplied distribution represents desired DNA fraction.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-M</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-fragment-size=INT</span></code></td>
-<td>Maximum fragment size (Default is 250)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-M</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-fragment-size=INT</span></code></p></td>
+<td><p>Maximum fragment size (Default is 250)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-fragment-size=INT</span></code></td>
-<td>Minimum fragment size (Default is 200)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-fragment-size=INT</span></code></p></td>
+<td><p>Minimum fragment size (Default is 200)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--n-rate=FLOAT</span></code></td>
-<td>Rate that the machine will generate new unknowns in the read (Default is 0.0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--n-rate=FLOAT</span></code></p></td>
+<td><p>Rate that the machine will generate new unknowns in the read (Default is 0.0)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--num-reads=INT</span></code></td>
-<td>Number of reads to be generated.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--num-reads=INT</span></code></p></td>
+<td><p>Number of reads to be generated.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--taxonomy-distribution=FILE</span></code></td>
-<td>File containing probability distribution for sequence selection expressed by taxonomy id.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--taxonomy-distribution=FILE</span></code></p></td>
+<td><p>File containing probability distribution for sequence selection expressed by taxonomy id.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="27%" />
-<col width="66%" />
+<col style="width: 6%" />
+<col style="width: 27%" />
+<col style="width: 66%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Illumina PE</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Illumina PE</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-L</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--left-read-length=INT</span></code></td>
-<td>Target read length on the left side.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-L</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--left-read-length=INT</span></code></p></td>
+<td><p>Target read length on the left side.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-R</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--right-read-length=INT</span></code></td>
-<td>Target read length on the right side.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-R</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--right-read-length=INT</span></code></p></td>
+<td><p>Target read length on the right side.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="27%" />
-<col width="66%" />
+<col style="width: 6%" />
+<col style="width: 27%" />
+<col style="width: 66%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Illumina SE</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Illumina SE</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--read-length=INT</span></code></td>
-<td>Target read length, must be positive.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--read-length=INT</span></code></p></td>
+<td><p>Target read length, must be positive.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="25%" />
-<col width="69%" />
+<col style="width: 6%" />
+<col style="width: 25%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">454 SE/PE</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>454 SE/PE</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--454-max-total-size=INT</span></code></td>
-<td>Maximum 454 read length (in paired end case the sum of the left and the right read lengths)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--454-max-total-size=INT</span></code></p></td>
+<td><p>Maximum 454 read length (in paired end case the sum of the left and the right read lengths)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--454-min-total-size=INT</span></code></td>
-<td>Minimum 454 read length (in paired end case the sum of the left and the right read lengths)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--454-min-total-size=INT</span></code></p></td>
+<td><p>Minimum 454 read length (in paired end case the sum of the left and the right read lengths)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="27%" />
-<col width="66%" />
+<col style="width: 6%" />
+<col style="width: 27%" />
+<col style="width: 66%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">IonTorrent SE</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>IonTorrent SE</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--ion-max-total-size=INT</span></code></td>
-<td>Maximum IonTorrent read length.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--ion-max-total-size=INT</span></code></p></td>
+<td><p>Maximum IonTorrent read length.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--ion-min-total-size=INT</span></code></td>
-<td>Minimum IonTorrent read length.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--ion-min-total-size=INT</span></code></p></td>
+<td><p>Minimum IonTorrent read length.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="19%" />
-<col width="77%" />
+<col style="width: 4%" />
+<col style="width: 19%" />
+<col style="width: 77%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--comment=STRING</span></code></td>
-<td>Comment to include in the generated SDF.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--comment=STRING</span></code></p></td>
+<td><p>Comment to include in the generated SDF.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-names</span></code></td>
-<td>Do not create read names in the output SDF.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-names</span></code></p></td>
+<td><p>Do not create read names in the output SDF.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-qualities</span></code></td>
-<td>Do not create read qualities in the output SDF.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-qualities</span></code></p></td>
+<td><p>Do not create read qualities in the output SDF.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--qual-range=STRING</span></code></td>
-<td>Set the range of base quality values permitted e.g.: 3-40 (Default is fixed qualities corresponding to overall machine base error rate)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--qual-range=STRING</span></code></p></td>
+<td><p>Set the range of base quality values permitted e.g.: 3-40 (Default is fixed qualities corresponding to overall machine base error rate)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></td>
-<td>File containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:READGROUP1\tSM:BACT_SAMPLE\tPL:ILLUMINA</span></code></td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sam-rg=STRING|FILE</span></code></p></td>
+<td><p>File containing a single valid read group SAM header line or a string in the form <code class="docutils literal notranslate"><span class="pre">&#64;RG\tID:READGROUP1\tSM:BACT_SAMPLE\tPL:ILLUMINA</span></code></p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Seed for random number generator.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Seed for random number generator.</p></td>
 </tr>
 </tbody>
 </table>
@@ -7588,8 +7441,8 @@ <h3>readsim<a class="headerlink" href="#readsim" title="Permalink to this headli
 from the designated sequence, and thus for a given fraction, a large
 sequence will have a lower depth of coverage than a short sequence.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#cgsim"><span class="std std-ref">cgsim</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#cgsim"><span class="std std-ref">cgsim</span></a>,
 <a class="reference internal" href="#genomesim"><span class="std std-ref">genomesim</span></a>,
 <a class="reference internal" href="#popsim"><span class="std std-ref">popsim</span></a>,
 <a class="reference internal" href="#samplesim"><span class="std std-ref">samplesim</span></a></p>
@@ -7609,123 +7462,123 @@ <h3>readsimeval<a class="headerlink" href="#readsimeval" title="Permalink to thi
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="18%" />
-<col width="76%" />
+<col style="width: 6%" />
+<col style="width: 18%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-M</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--mutations-vcf=FILE</span></code></td>
-<td>VCF file containing genomic mutations to be compensated for.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-M</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mutations-vcf=FILE</span></code></p></td>
+<td><p>VCF file containing genomic mutations to be compensated for.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reads=SDF</span></code></td>
-<td>SDF containing reads.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reads=SDF</span></code></p></td>
+<td><p>SDF containing reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-S</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>Name of the sample to use from the mutation VCF file, will default to using the first sample in the file.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-S</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>Name of the sample to use from the mutation VCF file, will default to using the first sample in the file.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files. Must be specified 1 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files. Must be specified 1 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="20%" />
-<col width="73%" />
+<col style="width: 7%" />
+<col style="width: 20%" />
+<col style="width: 73%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-duplicates</span></code></td>
-<td>Exclude all SAM records flagged as a PCR or optical duplicate.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-duplicates</span></code></p></td>
+<td><p>Exclude all SAM records flagged as a PCR or optical duplicate.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></td>
-<td>Exclude all mated SAM records.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></p></td>
+<td><p>Exclude all mated SAM records.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></td>
-<td>Exclude all unmated SAM records.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></p></td>
+<td><p>Exclude all unmated SAM records.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></td>
-<td>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></p></td>
+<td><p>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></td>
-<td>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></p></td>
+<td><p>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></td>
-<td>If set, ignore SAM records with MAPQ less than this value.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with MAPQ less than this value.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-v</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--variance=INT</span></code></td>
-<td>Variation allowed in start position (Default is 0).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-v</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--variance=INT</span></code></p></td>
+<td><p>Variation allowed in start position (Default is 0).</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="29%" />
-<col width="67%" />
+<col style="width: 5%" />
+<col style="width: 29%" />
+<col style="width: 67%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--mapq-histogram</span></code></td>
-<td>Output histogram of MAPQ scores.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mapq-histogram</span></code></p></td>
+<td><p>Output histogram of MAPQ scores.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--mapq-roc</span></code></td>
-<td>Output ROC table with respect to MAPQ scores.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mapq-roc</span></code></p></td>
+<td><p>Output ROC table with respect to MAPQ scores.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--score-histogram</span></code></td>
-<td>Output histogram of read alignment / generated scores.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--score-histogram</span></code></p></td>
+<td><p>Output histogram of read alignment / generated scores.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--verbose</span></code></td>
-<td>Provide more detailed breakdown of stats.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--verbose</span></code></p></td>
+<td><p>Provide more detailed breakdown of stats.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -7734,8 +7587,8 @@ <h3>readsimeval<a class="headerlink" href="#readsimeval" title="Permalink to thi
 have been generated by the <code class="docutils literal notranslate"><span class="pre">readsim</span></code> command. The ROC output files may
 be plotted with the <code class="docutils literal notranslate"><span class="pre">rocplot</span></code> command.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#cgsim"><span class="std std-ref">cgsim</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#cgsim"><span class="std std-ref">cgsim</span></a>,
 <a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
 <a class="reference internal" href="#rocplot"><span class="std std-ref">rocplot</span></a></p>
 </div>
@@ -7756,49 +7609,49 @@ <h3>popsim<a class="headerlink" href="#popsim" title="Permalink to this headline
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="19%" />
-<col width="74%" />
+<col style="width: 7%" />
+<col style="width: 19%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output VCF file name.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output VCF file name.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="19%" />
-<col width="74%" />
+<col style="width: 7%" />
+<col style="width: 19%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Seed for the random number generator.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Seed for the random number generator.</p></td>
 </tr>
 </tbody>
 </table>
@@ -7810,8 +7663,8 @@ <h3>popsim<a class="headerlink" href="#popsim" title="Permalink to this headline
 of variants and the allele-frequency distribution has been drawn from
 observed variants and allele frequency distribution in human studies.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
 <a class="reference internal" href="#genomesim"><span class="std std-ref">genomesim</span></a>,
 <a class="reference internal" href="#samplesim"><span class="std std-ref">samplesim</span></a>,
 <a class="reference internal" href="#childsim"><span class="std std-ref">childsim</span></a>,
@@ -7838,73 +7691,73 @@ <h3>samplesim<a class="headerlink" href="#samplesim" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="20%" />
-<col width="73%" />
+<col style="width: 7%" />
+<col style="width: 20%" />
+<col style="width: 73%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>Input VCF containing population variants.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>Input VCF containing population variants.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output VCF file name.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output VCF file name.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-sdf=SDF</span></code></td>
-<td>If set, output an SDF containing the sample genome.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-sdf=SDF</span></code></p></td>
+<td><p>If set, output an SDF containing the sample genome.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>Name for sample.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>Name for sample.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="21%" />
-<col width="72%" />
+<col style="width: 7%" />
+<col style="width: 21%" />
+<col style="width: 72%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--allow-missing-af</span></code></td>
-<td>If set, treat variants without allele frequency annotation as uniformly likely.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--allow-missing-af</span></code></p></td>
+<td><p>If set, treat variants without allele frequency annotation as uniformly likely.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--ploidy=STRING</span></code></td>
-<td>Ploidy to use. Allowed values are [auto, diploid, haploid] (Default is auto)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--ploidy=STRING</span></code></p></td>
+<td><p>Ploidy to use. Allowed values are [auto, diploid, haploid] (Default is auto)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Seed for the random number generator.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Seed for the random number generator.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></td>
-<td>Sex of individual. Allowed values are [male, female, either] (Default is either)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></p></td>
+<td><p>Sex of individual. Allowed values are [male, female, either] (Default is either)</p></td>
 </tr>
 </tbody>
 </table>
@@ -7932,8 +7785,8 @@ <h3>samplesim<a class="headerlink" href="#samplesim" title="Permalink to this he
 individuals genotype which can then be used by the <code class="docutils literal notranslate"><span class="pre">readsim</span></code> command to
 simulate a read set for the individual.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
 <a class="reference internal" href="#genomesim"><span class="std std-ref">genomesim</span></a>,
 <a class="reference internal" href="#popsim"><span class="std std-ref">popsim</span></a>,
 <a class="reference internal" href="#childsim"><span class="std std-ref">childsim</span></a>,
@@ -7955,77 +7808,77 @@ <h3>denovosim<a class="headerlink" href="#denovosim" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="10%" />
-<col width="24%" />
-<col width="66%" />
+<col style="width: 10%" />
+<col style="width: 24%" />
+<col style="width: 66%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>The input VCF containing parent variants.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>The input VCF containing parent variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--original=STRING</span></code></td>
-<td>The name of the existing sample to use as the original genotype.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--original=STRING</span></code></p></td>
+<td><p>The name of the existing sample to use as the original genotype.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>The output VCF file name.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>The output VCF file name.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-sdf=FILE</span></code></td>
-<td>Set to output an SDF of the genome generated.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-sdf=FILE</span></code></p></td>
+<td><p>Set to output an SDF of the genome generated.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></td>
-<td>The SDF containing the reference genome.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></p></td>
+<td><p>The SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>The name for the new derived sample.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>The name for the new derived sample.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="15%" />
-<col width="80%" />
+<col style="width: 5%" />
+<col style="width: 15%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Set this flag to create the VCF output file without compression.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Set this flag to create the VCF output file without compression.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--num-mutations=INT</span></code></td>
-<td>Set the expected number of de novo mutations per genome (Default is 70).</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--num-mutations=INT</span></code></p></td>
+<td><p>Set the expected number of de novo mutations per genome (Default is 70).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--ploidy=STRING</span></code></td>
-<td>The ploidy to use when the reference genome does not contain a reference text file. Allowed values are [auto, diploid, haploid] (Default is auto)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--ploidy=STRING</span></code></p></td>
+<td><p>The ploidy to use when the reference genome does not contain a reference text file. Allowed values are [auto, diploid, haploid] (Default is auto)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Set the seed for the random number generator.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Set the seed for the random number generator.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--show-mutations</span></code></td>
-<td>Set this flag to display information regarding de novo mutation points.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--show-mutations</span></code></p></td>
+<td><p>Set this flag to display information regarding de novo mutation points.</p></td>
 </tr>
 </tbody>
 </table>
@@ -8052,8 +7905,8 @@ <h3>denovosim<a class="headerlink" href="#denovosim" title="Permalink to this he
 derived genome which can then be used by the <code class="docutils literal notranslate"><span class="pre">readsim</span></code> command to
 simulate a read set for the new genome.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
 <a class="reference internal" href="#genomesim"><span class="std std-ref">genomesim</span></a>,
 <a class="reference internal" href="#popsim"><span class="std std-ref">popsim</span></a>,
 <a class="reference internal" href="#samplesim"><span class="std std-ref">samplesim</span></a>,
@@ -8076,89 +7929,89 @@ <h3>childsim<a class="headerlink" href="#childsim" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="24%" />
-<col width="69%" />
+<col style="width: 7%" />
+<col style="width: 24%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--father=STRING</span></code></td>
-<td>Name of the existing sample to use as the father.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--father=STRING</span></code></p></td>
+<td><p>Name of the existing sample to use as the father.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>Input VCF containing parent variants.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>Input VCF containing parent variants.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--mother=STRING</span></code></td>
-<td>Name of the existing sample to use as the mother.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--mother=STRING</span></code></p></td>
+<td><p>Name of the existing sample to use as the mother.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output VCF file name.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output VCF file name.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-sdf=SDF</span></code></td>
-<td>If set, output an SDF containing the sample genome.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-sdf=SDF</span></code></p></td>
+<td><p>If set, output an SDF containing the sample genome.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>Name for new child sample.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>Name for new child sample.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="25%" />
-<col width="68%" />
+<col style="width: 7%" />
+<col style="width: 25%" />
+<col style="width: 68%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--extra-crossovers=FLOAT</span></code></td>
-<td>Probability of extra crossovers per chromosome (Default is 0.01)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--extra-crossovers=FLOAT</span></code></p></td>
+<td><p>Probability of extra crossovers per chromosome (Default is 0.01)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--genetic-map-dir=DIR</span></code></td>
-<td>If set, load genetic maps from this directory for recombination point selection.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--genetic-map-dir=DIR</span></code></p></td>
+<td><p>If set, load genetic maps from this directory for recombination point selection.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--ploidy=STRING</span></code></td>
-<td>Ploidy to use. Allowed values are [auto, diploid, haploid] (Default is auto)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--ploidy=STRING</span></code></p></td>
+<td><p>Ploidy to use. Allowed values are [auto, diploid, haploid] (Default is auto)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Seed for the random number generator.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Seed for the random number generator.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></td>
-<td>Sex of individual. Allowed values are [male, female, either] (Default is either)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></p></td>
+<td><p>Sex of individual. Allowed values are [male, female, either] (Default is either)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--show-crossovers</span></code></td>
-<td>If set, display information regarding haplotype selection and crossover points.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--show-crossovers</span></code></p></td>
+<td><p>If set, display information regarding haplotype selection and crossover points.</p></td>
 </tr>
 </tbody>
 </table>
@@ -8184,8 +8037,8 @@ <h3>childsim<a class="headerlink" href="#childsim" title="Permalink to this head
 <a class="reference internal" href="appendix.html#genetic-map-directory"><span class="std std-ref">Genetic map directory</span></a>, and the directory containing the relevant
 files can be specified by using the <code class="docutils literal notranslate"><span class="pre">--genetic-map-dir</span></code> flag.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
 <a class="reference internal" href="#genomesim"><span class="std std-ref">genomesim</span></a>,
 <a class="reference internal" href="#popsim"><span class="std std-ref">popsim</span></a>,
 <a class="reference internal" href="#samplesim"><span class="std std-ref">samplesim</span></a>,
@@ -8208,81 +8061,81 @@ <h3>pedsamplesim<a class="headerlink" href="#pedsamplesim" title="Permalink to t
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="25%" />
-<col width="68%" />
+<col style="width: 7%" />
+<col style="width: 25%" />
+<col style="width: 68%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>Input VCF containing parent variants.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>Input VCF containing parent variants.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-sdf</span></code></td>
-<td>If set, output an SDF for the genome of each simulated sample.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-sdf</span></code></p></td>
+<td><p>If set, output an SDF for the genome of each simulated sample.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></td>
-<td>Genome relationships PED file.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></p></td>
+<td><p>Genome relationships PED file.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="25%" />
-<col width="68%" />
+<col style="width: 7%" />
+<col style="width: 25%" />
+<col style="width: 68%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--extra-crossovers=FLOAT</span></code></td>
-<td>Probability of extra crossovers per chromosome (Default is 0.01)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--extra-crossovers=FLOAT</span></code></p></td>
+<td><p>Probability of extra crossovers per chromosome (Default is 0.01)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--genetic-map-dir=DIR</span></code></td>
-<td>If set, load genetic maps from this directory for recombination point selection.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--genetic-map-dir=DIR</span></code></p></td>
+<td><p>If set, load genetic maps from this directory for recombination point selection.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--num-mutations=INT</span></code></td>
-<td>Expected number of mutations per genome (Default is 70)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--num-mutations=INT</span></code></p></td>
+<td><p>Expected number of mutations per genome (Default is 70)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--ploidy=STRING</span></code></td>
-<td>Ploidy to use. Allowed values are [auto, diploid, haploid] (Default is auto)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--ploidy=STRING</span></code></p></td>
+<td><p>Ploidy to use. Allowed values are [auto, diploid, haploid] (Default is auto)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-unused</span></code></td>
-<td>If set, output only variants used by at least one sample.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-unused</span></code></p></td>
+<td><p>If set, output only variants used by at least one sample.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Seed for the random number generator.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Seed for the random number generator.</p></td>
 </tr>
 </tbody>
 </table>
@@ -8324,8 +8177,8 @@ <h3>pedsamplesim<a class="headerlink" href="#pedsamplesim" title="Permalink to t
 <a class="reference internal" href="appendix.html#genetic-map-directory"><span class="std std-ref">Genetic map directory</span></a>, and the directory containing the relevant
 files can be specified by using the <code class="docutils literal notranslate"><span class="pre">--genetic-map-dir</span></code> flag.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#pedfilter"><span class="std std-ref">pedfilter</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#pedfilter"><span class="std std-ref">pedfilter</span></a>,
 <a class="reference internal" href="#popsim"><span class="std std-ref">popsim</span></a>,
 <a class="reference internal" href="#samplesim"><span class="std std-ref">samplesim</span></a>,
 <a class="reference internal" href="#childsim"><span class="std std-ref">childsim</span></a>,
@@ -8348,49 +8201,49 @@ <h3>samplereplay<a class="headerlink" href="#samplereplay" title="Permalink to t
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="19%" />
-<col width="74%" />
+<col style="width: 7%" />
+<col style="width: 19%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>Input VCF containing the sample genotype.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>Input VCF containing the sample genotype.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></td>
-<td>Name for output SDF.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></p></td>
+<td><p>Name for output SDF.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reference=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>Name of the sample to select from the VCF.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>Name of the sample to select from the VCF.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="19%" />
-<col width="74%" />
+<col style="width: 7%" />
+<col style="width: 19%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -8403,8 +8256,8 @@ <h3>samplereplay<a class="headerlink" href="#samplereplay" title="Permalink to t
 <p>Every chromosome for which the individual is diploid will have two
 sequences in the resulting SDF.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#readsim"><span class="std std-ref">readsim</span></a>,
 <a class="reference internal" href="#genomesim"><span class="std std-ref">genomesim</span></a>,
 <a class="reference internal" href="#popsim"><span class="std std-ref">popsim</span></a>,
 <a class="reference internal" href="#samplesim"><span class="std std-ref">samplesim</span></a>,
@@ -8430,57 +8283,57 @@ <h3>bgzip<a class="headerlink" href="#bgzip" title="Permalink to this headline">
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="21%" />
-<col width="73%" />
+<col style="width: 6%" />
+<col style="width: 21%" />
+<col style="width: 73%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-l</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--compression-level=INT</span></code></td>
-<td>The compression level to use, between 1 (least but fast) and 9 (highest but slow) (Default is 5)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-l</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--compression-level=INT</span></code></p></td>
+<td><p>The compression level to use, between 1 (least but fast) and 9 (highest but slow) (Default is 5)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-d</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--decompress</span></code></td>
-<td>Decompress.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-d</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--decompress</span></code></p></td>
+<td><p>Decompress.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--force</span></code></td>
-<td>Force overwrite of output file.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--force</span></code></p></td>
+<td><p>Force overwrite of output file.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-terminate</span></code></td>
-<td>If set, do not add the block gzip termination block.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-terminate</span></code></p></td>
+<td><p>If set, do not add the block gzip termination block.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--stdout</span></code></td>
-<td>Write on standard output, keep original files unchanged. Implied when using standard input.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--stdout</span></code></p></td>
+<td><p>Write on standard output, keep original files unchanged. Implied when using standard input.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>File to (de)compress, use ‘-‘ for standard input. Must be specified 1 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>File to (de)compress, use ‘-‘ for standard input. Must be specified 1 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="21%" />
-<col width="73%" />
+<col style="width: 6%" />
+<col style="width: 21%" />
+<col style="width: 73%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -8489,8 +8342,8 @@ <h3>bgzip<a class="headerlink" href="#bgzip" title="Permalink to this headline">
 SAM, TSV must be block-compressed before they can be indexed for fast
 retrieval of records corresponding to specific genomic regions.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#index"><span class="std std-ref">index</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#index"><span class="std std-ref">index</span></a></p>
 </div>
 </div>
 <div class="section" id="index">
@@ -8512,45 +8365,45 @@ <h3>index<a class="headerlink" href="#index" title="Permalink to this headline">
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="19%" />
-<col width="76%" />
+<col style="width: 5%" />
+<col style="width: 19%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></td>
-<td>Format of input to index. Allowed values are [sam, bam, cram, sv, coveragetsv, bed, vcf, auto] (Default is auto)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--format=FORMAT</span></code></p></td>
+<td><p>Format of input to index. Allowed values are [sam, bam, cram, sv, coveragetsv, bed, vcf, auto] (Default is auto)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of block compressed files (1 per line) containing genome position data.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of block compressed files (1 per line) containing genome position data.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>Block compressed files containing data to be indexed. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>Block compressed files containing data to be indexed. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="20%" />
-<col width="74%" />
+<col style="width: 6%" />
+<col style="width: 20%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -8560,8 +8413,8 @@ <h3>index<a class="headerlink" href="#index" title="Permalink to this headline">
 TSV output from RTG commands such as <code class="docutils literal notranslate"><span class="pre">coverage</span></code>. The <code class="docutils literal notranslate"><span class="pre">index</span></code> command
 can also be used to produce BAM indexes for BAM files with no index.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#coverage"><span class="std std-ref">coverage</span></a>,
 <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#extract"><span class="std std-ref">extract</span></a>,
@@ -8587,76 +8440,76 @@ <h3>extract<a class="headerlink" href="#extract" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="14%" />
-<col width="81%" />
+<col style="width: 5%" />
+<col style="width: 14%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE</span></code></td>
-<td>The indexed block compressed genome position data file to extract.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE</span></code></p></td>
+<td><p>The indexed block compressed genome position data file to extract.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="10%" />
-<col width="86%" />
+<col style="width: 4%" />
+<col style="width: 10%" />
+<col style="width: 86%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">REGION+</span></code></td>
-<td>The range to display. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;.
-May be specified 0 or more times.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">REGION+</span></code></p></td>
+<td><p>The range to display. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;.
+May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="32%" />
-<col width="62%" />
+<col style="width: 6%" />
+<col style="width: 32%" />
+<col style="width: 62%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--header</span></code></td>
-<td>Set to also display the file header.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--header</span></code></p></td>
+<td><p>Set to also display the file header.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--header-only</span></code></td>
-<td>Set to only display the file header.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--header-only</span></code></p></td>
+<td><p>Set to only display the file header.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -8665,8 +8518,8 @@ <h3>extract<a class="headerlink" href="#extract" title="Permalink to this headli
 compressed genome position data files such as those in SAM/BAM/BED/VCF
 format.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#coverage"><span class="std std-ref">coverage</span></a>,
 <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#index"><span class="std std-ref">index</span></a>,
@@ -8688,168 +8541,168 @@ <h3>aview<a class="headerlink" href="#aview" title="Permalink to this headline">
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="21%" />
-<col width="73%" />
+<col style="width: 5%" />
+<col style="width: 21%" />
+<col style="width: 73%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-b</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--baseline=FILE</span></code></td>
-<td>VCF file containing baseline variants.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-b</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--baseline=FILE</span></code></p></td>
+<td><p>VCF file containing baseline variants.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-B</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed=FILE</span></code></td>
-<td>BED file containing regions to overlay. May be specified 0 or more times.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-B</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed=FILE</span></code></p></td>
+<td><p>BED file containing regions to overlay. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--calls=FILE</span></code></td>
-<td>VCF file containing called variants. May be specified 0 or more times.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--calls=FILE</span></code></p></td>
+<td><p>VCF file containing called variants. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reads=SDF</span></code></td>
-<td>Read SDF (only needed to indicate correctness of simulated read mappings). May be specified 0 or more times.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reads=SDF</span></code></p></td>
+<td><p>Read SDF (only needed to indicate correctness of simulated read mappings). May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>Alignment SAM/BAM files. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>Alignment SAM/BAM files. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="16%" />
-<col width="80%" />
+<col style="width: 4%" />
+<col style="width: 16%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--padding=INT</span></code></td>
-<td>Padding around region of interest (Default is to automatically determine padding to avoid read truncation)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--padding=INT</span></code></p></td>
+<td><p>Padding around region of interest (Default is to automatically determine padding to avoid read truncation)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>The region of interest to display. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
-&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>The region of interest to display. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
+&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>Specify name of sample to select. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>Specify name of sample to select. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="21%" />
-<col width="74%" />
+<col style="width: 5%" />
+<col style="width: 21%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--html</span></code></td>
-<td>Output as HTML.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--html</span></code></p></td>
+<td><p>Output as HTML.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-base-colors</span></code></td>
-<td>Do not use base-colors.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-base-colors</span></code></p></td>
+<td><p>Do not use base-colors.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-color</span></code></td>
-<td>Do not use colors.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-color</span></code></p></td>
+<td><p>Do not use colors.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-dots</span></code></td>
-<td>Display nucleotide instead of dots.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-dots</span></code></p></td>
+<td><p>Display nucleotide instead of dots.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--print-cigars</span></code></td>
-<td>Print alignment cigars.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--print-cigars</span></code></p></td>
+<td><p>Print alignment cigars.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--print-mapq</span></code></td>
-<td>Print alignment MAPQ values.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--print-mapq</span></code></p></td>
+<td><p>Print alignment MAPQ values.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--print-mate-position</span></code></td>
-<td>Print mate position.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--print-mate-position</span></code></p></td>
+<td><p>Print mate position.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--print-names</span></code></td>
-<td>Print read names.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--print-names</span></code></p></td>
+<td><p>Print read names.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--print-readgroup</span></code></td>
-<td>Print read group id for each alignment.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--print-readgroup</span></code></p></td>
+<td><p>Print read group id for each alignment.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--print-reference-line=INT</span></code></td>
-<td>Print reference line every N lines (Default is 0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--print-reference-line=INT</span></code></p></td>
+<td><p>Print reference line every N lines (Default is 0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--print-sample</span></code></td>
-<td>Print sample id for each alignment.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--print-sample</span></code></p></td>
+<td><p>Print sample id for each alignment.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--print-soft-clipped-bases</span></code></td>
-<td>Print soft clipped bases.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--print-soft-clipped-bases</span></code></p></td>
+<td><p>Print soft clipped bases.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--project-track=INT</span></code></td>
-<td>If set, project highlighting for the specified track down through reads (Default projects the union of tracks)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--project-track=INT</span></code></p></td>
+<td><p>If set, project highlighting for the specified track down through reads (Default projects the union of tracks)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sort-readgroup</span></code></td>
-<td>Sort reads first on read group and then on start position.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sort-readgroup</span></code></p></td>
+<td><p>Sort reads first on read group and then on start position.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sort-reads</span></code></td>
-<td>Sort reads on start position.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sort-reads</span></code></p></td>
+<td><p>Sort reads on start position.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sort-sample</span></code></td>
-<td>Sort reads first on sample id and then on start position.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sort-sample</span></code></p></td>
+<td><p>Sort reads first on sample id and then on start position.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--unflatten</span></code></td>
-<td>Display unflattened CGI reads when present.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--unflatten</span></code></p></td>
+<td><p>Display unflattened CGI reads when present.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="23%" />
-<col width="72%" />
+<col style="width: 6%" />
+<col style="width: 23%" />
+<col style="width: 72%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -8862,8 +8715,8 @@ <h3>aview<a class="headerlink" href="#aview" title="Permalink to this headline">
 displays for multiple regions for later viewing (either as text or
 HTML).</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a></p>
 </div>
 </div>
@@ -8898,74 +8751,74 @@ <h3>sdfstats<a class="headerlink" href="#sdfstats" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="11%" />
-<col width="85%" />
+<col style="width: 4%" />
+<col style="width: 11%" />
+<col style="width: 85%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">SDF+</span></code></td>
-<td>Specifies an SDF on which statistics are to be reported. May be specified 1 or more times.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">SDF+</span></code></p></td>
+<td><p>Specifies an SDF on which statistics are to be reported. May be specified 1 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="9%" />
-<col width="86%" />
+<col style="width: 5%" />
+<col style="width: 9%" />
+<col style="width: 86%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--lengths</span></code></td>
-<td>Set to print out the name and length of each sequence. (Not recommended for read sets).</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--lengths</span></code></p></td>
+<td><p>Set to print out the name and length of each sequence. (Not recommended for read sets).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--position</span></code></td>
-<td>Set to include information about unknown bases (Ns) by read position.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--position</span></code></p></td>
+<td><p>Set to include information about unknown bases (Ns) by read position.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--quality</span></code></td>
-<td>Set to display mean of quality.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--quality</span></code></p></td>
+<td><p>Set to display mean of quality.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></td>
-<td>Set to display the reference sequence list for the given sex. Allowed values are [male, female, either]. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></p></td>
+<td><p>Set to display the reference sequence list for the given sex. Allowed values are [male, female, either]. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--taxonomy</span></code></td>
-<td>Set to display information about the taxonomy.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--taxonomy</span></code></p></td>
+<td><p>Set to display information about the taxonomy.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--unknowns</span></code></td>
-<td>Set to include information about unknown bases (Ns).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--unknowns</span></code></p></td>
+<td><p>Set to include information about unknown bases (Ns).</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -8973,8 +8826,8 @@ <h3>sdfstats<a class="headerlink" href="#sdfstats" title="Permalink to this head
 <p>Use the <code class="docutils literal notranslate"><span class="pre">sdfstats</span></code> command to get information about the contents of
 SDFs.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
 <a class="reference internal" href="#cg2sdf"><span class="std std-ref">cg2sdf</span></a>,
 <a class="reference internal" href="#sdf2fasta"><span class="std std-ref">sdf2fasta</span></a>,
 <a class="reference internal" href="#sdf2fastq"><span class="std std-ref">sdf2fastq</span></a>,
@@ -9002,57 +8855,57 @@ <h3>sdfsplit<a class="headerlink" href="#sdfsplit" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="22%" />
-<col width="71%" />
+<col style="width: 7%" />
+<col style="width: 22%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>Specifies a file containing a list of input SDFs (one per line).</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>Specifies a file containing a list of input SDFs (one per line).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Specifies the directory that will contain the split output bases (must be empty if present).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Specifies the directory that will contain the split output bases (must be empty if present).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">SDF+</span></code></td>
-<td>Specifies an input SDF. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">SDF+</span></code></p></td>
+<td><p>Specifies an input SDF. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="16%" />
-<col width="78%" />
+<col style="width: 5%" />
+<col style="width: 16%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--allow-duplicate-names</span></code></td>
-<td>Set to disable duplicate name detection. Use this if you need to use less memory and you are certain there are no duplicate names in the input.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--allow-duplicate-names</span></code></p></td>
+<td><p>Set to disable duplicate name detection. Use this if you need to use less memory and you are certain there are no duplicate names in the input.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--in-memory</span></code></td>
-<td>Process in memory instead of from disk. (Faster but requires more RAM).</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--in-memory</span></code></p></td>
+<td><p>Process in memory instead of from disk. (Faster but requires more RAM).</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-n</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--num-sequences</span></code></td>
-<td>Specifies the number of sequences allowed in each SDF. Generally, this command is used to split up read data sets of considerable size.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-n</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--num-sequences</span></code></p></td>
+<td><p>Specifies the number of sequences allowed in each SDF. Generally, this command is used to split up read data sets of considerable size.</p></td>
 </tr>
 </tbody>
 </table>
@@ -9078,8 +8931,8 @@ <h3>sdfsplit<a class="headerlink" href="#sdfsplit" title="Permalink to this head
 <code class="docutils literal notranslate"><span class="pre">--end-read</span></code> flag options that may be preferable to using <code class="docutils literal notranslate"><span class="pre">sdfsplit</span></code> in
 most situations.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
 <a class="reference internal" href="#cg2sdf"><span class="std std-ref">cg2sdf</span></a>,
 <a class="reference internal" href="#sdf2fasta"><span class="std std-ref">sdf2fasta</span></a>,
 <a class="reference internal" href="#sdfstats"><span class="std std-ref">sdfstats</span></a>,
@@ -9105,74 +8958,74 @@ <h3>sdfsubset<a class="headerlink" href="#sdfsubset" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="16%" />
-<col width="33%" />
-<col width="51%" />
+<col style="width: 16%" />
+<col style="width: 33%" />
+<col style="width: 51%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></td>
-<td>Specifies the input SDF.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></p></td>
+<td><p>Specifies the input SDF.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></td>
-<td>The name of the output SDF.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=SDF</span></code></p></td>
+<td><p>The name of the output SDF.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="13%" />
-<col width="81%" />
+<col style="width: 6%" />
+<col style="width: 13%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-id=INT</span></code></td>
-<td>Only output sequences with sequence id less than the given number. (Sequence ids start at 0).</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-id=INT</span></code></p></td>
+<td><p>Only output sequences with sequence id less than the given number. (Sequence ids start at 0).</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-id=INT</span></code></td>
-<td>Only output sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-id=INT</span></code></p></td>
+<td><p>Only output sequences with sequence id greater than or equal to the given number. (Sequence ids start at 0).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--id-file=FILE</span></code></td>
-<td>Name of a file containing a list of sequences to extract, one per line.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--id-file=FILE</span></code></p></td>
+<td><p>Name of a file containing a list of sequences to extract, one per line.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--names</span></code></td>
-<td>Interpret any specified sequence as names instead of numeric sequence ids.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--names</span></code></p></td>
+<td><p>Interpret any specified sequence as names instead of numeric sequence ids.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">STRING+</span></code></td>
-<td>Specifies the sequence id, or sequence name if the names flag is set to extract from the input SDF. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">STRING+</span></code></p></td>
+<td><p>Specifies the sequence id, or sequence name if the names flag is set to extract from the input SDF. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -9190,8 +9043,8 @@ <h3>sdfsubset<a class="headerlink" href="#sdfsubset" title="Permalink to this he
 <p>This will produce an SDF called subset_reads with sequences 10, 20, 30,
 40 and 50 from the original SDF contained in it.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#sdfsubseq"><span class="std std-ref">sdfsubseq</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#sdfsubseq"><span class="std std-ref">sdfsubseq</span></a>,
 <a class="reference internal" href="#sdfstats"><span class="std std-ref">sdfstats</span></a></p>
 </div>
 </div>
@@ -9213,71 +9066,71 @@ <h3>sdfsubseq<a class="headerlink" href="#sdfsubseq" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="17%" />
-<col width="34%" />
-<col width="48%" />
+<col style="width: 17%" />
+<col style="width: 34%" />
+<col style="width: 48%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>Specifies the input SDF.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>Specifies the input SDF.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="13%" />
-<col width="83%" />
+<col style="width: 4%" />
+<col style="width: 13%" />
+<col style="width: 83%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sequence-id</span></code></td>
-<td>If set, use sequence id instead of sequence name in region (0-based)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sequence-id</span></code></p></td>
+<td><p>If set, use sequence id instead of sequence name in region (0-based)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">REGION+</span></code></td>
-<td>The range to display. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;.
-Must be specified 1 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">REGION+</span></code></p></td>
+<td><p>The range to display. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;.
+Must be specified 1 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="12%" />
-<col width="35%" />
-<col width="53%" />
+<col style="width: 12%" />
+<col style="width: 35%" />
+<col style="width: 53%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--fasta</span></code></td>
-<td>Set to output in FASTA format.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--fasta</span></code></p></td>
+<td><p>Set to output in FASTA format.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--fastq</span></code></td>
-<td>Set to output in FASTQ format.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--fastq</span></code></p></td>
+<td><p>Set to output in FASTQ format.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reverse-complement</span></code></td>
-<td>Set to output in reverse complement.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reverse-complement</span></code></p></td>
+<td><p>Set to output in reverse complement.</p></td>
 </tr>
 </tbody>
 </table>
@@ -9290,8 +9143,8 @@ <h3>sdfsubseq<a class="headerlink" href="#sdfsubseq" title="Permalink to this he
 </pre></div>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#sdfsubset"><span class="std std-ref">sdfsubset</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#sdfsubset"><span class="std std-ref">sdfsubset</span></a>,
 <a class="reference internal" href="#sdfstats"><span class="std std-ref">sdfstats</span></a></p>
 </div>
 </div>
@@ -9309,41 +9162,41 @@ <h3>sam2bam<a class="headerlink" href="#sam2bam" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="17%" />
-<col width="75%" />
+<col style="width: 7%" />
+<col style="width: 17%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Name for output BAM file.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Name for output BAM file.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing mapped reads. Must be specified 1 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing mapped reads. Must be specified 1 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="17%" />
-<col width="75%" />
+<col style="width: 7%" />
+<col style="width: 17%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -9354,8 +9207,8 @@ <h3>sam2bam<a class="headerlink" href="#sam2bam" title="Permalink to this headli
 file.</p>
 <p>If additional filtering of alignments is required, use <code class="docutils literal notranslate"><span class="pre">sammerge</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#cgmap"><span class="std std-ref">cgmap</span></a>,
 <a class="reference internal" href="#sammerge"><span class="std std-ref">sammerge</span></a></p>
 </div>
@@ -9379,155 +9232,155 @@ <h3>sammerge<a class="headerlink" href="#sammerge" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="14%" />
-<col width="82%" />
+<col style="width: 4%" />
+<col style="width: 14%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read SAM records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read SAM records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Name for output SAM/BAM file. Use ‘-‘ to write to standard output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Name for output SAM/BAM file. Use ‘-‘ to write to standard output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
-or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only process SAM records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt;
+or &lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome to use when decoding CRAM input.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome to use when decoding CRAM input.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>SAM/BAM format files containing coordinate-sorted reads. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>SAM/BAM format files containing coordinate-sorted reads. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="21%" />
-<col width="74%" />
+<col style="width: 5%" />
+<col style="width: 21%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-duplicates</span></code></td>
-<td>Exclude all SAM records flagged as a PCR or optical duplicate.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-duplicates</span></code></p></td>
+<td><p>Exclude all SAM records flagged as a PCR or optical duplicate.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></td>
-<td>Exclude all mated SAM records.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-mated</span></code></p></td>
+<td><p>Exclude all mated SAM records.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-unmapped</span></code></td>
-<td>Exclude all unmapped SAM records.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-unmapped</span></code></p></td>
+<td><p>Exclude all unmapped SAM records.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></td>
-<td>Exclude all unmated SAM records.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-unmated</span></code></p></td>
+<td><p>Exclude all unmated SAM records.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-unplaced</span></code></td>
-<td>Exclude all SAM records with no alignment position.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-unplaced</span></code></p></td>
+<td><p>Exclude all SAM records with no alignment position.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-F</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--filter-flags=INT</span></code></td>
-<td>Decimal mask indicating SAM FLAG bits that must not be set for the record.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-F</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--filter-flags=INT</span></code></p></td>
+<td><p>Decimal mask indicating SAM FLAG bits that must not be set for the record.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--invert</span></code></td>
-<td>If set, invert the result of flag and attribute based filter criteria.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--invert</span></code></p></td>
+<td><p>If set, invert the result of flag and attribute based filter criteria.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></td>
-<td>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-mated=INT</span></code></p></td>
+<td><p>If set, ignore mated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-u</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></td>
-<td>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-u</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-as-unmated=INT</span></code></p></td>
+<td><p>If set, ignore unmated SAM records with an alignment score (AS attribute) that exceeds this value.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-hits=INT</span></code></td>
-<td>If set, ignore SAM records with an alignment count that exceeds this value.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-hits=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with an alignment count that exceeds this value.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></td>
-<td>If set, ignore SAM records with MAPQ less than this value.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-mapq=INT</span></code></p></td>
+<td><p>If set, ignore SAM records with MAPQ less than this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-read-length=INT</span></code></td>
-<td>If set, ignore SAM reads with read length less than this value.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-read-length=INT</span></code></p></td>
+<td><p>If set, ignore SAM reads with read length less than this value.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-duplicates</span></code></td>
-<td>Detect and remove duplicate reads based on mapping position.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-duplicates</span></code></p></td>
+<td><p>Detect and remove duplicate reads based on mapping position.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--require-flags=INT</span></code></td>
-<td>Decimal mask indicating SAM FLAG bits that must be set for the record.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--require-flags=INT</span></code></p></td>
+<td><p>Decimal mask indicating SAM FLAG bits that must be set for the record.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--select-read-group=STRING</span></code></td>
-<td>Select only SAM records with this read group ID. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--select-read-group=STRING</span></code></p></td>
+<td><p>Select only SAM records with this read group ID. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="24%" />
-<col width="69%" />
+<col style="width: 7%" />
+<col style="width: 24%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--legacy-cigars</span></code></td>
-<td>If set, produce legacy cigars (using M rather than X or =) in output.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--legacy-cigars</span></code></p></td>
+<td><p>If set, produce legacy cigars (using M rather than X or =) in output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></td>
-<td>Prevent SAM/BAM header from being written.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></p></td>
+<td><p>Prevent SAM/BAM header from being written.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></td>
-<td>Seed used during subsampling.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--seed=INT</span></code></p></td>
+<td><p>Seed used during subsampling.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--subsample=FLOAT</span></code></td>
-<td>If set, subsample the input to retain this fraction of reads.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--subsample=FLOAT</span></code></p></td>
+<td><p>If set, subsample the input to retain this fraction of reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -9545,8 +9398,8 @@ <h3>sammerge<a class="headerlink" href="#sammerge" title="Permalink to this head
 BAM. In this case, a warning is issued, and you should consider running
 <code class="docutils literal notranslate"><span class="pre">calibrate</span></code> separately on the newly created BAM file.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#cgmap"><span class="std std-ref">cgmap</span></a>,
 <a class="reference internal" href="#samstats"><span class="std std-ref">samstats</span></a></p>
 </div>
@@ -9564,78 +9417,78 @@ <h3>samstats<a class="headerlink" href="#samstats" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="20%" />
-<col width="73%" />
+<col style="width: 7%" />
+<col style="width: 20%" />
+<col style="width: 73%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>Specifies a file containing a list of SAM/BAM format files (one per line) containing mapped reads.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>Specifies a file containing a list of SAM/BAM format files (one per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--reads=SDF</span></code></td>
-<td>Specifies the SDF containing the reads.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--reads=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing the reads.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>Specifies the reference genome SDF.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>Specifies the reference genome SDF.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>Specifies a SAM/BAM result file (must contain read-ids not read names). May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>Specifies a SAM/BAM result file (must contain read-ids not read names). May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="17%" />
-<col width="75%" />
+<col style="width: 8%" />
+<col style="width: 17%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--consensus</span></code></td>
-<td>Set to record consensus data. Requires roughly 5 fold reference genome length of RAM.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--consensus</span></code></p></td>
+<td><p>Set to record consensus data. Requires roughly 5 fold reference genome length of RAM.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-D</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--distributions</span></code></td>
-<td>Set to display distributions of insert sizes, alignment scores and read hits.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-D</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--distributions</span></code></p></td>
+<td><p>Set to display distributions of insert sizes, alignment scores and read hits.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--per-file</span></code></td>
-<td>Set to output per-file statistics as well as the summary of all SAM/BAM files.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--per-file</span></code></p></td>
+<td><p>Set to output per-file statistics as well as the summary of all SAM/BAM files.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--validate</span></code></td>
-<td>Set to validate mapping of read to reference. Tests matching of bases according to CIGAR format.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--validate</span></code></p></td>
+<td><p>Set to validate mapping of read to reference. Tests matching of bases according to CIGAR format.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -9666,8 +9519,8 @@ <h3>samstats<a class="headerlink" href="#samstats" title="Permalink to this head
 <p>Set the <code class="docutils literal notranslate"><span class="pre">--validate</span></code> flag to force the reporting of problems in the
 alignments file.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#sdfstats"><span class="std std-ref">sdfstats</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#sdfstats"><span class="std std-ref">sdfstats</span></a></p>
 </div>
 </div>
 <div class="section" id="samrename">
@@ -9685,70 +9538,70 @@ <h3>samrename<a class="headerlink" href="#samrename" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="11%" />
-<col width="22%" />
-<col width="67%" />
+<col style="width: 11%" />
+<col style="width: 22%" />
+<col style="width: 67%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></td>
-<td>Specifies the SDF containing the reads in the SAM/BAM file.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></p></td>
+<td><p>Specifies the SDF containing the reads in the SAM/BAM file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Specifies the name for the output SAM/BAM file.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Specifies the name for the output SAM/BAM file.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE</span></code></td>
-<td>Specifies the input SAM/BAM file.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE</span></code></p></td>
+<td><p>Specifies the input SAM/BAM file.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="25%" />
-<col width="66%" />
+<col style="width: 8%" />
+<col style="width: 25%" />
+<col style="width: 66%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></td>
-<td>Set the exclusive upper bound of the read id set to rename.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--end-read=INT</span></code></p></td>
+<td><p>Set the exclusive upper bound of the read id set to rename.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></td>
-<td>Set the inclusive lower bound of the read id set to rename.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--start-read=INT</span></code></p></td>
+<td><p>Set the inclusive lower bound of the read id set to rename.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="20%" />
-<col width="73%" />
+<col style="width: 7%" />
+<col style="width: 20%" />
+<col style="width: 73%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
 </tbody>
 </table>
@@ -9761,8 +9614,8 @@ <h3>samrename<a class="headerlink" href="#samrename" title="Permalink to this he
 input file, adding <code class="docutils literal notranslate"><span class="pre">_rename</span></code> to the file name. For example,
 <code class="docutils literal notranslate"><span class="pre">alignments.bam</span></code> becomes <code class="docutils literal notranslate"><span class="pre">alignments_rename.bam</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#samstats"><span class="std std-ref">samstats</span></a></p>
 </div>
 </div>
@@ -9781,45 +9634,45 @@ <h3>mapxrename<a class="headerlink" href="#mapxrename" title="Permalink to this
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="15%" />
-<col width="79%" />
+<col style="width: 6%" />
+<col style="width: 15%" />
+<col style="width: 79%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></td>
-<td>SDF for the reads in the mapx file.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=SDF</span></code></p></td>
+<td><p>SDF for the reads in the mapx file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Renamed output mapx file.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Renamed output mapx file.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE</span></code></td>
-<td>Input mapx file.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE</span></code></p></td>
+<td><p>Input mapx file.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="15%" />
-<col width="79%" />
+<col style="width: 6%" />
+<col style="width: 15%" />
+<col style="width: 79%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -9832,8 +9685,8 @@ <h3>mapxrename<a class="headerlink" href="#mapxrename" title="Permalink to this
 adding <code class="docutils literal notranslate"><span class="pre">_rename</span></code> to the file name. For example, <code class="docutils literal notranslate"><span class="pre">alignments.tsv.gz</span></code>
 becomes <code class="docutils literal notranslate"><span class="pre">alignments_rename.tsv.gz</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#mapx"><span class="std std-ref">mapx</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#mapx"><span class="std std-ref">mapx</span></a></p>
 </div>
 </div>
 <div class="section" id="chrstats">
@@ -9867,82 +9720,82 @@ <h3>chrstats<a class="headerlink" href="#chrstats" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="23%" />
-<col width="69%" />
+<col style="width: 8%" />
+<col style="width: 23%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of SAM/BAM format files (1 per line) containing mapped reads.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>alignment files to process. Must be specified 1 or more times</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>alignment files to process. Must be specified 1 or more times</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="15%" />
-<col width="80%" />
+<col style="width: 5%" />
+<col style="width: 15%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-pedigree=FILE</span></code></td>
-<td>output best guest of per-sample sex information to PED file</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-pedigree=FILE</span></code></p></td>
+<td><p>output best guest of per-sample sex information to PED file</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>the name of the sample to check (required when checking single sample from multiple samples alignments)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>the name of the sample to check (required when checking single sample from multiple samples alignments)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></td>
-<td>sex setting that the individual was mapped as (when not using pedigree). Allowed values are [male, female, either] (Default is either)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex=SEX</span></code></p></td>
+<td><p>sex setting that the individual was mapped as (when not using pedigree). Allowed values are [male, female, either] (Default is either)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></td>
-<td>Genome relationships PED file containing sample sex information.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></p></td>
+<td><p>Genome relationships PED file containing sample sex information.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sex-z-threshold=NUM</span></code></td>
-<td>The z-score deviation threshold for sex chromosome consistency (Default is 5.0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sex-z-threshold=NUM</span></code></p></td>
+<td><p>The z-score deviation threshold for sex chromosome consistency (Default is 5.0)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--z-threshold=NUM</span></code></td>
-<td>The z-score deviation threshold for chromosome consistency (Default is 10.0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--z-threshold=NUM</span></code></p></td>
+<td><p>The z-score deviation threshold for chromosome consistency (Default is 10.0)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -9967,8 +9820,8 @@ <h3>chrstats<a class="headerlink" href="#chrstats" title="Permalink to this head
 exome sequencing, although the latter requires that mapping (or
 subsequent calibration) employed the <code class="docutils literal notranslate"><span class="pre">--bed-regions</span></code> flag.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a>,
 <a class="reference internal" href="#cgmap"><span class="std std-ref">cgmap</span></a>,
 <a class="reference internal" href="#calibrate"><span class="std std-ref">calibrate</span></a></p>
 </div>
@@ -9988,86 +9841,86 @@ <h3>mendelian<a class="headerlink" href="#mendelian" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="25%" />
-<col width="69%" />
+<col style="width: 6%" />
+<col style="width: 25%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>VCF file containing multi-sample variant calls. Use ‘-‘ to read from standard input.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>VCF file containing multi-sample variant calls. Use ‘-‘ to read from standard input.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>If set, output annotated calls to this VCF file. Use ‘-‘ to write to standard output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>If set, output annotated calls to this VCF file. Use ‘-‘ to write to standard output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-consistent=FILE</span></code></td>
-<td>If set, output only consistent calls to this VCF file.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-consistent=FILE</span></code></p></td>
+<td><p>If set, output only consistent calls to this VCF file.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-inconsistent=FILE</span></code></td>
-<td>If set, output only non-Mendelian calls to this VCF file.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-inconsistent=FILE</span></code></p></td>
+<td><p>If set, output only non-Mendelian calls to this VCF file.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF containing the reference genome.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF containing the reference genome.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="21%" />
-<col width="74%" />
+<col style="width: 5%" />
+<col style="width: 21%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--all-records</span></code></td>
-<td>Use all records, regardless of filters (Default is to only process records where FILTER is <code class="docutils literal notranslate"><span class="pre">.</span></code> or <code class="docutils literal notranslate"><span class="pre">PASS</span></code>)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all-records</span></code></p></td>
+<td><p>Use all records, regardless of filters (Default is to only process records where FILTER is <code class="docutils literal notranslate"><span class="pre">.</span></code> or <code class="docutils literal notranslate"><span class="pre">PASS</span></code>)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-l</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--lenient</span></code></td>
-<td>Allow homozygous diploid calls in place of haploid calls and assume missing values are equal to the reference.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-l</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--lenient</span></code></p></td>
+<td><p>Allow homozygous diploid calls in place of haploid calls and assume missing values are equal to the reference.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-concordance=FLOAT</span></code></td>
-<td>Percentage concordance required for consistent parentage (Default is 99.0)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-concordance=FLOAT</span></code></p></td>
+<td><p>Percentage concordance required for consistent parentage (Default is 99.0)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></td>
-<td>Genome relationships PED file (Default is to extract pedigree information from VCF header fields)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--pedigree=FILE</span></code></p></td>
+<td><p>Genome relationships PED file (Default is to extract pedigree information from VCF header fields)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="23%" />
-<col width="72%" />
+<col style="width: 6%" />
+<col style="width: 23%" />
+<col style="width: 72%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
 </tbody>
 </table>
@@ -10133,8 +9986,8 @@ <h3>mendelian<a class="headerlink" href="#mendelian" title="Permalink to this he
 missing are processed. All variant records can be examined by specifying
 the <code class="docutils literal notranslate"><span class="pre">--all-records</span></code> parameter.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#population"><span class="std std-ref">population</span></a>,
 <a class="reference internal" href="#vcfstats"><span class="std std-ref">vcfstats</span></a></p>
 </div>
@@ -10153,108 +10006,108 @@ <h3>vcfannotate<a class="headerlink" href="#vcfannotate" title="Permalink to thi
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="15%" />
-<col width="81%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read VCF records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read VCF records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>VCF file containing variants to annotate. Use ‘-‘ to read from standard input.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>VCF file containing variants to annotate. Use ‘-‘ to read from standard input.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output VCF file name. Use ‘-‘ to write to standard output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output VCF file name. Use ‘-‘ to write to standard output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
-&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
+&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="15%" />
-<col width="81%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-A</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--annotation=STRING</span></code></td>
-<td>Add computed annotation to VCF records. Allowed values are [AC, AN, EP, GQD, IC, LAL, MEANQAD, NAA, PD, QA, QD, RA, SCONT, VAF, VAF1, ZY]. May be specified 0 or
-more times, or as a comma separated list.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-A</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--annotation=STRING</span></code></p></td>
+<td><p>Add computed annotation to VCF records. Allowed values are [AC, AN, EP, GQD, IC, LAL, MEANQAD, NAA, PD, QA, QD, RA, SCONT, VAF, VAF1, ZY]. May be specified 0 or
+more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-ids=FILE</span></code></td>
-<td>Add variant IDs from BED file. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-ids=FILE</span></code></p></td>
+<td><p>Add variant IDs from BED file. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-info=FILE</span></code></td>
-<td>Add INFO annotations from BED file. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-info=FILE</span></code></p></td>
+<td><p>Add INFO annotations from BED file. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--fill-an-ac</span></code></td>
-<td>Add or update the AN and AC INFO fields.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--fill-an-ac</span></code></p></td>
+<td><p>Add or update the AN and AC INFO fields.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--info-description=STRING</span></code></td>
-<td>If the BED INFO field is not already declared, use this description in the header (Default is Annotation)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--info-description=STRING</span></code></p></td>
+<td><p>If the BED INFO field is not already declared, use this description in the header (Default is Annotation)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--info-id=STRING</span></code></td>
-<td>The INFO ID for BED INFO annotations (Default is ANN)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--info-id=STRING</span></code></p></td>
+<td><p>The INFO ID for BED INFO annotations (Default is ANN)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--relabel=FILE</span></code></td>
-<td>Relabel samples according to <code class="docutils literal notranslate"><span class="pre">old-name</span> <span class="pre">new-name</span></code> pairs in specified file.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--relabel=FILE</span></code></p></td>
+<td><p>Relabel samples according to <code class="docutils literal notranslate"><span class="pre">old-name</span> <span class="pre">new-name</span></code> pairs in specified file.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--vcf-ids=FILE</span></code></td>
-<td>Add variant IDs from VCF file. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--vcf-ids=FILE</span></code></p></td>
+<td><p>Add variant IDs from VCF file. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="22%" />
-<col width="72%" />
+<col style="width: 6%" />
+<col style="width: 22%" />
+<col style="width: 72%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--add-header=STRING|FILE</span></code></td>
-<td>File containing VCF header lines to add, or a literal header line. May be specified 0 or more times.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--add-header=STRING|FILE</span></code></p></td>
+<td><p>File containing VCF header lines to add, or a literal header line. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></td>
-<td>Prevent VCF header from being written.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></p></td>
+<td><p>Prevent VCF header from being written.</p></td>
 </tr>
 </tbody>
 </table>
@@ -10299,8 +10152,8 @@ <h3>vcfannotate<a class="headerlink" href="#vcfannotate" title="Permalink to thi
 annotation is a convenience to annotate with all of the contrary
 evidence annotations: <code class="docutils literal notranslate"><span class="pre">DCOC</span></code>, <code class="docutils literal notranslate"><span class="pre">DCOF</span></code>, <code class="docutils literal notranslate"><span class="pre">OCOC</span></code>, <code class="docutils literal notranslate"><span class="pre">OCOF</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#somatic"><span class="std std-ref">somatic</span></a>,
 <a class="reference internal" href="#population"><span class="std std-ref">population</span></a>,
@@ -10317,74 +10170,74 @@ <h3>vcfdecompose<a class="headerlink" href="#vcfdecompose" title="Permalink to t
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="18%" />
-<col width="75%" />
+<col style="width: 7%" />
+<col style="width: 18%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>VCF file containing variants to decompose. Use ‘-‘ to read from standard input.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>VCF file containing variants to decompose. Use ‘-‘ to read from standard input.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output VCF file name. Use ‘-‘ to write to standard output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output VCF file name. Use ‘-‘ to write to standard output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF of the reference genome the variants are called against.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF of the reference genome the variants are called against.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="18%" />
-<col width="75%" />
+<col style="width: 7%" />
+<col style="width: 18%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--break-indels</span></code></td>
-<td>If set, peel as many SNPs off an indel as possible.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--break-indels</span></code></p></td>
+<td><p>If set, peel as many SNPs off an indel as possible.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--break-mnps</span></code></td>
-<td>If set, break MNPs into individual SNPs.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--break-mnps</span></code></p></td>
+<td><p>If set, break MNPs into individual SNPs.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="18%" />
-<col width="75%" />
+<col style="width: 7%" />
+<col style="width: 18%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></td>
-<td>Prevent VCF header from being written.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></p></td>
+<td><p>Prevent VCF header from being written.</p></td>
 </tr>
 </tbody>
 </table>
@@ -10433,8 +10286,8 @@ <h3>vcfdecompose<a class="headerlink" href="#vcfdecompose" title="Permalink to t
 <p>The variants that are left vs right-padded are equivalent and identified
 as such by haplotype-aware comparison tools such as <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#vcffilter"><span class="std std-ref">vcffilter</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#vcffilter"><span class="std std-ref">vcffilter</span></a>,
 <a class="reference internal" href="#vcfeval"><span class="std std-ref">vcfeval</span></a></p>
 </div>
 </div>
@@ -10461,143 +10314,160 @@ <h3>vcfeval<a class="headerlink" href="#vcfeval" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="15%" />
-<col width="81%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-b</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--baseline=FILE</span></code></td>
-<td>VCF file containing baseline variants.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-b</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--baseline=FILE</span></code></p></td>
+<td><p>VCF file containing baseline variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read VCF records that overlap the ranges contained in the specified BED file.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read VCF records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--calls=FILE</span></code></td>
-<td>VCF file containing called variants.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--calls=FILE</span></code></p></td>
+<td><p>VCF file containing called variants.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-e</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--evaluation-regions=FILE</span></code></td>
-<td>If set, evaluate within regions contained in the supplied BED file, allowing transborder matches. To be used for truth-set high-confidence regions or other
-regions of interest where region boundary effects should be minimized.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-e</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--evaluation-regions=FILE</span></code></p></td>
+<td><p>If set, evaluate within regions contained in the supplied BED file, allowing transborder matches. To be used for truth-set high-confidence regions or other
+regions of interest where region boundary effects should be minimized.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
-&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
+&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></td>
-<td>SDF of the reference genome the variants are called against.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--template=SDF</span></code></p></td>
+<td><p>SDF of the reference genome the variants are called against.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="15%" />
-<col width="81%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--all-records</span></code></td>
-<td>Use all records regardless of FILTER status (Default is to only process records where FILTER is <code class="docutils literal notranslate"><span class="pre">.</span></code> or <code class="docutils literal notranslate"><span class="pre">PASS</span></code>)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all-records</span></code></p></td>
+<td><p>Use all records regardless of FILTER status (Default is to only process records where FILTER is <code class="docutils literal notranslate"><span class="pre">.</span></code> or <code class="docutils literal notranslate"><span class="pre">PASS</span></code>)</p></td>
+</tr>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--decompose</span></code></p></td>
+<td><p>Decompose complex variants into smaller constituents to allow partial credit.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--decompose</span></code></td>
-<td>Decompose complex variants into smaller constituents to allow partial credit.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--ref-overlap</span></code></p></td>
+<td><p>Allow alleles to overlap where bases of either allele are same-as-ref (Default is to only allow VCF anchor base overlap)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--ref-overlap</span></code></td>
-<td>Allow alleles to overlap where bases of either allele are same-as-ref (Default is to only allow VCF anchor base overlap)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>The name of the sample to select. Use &lt;baseline_sample&gt;,&lt;calls_sample&gt; to select different sample names for baseline and calls. (Required when using
+multi-sample VCF files)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>The name of the sample to select. Use &lt;baseline_sample&gt;,&lt;calls_sample&gt; to select different sample names for baseline and calls. (Required when using
-multi-sample VCF files)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample-ploidy=INT</span></code></p></td>
+<td><p>Expected ploidy of samples (Default is 2)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--squash-ploidy</span></code></td>
-<td>Treat heterozygous genotypes as homozygous ALT in both baseline and calls, to allow matches that ignore zygosity differences.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--squash-ploidy</span></code></p></td>
+<td><p>Treat heterozygous genotypes as homozygous ALT in both baseline and calls, to allow matches that ignore zygosity differences.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="15%" />
-<col width="81%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--at-precision=FLOAT</span></code></td>
-<td>Output summary statistics where precision &gt;= supplied value (Default is to summarize at maximum F-measure)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--at-precision=FLOAT</span></code></p></td>
+<td><p>Output summary statistics where precision &gt;= supplied value (Default is to summarize at maximum F-measure)</p></td>
+</tr>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--at-sensitivity=FLOAT</span></code></p></td>
+<td><p>Output summary statistics where sensitivity &gt;= supplied value (Default is to summarize at maximum F-measure)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--at-sensitivity=FLOAT</span></code></td>
-<td>Output summary statistics where sensitivity &gt;= supplied value (Default is to summarize at maximum F-measure)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-roc</span></code></p></td>
+<td><p>Do not produce ROCs.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-roc</span></code></td>
-<td>Do not produce ROCs.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-mode=STRING</span></code></p></td>
+<td><p>Output reporting mode. Allowed values are [split, annotate, combine, ga4gh, roc-only] (Default is split)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-mode=STRING</span></code></td>
-<td>Output reporting mode. Allowed values are [split, annotate, combine, ga4gh, roc-only] (Default is split)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--roc-expr=STRING</span></code></p></td>
+<td><p>Output ROC file for variants matching custom JavaScript expression. Use the form &lt;LABEL&gt;=&lt;EXPRESSION&gt;. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-O</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sort-order=STRING</span></code></td>
-<td>The order in which to sort the ROC scores so that <code class="docutils literal notranslate"><span class="pre">good</span></code> scores come before <code class="docutils literal notranslate"><span class="pre">bad</span></code> scores. Allowed values are [ascending, descending] (Default is descending)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--roc-regions=STRING</span></code></p></td>
+<td><p>Output ROC file for variants overlapping custom regions supplied in BED file. Use the form &lt;LABEL&gt;=&lt;FILENAME&gt;. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--vcf-score-field=STRING</span></code></td>
-<td>The name of the VCF FORMAT field to use as the ROC score. Also valid are <code class="docutils literal notranslate"><span class="pre">QUAL</span></code>, <code class="docutils literal notranslate"><span class="pre">INFO.&lt;name&gt;</span></code> or <code class="docutils literal notranslate"><span class="pre">FORMAT.&lt;name&gt;</span></code> to select the named VCF FORMAT or INFO
-field (Default is GQ)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--roc-subset=STRING</span></code></p></td>
+<td><p>Output ROC file for preset variant subset. Allowed values are [hom, het, snp, non-snp, mnp, indel]. May be specified 0 or more times, or as a comma separated
+list.</p></td>
+</tr>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-O</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sort-order=STRING</span></code></p></td>
+<td><p>The order in which to sort the ROC scores so that <code class="docutils literal notranslate"><span class="pre">good</span></code> scores come before <code class="docutils literal notranslate"><span class="pre">bad</span></code> scores. Allowed values are [ascending, descending] (Default is descending)</p></td>
+</tr>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--vcf-score-field=STRING</span></code></p></td>
+<td><p>The name of the VCF FORMAT field to use as the ROC score. Also valid are <code class="docutils literal notranslate"><span class="pre">QUAL</span></code>, <code class="docutils literal notranslate"><span class="pre">INFO.&lt;name&gt;</span></code> or <code class="docutils literal notranslate"><span class="pre">FORMAT.&lt;name&gt;</span></code> to select the named VCF FORMAT or INFO
+field (Default is GQ)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="16%" />
-<col width="77%" />
+<col style="width: 7%" />
+<col style="width: 26%" />
+<col style="width: 68%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Set this flag to create the output files without compression.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Specify the number of threads to use in a multi-core processor. (Default is all available cores).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -10668,6 +10538,18 @@ <h4>Common allele matching with <code class="docutils literal notranslate"><span
 heterogeneity that mean strict diploid genotype comparisons are not
 appropriate.</p>
 </div>
+<div class="section" id="comparing-non-diploid-genomes">
+<h4>Comparing non-diploid genomes<a class="headerlink" href="#comparing-non-diploid-genomes" title="Permalink to this headline">¶</a></h4>
+<p>By default, <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> assumes diploid organisms (that is, the expected
+ploidy of any GT call is 2). As a special case to ease the comparison of
+male calls on sex chromosomes (where callers often continue to use
+diploid representation), haploid calls are treated as homozygous
+diploid. Any calls made with unexpected ploidy are ignored and reported
+in the <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> log file.</p>
+<p>To compare genomes with non-diploid ploidy, the expected sample ploidy
+can be overridden via <code class="docutils literal notranslate"><span class="pre">--sample-ploidy</span></code> – for example
+<code class="docutils literal notranslate"><span class="pre">--sample-ploidy=4</span></code> would be used to compare tetraploid organisms.</p>
+</div>
 <div class="section" id="comparing-with-a-vcf-that-has-no-sample-column">
 <h4>Comparing with a VCF that has no sample column<a class="headerlink" href="#comparing-with-a-vcf-that-has-no-sample-column" title="Permalink to this headline">¶</a></h4>
 <p>A common scenario is to match a call set against a baseline which
@@ -10691,8 +10573,8 @@ <h4>Comparing with a VCF that has no sample column<a class="headerlink" href="#c
 resulting true positives file contains all the calls containing an
 allele present in the COSMIC VCF.</p>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">It is also possible to run a diploid comparison by omitting
+<p class="admonition-title">Note</p>
+<p>It is also possible to run a diploid comparison by omitting
 <code class="docutils literal notranslate"><span class="pre">--squash-ploidy</span></code>, but this is not usually required, and is
 computationally more intensive since there may be many more possible
 diploid genotypes to explore, particularly if the ALT VCF contains
@@ -10737,17 +10619,17 @@ <h5>Split (<code class="docutils literal notranslate"><span class="pre">--output
 are not altered in any way, preserving all annotations present in the
 input files.</p>
 <ul class="simple">
-<li><code class="docutils literal notranslate"><span class="pre">tp.vcf</span></code> – contains those variants from the <em>calls</em> VCF which agree
-with variants in the baseline VCF</li>
-<li><code class="docutils literal notranslate"><span class="pre">tp-baseline.vcf</span></code> – contains those variants from the <em>baseline</em> VCF
+<li><p><code class="docutils literal notranslate"><span class="pre">tp.vcf</span></code> – contains those variants from the <em>calls</em> VCF which agree
+with variants in the baseline VCF</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">tp-baseline.vcf</span></code> – contains those variants from the <em>baseline</em> VCF
 which agree with variants in the calls VCF. Thus, the variants in
 <code class="docutils literal notranslate"><span class="pre">tp.vcf</span></code> and <code class="docutils literal notranslate"><span class="pre">tp-baseline.vcf</span></code> are equivalent. This file can be used
 to successively refine a highly sensitive baseline variant set to
-produce a consensus from several call sets.</li>
-<li><code class="docutils literal notranslate"><span class="pre">fp.vcf</span></code> – contains variants from the <em>calls</em> VCF which do not agree
-with baseline variants.</li>
-<li><code class="docutils literal notranslate"><span class="pre">fn.vcf</span></code> – contains variants from the <em>baseline</em> VCF which were not
-correctly called.</li>
+produce a consensus from several call sets.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">fp.vcf</span></code> – contains variants from the <em>calls</em> VCF which do not agree
+with baseline variants.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">fn.vcf</span></code> – contains variants from the <em>baseline</em> VCF which were not
+correctly called.</p></li>
 </ul>
 <p>This mode performs a single pass comparison, either in diploid mode (the
 default), or haploid mode (if <code class="docutils literal notranslate"><span class="pre">--squash-ploidy</span></code> has been set). The
@@ -10760,10 +10642,10 @@ <h5>Annotate (<code class="docutils literal notranslate"><span class="pre">--out
 instead adds <code class="docutils literal notranslate"><span class="pre">INFO</span></code> annotations containing the match status of each
 record:</p>
 <ul class="simple">
-<li><code class="docutils literal notranslate"><span class="pre">calls.vcf</span></code> – contains variants from the <em>calls</em> VCF, augmented with
-match status annotations.</li>
-<li><code class="docutils literal notranslate"><span class="pre">baseline.vcf</span></code> – contains variants from the <em>baseline</em> VCF, augmented
-with match status annotations.</li>
+<li><p><code class="docutils literal notranslate"><span class="pre">calls.vcf</span></code> – contains variants from the <em>calls</em> VCF, augmented with
+match status annotations.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">baseline.vcf</span></code> – contains variants from the <em>baseline</em> VCF, augmented
+with match status annotations.</p></li>
 </ul>
 <p>This output mode automatically performs two comparison passes, the first
 finds diploid matches (assigned a match status of <code class="docutils literal notranslate"><span class="pre">TP</span></code>), and a second
@@ -10777,49 +10659,35 @@ <h5>Annotate (<code class="docutils literal notranslate"><span class="pre">--out
 otherwise containing a non-variant genotype). A status of <code class="docutils literal notranslate"><span class="pre">OUT</span></code>
 indicates a VCF record which does not contain a match status due to
 falling outside the evaluation regions when <code class="docutils literal notranslate"><span class="pre">--evaluation-regions</span></code> is
-being used.</p>
+being used. The annotated VCF files produced in this mode may also be
+used with <code class="docutils literal notranslate"><span class="pre">vcf2rocplot</span></code> to produce additional post-evaluation ROC data
+files.</p>
 </div>
 <div class="section" id="combine-output-mode-combine">
-<h5>Combine (–output-mode=combine)<a class="headerlink" href="#combine-output-mode-combine" title="Permalink to this headline">¶</a></h5>
+<h5>Combine (<code class="docutils literal notranslate"><span class="pre">--output-mode=combine</span></code>)<a class="headerlink" href="#combine-output-mode-combine" title="Permalink to this headline">¶</a></h5>
 <p>This output mode provides an easy way to view the baseline and call
 variants in a single two-sample VCF.</p>
 <ul class="simple">
-<li><code class="docutils literal notranslate"><span class="pre">output.vcf</span></code> – contains variants from both the <em>baseline</em> and <em>calls</em>
+<li><p><code class="docutils literal notranslate"><span class="pre">output.vcf</span></code> – contains variants from both the <em>baseline</em> and <em>calls</em>
 VCFs, augmented with match status annotations. The sample under
 comparison from each of the input VCFs is extracted as a column in
 the output. As the VCF records from the baseline and calls typically
 have very different input annotations which can be difficult to
 merge, and to keep the output format simple, there is no attempt to
-preserve any of the original variant annotations.</li>
+preserve any of the original variant annotations.</p></li>
 </ul>
 <p>As with the annotation output mode, this output mode automatically
 performs two comparison passes to find both diploid matches and haploid
 (lenient) matches.</p>
 </div>
 <div class="section" id="roc-only-output-mode-roc-only">
-<h5>ROC-only (–output-mode=roc-only)<a class="headerlink" href="#roc-only-output-mode-roc-only" title="Permalink to this headline">¶</a></h5>
+<h5>ROC-only (<code class="docutils literal notranslate"><span class="pre">--output-mode=roc-only</span></code>)<a class="headerlink" href="#roc-only-output-mode-roc-only" title="Permalink to this headline">¶</a></h5>
 <p>This output mode provides a lightweight way to run performance
 benchmarking, as VCF file output is omitted, and only ROC data files are
 produced.</p>
-<p>All of the output modes produce the following ROC data files:</p>
-<ul class="simple">
-<li><code class="docutils literal notranslate"><span class="pre">weighted_roc.tsv</span></code> – contains ROC data derived from all analyzed
-call variants, regardless of their representation. Columns include
-the score field, and standard accuracy metrics such as true
-positives, false positives, false negatives, precision, sensitivity,
-and f-measure corresponding to each score threshold.</li>
-<li><code class="docutils literal notranslate"><span class="pre">snp_roc.tsv</span></code> – contains ROC data derived from only those variants
-which were represented as SNPs. Since the representation conventions
-can differ between the baseline and calls, there are some subtleties
-to be aware of when interpreting metrics such as precision,
-sensitivity, etc, described below.</li>
-<li><code class="docutils literal notranslate"><span class="pre">non_snp_roc.tsv</span></code> – contains ROC data derived from those
-variants which were not represented as SNPs. As above, not all
-metrics are computed for this file.</li>
-</ul>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">In addition, <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> has an output mode
+<p class="admonition-title">Note</p>
+<p>In addition, <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> has an output mode
 (<code class="docutils literal notranslate"><span class="pre">--output-mode=ga4gh</span></code>) which produces the intermediate evaluation
 format defined by the GA4GH Benchmarking Team, without additional
 statistics files. This mode is not generally intended for end users,
@@ -10830,6 +10698,87 @@ <h5>ROC-only (–output-mode=roc-only)<a class="headerlink" href="#roc-only-outp
 </div>
 </div>
 </div>
+<div class="section" id="additional-roc-stratifications">
+<h4>Additional ROC stratifications<a class="headerlink" href="#additional-roc-stratifications" title="Permalink to this headline">¶</a></h4>
+<p>All of the output modes produce the following ROC data files (unless
+disabled by <code class="docutils literal notranslate"><span class="pre">--no-roc</span></code>):</p>
+<ul class="simple">
+<li><p><code class="docutils literal notranslate"><span class="pre">weighted_roc.tsv</span></code> – contains ROC data derived from all analyzed
+call variants, regardless of their representation. Columns include
+the score field, and standard accuracy metrics such as true
+positives, false positives, false negatives, precision, sensitivity,
+and f-measure corresponding to each score threshold.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">snp_roc.tsv</span></code> – contains ROC data derived from only those variants
+which were represented as SNPs. Since the representation conventions
+can differ between the baseline and calls, there are some subtleties
+to be aware of when interpreting metrics such as precision,
+sensitivity, etc, described below.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">non_snp_roc.tsv</span></code> – contains ROC data derived from those
+variants which were not represented as SNPs. As above, not all
+metrics are computed for this file.</p></li>
+</ul>
+<p><code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> also provides the ability to produce additional ROC data
+files corresponding to preset and customized variant stratifications
+with the following flags:</p>
+<div class="section" id="preset-stratifications">
+<h5>Preset stratifications<a class="headerlink" href="#preset-stratifications" title="Permalink to this headline">¶</a></h5>
+<p>The <code class="docutils literal notranslate"><span class="pre">--roc-subset</span></code> flag allows selection from preset stratifications
+based on variant type (according to their representation in the
+relevant input VCF):</p>
+<ul class="simple">
+<li><p><code class="docutils literal notranslate"><span class="pre">hom</span></code> – homozygous variants only</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">het</span></code> – heterozygous variants only</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">snp</span></code> – SNP variants (enabled by default)</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">non-snp</span></code> – non-SNP variants (enabled by default)</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">mnp</span></code> – multi-nucleotide polymorphisms only</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">indel</span></code> – length-changing variants only</p></li>
+</ul>
+<p>Multiple presets can be enabled in a single run, e.g. <code class="docutils literal notranslate"><span class="pre">--roc-subset</span> <span class="pre">hom,het,indel</span></code></p>
+</div>
+<div class="section" id="region-based-stratifications">
+<h5>Region-based stratifications<a class="headerlink" href="#region-based-stratifications" title="Permalink to this headline">¶</a></h5>
+<p>The <code class="docutils literal notranslate"><span class="pre">--roc-regions</span></code> flag produces a stratified ROC data file using only
+variants that overlap regions specified in a user-supplied BED file. The
+special syntax for this flag is: <code class="docutils literal notranslate"><span class="pre">--roc-regions</span> <span class="pre">LABEL=FILE</span></code>, where
+<code class="docutils literal notranslate"><span class="pre">LABEL</span></code> is a short tag used to determine ROC output file names and
+<code class="docutils literal notranslate"><span class="pre">FILE</span></code> is the path to the relevant BED file. For example, to produce
+additional stratifications based on BED files partitioning the genome
+based on GC content:</p>
+<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>$ rtg vcfeval -t build37.sdf -b baseline.vcf.gz -c calls.vcf.gz \
+  --roc-regions GC55TO60=/path/to/GCcontent/GRCh37_gc55to60_slop50.bed.gz \
+  --roc-regions GC60TO65=/path/to/GCcontent/GRCh37_gc60to65_slop50.bed.gz
+</pre></div>
+</div>
+</div>
+<div class="section" id="custom-javascript-based-stratifications">
+<h5>Custom JavaScript based stratifications<a class="headerlink" href="#custom-javascript-based-stratifications" title="Permalink to this headline">¶</a></h5>
+<p>The above stratification flags will satisfy most common usages, but
+<code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> also includes the ability to write custom stratifications
+using JavaScript expressions (similar to <code class="docutils literal notranslate"><span class="pre">vcffilter</span> <span class="pre">--keep-expr</span></code>). The
+special syntax for this flag is: <code class="docutils literal notranslate"><span class="pre">--roc-expr</span> <span class="pre">LABEL=EXPRESSION</span></code>, where
+<code class="docutils literal notranslate"><span class="pre">LABEL</span></code> is a short tag used to determine ROC output file names and
+<code class="docutils literal notranslate"><span class="pre">EXPRESSION</span></code> is the JavaScript expression that accepts a variant for
+inclusion in the stratification. This is most useful when the input VCFs
+contain annotations useful for the stratification. For example, to
+produce stratifications based on depth of coverage during variant
+calling:</p>
+<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>$ rtg vcfeval -t build37.sdf -b baseline.vcf.gz -c calls.vcf.gz \
+  --roc-expr &quot;DP10TO20=has(INFO.DP) &amp;&amp; INFO.DP&gt;=10 &amp;&amp; INFO.DP&lt;20&quot; \
+  --roc-expr &quot;DP20TO30=has(INFO.DP) &amp;&amp; INFO.DP&gt;=20 &amp;&amp; INFO.DP&lt;30&quot; \
+  --roc-expr &quot;DP30TO40=has(INFO.DP) &amp;&amp; INFO.DP&gt;=30 &amp;&amp; INFO.DP&lt;40&quot;
+</pre></div>
+</div>
+<p>Tips:</p>
+<ul class="simple">
+<li><p>Ensure the expression is valid to evaluate on all variants (for
+example, take care when referring to sample fields names if the sample
+names are different between baseline and calls files).</p></li>
+<li><p>It may be useful to test or debug the expression (without the label)
+via <code class="docutils literal notranslate"><span class="pre">vcffilter</span> <span class="pre">--keep-expr</span></code>.</p></li>
+</ul>
+<p>For more information on JavaScript expressions, see <a class="reference internal" href="appendix.html#rtg-javascript-filtering-api"><span class="std std-ref">RTG JavaScript filtering API</span></a></p>
+</div>
+</div>
 <div class="section" id="benchmarking-comparisons-using-roc-and-precision-sensitivity-curves">
 <h4>Benchmarking comparisons using ROC and precision/sensitivity curves<a class="headerlink" href="#benchmarking-comparisons-using-roc-and-precision-sensitivity-curves" title="Permalink to this headline">¶</a></h4>
 <p>Multiple ROC data files (from a single or several <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> runs) can
@@ -10862,14 +10811,14 @@ <h4>Benchmarking comparisons using ROC and precision/sensitivity curves<a class=
 two call sets. Since false negatives can only be measured in terms of
 the baseline representation, sensitivity is defined as:</p>
 <div class="math">
-<p><img src="_images/math/3d714ca7cb77ae0a59a33942b07a97523eb2ede6.png" alt="\text{Sensitivity} = \text{TP}_\text{baseline} / (\text{TP}_\text{baseline} + \text{FN})."/></p>
+<p><img src="_images/math/b6f66d1803a9dcb5f12f25c57d4e43fb6584ca7e.png" alt="\text{Sensitivity} = \text{TP}_\text{baseline} / (\text{TP}_\text{baseline} + \text{FN})."/></p>
 </div><p>Conversely since false positives can only be measured in terms of the
 call representation, precision is defined as:</p>
 <div class="math">
-<p><img src="_images/math/276ab2f76e62085e8ec1a3fb0c5fff842c0b98e4.png" alt="\text{Precision} = \text{TP}_\text{call} / (\text{TP}_\text{call} + \text{FP})."/></p>
+<p><img src="_images/math/67e012a427a90dc0c0f8a2d5939a95e5f6ffe591.png" alt="\text{Precision} = \text{TP}_\text{call} / (\text{TP}_\text{call} + \text{FP})."/></p>
 </div><div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">For definitions of the terminology used when evaluating caller
+<p class="admonition-title">Note</p>
+<p>For definitions of the terminology used when evaluating caller
 accuracy, see:
 <a class="reference external" href="https://en.wikipedia.org/wiki/Receiver_operating_characteristic">https://en.wikipedia.org/wiki/Receiver_operating_characteristic</a>
 and <a class="reference external" href="https://en.wikipedia.org/wiki/Sensitivity_and_specificity">https://en.wikipedia.org/wiki/Sensitivity_and_specificity</a></p>
@@ -10914,7 +10863,8 @@ <h4>Benchmarking performance for SNPs versus indels<a class="headerlink" href="#
 between a “baseline indel” and a “call-set indel” (or “variant-caller-A
 indel” and “variant-caller-B indel”), so caution should be applied when
 making conclusions related to SNP versus indel accuracy.</p>
-<p>In the <code class="docutils literal notranslate"><span class="pre">snp_roc.tsv</span></code> and <code class="docutils literal notranslate"><span class="pre">non_snp_roc.tsv</span></code> output files, <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code>
+<p>In the <code class="docutils literal notranslate"><span class="pre">snp_roc.tsv</span></code> and <code class="docutils literal notranslate"><span class="pre">non_snp_roc.tsv</span></code> output files (and other
+preset stratifications available via <code class="docutils literal notranslate"><span class="pre">--roc-subset</span></code>), <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code>
 notes the number of baseline and call variants of each variant
 type. When considering benchmarking metrics in the absence of any
 thresholding with respect to a score field, it is straight-forward to
@@ -10923,16 +10873,20 @@ <h4>Benchmarking performance for SNPs versus indels<a class="headerlink" href="#
 called variants). When computing threshold-specific metrics for ROC data
 points, the computation is more involved. Since only the call variants
 contain the score field used to rank variants, the number of (say) TP
-baseline indels that exceed threshold <img class="math" src="_images/math/a59f68a4202623bb859a7093f0316bf466e6f75d.png" alt="x"/> is not
+baseline indels that exceed threshold <img class="math" src="_images/math/888f7c323ac0341871e867220ae2d76467d74d6e.png" alt="x"/> is not
 defined. <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> computes a scaled count as:</p>
 <div class="math">
-<p><img src="_images/math/3a8b75e5acf08db588e4dceb7fb37bd6e45954e5.png" alt="\text{TP}_\text{baseline\_indel}(x) = \text{TP}_\text{call\_indel}(x) \times \text{TP}_\text{baseline\_indel} / \text{TP}_\text{call\_indel}"/></p>
+<p><img src="_images/math/b81c7a12342c0ee157b2c3f1bcfc4f91642187dc.png" alt="\text{TP}_\text{baseline\_indel}(x) = \text{TP}_\text{call\_indel}(x) \times \text{TP}_\text{baseline\_indel} / \text{TP}_\text{call\_indel}"/></p>
 </div><p>and thus threshold-specific sensitivity is computed as</p>
 <div class="math">
-<p><img src="_images/math/5163a30eacf7ec6ef0a4bacd6f37adc97e59a22e.png" alt="\text{Sensitivity}_\text{indel}(x) = \text{TP}_\text{baseline\_indel}(x) / (\text{TP}_\text{baseline\_indel} + \text{FN}_\text{indel})"/></p>
+<p><img src="_images/math/f13fefe97363643ae6879e8f163616d0cf50ab3f.png" alt="\text{Sensitivity}_\text{indel}(x) = \text{TP}_\text{baseline\_indel}(x) / (\text{TP}_\text{baseline\_indel} + \text{FN}_\text{indel})"/></p>
 </div><p>This scaling ensures that the end point of the variant type specific ROC
 or precision/sensitivity curve ends at the same point that is obtained
 when computing metrics without any threshold.</p>
+<p>The scaling described above is applied to all of the preset
+stratifications available via <code class="docutils literal notranslate"><span class="pre">--roc-subset</span></code>, but is not applied to
+any custom stratifications produced via <code class="docutils literal notranslate"><span class="pre">--roc-regions</span></code> or
+<code class="docutils literal notranslate"><span class="pre">--roc-expr</span></code>.</p>
 </div>
 <div class="section" id="variant-decomposition-and-benchmarking">
 <h4>Variant decomposition and benchmarking<a class="headerlink" href="#variant-decomposition-and-benchmarking" title="Permalink to this headline">¶</a></h4>
@@ -10949,12 +10903,13 @@ <h4>Variant decomposition and benchmarking<a class="headerlink" href="#variant-d
 representation. External VCF decomposition (with more control over
 decomposition options) is also available via <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">vcfdecompose</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#popsim"><span class="std std-ref">popsim</span></a>,
 <a class="reference internal" href="#samplesim"><span class="std std-ref">samplesim</span></a>,
 <a class="reference internal" href="#childsim"><span class="std std-ref">childsim</span></a>,
 <a class="reference internal" href="#rocplot"><span class="std std-ref">rocplot</span></a>,
+<a class="reference internal" href="#vcf2rocplot"><span class="std std-ref">vcf2rocplot</span></a>,
 <a class="reference internal" href="#vcfdecompose"><span class="std std-ref">vcfdecompose</span></a></p>
 </div>
 </div>
@@ -10978,251 +10933,251 @@ <h3>vcffilter<a class="headerlink" href="#vcffilter" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="17%" />
-<col width="79%" />
+<col style="width: 4%" />
+<col style="width: 17%" />
+<col style="width: 79%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--all-samples</span></code></td>
-<td>Apply sample-specific criteria to all samples contained in the input VCF.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all-samples</span></code></p></td>
+<td><p>Apply sample-specific criteria to all samples contained in the input VCF.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read VCF records that overlap the ranges contained in the specified BED file.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read VCF records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>VCF file containing variants to be filtered. Use ‘-‘ to read from standard input.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>VCF file containing variants to be filtered. Use ‘-‘ to read from standard input.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output VCF file. Use ‘-‘ to write to standard output. This option is required, unless <code class="docutils literal notranslate"><span class="pre">--javascript</span></code> is being used.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output VCF file. Use ‘-‘ to write to standard output. This option is required, unless <code class="docutils literal notranslate"><span class="pre">--javascript</span></code> is being used.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
-&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
+&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></td>
-<td>Apply sample-specific criteria to the named sample contained in the input VCF. May be specified 0 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=STRING</span></code></p></td>
+<td><p>Apply sample-specific criteria to the named sample contained in the input VCF. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="18%" />
-<col width="78%" />
+<col style="width: 4%" />
+<col style="width: 18%" />
+<col style="width: 78%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering (Record based)</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering (Record based)</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-w</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--density-window=INT</span></code></td>
-<td>Window within which multiple variants are discarded.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-w</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--density-window=INT</span></code></p></td>
+<td><p>Window within which multiple variants are discarded.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-bed=FILE</span></code></td>
-<td>Discard all variants within the regions in this BED file.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-bed=FILE</span></code></p></td>
+<td><p>Discard all variants within the regions in this BED file.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--exclude-vcf=FILE</span></code></td>
-<td>Discard all variants that overlap with the ones in this file.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--exclude-vcf=FILE</span></code></p></td>
+<td><p>Discard all variants that overlap with the ones in this file.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--include-bed=FILE</span></code></td>
-<td>Only keep variants within the regions in this BED file.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--include-bed=FILE</span></code></p></td>
+<td><p>Only keep variants within the regions in this BED file.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--include-vcf=FILE</span></code></td>
-<td>Only keep variants that overlap with the ones in this file.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--include-vcf=FILE</span></code></p></td>
+<td><p>Only keep variants that overlap with the ones in this file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-j</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--javascript=STRING</span></code></td>
-<td>Javascript filtering functions for determining whether to keep record. May be either an expression or a file name. May be specified 0 or more times.
-<a class="reference internal" href="#javascript-examples"><span class="std std-ref">See Examples</span></a></td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-j</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--javascript=STRING</span></code></p></td>
+<td><p>Javascript filtering functions for determining whether to keep record. May be either an expression or a file name. May be specified 0 or more times.
+<a class="reference internal" href="#javascript-examples"><span class="std std-ref">See Examples</span></a></p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-e</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-expr=STRING</span></code></td>
-<td>Records for which this expression evaluates to true will be retained.
-<a class="reference internal" href="#javascript-examples"><span class="std std-ref">See Examples</span></a></td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-e</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-expr=STRING</span></code></p></td>
+<td><p>Records for which this expression evaluates to true will be retained.
+<a class="reference internal" href="#javascript-examples"><span class="std std-ref">See Examples</span></a></p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-k</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-filter=STRING</span></code></td>
-<td>Only keep variants with this FILTER tag. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-k</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-filter=STRING</span></code></p></td>
+<td><p>Only keep variants with this FILTER tag. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-K</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-info=STRING</span></code></td>
-<td>Only keep variants with this INFO tag. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-K</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-info=STRING</span></code></p></td>
+<td><p>Only keep variants with this INFO tag. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-alleles=INT</span></code></td>
-<td>Maximum number of alleles (REF included)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-alleles=INT</span></code></p></td>
+<td><p>Maximum number of alleles (REF included)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-C</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-combined-read-depth=INT</span></code></td>
-<td>Maximum allowed combined read depth.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-C</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-combined-read-depth=INT</span></code></p></td>
+<td><p>Maximum allowed combined read depth.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-quality=FLOAT</span></code></td>
-<td>Maximum allowed quality.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-quality=FLOAT</span></code></p></td>
+<td><p>Maximum allowed quality.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-alleles=INT</span></code></td>
-<td>Minimum number of alleles (REF included)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-alleles=INT</span></code></p></td>
+<td><p>Minimum number of alleles (REF included)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-combined-read-depth=INT</span></code></td>
-<td>Minimum allowed combined read depth.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-combined-read-depth=INT</span></code></p></td>
+<td><p>Minimum allowed combined read depth.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-q</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-quality=FLOAT</span></code></td>
-<td>Minimum allowed quality.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-q</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-quality=FLOAT</span></code></p></td>
+<td><p>Minimum allowed quality.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-filter=STRING</span></code></td>
-<td>Remove variants with this FILTER tag. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-filter=STRING</span></code></p></td>
+<td><p>Remove variants with this FILTER tag. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-R</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-info=STRING</span></code></td>
-<td>Remove variants with this INFO tag. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-R</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-info=STRING</span></code></p></td>
+<td><p>Remove variants with this INFO tag. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-overlapping</span></code></td>
-<td>Remove records that overlap with previous records.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-overlapping</span></code></p></td>
+<td><p>Remove records that overlap with previous records.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="28%" />
-<col width="66%" />
+<col style="width: 6%" />
+<col style="width: 28%" />
+<col style="width: 66%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering (Sample based)</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering (Sample based)</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-A</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-ambiguity-ratio=FLOAT</span></code></td>
-<td>Maximum allowed ambiguity ratio.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-A</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-ambiguity-ratio=FLOAT</span></code></p></td>
+<td><p>Maximum allowed ambiguity ratio.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-avr-score=FLOAT</span></code></td>
-<td>Maximum allowed AVR score.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-avr-score=FLOAT</span></code></p></td>
+<td><p>Maximum allowed AVR score.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-denovo-score=FLOAT</span></code></td>
-<td>Maximum de novo score threshold.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-denovo-score=FLOAT</span></code></p></td>
+<td><p>Maximum de novo score threshold.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-G</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-genotype-quality=FLOAT</span></code></td>
-<td>Maximum allowed genotype quality.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-G</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-genotype-quality=FLOAT</span></code></p></td>
+<td><p>Maximum allowed genotype quality.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-D</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-read-depth=INT</span></code></td>
-<td>Maximum allowed sample read depth.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-D</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-read-depth=INT</span></code></p></td>
+<td><p>Maximum allowed sample read depth.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></td>
-<td>Minimum allowed AVR score.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-avr-score=FLOAT</span></code></p></td>
+<td><p>Minimum allowed AVR score.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-denovo-score=FLOAT</span></code></td>
-<td>Minimum de novo score threshold.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-denovo-score=FLOAT</span></code></p></td>
+<td><p>Minimum de novo score threshold.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-g</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-genotype-quality=FLOAT</span></code></td>
-<td>Minimum allowed genotype quality.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-g</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-genotype-quality=FLOAT</span></code></p></td>
+<td><p>Minimum allowed genotype quality.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-d</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--min-read-depth=INT</span></code></td>
-<td>Minimum allowed sample read depth.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-d</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--min-read-depth=INT</span></code></p></td>
+<td><p>Minimum allowed sample read depth.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--non-snps-only</span></code></td>
-<td>Only keep where sample variant is MNP or INDEL.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--non-snps-only</span></code></p></td>
+<td><p>Only keep where sample variant is MNP or INDEL.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-all-same-as-ref</span></code></td>
-<td>Remove where all samples are same as reference.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-all-same-as-ref</span></code></p></td>
+<td><p>Remove where all samples are same as reference.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-hom</span></code></td>
-<td>Remove where sample is homozygous.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-hom</span></code></p></td>
+<td><p>Remove where sample is homozygous.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-same-as-ref</span></code></td>
-<td>Remove where sample is same as reference.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-same-as-ref</span></code></p></td>
+<td><p>Remove where sample is same as reference.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></td>
-<td>Only keep where sample variant is a simple SNP.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--snps-only</span></code></p></td>
+<td><p>Only keep where sample variant is a simple SNP.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="28%" />
-<col width="66%" />
+<col style="width: 6%" />
+<col style="width: 28%" />
+<col style="width: 66%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--clear-failed-samples</span></code></td>
-<td>Retain failed records, set the sample GT field to missing.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--clear-failed-samples</span></code></p></td>
+<td><p>Retain failed records, set the sample GT field to missing.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--fail=STRING</span></code></td>
-<td>Retain failed records, add the provided label to the FILTER field.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--fail=STRING</span></code></p></td>
+<td><p>Retain failed records, add the provided label to the FILTER field.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-F</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--fail-samples=STRING</span></code></td>
-<td>Retain failed records, add the provided label to the sample FT field.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-F</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--fail-samples=STRING</span></code></p></td>
+<td><p>Retain failed records, add the provided label to the sample FT field.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="24%" />
-<col width="70%" />
+<col style="width: 6%" />
+<col style="width: 24%" />
+<col style="width: 70%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--add-header=STRING|FILE</span></code></td>
-<td>File containing VCF header lines to add, or a literal header line. May be specified 0 or more times.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--add-header=STRING|FILE</span></code></p></td>
+<td><p>File containing VCF header lines to add, or a literal header line. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></td>
-<td>Prevent VCF header from being written.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></p></td>
+<td><p>Prevent VCF header from being written.</p></td>
 </tr>
 </tbody>
 </table>
@@ -11263,8 +11218,8 @@ <h3>vcffilter<a class="headerlink" href="#vcffilter" title="Permalink to this he
 applied before <code class="docutils literal notranslate"><span class="pre">--javascript</span></code>, so the <code class="docutils literal notranslate"><span class="pre">--javascript</span></code> record
 function will not be called for records filtered out by <code class="docutils literal notranslate"><span class="pre">--keep-expr</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last">For full details of functions available in <code class="docutils literal notranslate"><span class="pre">--keep-expr</span></code> and <code class="docutils literal notranslate"><span class="pre">--javascript</span></code> see <a class="reference internal" href="appendix.html#rtg-javascript-filtering-api"><span class="std std-ref">RTG JavaScript filtering API</span></a></p>
+<p class="admonition-title">See also</p>
+<p>For full details of functions available in <code class="docutils literal notranslate"><span class="pre">--keep-expr</span></code> and <code class="docutils literal notranslate"><span class="pre">--javascript</span></code> see <a class="reference internal" href="appendix.html#rtg-javascript-filtering-api"><span class="std std-ref">RTG JavaScript filtering API</span></a></p>
 </div>
 <div class="section" id="simple-filtering-by-javascript-expression-with-keep-expr">
 <h4>Simple filtering by JavaScript expression with <code class="docutils literal notranslate"><span class="pre">--keep-expr</span></code><a class="headerlink" href="#simple-filtering-by-javascript-expression-with-keep-expr" title="Permalink to this headline">¶</a></h4>
@@ -11331,22 +11286,22 @@ <h4>Simple filtering by JavaScript expression with <code class="docutils literal
 <div class="section" id="advanced-javascript-filtering-with-javascript">
 <h4>Advanced JavaScript filtering with <code class="docutils literal notranslate"><span class="pre">--javascript</span></code><a class="headerlink" href="#advanced-javascript-filtering-with-javascript" title="Permalink to this headline">¶</a></h4>
 <p>The <code class="docutils literal notranslate"><span class="pre">--javascript</span></code> option aims to support more complicated processing
-than <code class="docutils literal notranslate"><span class="pre">--keep-expr</span></code>. permitting modification of the output VCF, or
+than <code class="docutils literal notranslate"><span class="pre">--keep-expr</span></code>, permitting modification of the output VCF, or
 supporting use cases where the script is tasked to compute and output
 alternative information in addition to (or instead of) the output VCF.
 The scripts specified by the user are evaluated once at the start of
 processing. Two special functions may be defined in a <code class="docutils literal notranslate"><span class="pre">--javascript</span></code>
 script, which will then be executed in different contexts:</p>
 <ul class="simple">
-<li>A function with the name <code class="docutils literal notranslate"><span class="pre">record</span></code> will be executed once for each VCF
+<li><p>A function with the name <code class="docutils literal notranslate"><span class="pre">record</span></code> will be executed once for each VCF
 record. If the <code class="docutils literal notranslate"><span class="pre">record</span></code> function has a return value it must have type
 boolean. Records which evaluate to <code class="docutils literal notranslate"><span class="pre">true</span></code> will be retained, while
 <code class="docutils literal notranslate"><span class="pre">false</span></code> will be removed. If the record function has no return value
 then the record will be retained. The <code class="docutils literal notranslate"><span class="pre">record</span></code> function is applied
-after any <code class="docutils literal notranslate"><span class="pre">--keep-expr</span></code> expression.</li>
-<li>A function with the name <code class="docutils literal notranslate"><span class="pre">end</span></code> will be called once at the end of
+after any <code class="docutils literal notranslate"><span class="pre">--keep-expr</span></code> expression.</p></li>
+<li><p>A function with the name <code class="docutils literal notranslate"><span class="pre">end</span></code> will be called once at the end of
 processing. This allows reporting of summary statistics collected
-during the filter process.</li>
+during the filter process.</p></li>
 </ul>
 <p>This <code class="docutils literal notranslate"><span class="pre">--javascript</span></code> flag may be specified multiple times, they will be
 evaluated in order, in a shared JavaScript namespace, before VCF
@@ -11449,8 +11404,12 @@ <h4>Advanced JavaScript filtering with <code class="docutils literal notranslate
 </pre></div>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p>For full details of functions available in <code class="docutils literal notranslate"><span class="pre">--keep-expr</span></code> and <code class="docutils literal notranslate"><span class="pre">--javascript</span></code> see <a class="reference internal" href="appendix.html#rtg-javascript-filtering-api"><span class="std std-ref">RTG JavaScript filtering API</span></a></p>
+</div>
+<div class="admonition seealso">
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#somatic"><span class="std std-ref">somatic</span></a>,
 <a class="reference internal" href="#population"><span class="std std-ref">population</span></a>,
@@ -11477,90 +11436,90 @@ <h3>vcfmerge<a class="headerlink" href="#vcfmerge" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="15%" />
-<col width="81%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read VCF records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read VCF records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-I</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></td>
-<td>File containing a list of VCF format files (1 per line) to be merged.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-I</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input-list-file=FILE</span></code></p></td>
+<td><p>File containing a list of VCF format files (1 per line) to be merged.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output VCF file. Use ‘-‘ to write to standard output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output VCF file. Use ‘-‘ to write to standard output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
-&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
+&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>Input VCF files to merge. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>Input VCF files to merge. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="17%" />
-<col width="79%" />
+<col style="width: 4%" />
+<col style="width: 17%" />
+<col style="width: 79%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-a</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--add-header=STRING|FILE</span></code></td>
-<td>File containing VCF header lines to add, or a literal header line. May be specified 0 or more times.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-a</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--add-header=STRING|FILE</span></code></p></td>
+<td><p>File containing VCF header lines to add, or a literal header line. May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--force-merge=STRING</span></code></td>
-<td>Allow merging of specified header ID even when descriptions do not match. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--force-merge=STRING</span></code></p></td>
+<td><p>Allow merging of specified header ID even when descriptions do not match. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-F</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--force-merge-all</span></code></td>
-<td>Attempt merging of all non-matching header declarations.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-F</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--force-merge-all</span></code></p></td>
+<td><p>Attempt merging of all non-matching header declarations.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></td>
-<td>Prevent VCF header from being written.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></p></td>
+<td><p>Prevent VCF header from being written.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-merge-alts</span></code></td>
-<td>Do not merge multiple records if the ALTs are different.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-merge-alts</span></code></p></td>
+<td><p>Do not merge multiple records if the ALTs are different.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-merge-records</span></code></td>
-<td>Do not merge multiple records at the same position into one.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-merge-records</span></code></p></td>
+<td><p>Do not merge multiple records at the same position into one.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--preserve-formats</span></code></td>
-<td>Do not merge multiple records containing unmergeable FORMAT fields (Default is to remove those FORMAT fields so the variants can be combined)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--preserve-formats</span></code></p></td>
+<td><p>Do not merge multiple records containing unmergeable FORMAT fields (Default is to remove those FORMAT fields so the variants can be combined)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--stats</span></code></td>
-<td>Output statistics for the merged VCF file.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--stats</span></code></p></td>
+<td><p>Output statistics for the merged VCF file.</p></td>
 </tr>
 </tbody>
 </table>
@@ -11611,8 +11570,8 @@ <h4>Merging records at the same position<a class="headerlink" href="#merging-rec
 merging as long as the records do not contain problematic <code class="docutils literal notranslate"><span class="pre">A</span></code>, <code class="docutils literal notranslate"><span class="pre">G</span></code>,
 or <code class="docutils literal notranslate"><span class="pre">R</span></code> annotations, or contain the same sample.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#population"><span class="std std-ref">population</span></a>,
 <a class="reference internal" href="#somatic"><span class="std std-ref">somatic</span></a>,
@@ -11638,79 +11597,79 @@ <h3>vcfsplit<a class="headerlink" href="#vcfsplit" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="16%" />
-<col width="80%" />
+<col style="width: 4%" />
+<col style="width: 16%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read VCF records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read VCF records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>The input VCF, or ‘-‘ to read from standard input.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>The input VCF, or ‘-‘ to read from standard input.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
-&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
+&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="19%" />
-<col width="76%" />
+<col style="width: 5%" />
+<col style="width: 19%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-ref</span></code></td>
-<td>Keep records where the sample is reference.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-ref</span></code></p></td>
+<td><p>Keep records where the sample is reference.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-sample=STRING|FILE</span></code></td>
-<td>File containing sample IDs to select, or a literal sample name. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-sample=STRING|FILE</span></code></p></td>
+<td><p>File containing sample IDs to select, or a literal sample name. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-sample=STRING|FILE</span></code></td>
-<td>File containing sample IDs to ignore, or a literal sample name. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-sample=STRING|FILE</span></code></p></td>
+<td><p>File containing sample IDs to ignore, or a literal sample name. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="27%" />
-<col width="67%" />
+<col style="width: 7%" />
+<col style="width: 27%" />
+<col style="width: 67%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
 </tbody>
 </table>
@@ -11725,8 +11684,8 @@ <h3>vcfsplit<a class="headerlink" href="#vcfsplit" title="Permalink to this head
 where the sample has a non-reference genotype will be output, unless
 <code class="docutils literal notranslate"><span class="pre">--keep-ref</span></code> is used.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#vcfsubset"><span class="std std-ref">vcfsubset</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#vcfsubset"><span class="std std-ref">vcfsubset</span></a></p>
 </div>
 </div>
 <div class="section" id="vcfstats">
@@ -11761,66 +11720,66 @@ <h3>vcfstats<a class="headerlink" href="#vcfstats" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="3%" />
-<col width="13%" />
-<col width="84%" />
+<col style="width: 3%" />
+<col style="width: 13%" />
+<col style="width: 84%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--known</span></code></td>
-<td>Set to only calculate statistics for known variants.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--known</span></code></p></td>
+<td><p>Set to only calculate statistics for known variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--novel</span></code></td>
-<td>Set to only calculate statistics for novel variants.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--novel</span></code></p></td>
+<td><p>Set to only calculate statistics for novel variants.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--sample=FILE</span></code></td>
-<td>Set to only calculate statistics for the specified sample. (Default is to include all samples). May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sample=FILE</span></code></p></td>
+<td><p>Set to only calculate statistics for the specified sample. (Default is to include all samples). May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td>FILE+</td>
-<td>VCF file from which to derive statistics. Use ‘-‘ to read from standard input. Must be specified 1 or more times.</td>
+<tr class="row-odd"><td></td>
+<td><p>FILE+</p></td>
+<td><p>VCF file from which to derive statistics. Use ‘-‘ to read from standard input. Must be specified 1 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="34%" />
-<col width="61%" />
+<col style="width: 6%" />
+<col style="width: 34%" />
+<col style="width: 61%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--allele-lengths</span></code></td>
-<td>Set to output variant length histogram.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--allele-lengths</span></code></p></td>
+<td><p>Set to output variant length histogram.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -11866,8 +11825,8 @@ <h3>vcfstats<a class="headerlink" href="#vcfstats" title="Permalink to this head
 length of an indel is taken as the change in length rather than the
 overall length.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#somatic"><span class="std std-ref">somatic</span></a>,
 <a class="reference internal" href="#vcffilter"><span class="std std-ref">vcffilter</span></a>,
@@ -11888,123 +11847,123 @@ <h3>vcfsubset<a class="headerlink" href="#vcfsubset" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="16%" />
-<col width="80%" />
+<col style="width: 4%" />
+<col style="width: 16%" />
+<col style="width: 80%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read VCF records that overlap the ranges contained in the specified BED file.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read VCF records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>VCF file containing variants to manipulate. Use ‘-‘ to read from standard input.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>VCF file containing variants to manipulate. Use ‘-‘ to read from standard input.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output VCF file. Use ‘-‘ to write to standard output.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output VCF file. Use ‘-‘ to write to standard output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
-&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
+&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="19%" />
-<col width="76%" />
+<col style="width: 5%" />
+<col style="width: 19%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-filter=STRING</span></code></td>
-<td>Keep the specified FILTER tag. May be specified 0 or more times, or as a comma separated list.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-filter=STRING</span></code></p></td>
+<td><p>Keep the specified FILTER tag. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-format=STRING</span></code></td>
-<td>Keep the specified FORMAT field. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-format=STRING</span></code></p></td>
+<td><p>Keep the specified FORMAT field. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-info=STRING</span></code></td>
-<td>Keep the specified INFO tag. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-info=STRING</span></code></p></td>
+<td><p>Keep the specified INFO tag. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-sample=STRING|FILE</span></code></td>
-<td>File containing sample IDs to keep, or a literal sample name. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-sample=STRING|FILE</span></code></p></td>
+<td><p>File containing sample IDs to keep, or a literal sample name. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-filter=STRING</span></code></td>
-<td>Remove the specified FILTER tag. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-filter=STRING</span></code></p></td>
+<td><p>Remove the specified FILTER tag. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-filters</span></code></td>
-<td>Remove all FILTER tags.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-filters</span></code></p></td>
+<td><p>Remove all FILTER tags.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-format=STRING</span></code></td>
-<td>Remove the specified FORMAT field. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-format=STRING</span></code></p></td>
+<td><p>Remove the specified FORMAT field. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-ids</span></code></td>
-<td>Remove the contents of the ID field.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-ids</span></code></p></td>
+<td><p>Remove the contents of the ID field.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-info=STRING</span></code></td>
-<td>Remove the specified INFO tag. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-info=STRING</span></code></p></td>
+<td><p>Remove the specified INFO tag. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-infos</span></code></td>
-<td>Remove all INFO tags.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-infos</span></code></p></td>
+<td><p>Remove all INFO tags.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-qual</span></code></td>
-<td>Remove the QUAL field.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-qual</span></code></p></td>
+<td><p>Remove the QUAL field.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-sample=STRING|FILE</span></code></td>
-<td>File containing sample IDs to remove, or a literal sample name. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-sample=STRING|FILE</span></code></p></td>
+<td><p>File containing sample IDs to remove, or a literal sample name. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-samples</span></code></td>
-<td>Remove all samples.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-samples</span></code></p></td>
+<td><p>Remove all samples.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="24%" />
-<col width="69%" />
+<col style="width: 7%" />
+<col style="width: 24%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></td>
-<td>Prevent VCF header from being written.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></p></td>
+<td><p>Prevent VCF header from being written.</p></td>
 </tr>
 </tbody>
 </table>
@@ -12017,8 +11976,8 @@ <h3>vcfsubset<a class="headerlink" href="#vcfsubset" title="Permalink to this he
 specified multiple times or with comma separated lists, for example,
 <code class="docutils literal notranslate"><span class="pre">--keep-format</span> <span class="pre">GT</span> <span class="pre">--keep-format</span> <span class="pre">DP</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">–keep-format</span> <span class="pre">GT,DP</span></code>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#somatic"><span class="std std-ref">somatic</span></a>,
 <a class="reference internal" href="#population"><span class="std std-ref">population</span></a>,
@@ -12026,6 +11985,158 @@ <h3>vcfsubset<a class="headerlink" href="#vcfsubset" title="Permalink to this he
 <a class="reference internal" href="#vcfannotate"><span class="std std-ref">vcfannotate</span></a></p>
 </div>
 </div>
+<div class="section" id="vcf2rocplot">
+<h3>vcf2rocplot<a class="headerlink" href="#vcf2rocplot" title="Permalink to this headline">¶</a></h3>
+<p><strong>Synopsis:</strong></p>
+<p>Produce rocplot compatible ROC data files from vcfeval annotated
+VCFs. The primary use cases for this command are to produce aggregate
+ROCs from several independent <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> evaluation runs, and to
+generate ROCs with respect to different criteria than were used during
+the initial <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> evaluation.</p>
+<p><strong>Syntax:</strong></p>
+<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>$ rtg vcf2rocplot [OPTION]... -o DIR FILE+
+</pre></div>
+</div>
+<p>Create an aggregate ROC from evaluations of several independent samples:</p>
+<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>$ rtg vcfeval -b goldstandard.vcf.gz -c snps.vcf.gz -t HUMAN_reference \
+  --sample daughter1 -f AVR -o eval -m annotate
+$ rtg vcfeval -b goldstandard.vcf.gz -c snps.vcf.gz -t HUMAN_reference \
+  --sample daughter2 -f AVR -o eval -m annotate
+$ rtg vcfeval -b goldstandard.vcf.gz -c snps.vcf.gz -t HUMAN_reference \
+  --sample son2 -f AVR -o eval -m annotate
+$ rtg vcf2rocplot -o eval_family -f AVR \
+  eval_{daughter1,daughter2,son1}/{baseline,calls}.vcf.gz
+$ rtg rocplot eval_family/weighted_roc.tsv.gz \
+  --png eval_family_roc.png
+</pre></div>
+</div>
+<p><strong>Parameters:</strong></p>
+<table class="docutils align-default">
+<colgroup>
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
+</colgroup>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
+</tr>
+</thead>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read VCF records that overlap the ranges contained in the specified BED file.</p></td>
+</tr>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
+</tr>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
+&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
+</tr>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>Input VCF files containing vcfeval annotations. Must be specified 1 or more times.</p></td>
+</tr>
+</tbody>
+</table>
+<table class="docutils align-default">
+<colgroup>
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
+</colgroup>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
+</tr>
+</thead>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--at-precision=FLOAT</span></code></p></td>
+<td><p>Output summary statistics where precision &gt;= supplied value (Default is to summarize at maximum F-measure)</p></td>
+</tr>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--at-sensitivity=FLOAT</span></code></p></td>
+<td><p>Output summary statistics where sensitivity &gt;= supplied value (Default is to summarize at maximum F-measure)</p></td>
+</tr>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--roc-expr=STRING</span></code></p></td>
+<td><p>Output ROC file for variants matching custom JavaScript expression. Use the form &lt;LABEL&gt;=&lt;EXPRESSION&gt;. May be specified 0 or more times.</p></td>
+</tr>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--roc-regions=STRING</span></code></p></td>
+<td><p>Output ROC file for variants overlapping custom regions supplied in BED file. Use the form &lt;LABEL&gt;=&lt;FILENAME&gt;. May be specified 0 or more times.</p></td>
+</tr>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--roc-subset=STRING</span></code></p></td>
+<td><p>Output ROC file for preset variant subset. Allowed values are [hom, het, snp, non-snp, mnp, indel]. May be specified 0 or more times, or as a comma separated
+list.</p></td>
+</tr>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-O</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sort-order=STRING</span></code></p></td>
+<td><p>The order in which to sort the ROC scores so that <code class="docutils literal notranslate"><span class="pre">good</span></code> scores come before <code class="docutils literal notranslate"><span class="pre">bad</span></code> scores. Allowed values are [ascending, descending] (Default is descending)</p></td>
+</tr>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--vcf-score-field=STRING</span></code></p></td>
+<td><p>The name of the VCF FORMAT field to use as the ROC score. Also valid are <code class="docutils literal notranslate"><span class="pre">QUAL</span></code>, <code class="docutils literal notranslate"><span class="pre">INFO.&lt;name&gt;</span></code> or <code class="docutils literal notranslate"><span class="pre">FORMAT.&lt;name&gt;</span></code> to select the named VCF FORMAT or INFO
+field (Default is GQ)</p></td>
+</tr>
+</tbody>
+</table>
+<table class="docutils align-default">
+<colgroup>
+<col style="width: 7%" />
+<col style="width: 25%" />
+<col style="width: 68%" />
+</colgroup>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
+</tr>
+</thead>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
+</tr>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
+</tr>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
+</tr>
+</tbody>
+</table>
+<p><strong>Usage:</strong></p>
+<p>While the ROC outputs generated by <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> are sufficient for many
+scenarios, there are some situations where it is useful to regenerate
+ROC files from one or more existing vcfeval outputs.</p>
+<p>One such situation is when evaluating caller accuracy across a cohort of
+samples where the number of variants per individual sample is
+low. Individual sample ROC curves are fairly uninformative with regard
+to overall accuracy or where to place suitable filter thresholds. An ROC
+curve from the combined evaluations provides a much better indication of
+overall caller accuracy.</p>
+<p>Another use case for generating ROC files from an existing <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code>
+run is to look at alternative scoring methods or stratifications without
+having to execute the time-consuming variant matching stage implied by a
+new <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> run.</p>
+<p>The prerequisite for using <code class="docutils literal notranslate"><span class="pre">vcf2rocplot</span></code> is that <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code> must
+have been run in “annotation” mode (i.e. via <code class="docutils literal notranslate"><span class="pre">--output-mode=annotate</span></code>)
+so that the output VCF files contain sufficient annotations regarding
+variant classification status. It is important that <code class="docutils literal notranslate"><span class="pre">vcf2rocplot</span></code> be
+provided with both annotated baseline and call VCFs in order to produce
+correct outputs.</p>
+<p>The operation of the various score field selection and ROC
+stratification flags works the same as when running <code class="docutils literal notranslate"><span class="pre">vcfeval</span></code>.</p>
+<div class="admonition seealso">
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#rocplot"><span class="std std-ref">rocplot</span></a>,
+<a class="reference internal" href="#vcfeval"><span class="std std-ref">vcfeval</span></a></p>
+</div>
+</div>
 <div class="section" id="svdecompose">
 <h3>svdecompose<a class="headerlink" href="#svdecompose" title="Permalink to this headline">¶</a></h3>
 <p><strong>Synopsis:</strong></p>
@@ -12035,49 +12146,49 @@ <h3>svdecompose<a class="headerlink" href="#svdecompose" title="Permalink to thi
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="17%" />
-<col width="75%" />
+<col style="width: 7%" />
+<col style="width: 17%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>VCF file containing variants to filter. Use ‘-‘ to read from standard input.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>VCF file containing variants to filter. Use ‘-‘ to read from standard input.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Output VCF file name. Use ‘-‘ to write to standard output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Output VCF file name. Use ‘-‘ to write to standard output.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="17%" />
-<col width="75%" />
+<col style="width: 7%" />
+<col style="width: 17%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></td>
-<td>Prevent VCF header from being written.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-header</span></code></p></td>
+<td><p>Prevent VCF header from being written.</p></td>
 </tr>
 </tbody>
 </table>
@@ -12114,8 +12225,8 @@ <h3>svdecompose<a class="headerlink" href="#svdecompose" title="Permalink to thi
 </pre></div>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#bndeval"><span class="std std-ref">bndeval</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#bndeval"><span class="std std-ref">bndeval</span></a></p>
 </div>
 </div>
 <div class="section" id="bndeval">
@@ -12132,113 +12243,113 @@ <h3>bndeval<a class="headerlink" href="#bndeval" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="15%" />
-<col width="81%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-b</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--baseline=FILE</span></code></td>
-<td>VCF file containing baseline variants.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-b</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--baseline=FILE</span></code></p></td>
+<td><p>VCF file containing baseline variants.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></td>
-<td>If set, only read VCF records that overlap the ranges contained in the specified BED file.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bed-regions=FILE</span></code></p></td>
+<td><p>If set, only read VCF records that overlap the ranges contained in the specified BED file.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-c</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--calls=FILE</span></code></td>
-<td>VCF file containing called variants.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-c</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--calls=FILE</span></code></p></td>
+<td><p>VCF file containing called variants.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></td>
-<td>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
-&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--region=REGION</span></code></p></td>
+<td><p>If set, only read VCF records within the specified range. The format is one of &lt;sequence_name&gt;, &lt;sequence_name&gt;:&lt;start&gt;-&lt;end&gt;, &lt;sequence_name&gt;:&lt;pos&gt;+&lt;length&gt; or
+&lt;sequence_name&gt;:&lt;pos&gt;~&lt;padding&gt;</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="19%" />
-<col width="75%" />
+<col style="width: 5%" />
+<col style="width: 19%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--all-records</span></code></td>
-<td>Use all records regardless of FILTER status (Default is to only process records where FILTER is “.” or “PASS”)</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--all-records</span></code></p></td>
+<td><p>Use all records regardless of FILTER status (Default is to only process records where FILTER is “.” or “PASS”)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--bidirectional</span></code></td>
-<td>If set, allow matches between flipped breakends.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--bidirectional</span></code></p></td>
+<td><p>If set, allow matches between flipped breakends.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--tolerance=INT</span></code></td>
-<td>Positional tolerance for breakend matching (Default is 100)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--tolerance=INT</span></code></p></td>
+<td><p>Positional tolerance for breakend matching (Default is 100)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="15%" />
-<col width="81%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-roc</span></code></td>
-<td>Do not produce ROCs.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-roc</span></code></p></td>
+<td><p>Do not produce ROCs.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-m</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output-mode=STRING</span></code></td>
-<td>Output reporting mode. Allowed values are [split, annotate] (Default is split)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-m</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output-mode=STRING</span></code></p></td>
+<td><p>Output reporting mode. Allowed values are [split, annotate] (Default is split)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-O</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--sort-order=STRING</span></code></td>
-<td>The order in which to sort the ROC scores so that <code class="docutils literal notranslate"><span class="pre">good</span></code> scores come before <code class="docutils literal notranslate"><span class="pre">bad</span></code> scores. Allowed values are [ascending, descending] (Default is descending)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-O</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--sort-order=STRING</span></code></p></td>
+<td><p>The order in which to sort the ROC scores so that <code class="docutils literal notranslate"><span class="pre">good</span></code> scores come before <code class="docutils literal notranslate"><span class="pre">bad</span></code> scores. Allowed values are [ascending, descending] (Default is descending)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-f</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--vcf-score-field=STRING</span></code></td>
-<td>The name of the VCF FORMAT field to use as the ROC score. Also valid are <code class="docutils literal notranslate"><span class="pre">QUAL</span></code>, <code class="docutils literal notranslate"><span class="pre">INFO.&lt;name&gt;</span></code> or <code class="docutils literal notranslate"><span class="pre">FORMAT.&lt;name&gt;</span></code> to select the named VCF FORMAT or INFO
-field (Default is INFO.DP)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-f</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--vcf-score-field=STRING</span></code></p></td>
+<td><p>The name of the VCF FORMAT field to use as the ROC score. Also valid are <code class="docutils literal notranslate"><span class="pre">QUAL</span></code>, <code class="docutils literal notranslate"><span class="pre">INFO.&lt;name&gt;</span></code> or <code class="docutils literal notranslate"><span class="pre">FORMAT.&lt;name&gt;</span></code> to select the named VCF FORMAT or INFO
+field (Default is INFO.DP)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="25%" />
-<col width="68%" />
+<col style="width: 7%" />
+<col style="width: 25%" />
+<col style="width: 68%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-Z</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></td>
-<td>Do not gzip the output.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-Z</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--no-gzip</span></code></p></td>
+<td><p>Do not gzip the output.</p></td>
 </tr>
 </tbody>
 </table>
@@ -12276,21 +12387,21 @@ <h4>bndeval outputs<a class="headerlink" href="#bndeval-outputs" title="Permalin
 <p>Once complete, <code class="docutils literal notranslate"><span class="pre">bndeval</span></code> command produces summary statistics and the
 following primary result files in the output directory:</p>
 <ul class="simple">
-<li><code class="docutils literal notranslate"><span class="pre">weighted_roc.tsv.gz</span></code> - contains ROC data that can be plotted
-with <code class="docutils literal notranslate"><span class="pre">rocplot</span></code></li>
-<li><code class="docutils literal notranslate"><span class="pre">baseline.bed.gz</span></code> contains the <em>truth breakend regions</em>, where each BED
+<li><p><code class="docutils literal notranslate"><span class="pre">weighted_roc.tsv.gz</span></code> - contains ROC data that can be plotted
+with <code class="docutils literal notranslate"><span class="pre">rocplot</span></code></p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">baseline.bed.gz</span></code> contains the <em>truth breakend regions</em>, where each BED
 record contains the region status as <code class="docutils literal notranslate"><span class="pre">TP</span></code> or <code class="docutils literal notranslate"><span class="pre">FN</span></code>, the <code class="docutils literal notranslate"><span class="pre">SVTYPE</span></code>,
-and the span of the original truth VCF record.</li>
-<li><code class="docutils literal notranslate"><span class="pre">calls.bed.gz</span></code> contains the <em>called breakend regions</em>, where each BED
+and the span of the original truth VCF record.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">calls.bed.gz</span></code> contains the <em>called breakend regions</em>, where each BED
 record contains the region status as <code class="docutils literal notranslate"><span class="pre">TP</span></code> or <code class="docutils literal notranslate"><span class="pre">FP</span></code>, the <code class="docutils literal notranslate"><span class="pre">SVTYPE</span></code>,
 the span of the original calls VCF record, and the score value used
-for ranking in the ROC plot.</li>
-<li><code class="docutils literal notranslate"><span class="pre">summary.txt</span></code> contains the same summary statistics printed to
-standard output.</li>
+for ranking in the ROC plot.</p></li>
+<li><p><code class="docutils literal notranslate"><span class="pre">summary.txt</span></code> contains the same summary statistics printed to
+standard output.</p></li>
 </ul>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#discord"><span class="std std-ref">discord</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#discord"><span class="std std-ref">discord</span></a>,
 <a class="reference internal" href="#svdecompose"><span class="std std-ref">svdecompose</span></a>,
 <a class="reference internal" href="#vcfeval"><span class="std std-ref">vcfeval</span></a>,
 <a class="reference internal" href="#rocplot"><span class="std std-ref">rocplot</span></a></p>
@@ -12310,83 +12421,83 @@ <h3>pedfilter<a class="headerlink" href="#pedfilter" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="18%" />
-<col width="76%" />
+<col style="width: 6%" />
+<col style="width: 18%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE</span></code></td>
-<td>The pedigree file to process, may be PED or VCF, use ‘-‘ to read from stdin.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE</span></code></p></td>
+<td><p>The pedigree file to process, may be PED or VCF, use ‘-‘ to read from stdin.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="17%" />
-<col width="77%" />
+<col style="width: 5%" />
+<col style="width: 17%" />
+<col style="width: 77%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-family=STRING</span></code></td>
-<td>Keep only individuals with the specified family ID. May be specified 0 or more times, or as a comma separated list.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-family=STRING</span></code></p></td>
+<td><p>Keep only individuals with the specified family ID. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-ids=STRING</span></code></td>
-<td>Keep only individuals with the specified ID. May be specified 0 or more times, or as a comma separated list.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-ids=STRING</span></code></p></td>
+<td><p>Keep only individuals with the specified ID. May be specified 0 or more times, or as a comma separated list.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--keep-primary</span></code></td>
-<td>Keep only primary individuals (those with a PED individual line / VCF sample column)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--keep-primary</span></code></p></td>
+<td><p>Keep only primary individuals (those with a PED individual line / VCF sample column)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-parentage</span></code></td>
-<td>Remove all parent-child relationship information.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-parentage</span></code></p></td>
+<td><p>Remove all parent-child relationship information.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="18%" />
-<col width="76%" />
+<col style="width: 6%" />
+<col style="width: 18%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--vcf</span></code></td>
-<td>Output pedigree in in the form of a VCF header rather than PED.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--vcf</span></code></p></td>
+<td><p>Output pedigree in in the form of a VCF header rather than PED.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="18%" />
-<col width="76%" />
+<col style="width: 6%" />
+<col style="width: 18%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -12401,8 +12512,8 @@ <h3>pedfilter<a class="headerlink" href="#pedfilter" title="Permalink to this he
 <p>This command produces the pedigree output on standard output, which can
 be redirected to a file or another pipeline command as required.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#population"><span class="std std-ref">population</span></a>,
 <a class="reference internal" href="#mendelian"><span class="std std-ref">mendelian</span></a>,
 <a class="reference internal" href="#pedstats"><span class="std std-ref">pedstats</span></a></p>
@@ -12447,90 +12558,90 @@ <h3>pedstats<a class="headerlink" href="#pedstats" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="18%" />
-<col width="75%" />
+<col style="width: 7%" />
+<col style="width: 18%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE</span></code></td>
-<td>The pedigree file to process, may be PED or VCF, use ‘-‘ to read from stdin.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE</span></code></p></td>
+<td><p>The pedigree file to process, may be PED or VCF, use ‘-‘ to read from stdin.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="13%" />
-<col width="82%" />
+<col style="width: 4%" />
+<col style="width: 13%" />
+<col style="width: 82%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-d</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--delimiter=STRING</span></code></td>
-<td>Output id lists using this separator (Default is \n)</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-d</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--delimiter=STRING</span></code></p></td>
+<td><p>Output id lists using this separator (Default is \n)</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--dot=STRING</span></code></td>
-<td>Output pedigree in Graphviz format, using the supplied text as a title.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--dot=STRING</span></code></p></td>
+<td><p>Output pedigree in Graphviz format, using the supplied text as a title.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--families</span></code></td>
-<td>Output information about family structures.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--families</span></code></p></td>
+<td><p>Output information about family structures.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--female-ids</span></code></td>
-<td>Output ids of all females.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--female-ids</span></code></p></td>
+<td><p>Output ids of all females.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--founder-ids</span></code></td>
-<td>Output ids of all founders.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--founder-ids</span></code></p></td>
+<td><p>Output ids of all founders.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--male-ids</span></code></td>
-<td>Output ids of all males.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--male-ids</span></code></p></td>
+<td><p>Output ids of all males.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--maternal-ids</span></code></td>
-<td>Output ids of maternal individuals.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--maternal-ids</span></code></p></td>
+<td><p>Output ids of maternal individuals.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--paternal-ids</span></code></td>
-<td>Output ids of paternal individuals.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--paternal-ids</span></code></p></td>
+<td><p>Output ids of paternal individuals.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--primary-ids</span></code></td>
-<td>Output ids of all primary individuals.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--primary-ids</span></code></p></td>
+<td><p>Output ids of all primary individuals.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--simple-dot</span></code></td>
-<td>When outputting Graphviz format, use a layout that looks less like a traditional pedigree diagram but works better with large complex pedigrees.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--simple-dot</span></code></p></td>
+<td><p>When outputting Graphviz format, use a layout that looks less like a traditional pedigree diagram but works better with large complex pedigrees.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="18%" />
-<col width="75%" />
+<col style="width: 7%" />
+<col style="width: 18%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -12581,14 +12692,14 @@ <h3>pedstats<a class="headerlink" href="#pedstats" title="Permalink to this head
 <p>Would produce the following pedigree directly from the VCF:</p>
 <img alt="_images/ceph-1463.png" src="_images/ceph-1463.png" />
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">Graphviz is provided directly via many operating system
+<p class="admonition-title">Note</p>
+<p>Graphviz is provided directly via many operating system
 package managers, and can also be downloaded from their web site:
 <a class="reference external" href="https://www.graphviz.org/">https://www.graphviz.org/</a></p>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
 <a class="reference internal" href="#population"><span class="std std-ref">population</span></a>,
 <a class="reference internal" href="#pedfilter"><span class="std std-ref">pedfilter</span></a>,
 <a class="reference internal" href="#vcfsubset"><span class="std std-ref">vcfsubset</span></a></p>
@@ -12607,37 +12718,37 @@ <h3>avrstats<a class="headerlink" href="#avrstats" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="10%" />
-<col width="84%" />
+<col style="width: 7%" />
+<col style="width: 10%" />
+<col style="width: 84%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">MODEL</span></code></td>
-<td>Name of AVR model to use when scoring variants.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">MODEL</span></code></p></td>
+<td><p>Name of AVR model to use when scoring variants.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="10%" />
-<col width="84%" />
+<col style="width: 7%" />
+<col style="width: 10%" />
+<col style="width: 84%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -12646,8 +12757,8 @@ <h3>avrstats<a class="headerlink" href="#avrstats" title="Permalink to this head
 the model was built and which predictor attributes were employed during
 the model build.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#avrbuild"><span class="std std-ref">avrbuild</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#avrbuild"><span class="std std-ref">avrbuild</span></a>,
 <a class="reference internal" href="#avrpredict"><span class="std std-ref">avrpredict</span></a>,
 <a class="reference internal" href="#snp"><span class="std std-ref">snp</span></a>,
 <a class="reference internal" href="#family"><span class="std std-ref">family</span></a>,
@@ -12671,90 +12782,103 @@ <h3>rocplot<a class="headerlink" href="#rocplot" title="Permalink to this headli
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="5%" />
-<col width="19%" />
-<col width="75%" />
+<col style="width: 5%" />
+<col style="width: 19%" />
+<col style="width: 75%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--curve=STRING</span></code></td>
-<td>ROC data file with title optionally specified (path[=title]). May be specified 0 or more times.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--curve=STRING</span></code></p></td>
+<td><p>ROC data file with title optionally specified (path[=title]). May be specified 0 or more times.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--png=FILE</span></code></td>
-<td>If set, output a PNG image to the given file.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--png=FILE</span></code></p></td>
+<td><p>If set, output a PNG image to the given file.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--svg=FILE</span></code></td>
-<td>If set, output a SVG image to the given file.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--svg=FILE</span></code></p></td>
+<td><p>If set, output a SVG image to the given file.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--zoom=STRING</span></code></td>
-<td>Show a zoomed view with the given coordinates, supplied in the form &lt;xmax&gt;,&lt;ymax&gt; or &lt;xmin&gt;,&lt;ymin&gt;,&lt;xmax&gt;,&lt;ymax&gt;</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--zoom=STRING</span></code></p></td>
+<td><p>Show a zoomed view with the given coordinates, supplied in the form &lt;xmax&gt;,&lt;ymax&gt; or &lt;xmin&gt;,&lt;ymin&gt;,&lt;xmax&gt;,&lt;ymax&gt;</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></td>
-<td>ROC data file. May be specified 0 or more times.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">FILE+</span></code></p></td>
+<td><p>ROC data file. May be specified 0 or more times.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="24%" />
-<col width="69%" />
+<col style="width: 4%" />
+<col style="width: 15%" />
+<col style="width: 81%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--hide-sidepane</span></code></td>
-<td>If set, hide the side pane from the GUI on startup.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--cmd=FILE</span></code></p></td>
+<td><p>If set, print rocplot command used in previously saved image.</p></td>
+</tr>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--hide-sidepane</span></code></p></td>
+<td><p>If set, hide the side pane from the GUI on startup.</p></td>
+</tr>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--interpolate</span></code></p></td>
+<td><p>If set, interpolate curves at regular intervals.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--interpolate</span></code></td>
-<td>If set, interpolate curves at regular intervals.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--line-width=INT</span></code></p></td>
+<td><p>Sets the plot line width (Default is 2)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--line-width=INT</span></code></td>
-<td>Sets the plot line width (Default is 2)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--palette=STRING</span></code></p></td>
+<td><p>Name of color palette to use. Allowed values are [blind_13, blind_15, blind_8, brewer_accent, brewer_dark2, brewer_paired, brewer_pastel1, brewer_pastel2,
+brewer_set1, brewer_set2, brewer_set3, classic] (Default is classic)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-P</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--precision-sensitivity</span></code></td>
-<td>If set, plot precision vs sensitivity rather than ROC.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--plain</span></code></p></td>
+<td><p>If set, use a plain plot style.</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--scores</span></code></td>
-<td>If set, show scores on the plot.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-P</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--precision-sensitivity</span></code></p></td>
+<td><p>If set, plot precision vs sensitivity rather than ROC.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-t</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--title=STRING</span></code></td>
-<td>Title for the plot.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--scores</span></code></p></td>
+<td><p>If set, show scores on the plot.</p></td>
+</tr>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-t</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--title=STRING</span></code></p></td>
+<td><p>Title for the plot.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="7%" />
-<col width="24%" />
-<col width="69%" />
+<col style="width: 7%" />
+<col style="width: 24%" />
+<col style="width: 69%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -12803,6 +12927,15 @@ <h3>rocplot<a class="headerlink" href="#rocplot" title="Permalink to this headli
 on the ROC convex hull and can over-estimate the accuracy. Instead, we
 can plot appropriately interpolated values with the <code class="docutils literal notranslate"><span class="pre">--interpolate</span></code>
 option.</p>
+<p>The default ROC graphs include some flourishes such as background
+gradients and axes drop shadows, these can be disabled via the
+<code class="docutils literal notranslate"><span class="pre">--plain</span></code> parameter.  Alternative preset color palettes for the curve
+colors may be selected with the <code class="docutils literal notranslate"><span class="pre">--palette</span></code> parameter, and in
+particular some palettes are more color-blind friendly than the default
+palette. In addition, PNG images saved by <code class="docutils literal notranslate"><span class="pre">rocplot</span></code> include metadata
+indicating the graph configuration that may be useful when recreating
+graphs. This metadata can be displayed (when present) via the <code class="docutils literal notranslate"><span class="pre">--cmd</span></code>
+parameter.</p>
 <div class="section" id="interactive-gui">
 <h4>Interactive GUI<a class="headerlink" href="#interactive-gui" title="Permalink to this headline">¶</a></h4>
 <p>The following image shows the <code class="docutils literal notranslate"><span class="pre">rocplot</span></code> GUI with an example ROC plot :</p>
@@ -12811,65 +12944,66 @@ <h4>Interactive GUI<a class="headerlink" href="#interactive-gui" title="Permalin
 <img alt="_images/rocplot_ps.png" src="_images/rocplot_ps.png" />
 <p>Some quick tips for the interactive GUI:</p>
 <ul class="simple">
-<li>Select regions within the graph to zoom in. Right click within the
+<li><p>Select regions within the graph to zoom in. Right click within the
 graph area to bring up a context menu that allows undoing the zoom one
-level at a time, or resetting the zoom to the default.</li>
-<li>The graph right click menu also allows exporting the image as PNG or
-SVG. (The saved image does not include the RTG banner or background
-gradient).</li>
-<li>Click on a spot in the graph to show the equivalent accuracy metrics
+level at a time, or resetting the zoom to the default.</p></li>
+<li><p>The graph right click menu also allows exporting the image as PNG or
+SVG. (The saved image does not include the RTG banner).</p></li>
+<li><p>Click on a spot in the graph to show the equivalent accuracy metrics
 for that location in the status bar. Clicking to the left or below the
 axes will remove the cross-hair. Note that sensitivity depends on the
 baseline total number of variants being correct. If for example the
 ROC curve corresponds to evaluating an exome call-set against a
-whole-genome baseline, this number will be inaccurate.</li>
-<li>A secondary cross-hair is also available by holding down shift when
+whole-genome baseline, this number will be inaccurate.</p></li>
+<li><p>A secondary cross-hair is also available by holding down shift when
 placing (or removing) the cross-hair. When two cross-hairs are placed
 or moved, metrics in the status bar indicate the difference between
-the two positions.</li>
-<li>Additional ROC data files can be loaded by clicking on the “Open…”
+the two positions.</p></li>
+<li><p>Additional ROC data files can be loaded by clicking on the “Open…”
 button, and multiple ROC data files within a directory can be loaded
-at once using multi-select.</li>
-<li>The “Cmd” button will open a message window that contains a
+at once using multi-select. Alternatively, you may use Drag and Drop
+from your file browser to drop ROC data files into either the graph
+area or the right hand ROC curve widget area.</p></li>
+<li><p>The “Cmd” button will open a message window that contains a
 command-line equivalent to the currently displayed set of curves. This
 command-line may be copy-pasted, providing an easy way to replicate
 the current set of curves in another session, generate a curve in a
-script, or share with a colleague.</li>
-<li>There is a drop down that allows for switching between ROC and
-precision/sensitivity graph types.</li>
+script, or share with a colleague.</p></li>
+<li><p>There is a drop down that allows for switching between ROC and
+precision/sensitivity graph types.</p></li>
 </ul>
 <p>Each curve in the GUI has a customization widget on the right hand
 side of the window that allows several operations:</p>
 <ul class="simple">
-<li>Rename the title used for the curve via the editable text.</li>
-<li>Temporarily hide/show the curve via selection checkbox.</li>
-<li>Reorder curves via drag and drop using the colored handle on the left.</li>
-<li>Right click within the ROC widget area to bring up a context menu that
+<li><p>Rename the title used for the curve via the editable text.</p></li>
+<li><p>Temporarily hide/show the curve via selection checkbox.</p></li>
+<li><p>Reorder curves via drag and drop using the colored handle on the left.</p></li>
+<li><p>Right click within the ROC widget area to bring up a context menu that
 allows permanently removing that curve, or customizing the color used
-for the curve</li>
-<li>Each curve has a slider to simulate the effect of applying a threshold
+for the curve</p></li>
+<li><p>Each curve has a slider to simulate the effect of applying a threshold
 on the scoring attribute. If the “show scores” option is set, this
 provides an easy way to select appropriate filter threshold values,
 which you might apply to variant sets using <code class="docutils literal notranslate"><span class="pre">rtg</span> <span class="pre">vcffilter</span></code> or
-similar VCF filtering tools.</li>
+similar VCF filtering tools.</p></li>
 </ul>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">For definitions of the terminology used when evaluating caller
+<p class="admonition-title">Note</p>
+<p>For definitions of the terminology used when evaluating caller
 accuracy, see:
 <a class="reference external" href="https://en.wikipedia.org/wiki/Receiver_operating_characteristic">https://en.wikipedia.org/wiki/Receiver_operating_characteristic</a>
 and <a class="reference external" href="https://en.wikipedia.org/wiki/Sensitivity_and_specificity">https://en.wikipedia.org/wiki/Sensitivity_and_specificity</a></p>
 </div>
 <div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">For a description of the precision/sensitivity interpolation,
+<p class="admonition-title">Note</p>
+<p>For a description of the precision/sensitivity interpolation,
 see: “The relationship between Precision-Recall and ROC
 curves”, Davis, J., (2006),
 <a class="reference external" href="https://dx.doi.org/10.1145/1143844.1143874">https://dx.doi.org/10.1145/1143844.1143874</a></p>
 </div>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#readsimeval"><span class="std std-ref">readsimeval</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#readsimeval"><span class="std std-ref">readsimeval</span></a>,
 <a class="reference internal" href="#bndeval"><span class="std std-ref">bndeval</span></a>,
 <a class="reference internal" href="#vcfeval"><span class="std std-ref">vcfeval</span></a></p>
 </div>
@@ -12886,82 +13020,82 @@ <h3>hashdist<a class="headerlink" href="#hashdist" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="23%" />
-<col width="71%" />
+<col style="width: 6%" />
+<col style="width: 23%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></td>
-<td>Directory for output.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=DIR</span></code></p></td>
+<td><p>Directory for output.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">SDF</span></code></td>
-<td>SDF containing sequence data to analyse.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">SDF</span></code></p></td>
+<td><p>SDF containing sequence data to analyse.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="23%" />
-<col width="71%" />
+<col style="width: 6%" />
+<col style="width: 23%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Sensitivity Tuning</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Sensitivity Tuning</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--blacklist-threshold=INT</span></code></td>
-<td>If set, output a blacklist containing all <em>k</em>-mer hashes with counts exceeding this value.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--blacklist-threshold=INT</span></code></p></td>
+<td><p>If set, output a blacklist containing all <em>k</em>-mer hashes with counts exceeding this value.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--hashmap-size-factor=FLOAT</span></code></td>
-<td>Multiplier for the minimum size of the hash map (Default is 1.0)</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--hashmap-size-factor=FLOAT</span></code></p></td>
+<td><p>Multiplier for the minimum size of the hash map (Default is 1.0)</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--max-count=INT</span></code></td>
-<td>Soft minimum for hash count (i.e. will record exact counts of at least this value) (Default is 500)</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--max-count=INT</span></code></p></td>
+<td><p>Soft minimum for hash count (i.e. will record exact counts of at least this value) (Default is 500)</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></td>
-<td>Step size (Default is 1)</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--step=INT</span></code></p></td>
+<td><p>Step size (Default is 1)</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-w</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></td>
-<td>Number of bases in each hash (Default is 22)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-w</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--word=INT</span></code></p></td>
+<td><p>Number of bases in each hash (Default is 22)</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="23%" />
-<col width="71%" />
+<col style="width: 6%" />
+<col style="width: 23%" />
+<col style="width: 71%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Print help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Print help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--install-blacklist</span></code></td>
-<td>Install the blacklist into the SDF for use during mapping.</td>
+<tr class="row-odd"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--install-blacklist</span></code></p></td>
+<td><p>Install the blacklist into the SDF for use during mapping.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Number of threads (Default is the number of available cores)</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Number of threads (Default is the number of available cores)</p></td>
 </tr>
 </tbody>
 </table>
@@ -12989,8 +13123,8 @@ <h3>hashdist<a class="headerlink" href="#hashdist" title="Permalink to this head
 could be reduced in order to run on a machine with lower RAM, but this
 may reduce the likelihood that the command will complete successfully.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#map"><span class="std std-ref">map</span></a></p>
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#map"><span class="std std-ref">map</span></a></p>
 </div>
 </div>
 <div class="section" id="ncbi2tax">
@@ -13009,37 +13143,37 @@ <h3>ncbi2tax<a class="headerlink" href="#ncbi2tax" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="17%" />
-<col width="76%" />
+<col style="width: 6%" />
+<col style="width: 17%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">DIR</span></code></td>
-<td>Directory containing the NCBI taxonomy dump.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">DIR</span></code></p></td>
+<td><p>Directory containing the NCBI taxonomy dump.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -13052,8 +13186,8 @@ <h3>ncbi2tax<a class="headerlink" href="#ncbi2tax" title="Permalink to this head
 sequence to taxon mapping file needed to create a species reference SDF,
 see <a class="reference internal" href="appendix.html#rtg-taxonomic-reference-file-format"><span class="std std-ref">RTG taxonomic reference file format</span></a>.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
 <a class="reference internal" href="#species"><span class="std std-ref">species</span></a>,
 <a class="reference internal" href="#taxfilter"><span class="std std-ref">taxfilter</span></a>,
 <a class="reference internal" href="#taxstats"><span class="std std-ref">taxstats</span></a></p>
@@ -13073,82 +13207,82 @@ <h3>taxfilter<a class="headerlink" href="#taxfilter" title="Permalink to this he
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="17%" />
-<col width="76%" />
+<col style="width: 8%" />
+<col style="width: 17%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-i</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></td>
-<td>Taxonomy input. May be either a taxonomy TSV file or an SDF containing taxonomy information.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-i</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--input=FILE</span></code></p></td>
+<td><p>Taxonomy input. May be either a taxonomy TSV file or an SDF containing taxonomy information.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-o</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></td>
-<td>Filename for output TSV or SDF.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-o</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--output=FILE</span></code></p></td>
+<td><p>Filename for output TSV or SDF.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="31%" />
-<col width="62%" />
+<col style="width: 8%" />
+<col style="width: 31%" />
+<col style="width: 62%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Filtering</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Filtering</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-P</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--prune-below-internal-sequences</span></code></td>
-<td>When filtering an SDF, remove nodes below the first containing sequence data.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-P</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--prune-below-internal-sequences</span></code></p></td>
+<td><p>When filtering an SDF, remove nodes below the first containing sequence data.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--prune-internal-sequences</span></code></td>
-<td>When filtering an SDF, exclude sequence data from non-leaf output nodes.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--prune-internal-sequences</span></code></p></td>
+<td><p>When filtering an SDF, exclude sequence data from non-leaf output nodes.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-r</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove=FILE</span></code></td>
-<td>File containing ids of nodes to remove.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-r</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove=FILE</span></code></p></td>
+<td><p>File containing ids of nodes to remove.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-R</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--remove-sequences=FILE</span></code></td>
-<td>File containing ids of nodes to remove sequence data from (if any).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-R</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--remove-sequences=FILE</span></code></p></td>
+<td><p>File containing ids of nodes to remove sequence data from (if any).</p></td>
 </tr>
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--rename-norank=FILE</span></code></td>
-<td>Assign a rank to “no rank” nodes from file containing id/rank pairs.</td>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--rename-norank=FILE</span></code></p></td>
+<td><p>Assign a rank to “no rank” nodes from file containing id/rank pairs.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-s</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--subset=FILE</span></code></td>
-<td>File containing ids of nodes to include in subset.</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-s</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--subset=FILE</span></code></p></td>
+<td><p>File containing ids of nodes to include in subset.</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-S</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--subtree=FILE</span></code></td>
-<td>File containing ids of nodes to include as subtrees in subset.</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-S</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--subtree=FILE</span></code></p></td>
+<td><p>File containing ids of nodes to include as subtrees in subset.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -13191,8 +13325,8 @@ <h3>taxfilter<a class="headerlink" href="#taxfilter" title="Permalink to this he
 with a species (or multiple species) is to use the <code class="docutils literal notranslate"><span class="pre">sdf2fasta</span></code> command
 with the <code class="docutils literal notranslate"><span class="pre">--taxon</span></code> flag.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
 <a class="reference internal" href="#sdf2fasta"><span class="std std-ref">sdf2fasta</span></a>,
 <a class="reference internal" href="#species"><span class="std std-ref">species</span></a>,
 <a class="reference internal" href="#taxstats"><span class="std std-ref">taxstats</span></a></p>
@@ -13252,54 +13386,54 @@ <h3>taxstats<a class="headerlink" href="#taxstats" title="Permalink to this head
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="6%" />
-<col width="18%" />
-<col width="76%" />
+<col style="width: 6%" />
+<col style="width: 18%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">File Input/Output</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>File Input/Output</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">SDF</span></code></td>
-<td>SDF to verify the taxonomy information for.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">SDF</span></code></p></td>
+<td><p>SDF to verify the taxonomy information for.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="4%" />
-<col width="22%" />
-<col width="74%" />
+<col style="width: 4%" />
+<col style="width: 22%" />
+<col style="width: 74%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Reporting</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Reporting</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td>&#160;</td>
-<td><code class="docutils literal notranslate"><span class="pre">--show-details</span></code></td>
-<td>List details of sequences attached to internal nodes of the taxonomy.</td>
+<tbody>
+<tr class="row-even"><td></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--show-details</span></code></p></td>
+<td><p>List details of sequences attached to internal nodes of the taxonomy.</p></td>
 </tr>
 </tbody>
 </table>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="15%" />
-<col width="21%" />
-<col width="64%" />
+<col style="width: 15%" />
+<col style="width: 21%" />
+<col style="width: 64%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
 </tbody>
 </table>
@@ -13310,8 +13444,8 @@ <h3>taxstats<a class="headerlink" href="#taxstats" title="Permalink to this head
 contained within the database.</p>
 <p>Any discrepancies found within the database will be issued as warnings.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#format"><span class="std std-ref">format</span></a>,
 <a class="reference internal" href="#species"><span class="std std-ref">species</span></a>,
 <a class="reference internal" href="#taxfilter"><span class="std std-ref">taxfilter</span></a></p>
 </div>
@@ -13329,28 +13463,28 @@ <h3>usageserver<a class="headerlink" href="#usageserver" title="Permalink to thi
 </pre></div>
 </div>
 <p><strong>Parameters:</strong></p>
-<table border="1" class="docutils">
+<table class="docutils align-default">
 <colgroup>
-<col width="8%" />
-<col width="16%" />
-<col width="76%" />
+<col style="width: 8%" />
+<col style="width: 16%" />
+<col style="width: 76%" />
 </colgroup>
-<thead valign="bottom">
-<tr class="row-odd"><th class="head" colspan="3">Utility</th>
+<thead>
+<tr class="row-odd"><th class="head" colspan="3"><p>Utility</p></th>
 </tr>
 </thead>
-<tbody valign="top">
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-h</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--help</span></code></td>
-<td>Prints help on command-line flag usage.</td>
+<tbody>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-h</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--help</span></code></p></td>
+<td><p>Prints help on command-line flag usage.</p></td>
 </tr>
-<tr class="row-odd"><td><code class="docutils literal notranslate"><span class="pre">-p</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--port=INT</span></code></td>
-<td>Set this flag to change which port to listen for usage logging connections. (Default is 8080).</td>
+<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-p</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--port=INT</span></code></p></td>
+<td><p>Set this flag to change which port to listen for usage logging connections. (Default is 8080).</p></td>
 </tr>
-<tr class="row-even"><td><code class="docutils literal notranslate"><span class="pre">-T</span></code></td>
-<td><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></td>
-<td>Set this flag to change the number of threads for handling incoming connections. (Default is 4).</td>
+<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">-T</span></code></p></td>
+<td><p><code class="docutils literal notranslate"><span class="pre">--threads=INT</span></code></p></td>
+<td><p>Set this flag to change the number of threads for handling incoming connections. (Default is 4).</p></td>
 </tr>
 </tbody>
 </table>
@@ -13398,8 +13532,8 @@ <h3>version<a class="headerlink" href="#version" title="Permalink to this headli
 <p><strong>Usage:</strong></p>
 <p>Use the <code class="docutils literal notranslate"><span class="pre">version</span></code> command to display release and version information.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#help"><span class="std std-ref">help</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#help"><span class="std std-ref">help</span></a>,
 <a class="reference internal" href="#license"><span class="std std-ref">license</span></a></p>
 </div>
 </div>
@@ -13422,8 +13556,8 @@ <h3>license<a class="headerlink" href="#license" title="Permalink to this headli
 date. Output at the command line (standard output) shows command name,
 licensed status, and command release level.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#help"><span class="std std-ref">help</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#help"><span class="std std-ref">help</span></a>,
 <a class="reference internal" href="#version"><span class="std std-ref">version</span></a></p>
 </div>
 </div>
@@ -13450,8 +13584,8 @@ <h3>help<a class="headerlink" href="#help" title="Permalink to this headline">¶
 <p>Use the <code class="docutils literal notranslate"><span class="pre">help</span></code> command to view syntax and usage information for the main
 <code class="docutils literal notranslate"><span class="pre">rtg</span></code> command as well as individual RTG commands.</p>
 <div class="admonition seealso">
-<p class="first admonition-title">See also</p>
-<p class="last"><a class="reference internal" href="#license"><span class="std std-ref">license</span></a>,
+<p class="admonition-title">See also</p>
+<p><a class="reference internal" href="#license"><span class="std std-ref">license</span></a>,
 <a class="reference internal" href="#version"><span class="std std-ref">version</span></a></p>
 </div>
 </div>
@@ -13459,9 +13593,161 @@ <h3>help<a class="headerlink" href="#help" title="Permalink to this headline">¶
 </div>
 
 
+            <div class="clearer"></div>
           </div>
         </div>
       </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="index.html">
+              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
+            </a></p>
+  <h3><a href="index.html">Table of Contents</a></h3>
+  <ul>
+<li><a class="reference internal" href="#">RTG Command Reference</a><ul>
+<li><a class="reference internal" href="#command-line-interface-cli">Command line interface (CLI)</a></li>
+<li><a class="reference internal" href="#rtg-command-syntax">RTG command syntax</a></li>
+<li><a class="reference internal" href="#data-formatting-commands">Data Formatting Commands</a><ul>
+<li><a class="reference internal" href="#format">format</a></li>
+<li><a class="reference internal" href="#cg2sdf">cg2sdf</a></li>
+<li><a class="reference internal" href="#sdf2cg">sdf2cg</a></li>
+<li><a class="reference internal" href="#sdf2fasta">sdf2fasta</a></li>
+<li><a class="reference internal" href="#sdf2fastq">sdf2fastq</a></li>
+<li><a class="reference internal" href="#sdf2sam">sdf2sam</a></li>
+<li><a class="reference internal" href="#fastqtrim">fastqtrim</a></li>
+<li><a class="reference internal" href="#petrim">petrim</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#read-mapping-commands">Read Mapping Commands</a><ul>
+<li><a class="reference internal" href="#map">map</a></li>
+<li><a class="reference internal" href="#mapf">mapf</a></li>
+<li><a class="reference internal" href="#cgmap">cgmap</a></li>
+<li><a class="reference internal" href="#coverage">coverage</a></li>
+<li><a class="reference internal" href="#calibrate">calibrate</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#protein-search-commands">Protein Search Commands</a><ul>
+<li><a class="reference internal" href="#mapx">mapx</a></li>
+<li><a class="reference internal" href="#mapp">mapp</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#assembly-commands">Assembly Commands</a><ul>
+<li><a class="reference internal" href="#assemble">assemble</a><ul>
+<li><a class="reference internal" href="#output">Output</a></li>
+<li><a class="reference internal" href="#graph-construction">Graph Construction</a></li>
+<li><a class="reference internal" href="#read-mapping">Read Mapping</a></li>
+<li><a class="reference internal" href="#filtering">Filtering</a></li>
+<li><a class="reference internal" href="#consensus">Consensus</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#addpacbio">addpacbio</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#variant-detection-commands">Variant Detection Commands</a><ul>
+<li><a class="reference internal" href="#snp">snp</a><ul>
+<li><a class="reference internal" href="#quality-calibration">Quality calibration</a></li>
+<li><a class="reference internal" href="#coverage-filtering">Coverage filtering</a></li>
+<li><a class="reference internal" href="#prior-distributions">Prior distributions</a></li>
+<li><a class="reference internal" href="#adaptive-variant-rescoring">Adaptive Variant Rescoring</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#family">family</a></li>
+<li><a class="reference internal" href="#somatic">somatic</a></li>
+<li><a class="reference internal" href="#tumoronly">tumoronly</a></li>
+<li><a class="reference internal" href="#population">population</a></li>
+<li><a class="reference internal" href="#lineage">lineage</a></li>
+<li><a class="reference internal" href="#avrpredict">avrpredict</a></li>
+<li><a class="reference internal" href="#avrbuild">avrbuild</a></li>
+<li><a class="reference internal" href="#svprep">svprep</a></li>
+<li><a class="reference internal" href="#discord">discord</a></li>
+<li><a class="reference internal" href="#sv">sv</a></li>
+<li><a class="reference internal" href="#cnv">cnv</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#metagenomics-commands">Metagenomics Commands</a><ul>
+<li><a class="reference internal" href="#species">species</a></li>
+<li><a class="reference internal" href="#similarity">similarity</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#pipeline-commands">Pipeline Commands</a><ul>
+<li><a class="reference internal" href="#composition-meta-pipeline">composition-meta-pipeline</a></li>
+<li><a class="reference internal" href="#functional-meta-pipeline">functional-meta-pipeline</a></li>
+<li><a class="reference internal" href="#composition-functional-meta-pipeline">composition-functional-meta-pipeline</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#simulation-commands">Simulation Commands</a><ul>
+<li><a class="reference internal" href="#genomesim">genomesim</a></li>
+<li><a class="reference internal" href="#cgsim">cgsim</a></li>
+<li><a class="reference internal" href="#readsim">readsim</a></li>
+<li><a class="reference internal" href="#readsimeval">readsimeval</a></li>
+<li><a class="reference internal" href="#popsim">popsim</a></li>
+<li><a class="reference internal" href="#samplesim">samplesim</a></li>
+<li><a class="reference internal" href="#denovosim">denovosim</a></li>
+<li><a class="reference internal" href="#childsim">childsim</a></li>
+<li><a class="reference internal" href="#pedsamplesim">pedsamplesim</a></li>
+<li><a class="reference internal" href="#samplereplay">samplereplay</a></li>
+</ul>
+</li>
+<li><a class="reference internal" href="#utility-commands">Utility Commands</a><ul>
+<li><a class="reference internal" href="#bgzip">bgzip</a></li>
+<li><a class="reference internal" href="#index">index</a></li>
+<li><a class="reference internal" href="#extract">extract</a></li>
+<li><a class="reference internal" href="#aview">aview</a></li>
+<li><a class="reference internal" href="#sdfstats">sdfstats</a></li>
+<li><a class="reference internal" href="#sdfsplit">sdfsplit</a></li>
+<li><a class="reference internal" href="#sdfsubset">sdfsubset</a></li>
+<li><a class="reference internal" href="#sdfsubseq">sdfsubseq</a></li>
+<li><a class="reference internal" href="#sam2bam">sam2bam</a></li>
+<li><a class="reference internal" href="#sammerge">sammerge</a></li>
+<li><a class="reference internal" href="#samstats">samstats</a></li>
+<li><a class="reference internal" href="#samrename">samrename</a></li>
+<li><a class="reference internal" href="#mapxrename">mapxrename</a></li>
+<li><a class="reference internal" href="#chrstats">chrstats</a></li>
+<li><a class="reference internal" href="#mendelian">mendelian</a></li>
+<li><a class="reference internal" href="#vcfannotate">vcfannotate</a></li>
+<li><a class="reference internal" href="#vcfdecompose">vcfdecompose</a></li>
+<li><a class="reference internal" href="#vcfeval">vcfeval</a></li>
+<li><a class="reference internal" href="#vcffilter">vcffilter</a></li>
+<li><a class="reference internal" href="#vcfmerge">vcfmerge</a></li>
+<li><a class="reference internal" href="#vcfsplit">vcfsplit</a></li>
+<li><a class="reference internal" href="#vcfstats">vcfstats</a></li>
+<li><a class="reference internal" href="#vcfsubset">vcfsubset</a></li>
+<li><a class="reference internal" href="#vcf2rocplot">vcf2rocplot</a></li>
+<li><a class="reference internal" href="#svdecompose">svdecompose</a></li>
+<li><a class="reference internal" href="#bndeval">bndeval</a></li>
+<li><a class="reference internal" href="#pedfilter">pedfilter</a></li>
+<li><a class="reference internal" href="#pedstats">pedstats</a></li>
+<li><a class="reference internal" href="#avrstats">avrstats</a></li>
+<li><a class="reference internal" href="#rocplot">rocplot</a></li>
+<li><a class="reference internal" href="#hashdist">hashdist</a></li>
+<li><a class="reference internal" href="#ncbi2tax">ncbi2tax</a></li>
+<li><a class="reference internal" href="#taxfilter">taxfilter</a></li>
+<li><a class="reference internal" href="#taxstats">taxstats</a></li>
+<li><a class="reference internal" href="#usageserver">usageserver</a></li>
+<li><a class="reference internal" href="#version">version</a></li>
+<li><a class="reference internal" href="#license">license</a></li>
+<li><a class="reference internal" href="#help">help</a></li>
+</ul>
+</li>
+</ul>
+</li>
+</ul>
+
+  <h4>Previous topic</h4>
+  <p class="topless"><a href="overview.html"
+                        title="previous chapter">Overview</a></p>
+  <h4>Next topic</h4>
+  <p class="topless"><a href="product_usage.html"
+                        title="next chapter">RTG product usage - baseline progressions</a></p>
+  <div role="note" aria-label="source link">
+    <h3>This Page</h3>
+    <ul class="this-page-menu">
+      <li><a href="_sources/rtg_command_reference.rst.txt"
+            rel="nofollow">Show Source</a></li>
+    </ul>
+   </div>
+        </div>
+      </div>
       <div class="clearer"></div>
     </div>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -13476,12 +13762,13 @@ <h3>Navigation</h3>
         <li class="right" >
           <a href="overview.html" title="Overview"
              >previous</a> |</li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">RTG Command Reference</a></li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2017, Real Time Genomics.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.8.5.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.1.2.
     </div>
   </body>
 </html>
\ No newline at end of file
diff --git a/installer/resources/core/RTGOperationsManual/search.html b/installer/resources/core/RTGOperationsManual/search.html
index c5ee8af27..98c6ccc11 100644
--- a/installer/resources/core/RTGOperationsManual/search.html
+++ b/installer/resources/core/RTGOperationsManual/search.html
@@ -2,33 +2,29 @@
 
 <!doctype html>
 
-<html xmlns="http://www.w3.org/1999/xhtml">
+<html>
   <head>
-    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Search &#8212; RTG Core Operations Manual v3.11</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Search &#8212; RTG Core Operations Manual v3.12</title>
     <link rel="stylesheet" href="_static/bizstyle.css" type="text/css" />
     <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
     
     
-    <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
-    <script type="text/javascript" src="_static/jquery.js"></script>
-    <script type="text/javascript" src="_static/underscore.js"></script>
-    <script type="text/javascript" src="_static/doctools.js"></script>
-    <script type="text/javascript" src="_static/language_data.js"></script>
-    <script type="text/javascript" src="_static/bizstyle.js"></script>
-    <script type="text/javascript" src="_static/searchtools.js"></script>
+    <script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+    <script src="_static/jquery.js"></script>
+    <script src="_static/underscore.js"></script>
+    <script src="_static/doctools.js"></script>
+    <script src="_static/language_data.js"></script>
+    <script src="_static/bizstyle.js"></script>
+    <script src="_static/searchtools.js"></script>
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="#" />
-  <script type="text/javascript">
-    jQuery(function() { Search.loadIndex("searchindex.js"); });
-  </script>
-  
-  <script type="text/javascript" id="searchindexloader"></script>
+  <script src="searchindex.js" defer></script>
   
     <meta name="viewport" content="width=device-width,initial-scale=1.0">
     <!--[if lt IE 9]>
-    <script type="text/javascript" src="_static/css3-mediaqueries.js"></script>
+    <script src="_static/css3-mediaqueries.js"></script>
     <![endif]-->
 
   </head><body>
@@ -38,16 +34,10 @@ <h3>Navigation</h3>
         <li class="right" style="margin-right: 10px">
           <a href="genindex.html" title="General Index"
              accesskey="I">index</a></li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Search</a></li> 
       </ul>
-    </div>
-      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
-        <div class="sphinxsidebarwrapper">
-            <p class="logo"><a href="index.html">
-              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
-            </a></p>
-        </div>
-      </div>
+    </div>  
 
     <div class="document">
       <div class="documentwrapper">
@@ -56,20 +46,18 @@ <h3>Navigation</h3>
             
   <h1 id="search-documentation">Search</h1>
   <div id="fallback" class="admonition warning">
-  <script type="text/javascript">$('#fallback').hide();</script>
+  <script>$('#fallback').hide();</script>
   <p>
     Please activate JavaScript to enable the search
     functionality.
   </p>
   </div>
   <p>
-    From here you can search these documents. Enter your search
-    words into the box below and click "search". Note that the search
-    function will automatically search for all of the words. Pages
-    containing fewer words won't appear in the result list.
+    Searching for multiple words only shows matches that contain
+    all words.
   </p>
   <form action="" method="get">
-    <input type="text" name="q" value="" />
+    <input type="text" name="q" aria-labelledby="search-documentation" value="" />
     <input type="submit" value="search" />
     <span id="search-progress" style="padding-left: 10px"></span>
   </form>
@@ -78,9 +66,17 @@ <h1 id="search-documentation">Search</h1>
   
   </div>
 
+            <div class="clearer"></div>
           </div>
         </div>
       </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+            <p class="logo"><a href="index.html">
+              <img class="logo" src="_static/html_logo.png" alt="Logo"/>
+            </a></p>
+        </div>
+      </div>
       <div class="clearer"></div>
     </div>
     <div class="related" role="navigation" aria-label="related navigation">
@@ -89,12 +85,13 @@ <h3>Navigation</h3>
         <li class="right" style="margin-right: 10px">
           <a href="genindex.html" title="General Index"
              >index</a></li>
-        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.11</a> &#187;</li> 
+        <li class="nav-item nav-item-0"><a href="index.html">RTG Core Operations Manual v3.12</a> &#187;</li>
+        <li class="nav-item nav-item-this"><a href="">Search</a></li> 
       </ul>
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2017, Real Time Genomics.
-      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.8.5.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.1.2.
     </div>
   </body>
 </html>
\ No newline at end of file
diff --git a/installer/resources/core/RTGOperationsManual/searchindex.js b/installer/resources/core/RTGOperationsManual/searchindex.js
index 990071f4c..39a20b590 100644
--- a/installer/resources/core/RTGOperationsManual/searchindex.js
+++ b/installer/resources/core/RTGOperationsManual/searchindex.js
@@ -1 +1 @@
-Search.setIndex({docnames:["administration","appendix","index","overview","product_usage","rtg_command_reference"],envversion:{"sphinx.domains.c":1,"sphinx.domains.changeset":1,"sphinx.domains.cpp":1,"sphinx.domains.javascript":1,"sphinx.domains.math":2,"sphinx.domains.python":1,"sphinx.domains.rst":1,"sphinx.domains.std":1,sphinx:54},filenames:["administration.rst","appendix.rst","index.rst","overview.rst","product_usage.rst","rtg_command_reference.rst"],objects:{},objnames:{},objtypes:{},terms:{"0_07":0,"0_161":5,"0bfc":0,"0daf":1,"0gb":5,"0x02":1,"0x08":1,"0x100":1,"1000g_v37_phase2":4,"1000genom":4,"100m":4,"1219061gi":1,"143_____1":1,"15_grch38":4,"15_grch38_no_alt_plus_hs38d1_analysis_set":4,"16g":5,"1b19":1,"1i11":1,"1i14":1,"1r1":1,"1r2":1,"1r5":1,"1r5n10":1,"1sampl":5,"1t2":1,"1x1":1,"1x11":1,"1x15":1,"1x19":1,"20human":4,"20humans_an_ac":4,"20humans_prior":4,"283m1d1i32n8m":1,"2a36ba21397":1,"2b20":1,"2b5":1,"2sampl":5,"2x18":1,"2x46":1,"314_pool30":4,"36c48ec4":1,"3gb":5,"3sampl":5,"4157329b":1,"419a":1,"41d195dec4cd":1,"44116e7a2195":1,"454_pe":5,"454_read":5,"454_sdf":5,"454_se":5,"455d":1,"467b":4,"48d5":1,"48e6":1,"48g":[0,1,3],"4b11":1,"4d74":1,"4ecc9eb83e0ccec4":1,"4f6c2eca":0,"52b7":1,"5c2ee18":1,"5n10":1,"5n23":1,"5n25":1,"5n8":1,"6236f4e":5,"6aef897c3d6ff0c78aff06ac189178dd":4,"70s":1,"718f8317b7":5,"71dce5dba129":1,"73e374719c7f":4,"7798b1a5":1,"79d6626":1,"7ded37d7":4,"7f77":1,"817f":4,"86b4f8e98fa6":1,"8acc8413":1,"96ca":1,"976e":1,"9f7b8a5":1,"boolean":5,"break":[1,3,4,5],"byte":3,"case":[0,1,3,4,5],"class":5,"default":[0,1,3,4,5],"export":5,"final":[4,5],"float":[1,5],"function":[2,4],"import":[1,4,5],"int":5,"long":[1,5],"na\u00efv":5,"new":[0,1,3,4,5],"null":[1,5],"public":[1,3,4],"return":[1,5],"short":[1,3,4,5],"switch":[3,4,5],"throw":5,"true":[0,5],"try":4,"typeof":5,"var":[1,5],"while":[1,4,5],ADE:1,AND:1,ARE:1,Adding:[0,1],And:[1,5],BOING:1,BUT:1,But:1,DHS:1,DOING:1,DOS:5,Doing:5,FOR:1,For:[0,1,3,4,5],IDs:[1,3,4,5],INS:5,NCS:[1,4,5],NOT:1,Not:[4,5],One:[1,3,4,5],SAS:3,SUCH:1,Such:[1,5],THE:1,The:[0,1,3,4,5],Then:[0,4,5],There:[1,3,4,5],These:[0,1,3,4,5],USE:1,Use:[0,1,2,3,5],Used:[1,5],Uses:5,Using:[2,3,5],WGS:5,WITH:1,Will:1,With:[0,1,3,4,5],_____27:1,_indel:5,_renam:5,a10:1,a7da:4,aagtacttcttagttcaattactatcatcatcttacctaattactact:1,aat:1,aatacttttcattctttactattacttacttattcttacttacttact:1,abbrevi:5,abc:1,aberr:[3,5],abi:1,abil:[0,3,4,5],abl:[1,4,5],abnorm:[4,5],about:[1,3,4,5],abov:[0,1,4,5],abp:[1,4],abs:5,absenc:5,absent:5,absolut:5,abund:[1,2,4,5],acaryochloris_marina:1,accacct:1,accept:[1,3,4,5],access:[0,2,3,4,5],accessor:1,accg:1,accgttgactctgtgacgctgcacgtacgt:1,accommod:[3,4],accompani:[1,3,5],accomplish:[1,3,4,5],accord:[3,4,5],accordingli:5,account:[1,4,5],accumul:[1,3],accur:[1,4,5],accuraci:[3,4,5],acgc:5,acgt:1,achiev:[4,5],acholeplasma_laidlawii:1,acid:[1,5],acidiphilium_cryptum:1,acidobacteria_bacterium:1,acidothermus_cellulolyticu:1,acidovorax_avena:1,across:[1,3,4,5],act:5,action:1,actual:[1,3,4,5],adam:1,adapt:[1,4],adaptor:5,add:[0,1,5],added:5,adding:[0,1,3,5],addit:[0,2,3,4,5],addition:[0,4,5],addpacbio:2,address:5,adequ:4,adf1:1,adf2:1,adf:1,adjac:[1,4,5],adjust:[1,3,4,5],administr:[1,2,3],adr1:1,adr2:1,adr:1,advanc:2,advantag:[3,5],advers:4,advic:[3,5],advis:1,affect:[1,4,5],affin:5,afflict:[4,5],after:[0,1,3,4,5],agaggagagaacnggtttggaaccattc:1,against:[1,2,3,5],age:1,aggcgtctgcagccgacgcg:5,aggreg:5,aggress:3,agre:[1,5],agreement:[1,5],aim:[4,5],aka:5,alan:[1,5],algorithm:[1,3,4,5],alia:5,align:[2,4,5],alignments1:5,alignments2:5,alignments_renam:5,all:[0,1,3,4,5],allel:[1,4],allevi:5,alloc:[0,1,3],allosom:1,allow:[1,3,4,5],alon:1,along:[1,3,4,5],alongsid:5,alphanumer:1,alreadi:[1,4,5],also:[0,1,3,4,5],alt:5,altdepth:5,alter:[0,1,3,4,5],altern:[1,2,3,4,5],although:[0,1,4,5],altogeth:5,alwai:[1,3,4,5],ambigu:[1,3,4,5],amino:[1,5],amongst:4,amount:[0,4,5],amplif:4,amplifi:3,amqv00000000:1,amqv01000000:1,amqv01000002:1,amqv01000004:1,amqv01000006:1,anagaacnggaaccattcatggaaggccagagtga:1,anagaactgg_____aaccattcatggaaggccagagtga:1,anagaactggaaccattcatggaaggccagtga:1,analys:5,analysi:[0,1,2,4,5],analyt:[3,5],analyz:[3,5],anchor:5,ancillari:3,ani:[0,1,3,4,5],anim:1,ann:5,annot:[1,3,4],announc:[1,3],anomali:4,anonym:4,anoth:[0,1,4,5],ansi:0,ansicon:0,ant:1,anywher:1,apach:1,api:[2,5],appear:[1,5],append:5,appendix:[2,3,5],appl:[1,3],appli:[0,1,4,5],applic:[0,1,3,4,5],approach:[2,3,4,5],appropri:[0,1,3,4,5],approxim:[4,5],arbitrari:[4,5],arch:0,archiv:4,area:[1,3,5],arg:5,argument:[0,1,3,5],aris:[1,3,4,5],arithmet:4,arm:[1,3,5],around:[1,5],arrai:[1,5],arrang:5,artifact:5,ascend:5,ascii:[1,3,5],ask:0,assembl:[2,4],assert:5,assign:[0,1,3,5],assist:[1,2,4,5],associ:[1,3,4,5],assum:[0,1,3,4,5],assumpt:5,assur:3,ata:0,atcgtaaaataaatgca:5,atcgtaaataaaatgca:5,atgc:5,atgg:5,att:5,attach:5,attempt:[1,5],attract:5,attribut:[1,3,4,5],atttt:5,aug:4,augment:[0,5],australia:[1,5],author:[1,5],auto:[0,5],autom:3,automat:[0,1,3,4,5],autosom:[1,4,5],avail:[0,1,3,4,5],averag:[1,4,5],aview:2,avoid:[1,5],avr:[0,1,2,5],avrbuild:[2,4],avrpredict:[2,4],avrstat:[2,4],awai:[1,5],awar:[1,3,4,5],awk:[4,5],axes:5,axi:5,b06:0,b14:4,b1f96b37:1,b37:4,b472:1,b6318de1:1,b68c:1,b7baa85ebf66:0,b7ed:4,bac:1,bac_map:1,bac_reads_sdf:1,bac_ref_sdf:1,back:[1,5],background:5,backstep:1,bact:5,bact_db:5,bact_read:5,bact_sampl:5,bacteri:[2,3],bacteria:[1,4],bacteriophage_kvp40:5,bad:[1,3,4,5],bai:4,balanc:[3,4,5],bam:[2,4,5],band:5,bang:1,banner:5,bar:5,bare:1,barrier:5,base:[0,1,3,4,5],baselin:[2,3,5],baseline_sampl:5,basenam:4,bash:[1,3,5],basi:[1,3,4,5],basic:[1,3,4],bat:[0,1,3],batch:4,battel:1,bayesian:[1,3,4,5],baz:1,bdd9:1,be70:0,beagl:1,becaus:[1,3,4,5],becom:[4,5],bed:[2,3,4,5],bedgraph:[1,5],bedtool:4,been:[1,3,4,5],befor:[1,5],beforehand:5,begin:[3,5],behav:5,behavior:[0,4,5],being:[1,3,4,5],belong:1,below:[1,3,4,5],benchmark:[0,2],bergman:1,best:[1,3,4,5],better:[1,3,4,5],between:[1,3,4,5],beyond:4,bf9f:1,bgzip:[1,2,4],bherer:1,bherer_etal_sexualdimorphismrecombin:1,bia:[1,4,5],biallel:5,bias:5,bidirect:5,billion:1,bin:[1,3,5],binari:[1,3,4,5],biodefens:1,bioinformat:3,biolog:3,biologi:[1,5],biorxiv:5,bioscienc:5,biostat:1,bit:[1,3,5],blacklist:5,blade:0,blank:1,blast:[1,5],blastp:5,blastx:[3,5],block:[4,5],blosum45:5,blosum62:[3,5],blosum80:5,bnbi:1,bnd:[1,5],bndeval:2,board:0,bochet:1,bodi:3,border:5,boston:1,both:[1,3,4,5],bound:[1,3,5],boundari:[1,4,5],braithwait:[1,5],branch:5,brand:1,breadth:[1,3,4],break_out:5,breakdown:[2,5],breakend:[1,4,5],breakpoint:[1,4,5],brian:[1,5],bring:5,broad:[1,4],broadinstitut:4,broadli:5,broken:1,browser:4,bruijn:5,bubbl:5,bucket:[4,5],bui:5,build37:5,build:[0,1,2,3,5],builder:5,built:[1,3,4,5],bundl:4,busi:1,button:5,bz2:5,bzip2:[1,5],c0561a1d:1,c477b940:4,c_sampl:5,cach:0,cad2cc3c476a:1,calcul:[1,3,4,5],calibr:[1,2,3,4],call:[0,1,2,3,5],callabl:4,caller:[1,2,4,5],calls_sampl:5,came:5,can:[0,1,3,4,5],cancer:[1,2,3,5],candid:[1,5],cannot:5,cap:5,capabl:[0,1,3,4,5],capac:[2,3],captur:[4,5],card:5,care:[4,5],carri:[4,5],cat:[1,4],categor:[1,5],categori:[1,5],caus:[1,5],causal:3,caution:5,caveat:4,cbherer:1,ccaaaaataagt:1,cccccca:1,ccctcca:1,cctcctagcggtacatctccagccccttcctagna:1,cctggagg:1,ceil:5,cell:[1,5],cellular:1,center:[0,1,3],centimorgan:1,central:[0,1],ceph:[4,5],ceph_pedigre:5,certain:[1,5],certainli:5,ceu:4,ceu_trio:5,cfg:[0,1,3],cftr:1,cg1:[4,5],cg2:[4,5],cg2sdf:[2,3,4],cg_3x_readst:5,cg_map:5,cg_read:5,cg_source_fil:5,cggaggggagggcgcggagcggagg:5,cggaggggagggcgcggagcggaggggagggcgcggagcggagg:5,cgi:[1,4,5],cgmap:[2,3,4],cgmap_sample_na12878:4,cgsim:[2,3],cgt:1,chain:1,chanc:[4,5],chang:[1,3,4,5],chapter:[1,3,4,5],charact:[0,1,4,5],characterist:[1,3,4,5],charg:1,chart:[1,4,5],check:[1,2,5],checkbox:5,child:[1,4,5],children:[4,5],childsim:[1,2,3],chines:5,choic:[4,5],choos:[0,4,5],chosen:[1,4,5],chr10:[1,4,5],chr11:[1,4],chr12:[1,4],chr13:[1,4],chr14:[1,4],chr15:[1,4],chr16:[1,4],chr17:[1,4],chr18:[1,4],chr19:[1,4],chr1:[1,4,5],chr1_ki270706v1_random:4,chr1_ki270707v1_random:4,chr1_ki270708v1_random:4,chr20:[1,4],chr21:[1,4,5],chr22:[1,4],chr2:[1,4],chr3:[1,4],chr4:[1,4],chr5:[1,4],chr6:[1,4],chr7:[1,4],chr8:[1,4],chr9:[1,4],chr:[1,4,5],chrm:[1,4],chrom:5,chrominfopag:1,chromosom:[1,3,4,5],chrstat:2,chrx:[1,4,5],chry:[1,4],chunk:[1,5],cigar:[1,5],cipo:[1,5],circular:[1,4],circumst:5,citat:5,cite:1,clade:5,claim:1,clariti:1,classifi:[3,5],classpath:1,clear:[1,3,5],cleari:[1,5],cli:[2,3],click:5,clip:[1,5],clist:1,clock:[0,1,3,4],close:[1,5],closer:5,closest:[1,4,5],clu:1,cluster:[0,1,3,4,5],cm000663:4,cmb:[1,5],cmd:5,cmpk:1,cmpkasgnypallrvpgag:1,cnv:[1,2,4],cnv_s1_:4,cnv_s1_s2:4,cnvsim:5,code:[1,4,5],coeffici:1,cohort:5,coli:4,collaps:[4,5],collat:[0,5],colleagu:5,collect:[0,4,5],collis:5,color:[2,5],column:[1,3,4],com:[1,3,4,5],combin:[1,3,4],come:[3,5],comma:[0,1,5],command:[2,4],commandlin:0,commenc:5,comment:[1,4,5],commerci:[0,3],common:[1,3,4],commonli:[0,5],commun:[3,4,5],comp_out:5,compar:[3,4],comparison:[0,1,3,4],compat:5,compens:5,complement:[1,5],complet:[1,3,4,5],complete_genom:5,complete_genomics_2:5,completegenom:[1,4,5],complex:[1,2,4,5],complianc:1,complic:5,compon:[1,3,4,5],composit:[2,3],comprehens:[1,3,5],compress:[0,3,4,5],compris:[1,3,4,5],comput:[0,2,3,4,5],computation:[4,5],con:4,concaten:5,concept:5,conceptu:[3,5],concern:5,conclus:5,concord:5,condit:[0,1,4,5],conemu:0,confid:[1,3,5],confidenti:0,configur:[1,2,3,4,5],conjunct:[4,5],connect:[1,5],consensu:3,consequ:5,consequenti:1,conserv:5,consid:[1,4,5],consider:[4,5],consist:[0,1,3,5],consol:[0,5],constant:1,constitu:5,constitut:4,constrain:5,constraint:[1,3,5],construct:[1,3,4],consult:[1,5],consum:5,consumpt:5,contact:[1,3,4,5],contain:[0,1,3,4,5],contamin:[2,5],content:[0,5],context:[1,5],contig:[1,4,5],contigu:5,continu:1,contract:1,contrari:[1,5],contrast:5,contribut:[1,5],contributor:1,control:[0,3,5],convei:1,conveni:[1,4,5],convent:[1,5],convers:[1,3,4,5],convert:[1,3,4,5],convex:5,coordin:[1,4,5],cope:4,copi:[0,1,2,5],copyright:1,core:[0,1,3,5],correct:[1,3,4,5],correctli:[4,5],correspond:[1,4,5],cosm3805:1,cosmic:[4,5],cost:[1,3,5],could:[1,4,5],count:[1,4,5],countermeasur:1,coupl:5,cours:4,cov_sample_na12878:4,cover:[1,3,4,5],coverag:[0,2],coverage_level:1,coveragetsv:5,cpu:[0,3,5],cram:5,crash:0,creat:[0,1,2,5],creation:[1,4,5],credit:5,criteria:[1,5],criterion:5,crop:3,cross:[3,4,5],crossov:[1,5],ctcatggaga:1,ctt:5,cttaaac:1,cttaac:1,cttt:5,cumul:[1,4],curat:5,current:[0,1,3,4,5],custom:[0,1,3,4,5],customis:5,customiz:3,cut:5,cutoff:[4,5],cyanobacteria:1,d74f45d:0,d_sampl:5,damag:1,dash:5,data:[0,1,2],databas:[1,2,3,5],dataset:[0,1,5],date:[0,1,4,5],daughter:[3,4,5],davi:5,david:[1,5],dbsnp:[4,5],dcoc:[1,5],dcof:[1,5],ddr3:3,deal:[1,4,5],debug:3,decid:[1,5],decim:5,decis:[0,1,5],declar:[1,5],decod:5,decoi:[1,4],decompos:5,decompress:[1,4,5],decreas:[3,4,5],dedic:1,deep:3,deeper:[3,4],def:1,defin:[0,1,3,4,5],definit:[1,5],degre:[4,5],del:5,delet:[1,3,4,5],delimit:[1,5],delin:3,deliv:[1,3,5],delta:[1,5],demand:[0,1,3],demo:1,demonstr:[0,4,5],denot:[1,4,5],denovo:5,denovosim:[2,3],dens:[4,5],densiti:5,depart:[1,5],depend:[0,1,3,4,5],deploy:[0,1,2,5],depth:[1,3,4,5],deriv:[1,3,4,5],descend:[1,5],describ:[0,1,3,4,5],descript:[0,2,4,5],design:[1,3,5],desir:[0,1,3,4,5],destin:[0,5],detail:[1,3,4,5],detect:[0,1,2],determin:[0,1,3,4,5],determinist:5,develop:[1,3,4,5],deviat:[1,5],dh10b:4,diagram:5,dictionari:1,did:[3,4,5],didn:5,differ:[0,1,3,4,5],difficult:5,difficulti:5,dimension:[1,4,5],diploid:[1,3,4,5],dir:[3,5],dir_map:5,direct:[1,5],directli:[0,1,3,4,5],directori:[0,2,3,4,5],disabl:[0,5],disagre:1,disambigu:5,discard:[1,3,4,5],disclaim:1,disconnect:5,discord:2,discord_pair:1,discord_sample_na12878:4,discordantli:[1,4,5],discov:[1,4],discrep:5,discuss:[1,3,5],diseas:3,disk:[0,3,4,5],displai:[0,1,3,4,5],distanc:[1,3,5],distinct:[1,4],distribut:[2,3,4],divers:[1,3],diversity_index:1,divid:[0,1,5],dna:[1,2,3,5],dnp:[1,5],document:[0,1,4,5],doe:[1,3,4,5],doesn:5,doi:[1,5],doing:[1,4],dokladi:1,domin:5,don:[4,5],done:[1,4,5],dot:[4,5],doubl:[1,5],doubt:5,down:5,download:[1,4,5],downstream:[3,4,5],dpr:[1,4],drag:5,dramat:[1,5],draw:5,drawn:5,drive:0,drop:[4,5],drtg:0,dual:3,due:[1,3,4,5],dump:[1,5],duo:0,dup:[1,5],duplic:[1,4,5],dure:[0,1,3,4,5],duster:5,dynam:[1,5],e9e7:4,each:[0,1,3,4,5],eap2:1,earlier:[1,5],eas:[3,5],easi:[3,5],easier:[1,3,4,5],easili:[1,4,5],ebi:4,echo:1,ecoli:4,ecolog:1,edb9:1,edg:1,edit:[0,1,3,5],editor:4,edu:1,effect:[1,4,5],effici:[1,3,4,5],effort:1,either:[1,3,4,5],elaps:5,elimin:3,ell:5,els:5,elsewher:4,email:3,embark:5,embed:0,emploi:[1,3,4,5],empti:[0,5],enabl:[0,1,3,4,5],encapsul:1,encod:[1,5],encompass:5,encount:[0,1,3,5],end:[1,3,4],endors:1,engin:[4,5],enhanc:[0,3],enough:5,ensur:[1,3,4,5],ensureformathead:5,enter:[1,3,5],enterpris:3,entir:[1,3,4,5],entireti:5,entri:[1,5],env:[1,3],environ:[0,1,3,5],equal:[1,3,4,5],equilibrium:[1,5],equival:[1,3,4,5],ergonom:3,erron:3,error:[3,4,5],escherichia:4,escherichia_coli_k_12_substr__dh10b_uid58979:4,especi:[3,5],essenti:[1,5],establish:[1,3],estim:[0,1,2,3,5],etc:[1,3,4,5],european:4,eval:5,evalu:[1,2,3],even:[1,5],event:[1,5],everi:[0,1,3,4,5],evid:[1,3,5],evolv:1,exac:5,exact:[1,3,5],exactli:[1,4,5],examin:[3,4,5],exampl:[0,1,3,4],exce:[0,1,5],exceed:[1,5],excel:[3,4],except:[1,2,4,5],excerpt:1,excess:[4,5],exclud:[4,5],exclus:[1,5],execut:[0,1,3,4,5],exemplari:1,exist:[1,4,5],exit:1,exom:[1,4,5],expect:[0,1,3,4,5],expens:[3,5],experi:[3,4,5],experiment:4,expir:5,explan:[3,5],explicit:[4,5],explicitli:[0,1,4,5],explor:5,expr:1,express:1,extend:[1,3,5],extens:[0,2,3,4,5],extern:[4,5],extra:[0,1,4,5],extract:[2,4],extrem:[1,5],f1_g_s_1m:1,f1_n_an_1m:1,f1_o_bm_1m:1,f1_o_sp_1m:1,f1_o_td_1m:1,f1_v_pf_1m:1,f8968de308e3:4,f_sampl:5,facil:4,facilit:5,factor:[1,5],fail:[0,1,4,5],fail_val:1,failur:5,fairer:5,fairli:1,fall:[1,5],fals:[0,4,5],falsi:5,fam01:1,fam:[1,4,5],famili:[1,2,3],familiar:[3,5],family1:5,family_sim:5,farther:5,fashion:4,fast:[3,4,5],fasta:[3,4,5],faster:[0,4,5],fastq:[3,4,5],fastqtrim:2,fatal:0,father:[1,3,4,5],father_gt:5,favor:1,fb3b:1,fb8b6b34c5d0:1,featur:[0,1,3,4,5],feb:4,fed:5,feder:1,feedback:0,femal:[1,4,5],few:[1,4,5],fewer:[4,5],field:[0,2,3,4,5],fifth:1,figur:0,file:[2,5],filed:1,fileformat:1,filenam:5,fill:[4,5],filter:2,filtered_sample_na12878:4,find:[1,2,3,5],fine:[0,1,5],finish:[0,4],firefox:4,firmicut:5,first:[0,1,3,4,5],firstli:5,fit:[1,3],five:[1,5],fix:[3,5],flag:[0,1,3,4,5],flatten:1,flexibl:[3,5],flip:5,floor:[1,5],flow:5,fn_ca:5,fna:4,focu:4,focus:[3,5],fold:[1,4,5],follow:[0,1,3,4,5],forc:5,foreach:5,form:[0,1,3,4,5],format:[0,2],former:5,formerli:1,formula:[1,5],fortun:1,forum:[1,3],forward:[1,5],found:[1,4,5],foundat:1,founder:[4,5],four:[1,3],fourth:4,fp_ca:5,frac:5,fraction:[1,3,4,5],fragment:[1,5],frame:1,francisco:[1,5],franklin:1,free:[0,1,3],freememori:0,freq:5,frequenc:[2,3,5],frequent:[1,5],from:[0,1,3,4,5],front:5,ftp:[4,5],full:[0,1,3,4,5],fulli:[1,4,5],fund:1,furnish:1,further:[0,1,3,4,5],g1_samp:5,ga4gh:5,gaastra:[1,5],gac:1,gactctctgacgctgcncgtacgtgccaaaaataagt:1,gagtgctgcaggccgaccagcaactcatggagaagaccaagg:1,gain:5,gap:[2,3,4,5],gca:4,gca_000001405:4,gcc:1,gcg:1,gcgcgcgcgcg:5,gena:1,genb:1,gender:1,gene:5,gener:[0,1,2,3,5],genet:[2,3,5],genetic_map:1,genom:[0,1,2,3,5],genome_ref:5,genomesim:[2,3],genometest:5,genotyp:[1,4,5],genu:5,genuin:5,germlin:[1,4,5],get:[1,5],ggaaggagtgctgcaggccgaccctcatggaga:1,ggaaggggagtgctgcaggccgacc:1,ggaaggggagtgctgcaggccgaccctcatggaga:1,ggi:4,ghz:0,gigabyt:0,github:[1,3,4,5],give:[0,3,4,5],given:[1,3,4,5],glob:5,global:[1,3,5],gnu:1,gnuplot:3,gold:5,goldstandard:5,good:[1,3,4,5],googl:[1,3],gov:[4,5],govern:[1,5],gqd:[1,4,5],gradient:5,grain:5,grant:1,granular:5,graph:4,graphic:[1,3,5],graphviz:[4,5],grch38:4,greater:[1,3,5],greatli:5,grep:5,gridhost:0,gross:5,ground:5,group:[0,2,3,5],gs002290:4,gs00290:4,gsapubftp:4,gsr:1,gsrt:1,gsrtfgi:1,gtct:5,guarante:[3,4,5],guest:5,guid:[1,3],guidelin:3,gunzip:5,gut:4,gzip:[1,5],gzipfix:1,gzipinputstream:1,h1_base:5,h1_cnv:5,h1_coverag:5,h1_read:5,h1_sample_left:5,h1_sample_right:5,h1_test:5,had:[1,5],hair:5,half:[1,3,5],hand:[4,5],handl:[0,1,3,4,5],hap:5,haploid:[1,2,3,5],haplotyp:[4,5],hapmap:2,hapmap_3:4,happen:5,hard:5,hardi:[1,5],hardwar:[0,5],harvard:1,has:[0,1,3,4],hash:5,hashdist:2,hashmap:5,have:[0,1,3,4,5],haven:5,head:4,header:[2,4,5],held:1,help:[1,2,3,4],helper:1,here:[0,3,4,5],herebi:1,herein:1,het:[1,5],heterogen:5,heterozyg:[1,3,5],heterozygos:[1,5],hg18:1,hg19:[1,4,5],hgsid:1,hgtrack:1,hide:5,hierarch:1,high:[0,1,3,4,5],higher:[1,3,4,5],highest:[4,5],highli:[0,3,5],highlight:[2,5],hilbush:[1,5],histogram:[3,5],hit:[1,3,4,5],hold:[0,1,4,5],holder:1,hom:[1,5],home:5,homeland:1,homolog:[3,4],homopolym:[1,5],homozyg:[1,3,5],hope:1,host0:1,host1:1,host:[0,1,3,4],hostnam:[0,1,3],hotspot:5,hour:4,how:[1,3,4,5],howev:[0,1,3,4,5],hs37d5:4,hs38d1:4,hs_map:5,hs_refer:5,hs_snp:5,hshqdc:1,hslo:1,hst1:1,html5:[1,4,5],html:[1,3,4,5],hts:[1,3,4],htsjdk:1,http:[0,1,3,4,5],hull:5,human:[0,1,2,3,5],human_protein_read:5,human_reads_sdf:[1,5],human_ref:5,human_ref_sdf:[1,5],human_refer:[4,5],humanfasta_return:5,humanfastq_return:5,humanmapping8:1,humansdf:5,hyper:1,hypercomplex:1,hypothes:[1,4],hypothesi:[1,4,5],i_22:5,i_7:5,idea:[1,4,5],ideal:4,ident:[1,3,4,5],identif:[1,3,5],identifi:[1,3,4,5],ids:[4,5],ign:5,ignor:[1,4,5],igv:5,illumina1:5,illumina:[1,3,4,5],illumina_p:5,illumina_read:5,illumina_s:5,illumina_sdf:5,illustr:5,imag:[4,5],imagemagick:5,imbal:1,immedi:5,immut:1,impact:[0,5],imping:5,implement:3,impli:[1,5],imprecis:1,improv:[0,3,4,5],impur:5,imput:[1,5],inaccur:5,inadequ:4,inappropri:5,inbreed:1,inc:[1,3,5],incident:1,includ:[0,1,3,4,5],inclus:[1,5],incom:5,inconsist:[1,4,5],incorpor:[4,5],incorrect:[4,5],incorrectli:[1,4,5],increas:[1,3,4,5],increment:5,incur:[1,5],ind:[1,4,5],indel:[1,2,4],independ:[0,1,3,4,5],index:[0,2,3,4],indic:[0,1,3,4,5],indirect:1,individu:[1,3,4,5],industri:[3,5],inexactli:5,infer:4,info:[4,5],inform:[0,2,3,5],ingli:[1,5],inherit:[1,3,4,5],initi:[1,3,4,5],initial_assembl:5,inner:1,innov:3,input:[0,2,4,5],input_readgroup_id:5,ins_1:5,ins_a:5,insert:[1,3,4,5],insid:[1,5],insight:5,inspect:[3,4,5],instal:[1,2,5],instanc:[4,5],instead:[0,1,3,4,5],institut:[0,1,4],instruct:[1,2,4,5],insuffici:4,integ:[1,5],integr:[3,5],intel:[0,3],intend:[1,3,5],intens:[1,5],interact:[1,3,4],interest:[1,4,5],interfac:[2,3],interleav:5,intermedi:5,intern:[0,1,3,4,5],internet:0,interpol:5,interpret:[1,3,5],interrupt:1,intersect:[1,3,4,5],interv:[1,4,5],introduc:[1,3,4,5],introduct:[2,5],inv:5,invers:[1,5],inverse_simpson_index:1,invert:5,investig:[0,3,4,5],invok:[4,5],involv:[4,5],ion:[1,2,5],iont:1,iontorr:[1,4,5],irrelev:5,irrespect:5,irvin:[1,5],isn:5,issu:[3,4,5],iter:3,its:[1,3,4,5],itself:[1,5],iupac:4,jackson:[1,5],jar:[0,1,3],java:[0,1,3,5],javascript:2,jivesoftwar:4,job:[0,1,3,4,5],john:[1,5],join:[1,5],joint:[1,3,4,5],jointli:[4,5],journal:[1,5],jre:[1,3],june:[1,5],just:[0,4],justin:5,jvm:[0,3,5],keep:[1,4],kei:[3,5],kept:[4,5],kind:[1,4,5],kmer:5,know:[4,5],knowledg:[1,5],known:[1,3,4,5],krona:1,kurt:[1,5],kvp40_sample1:5,kvp40_sample2:5,label:[1,3,5],lack:5,lal:[1,4,5],lambda:1,lane:[1,4],lane_id:4,languag:1,laptop:[0,3],larg:[0,1,3,4,5],larger:[4,5],largest:[4,5],last:[1,4,5],later:[0,1,4,5],latter:[4,5],launch:5,law:1,layout:5,lead:[1,3,4,5],leaf:5,learn:[4,5],least:[1,3,4,5],leav:[0,4],left:[1,3,4,5],left_fq:4,legaci:5,len:[1,5],length:[0,1,3,4,5],lenient:5,leq:1,less:[1,3,4,5],let:5,level:[0,1,3,4,5],levenshtein:1,leverag:3,liabil:1,liabl:1,librari:[1,5],licens:[0,1,2],lies:5,life:1,lifetech:4,lift:4,ligat:5,lightweight:5,like:[1,3,4,5],likelihood:[1,3,5],limit:[0,1,3,4,5],lin:[1,5],line:[1,2,3,4],lineag:[1,2],linear:[1,4,5],link:5,linkag:[1,5],linux:[1,3],list:[0,1,3,4,5],listen:[0,5],liter:[1,5],littin:[1,5],littl:[0,1],llc:1,load:[1,3,4,5],local:[0,1,5],locat:[1,3,4,5],loci:[3,5],log10:1,log:[2,3,4,5],log_10:1,logic:5,loh:[1,4,5],longer:[3,5],longest:1,look:[1,4,5],lookup:[2,5],loop:[1,4],loss:[1,5],lot:[4,5],low:[1,3,4,5],lower:[1,3,4,5],ls454:[1,4,5],ls454_pe:5,ls454_se:5,m_sampl:5,mac:0,macbook:0,machin:[1,2,3,4,5],maco:[1,3],made:[1,3,4,5],mai:[0,1,3,4,5],main:[4,5],mainindex:3,maintain:3,maize_chr:5,maize_refer:5,major:0,make:[0,1,3,4,5],malakshah:[1,5],male:[1,4,5],mammalian:4,manag:[1,2,5],mandat:5,mani:[0,1,3,4,5],manipul:[1,5],manner:[1,4],manual:[0,1,3,4,5],manufactur:5,map:[0,2],map_out:5,map_popul:4,map_rs:5,map_sample1:4,map_sample_na12878:4,map_temp_sample1:4,map_trio:4,mapf:[2,3,4],mapp:[2,3,4],mapper:5,mapq:[1,5],mapx1:5,mapx2:5,mapx:[2,3,4],mapx_out:5,mapx_result:4,mapxrenam:2,mar:4,mark:[4,5],marker:3,markup:0,mask:[4,5],mat:[1,4,5],match:[1,3,4],mate:[1,3,4,5],materi:[1,4,5],matern:[1,5],math:5,matric:1,matrix:[1,3,4,5],matter:4,max:[1,3,4,5],maxaltdepth:5,maxdel:5,maxim:[3,5],maximis:5,maximum:[0,1,4,5],maxin:5,maxscor:1,mcp:5,mcu:5,mcv:5,mean:[1,4,5],meaning:[1,5],meaningfulli:5,meaningless:5,meanqad:[1,5],meant:3,measur:[4,5],mechan:[0,3,5],med_qual:5,medic:3,medicin:3,meet:[0,1,5],mehul:[1,5],member:[3,4,5],memori:[0,1,3,4,5],mendelian:[1,2,4],menu:5,mer:[1,3,4,5],merchant:1,merg:[1,4],messag:[1,3,4,5],met:[1,4],meta:[2,3],metabol:3,metadata:[3,4,5],metagenom:[0,1,2],method:[0,1,5],metric:[1,5],mgh:1,microbi:[1,3],microsoft:[3,4],midpoint:5,might:[1,3,4,5],million:[1,4],min:[1,4,5],minim:[3,4,5],minimum:[0,1,4,5],minor:1,mis:5,mislabel:5,mismatch:[1,3,5],miss:[1,4,5],mit:1,mitochondria:1,mix:[3,5],mixtur:[1,3],mkdir:4,mnp:[1,3,4,5],mode:[2,3],model:[0,1,2,3,5],modif:[2,3,5],modifi:[1,3,4,5],modul:[0,1],molecular:1,monitor:3,month:0,more:[0,1,3,4,5],mosaic:5,most:[1,3,4,5],mostli:3,mother:[1,3,4,5],mother_gt:5,mount:0,move:[4,5],ms_8399:4,ms_auto_b14:4,much:[3,4,5],multi:[1,2,3,4,5],multiallel:5,multipl:[1,2,3,4,5],multipli:5,must:[0,1,3,4,5],mutat:[1,3,5],mylan:0,mypedigre:5,mysamrg:1,mysdf:5,n_sampl:5,na12877:[1,4],na12878:[1,4,5],na12878_gs002290:4,na12878_l001:4,na12878_l001_1:4,na12878_l001_2:4,na12878_map:5,na12878model:4,na12878trio:4,na12879:4,na12880:4,na12881:4,na12882:4,na12883:4,na12884:4,na12885:4,na12886:4,na12887:4,na12888:4,na12889:[4,5],na12890:[4,5],na12891:[4,5],na12892:[4,5],na12893:4,na19238:1,na19239:1,na19240:[1,4,5],na24143:5,na24149:5,na24385:5,na24631:5,na24694:5,na24695:5,naa:[1,5],name:[0,1,2,3,5],namedata0:3,nameindex0:3,namepointer0:3,namespac:5,nation:1,nativ:4,natur:[1,4,5],nbacc:1,nc_010473:4,ncbi2tax:[1,2],ncbi:[1,4,5],ncbitaxdir:5,nearbi:5,nearest:[3,4,5],necessari:[1,4,5],necessarili:[1,5],need:[0,1,3,4,5],needleman:1,neg:[4,5],negat:1,neglig:1,neighbor:[3,4,5],neither:[1,5],neq:5,net:[0,1],network:[0,4,5],new_human:4,new_human_snp:4,newer:[0,5],newick:[1,3,4],newick_format:1,newli:5,next:[4,5],ngsparam:0,nichola:1,nicngsrtfgilcipkkpgkypallrvpgagvr:1,nih:[4,5],nirqgsrtfgi:1,nirqgsrtfgifcmpkasgnypallrvpgaggr:1,nirqgsrtfgilcmpkasgnypallrvpgagvr:1,nlm:[4,5],node:[0,1,3,4,5],nohzadeh:[1,5],nois:5,nomenclatur:3,non:[0,1,3,4,5],non_snp_roc:5,none:[0,1,4,5],noninfring:1,nonneg:5,nonspecif:1,nor:1,norank:5,normal:[1,2,3,5],normal_:4,normal_map_:4,normal_reads_:4,normalis:5,note:[0,1,4,5],notic:[2,4],notif:0,notion:1,novel:[1,3,4,5],novo:[1,3,5],now:[0,1,4,5],nref:1,nuccor:4,nuclear:5,nucleotid:[1,3,4,5],num:5,number:[0,1,2,5],numer:[1,5],nvrpgsrtygilcmpkkegkypallrvpgagir:1,object:[1,3,4,5],observ:[1,4,5],obtain:[1,4,5],obviat:5,obviou:5,obvious:1,occasion:[1,5],occupi:5,occur:[1,3,4,5],ococ:[1,5],ocof:[1,5],oct:4,off:[1,4,5],offic:3,offspr:4,often:5,old:5,omit:[1,4,5],omni:[4,5],onc:[1,4,5],ondov:1,one:[0,1,3,4,5],ones:[4,5],onli:[0,1,3,4],onlin:[1,3,5],onto:5,open:[1,3,5],openjdk:1,oper:[0,1,3,5],oppos:4,opt:0,optic:5,optim:[1,2,5],option:[0,1,2,3,5],oracl:1,order:[1,3,4,5],ordinari:5,ordinarili:5,org:[1,4,5],organ:[0,1,3,5],orient:[1,4,5],origin:[1,3,4,5],orl:5,orp:5,other:[0,1,3,4,5],otherwis:[0,1,4,5],our:[1,3,4,5],out:[1,4,5],output:[0,2,4],output_readgroup_id:5,outset:5,outsid:[1,4,5],over:[1,3,4,5],overal:[3,4,5],overlai:5,overlap:[1,4,5],overrid:[1,3,5],overridden:[1,3],overview:[2,4],overwrit:5,own:[0,1,4,5],owner:1,ownership:3,pac_bio:5,pacbio:[1,5],pacif:5,packag:[3,5],pad:5,pai:0,pair:[1,3,4],pairwis:5,pane:5,par1:1,par2:1,par:[1,4],parallel:[0,2,4,5],paramet:[0,1,3,4,5],parent:[1,4,5],parentag:5,parid:1,parkwai:1,pars:4,parseint:5,part:[1,4,5],parti:[1,4,5],partial:5,particular:[1,3,4,5],particularli:[4,5],partit:[4,5],partition1:4,partition2:4,partition3:4,pass:[1,5],past:[1,5],pat:[1,4,5],patent:[1,3,5],patern:[1,5],path:[0,1,4,5],pathwai:3,patient:4,pattern:4,pca:[1,4],pcr:5,pdf:[1,3,4,5],ped:[2,3,4,5],ped_vcf_head:5,pedfilt:[1,2],pedigre:[2,5],pedsamplesim:[1,2],pedstat:[1,2,4],peel:5,penal:5,penalti:[1,5],pend:[1,5],per:[0,1,3,4,5],percent:[1,5],percentag:[1,3,5],perform:[1,2,3],perl:5,perman:5,permiss:[0,1,5],permit:[1,3,4,5],person1:5,person2:5,person3:5,person:[1,3],persona:5,personb:5,pertain:4,petrim:2,pf3:5,pflow:0,pfread:0,pftemplat:0,pgm:4,phase2_reference_assembly_sequ:4,phase:[1,3,4,5],phen:[1,4,5],phenotyp:[1,5],phillippi:1,phred:[1,5],phylogenet:[1,5],phyloxml:[1,3,4],phylum:[1,5],physic:1,pick:5,pie:[1,4,5],piec:3,pielou:1,pileup:[3,5],pipelin:[0,1,2,4],place:[1,3,4,5],placement:[3,5],plan:[1,2,3,4],plant:[1,3],plasmid:1,platform:[1,3,4,5],platinum:4,platinumgenom:4,plausibl:5,pleas:[1,3,5],plink:1,ploidi:[1,4],plot:[1,3,4,5],plu:[1,3,5],pnext:[1,5],png:[4,5],pngu:1,point:[1,4,5],poisson:5,polymorph:[1,3,5],polymutt2:1,polyploid:[1,4],poor:[1,3,4,5],pop:5,pop_vari:4,popsim:[2,3],popul:[1,2,3],popular:5,population_prior:4,popvar:5,port:[0,5],portabl:[4,5],portion:1,pos:[1,4,5],posit:[1,3,4],possess:4,possibl:[0,1,4,5],post:[1,3,5],posterior:[1,3,5],potenti:[1,4,5],power:5,ppb:1,practic:[1,4,5],pragmat:5,pre:[1,4,5],prebuilt:4,preced:1,precis:1,predict:[1,3,4,5],predictor:5,prefer:[3,4,5],prefix:5,prepar:[0,1,2,3,5],preprocess:5,prerequisit:4,presenc:[3,4,5],present:[1,3,4,5],preserv:5,preset:5,presum:5,prevent:[1,4,5],previou:[1,4,5],previous:5,primari:[4,5],primarili:[1,4,5],princip:[1,3,4,5],principl:5,print:[4,5],prior:[1,2,3],prioriti:5,privileg:[0,1,3],pro:4,probabl:[1,3,4,5],probe:5,problem:[0,1,5],problemat:5,procedur:[4,5],proceed:1,process:[0,2,4,5],processor:[0,1,3,5],procur:1,produc:[1,2,3,5],product:[0,1,2,3,5],profit:1,program:[1,3,4,5],progress:[0,2,3,5],project:[1,4,5],promot:1,prompt:[1,3,5],proper:[1,5],properli:1,properti:[0,1,5],proport:[1,4,5],proprietari:1,protein:[1,2],protein_db:5,proteobacteria:5,prototyp:1,prove:4,provid:[0,1,3,4,5],proxi:0,prune:5,pseudo:1,pseudoautosom:[1,4],pub:5,publish:1,pur:1,purcel:1,purchas:3,pure:5,puriti:1,purpos:[1,3,4,5],push:[1,5],put:[1,3,4,5],qname:[1,5],quad:3,qual:[4,5],qualiti:[0,1,3,4],qualti:5,quantiti:4,quarantin:[1,3],queri:[1,3,5],query_seq:5,querylength:1,question:[1,3,5],quick:[1,2,5],quickli:4,quit:5,quot:1,r121336:4,r_2011_07_19_20_05_38_user_b14:4,rack:[0,3],rais:[4,5],ram:[0,1,3,4,5],random:[4,5],randomli:5,rang:[1,3,4,5],rank:[1,5],ranknam:1,rapid:3,rate:[1,3,5],rather:[1,3,4,5],rathod:[1,5],ratio:[1,3,4,5],raw:[1,4,5],rce:1,rcequiv:1,rdefault:5,reach:[1,5],read:[0,2],read_data:1,readabl:[3,5],readcount:5,readgroup1:5,readgroup:[1,5],readi:[4,5],readm:[2,3],reads_1:4,reads_2:4,reads_sd:5,reads_shuffl:5,readsim:[2,3],readsimev:2,real:[0,1,3,4,5],realign:1,realist:0,realiti:4,realli:5,realtimegenom:[1,3,4,5],reason:[1,4,5],recal:[4,5],recalibr:[4,5],receiv:[1,4,5],receiver_operating_characterist:5,recip:4,recogn:[4,5],recombin:5,recommend:[1,3,4,5],recomput:1,reconstruct:1,record:[0,2,3,4],redirect:5,redistribut:1,reduc:[1,3,4,5],reduct:[1,5],redund:[4,5],redwood:1,ref:[4,5],refer:[0,2,3],referenc:1,refin:5,reflect:[1,5],refseq:4,regard:[1,3,4,5],regardless:[1,5],regener:5,region:[2,3,4],regist:1,registr:4,regular:5,reject:5,rel:[1,4,5],relabel:[1,5],relat:[1,3,4,5],related:4,relationship:[1,2,4,5],relax:5,releas:[1,3,5],relev:[4,5],reli:5,reliabl:[3,5],remain:[1,5],remap:4,remot:1,remov:[1,3,4,5],renam:[4,5],reorder:5,repeat:[1,4,5],repetit:5,replac:[1,4,5],replic:5,report:[0,1,2,3,5],repres:[1,3,4,5],represent:[1,4,5],reproduc:1,request:0,requir:[0,1,3,4,5],requisit:5,rerun:[4,5],rescor:[1,4],research:[1,3,4,5],reserv:1,reset:5,resid:[4,5],residu:[1,4,5],resolut:5,resolv:5,resourc:4,respect:[1,3,4],restor:5,restrict:[1,3,4,5],result:[0,2,3,4,5],retain:[1,4,5],retriev:[1,3,5],reus:4,reusabl:4,revers:[1,5],review:[2,3],rg1:5,rgstat:[1,4,5],richard:[1,5],right:[1,3,4,5],right_fq:4,rightarrow:5,rname:1,rnext:[1,5],roch:1,rocplot:2,root:[1,3,4,5],ross:[1,5],rough:5,roughli:5,row:4,rpb:[1,4],rpm:[0,3],rs23987382:1,rsh:1,rtg:[0,2],rtg_default_thread:0,rtg_jar:0,rtg_java:0,rtg_java_opt:0,rtg_mem:[0,1,3,5],rtg_models_dir:0,rtg_proxi:0,rtg_references_dir:[0,5],rtg_talk_back:0,rtg_talkback:0,rtg_taxonomi:5,rtg_usag:0,rtg_usage_dir:0,rtg_usage_host:0,rtg_usage_opt:0,rtgcustom:5,rtgv2:1,rule:0,run:[1,2,3,5],runtim:[0,1],s12_r1:5,s12_r2:5,s12_trim:5,s12_trimmed_r1:5,s_sampl:5,sahar:[1,5],sai:5,sam2bam:2,sam:[2,4,5],same:[0,1,3,4],samfil:5,sammerg:2,sampl:[0,2],sample1:[4,5],sample1_1:4,sample2:4,sample2_2:4,sample3:4,sample4:4,sample5:4,sample_1:4,sample_2:4,sample_id:4,sample_na12878:4,sample_nam:5,sampleread:5,samplereadssdf:5,samplereplai:[2,3],samplesim:[2,3],samrenam:[1,2,3],samstat:[2,4],samtool:[1,3,4,5],samv1:[1,3],sanger:[4,5],sars_coronaviru:5,sars_sample1:5,sars_sample2:5,satisfi:1,save:[0,1,5],sbp:[1,4],scale:[0,1,3,5],scan:[3,5],scenario:[3,4,5],scheme:5,scienc:1,scont:5,score:[0,2,3,5],screen:[1,4,5],script:[0,1,3,4],sdf2cg:2,sdf2fasta:[2,3],sdf2fastq:[2,3],sdf2sam:2,sdf:[1,3,4,5],sdf_proteinref:5,sdf_read:5,sdfsplit:[2,3],sdfstat:[1,2,4],sdfsubseq:2,sdfsubset:2,sean:[1,5],search:[1,2],search_out:5,second:[0,1,3,4,5],secondari:5,secondli:5,section:[1,3,4,5],secur:1,see:[1,3,4,5],seed:5,seem:1,seen:5,segment:[1,3,4,5],segreg:4,select:[1,3,4,5],self:3,sell:1,semant:[1,4,5],semi:[1,3,5],semicolon:1,send:0,sens:[1,5],sensit:[0,2,4],sensitivity_and_specif:5,sent:0,sep:4,separ:[0,1,3,4,5],seq:[1,4],seqdata0:3,seqpointer0:3,seqs_for_alignment_pipelin:4,sequenc:[1,2,5],sequence_nam:5,sequenceindex0:3,seri:[3,5],serial:0,server:[0,1,3,4,5],servic:[1,5],session:5,set:[0,1,2,3,5],setup:5,sever:[0,1,3,4,5],sex:[1,2,3,5],shall:1,shannon:1,shannon_index:1,shape:1,share:[0,1,5],shell:[1,4,5],shift:[1,5],shore:1,shorter:[3,5],should:[1,4,5],show:[1,3,4,5],shown:[1,3,4,5],shtml:1,shuffl:5,side:[1,5],sidepan:5,sign:4,signal:[1,5],signific:[3,5],significantli:3,sim:5,sim_read:5,simil_out:5,similar:[2,3],similarli:[3,4,5],simpl:[0,1,3,4],simpli:[4,5],simpson:1,simul:[1,2,3],simulatedsequence1:1,simulatedsequencen:5,simultan:[1,4,5],sinc:[1,4,5],singapor:[1,5],singl:[1,2,3,5],site:[1,2,3,5],situat:[1,3,4,5],six:[1,3],size:[0,1,3,4,5],skew:5,skip:[1,5],slice:5,slider:5,slightli:[1,5],slow:[4,5],sm_base:1,sm_father:1,sm_mother:1,sm_normal:4,sm_son:1,sm_tumor:[1,4],small:[2,3,4,5],smaller:[0,1,3,4,5],smith:1,smooth:[1,3,4,5],snp1:5,snp2:5,snp:[1,2,4],snp_chr5:5,snp_roc:5,snp_sample_na12878:4,snp_sample_na12878_chr:4,snp_sample_na12891:4,snps_biallel:5,snps_cov5:5,soft:[1,5],softwar:[0,1,2,4,5],solari:3,sole:5,solexa:[1,4,5],solut:[3,5],som:5,somat:[1,2],somatic_out:4,some:[0,1,3,4,5],someth:5,sometim:[3,5],somewhat:[4,5],somewher:5,son:[3,4,5],son_gt:5,sort:[1,3,4,5],sourc:[1,3,4,5],sourceforg:1,soviet:1,sp_out:5,space:[1,3,4,5],span:5,spars:5,speak:5,spec:[1,3,4],speci:[2,3],special:[1,4,5],specialist:3,species_even:1,species_genom:5,species_result:4,specif:[0,1,2,3,5],specifi:[0,1,3,4,5],speed:[0,3,5],sph:1,split:[1,4],split_read:5,spot:5,spotti:4,spread:5,spreadsheet:[3,4,5],spuriou:5,sqrt:5,squar:5,srr002978:1,srr005490:5,ssc:[1,4,5],stage:[1,4,5],stand:1,standard:[0,1,2,4,5],start:[0,1,2,4,5],startup:5,stat:[1,5],statist:[1,2,3,5],statu:[0,1,4,5],stdin:5,stdout:5,step:[1,3,4,5],still:[1,4,5],storag:[0,3],store:[0,1,3,4,5],straight:[1,5],strain:[3,4,5],strain_map:5,strain_read:5,strain_ref:5,strand:[1,4],strategi:[4,5],streamlin:4,strength:[1,4,5],stretch:5,strict:[1,5],stricter:5,strictli:5,string:5,stringenc:5,strl:1,strong:[1,5],strongli:4,stru:1,structur:[1,2,3,5],stuart:[1,5],studi:5,sub:[4,5],subclass:5,subdirectori:[1,4,5],subfamili:5,subgenu:5,subgroup:5,subject:[1,3,5],sublicens:1,submiss:0,submit:0,subord:5,subphylum:5,subsampl:5,subscrib:1,subsequ:[1,3,4,5],subset:[3,5],subset_read:5,subspeci:5,substanti:1,substitut:[1,3,4,5],subtleti:5,subtli:5,subtre:5,succeed:0,success:[1,3,5],successfulli:[3,5],suffic:1,suffici:[1,4,5],suffix:0,suggest:[1,3,4,5],suit:[3,4],suitabl:[1,4],sum:[1,5],sum_:5,summar:5,summari:[1,3,4,5],superkingdom:[1,5],superphylum:5,suppli:[0,1,3,4,5],support:[0,1,2,4,5],suppress:5,sure:[3,4],suspect:5,sv_bayesian:[1,4,5],sv_interest:[1,5],sv_out:5,sv_sample_na12878:4,sv_simpl:1,svdecompos:2,svg:5,svprep:2,svtype:[1,5],sweep:5,symbol:[3,4,5],synonym:5,synopsi:5,syntax:[2,3],synthet:[3,5],system:[0,1,3,4,5],tab:[1,3,4,5],tabix:[1,4,5],tabl:[1,3,4,5],tabular:[4,5],tacttactttcttcttacttatgtggtaataagctactcggttgggca:1,tag:[1,5],take:[1,3,4,5],taken:[1,3,4,5],talkback:2,tandem:[1,5],tar:5,target:[1,4,5],task:[1,2,3,5],taxa:[1,3],taxdump:5,taxfilt:[1,2],taxid:1,taxon:[1,2,5],taxonom:[2,3,5],taxonomi:[2,4,5],taxonomy_lookup:1,taxstat:[1,2],tbi:4,tcca:1,tcctcca:1,tccttca:1,tcount:5,tdrwgsrfygvlcvpkkegkypallrvpgagir:1,team:5,technic:[2,4,5],technolog:[1,3,4,5],tell:5,temp:5,tempdir:[4,5],templat:[1,5],temporari:[0,4,5],temporarili:5,ten:5,term:[1,5],termin:[0,1,3,4,5],terminolog:5,test:[0,1,3,4,5],text:[0,1,3,4,5],textual:5,tgacgcctctgctcttgcaagtcnttcacattca:1,tgagctgtgtt:1,tggaaggccag:1,than:[1,3,4,5],thei:[0,1,4,5],them:[1,3,4,5],themselv:[3,4,5],theori:1,thereof:1,thi:[0,1,3,4,5],thing:4,think:5,third:[1,3,4,5],thirdli:5,thorough:[1,5],those:[1,3,4,5],though:0,thread:[0,1,5],three:[1,4,5],threshold:[0,1,3,4,5],through:[1,3,4,5],throughout:4,throughput:[1,3,4,5],thu:[1,4,5],thumb:0,tid:[1,4,5],tie:1,tied:4,time:[1,2,3,4,5],tip:[1,5],tissu:4,titl:5,tlen:[4,5],tmp:[4,5],tofix:5,togeth:[1,3,4,5],toler:5,too:[1,3,5],tool:[1,2,3,5],top:[1,4,5],topequ:5,topn:[0,5],torrent:[1,2],tort:1,total:[1,3,4,5],totalmemori:0,tpl:[1,4,5],tpng:[4,5],trace:4,track:[1,4,5],trade:[4,5],trademark:1,tradeoff:5,tradit:5,traffic:[1,3],trail:5,train:[0,2,5],transbord:5,transform:[1,3,5],transit:5,translat:[1,2,3,5],transvers:5,trap:0,tre:[1,4],treat:[1,5],tree:[1,3,4,5],triallel:5,tribe:5,trigg:[1,5],trigger:5,trim:4,trio:[4,5],trio_map:5,trio_vari:4,trivial:5,truncat:[0,5],truth:[4,5],truthi:5,tsm:[1,4,5],tsv:[1,3,4,5],tta:1,ttgg:5,tttaaat:1,tttg:5,tttgcgcgcttgcgcgttt:5,tttt:5,tttttttttctttctttctttctttctttctttctttctttctttctttctttc:5,tumor:[2,3,5],tumor_:4,tumor_map_:4,tumor_reads_:4,tumoronli:[1,2,3,4],tumoronly_out:4,tune:[2,4,5],turn:[1,4,5],two:[0,1,3,4,5],txt:[0,2,3,4,5],type:[1,3,4,5],typic:[0,1,3,4,5],ucsc:[1,4],ucsc_id:4,umich:1,unaffect:[1,5],unalign:5,unambigu:5,unavail:[4,5],unchang:5,unclassifi:1,uncompress:5,undecid:5,undefin:[1,5],under:[1,5],undergo:5,undergon:3,underli:0,underneath:[1,5],undescrib:1,undesir:[4,5],undo:5,unduli:5,unexpect:[4,5],unfilt:5,unfiltered_fin:5,unflatten:5,uniform:[1,5],uniformli:5,union:5,uniqu:[0,1,3,4,5],unit:[1,4,5],unix:[0,3,5],unknown:[1,4,5],unless:[1,4,5],unlik:5,unmap:[1,3,4,5],unmat:[1,3,4,5],unmerg:5,unnam:5,unnecessari:4,unpair:[1,5],unphas:5,unplac:[1,5],unpreced:3,unrel:[3,4],unreli:1,unset:[1,5],unsign:[1,3],until:1,untransl:[1,3,5],unus:5,unusu:4,unwant:3,unwieldi:[1,4],unzip:[1,3],uon:5,updat:[1,3,4,5],upload:1,upon:4,upper:[1,3,5],url:[0,1],usa:1,usag:[1,2,3,5],usageserv:[0,2],use:[0,1,2,3,5],used:[0,1,3,4,5],useful:[0,1,3,5],user:[1,2,3,4,5],usernam:0,uses:[0,1,3,4,5],using:[0,2,3],usr:[1,3],usual:[1,3,5],utah:4,util:[1,2,4],vaf1:[1,5],vaf:[1,5],valid:[1,3,5],valu:[0,1,3,4,5],valuabl:5,vari:[0,1,3,4,5],variabl:[0,1,3,5],varianc:5,variant:2,variat:[0,1,2,5],varieti:[3,4,5],variou:[1,3,5],vcf:[2,3,4],vcfannot:[2,4],vcfdecompos:2,vcfeval:[2,4],vcffilter:[1,2,4],vcfmerg:[2,4],vcfsplit:2,vcfstat:[2,4],vcfsubset:[2,4],vcfv4:[1,3,4],vega:[1,5],vendor:[4,5],verbos:5,veri:[0,1,3,4,5],verif:5,verifi:[1,3,4,5],version1:1,version:[0,1,2,3,4],versu:1,via:[0,1,3,4,5],view:[1,2,3,5],viewer:[3,5],viewpoint:5,violat:5,virtual:[1,3,5],visibl:3,visit:1,visual:[0,1,3,4,5],vof:4,vol1:4,volum:3,vulner:4,wai:[1,4,5],wall:[1,3,4],want:[4,5],ware:[1,5],warn:[4,5],warranti:1,washington:1,waterman:1,web:[4,5],websit:[1,4,5],wedg:[1,5],weight:[4,5],weighted_roc:5,weinberg:[1,5],well:[1,3,4,5],were:[1,5],wget:5,wgs:[4,5],what:[1,4,5],when:[0,1,3,4,5],whenev:[3,5],where:[0,1,3,4,5],wherea:[4,5],whether:[0,1,4,5],which:[0,1,3,4,5],whichev:[3,5],white:1,whole:[1,4,5],whom:1,whose:5,why:3,wide:[3,4,5],widget:5,width:5,wiki:[1,5],wikipedia:[1,5],wild:[1,5],window:[0,1,3,5],wise:4,wish:[0,4,5],within:[0,1,3,4,5],without:[0,1,3,5],word:[1,3,4,5],work:[0,1,4,5],workflow:[4,5],workspac:1,would:[1,3,4,5],wrapper:[1,3],write:[0,1,3,4,5],written:[0,1,3,4,5],wunsch:1,www:[1,4,5],x86_64:0,xattr:[1,3],xmax:5,xmin:5,xml:[1,4],xrx:[1,4],year:5,yes:[1,4],yet:[3,5],yield:[3,4,5],ymax:5,ymin:5,you:[0,1,3,4,5],your:[0,1,3,4,5],yourself:5,ypallrvpgag:1,yyyi:0,zcat:[4,5],zealand:[1,5],zero:[1,4,5],zip:[1,3],zless:4,zook:5,zoom:5,zp_03299218:1,zp_03678041:1,zp_05285664:1,zp_05759216:1,zxf:5,zygos:[1,4,5]},titles:["Administration &amp; Capacity Planning","Appendix","Table Of Contents","Overview","RTG product usage - baseline progressions","RTG Command Reference"],titleterms:{"function":[1,3,5],POS:1,Use:4,Using:[1,4],abund:3,access:1,adapt:5,addit:1,addpacbio:5,administr:0,advanc:[0,5],against:4,align:[1,3],allel:5,alt:1,altern:0,analysi:3,annot:5,api:1,appendix:1,approach:1,assembl:5,assist:3,aview:5,avr:4,avrbuild:5,avrpredict:5,avrstat:5,bacteri:4,bam:[1,3],baselin:4,bed:1,benchmark:[3,5],bgzip:5,bndeval:5,breakdown:3,build:4,calibr:5,call:4,caller:3,cancer:4,capac:0,cg2sdf:5,cgmap:[1,5],cgsim:5,check:4,checkminvers:1,childsim:5,chrom:1,chrstat:5,cli:5,cnv:[3,5],color:0,column:5,combin:5,command:[0,1,3,5],common:5,compar:5,comparison:5,complex:3,composit:5,comput:1,configur:0,consensu:5,construct:5,contamin:[3,4],content:[1,2],copi:[3,4],coverag:[1,3,4,5],creat:[3,4],curv:5,data:[3,4,5],databas:4,decomposit:5,denovosim:5,deploy:3,descript:[1,3],detect:[3,4,5],directori:1,discord:[1,4,5],distribut:[1,5],dna:4,end:5,ensurefilterhead:1,ensureformathead:1,ensureinfohead:1,error:1,estim:4,evalu:[4,5],exampl:5,except:0,expr:5,express:5,extens:1,extract:5,famili:[4,5],fastqtrim:5,field:1,file:[0,1,3,4],filter:[1,3,4,5],filter_header_str:1,find:4,fly:5,format:[1,3,4,5],format_field:1,format_header_str:1,frequenc:4,gap:1,gener:4,genet:1,genom:4,genomesim:5,graph:5,group:[1,4],gui:5,haploid:4,hapmap:4,has:5,hashdist:5,header:1,help:5,highlight:0,human:4,indel:[3,5],index:[1,5],info:1,info_field:1,info_header_str:1,inform:[1,4],input:[1,3],instal:[0,3,4],instruct:3,interact:5,interfac:5,introduct:3,ion:4,javascript:[1,5],keep:5,licens:[3,5],line:[0,5],lineag:5,log:0,lookup:1,machin:0,manag:[0,3,4],map:[1,3,4,5],mapf:5,mapp:[1,5],mapx:[1,5],mapxrenam:5,match:5,mendelian:[3,5],merg:5,meta:5,metagenom:[3,4,5],mode:[4,5],model:4,modif:1,multi:0,multipl:0,name:4,ncbi2tax:5,normal:4,notic:1,number:[3,4],onli:5,optim:[0,3],option:4,output:[1,3,5],overview:3,pair:5,parallel:[1,3],ped:1,pedfilt:5,pedigre:[1,3,4],pedsamplesim:5,pedstat:5,perform:[0,4,5],petrim:5,pipelin:[3,5],plan:0,ploidi:5,popsim:5,popul:[4,5],posit:5,precis:5,prepar:4,print:1,prior:[4,5],process:[1,3],produc:4,product:4,progress:4,protein:[3,4,5],qual:1,qualiti:5,quick:3,read:[1,3,4,5],readm:1,readsim:5,readsimev:5,record:[1,5],ref:1,refer:[1,4,5],region:[1,5],relationship:3,report:4,rescor:5,respect:5,result:1,review:4,roc:5,rocplot:5,rtg:[1,3,4,5],rtg_minimum_vers:1,run:[0,4],sam2bam:5,sam:[1,3],same:5,sammerg:5,sampl:[1,3,4,5],sample_nam:1,samplereplai:5,samplesim:5,samrenam:5,samstat:5,score:[1,4],script:5,sdf2cg:5,sdf2fasta:5,sdf2fastq:5,sdf2sam:5,sdfsplit:5,sdfstat:5,sdfsubseq:5,sdfsubset:5,search:[3,4,5],sensit:[3,5],sequenc:[3,4],set:4,sex:4,similar:[1,4,5],simpl:5,simul:5,singl:[0,4],site:4,small:1,snp:[3,5],softwar:3,somat:[3,4,5],speci:[1,4,5],specif:4,split:5,squash:5,standard:3,start:3,statist:4,string:1,structur:4,support:3,svdecompos:5,svprep:5,syntax:5,tabl:2,talkback:0,task:4,taxfilt:5,taxon:3,taxonom:1,taxonomi:1,taxstat:5,technic:[1,3],time:0,tool:4,torrent:4,train:4,translat:4,trim:5,tumor:4,tumoronli:5,tune:3,txt:1,usag:[0,4],usageserv:5,use:4,user:0,using:[1,4,5],util:[3,5],variant:[1,3,4,5],variat:[3,4],vcf:[1,5],vcfannot:5,vcfdecompos:5,vcfeval:5,vcffilter:5,vcfmerg:5,vcfsplit:5,vcfstat:5,vcfsubset:5,version:5,versu:5,view:4}})
\ No newline at end of file
+Search.setIndex({docnames:["administration","appendix","index","overview","product_usage","rtg_command_reference"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":3,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":2,"sphinx.domains.rst":2,"sphinx.domains.std":1,sphinx:56},filenames:["administration.rst","appendix.rst","index.rst","overview.rst","product_usage.rst","rtg_command_reference.rst"],objects:{},objnames:{},objtypes:{},terms:{"0_07":0,"0_161":5,"0bfc":0,"0daf":1,"0gb":5,"0x02":1,"0x08":1,"0x100":1,"1000g_v37_phase2":4,"1000genom":4,"100m":4,"1219061gi":1,"143_____1":1,"15_grch38":4,"15_grch38_no_alt_plus_hs38d1_analysis_set":4,"16g":5,"1b19":1,"1i11":1,"1i14":1,"1r1":1,"1r2":1,"1r5":1,"1r5n10":1,"1sampl":5,"1t2":1,"1x1":1,"1x11":1,"1x15":1,"1x19":1,"20human":4,"20humans_an_ac":4,"20humans_prior":4,"283m1d1i32n8m":1,"2a36ba21397":1,"2b20":1,"2b5":1,"2sampl":5,"2x18":1,"2x46":1,"314_pool30":4,"36c48ec4":1,"3gb":5,"3sampl":5,"4157329b":1,"419a":1,"41d195dec4cd":1,"44116e7a2195":1,"454_pe":5,"454_read":5,"454_sdf":5,"454_se":5,"455d":1,"467b":4,"48d5":1,"48e6":1,"48g":[0,1,3],"4b11":1,"4d74":1,"4ecc9eb83e0ccec4":1,"4f6c2eca":0,"52b7":1,"5c2ee18":1,"5n10":1,"5n23":1,"5n25":1,"5n8":1,"6236f4e":5,"6aef897c3d6ff0c78aff06ac189178dd":4,"70s":1,"718f8317b7":5,"71dce5dba129":1,"73e374719c7f":4,"7798b1a5":1,"79d6626":1,"7ded37d7":4,"7f77":1,"817f":4,"86b4f8e98fa6":1,"8acc8413":1,"96ca":1,"976e":1,"9f7b8a5":1,"boolean":5,"break":[1,3,4,5],"byte":3,"case":[0,1,3,4,5],"class":5,"default":[0,1,3,4,5],"export":5,"final":[4,5],"float":[1,5],"function":[2,4],"import":[1,4,5],"int":5,"long":[1,5],"na\u00efv":5,"new":[0,1,3,4,5],"null":[1,5],"public":[1,3,4],"return":[1,5],"short":[1,3,4,5],"switch":[3,4,5],"throw":5,"true":[0,1,5],"try":4,"typeof":5,"var":[1,5],"while":[1,4,5],ADE:1,AND:1,ARE:1,Adding:[0,1],And:[1,5],BOING:1,BUT:1,But:1,DHS:1,DOING:1,DOS:5,Doing:5,FOR:1,For:[0,1,3,4,5],IDs:[1,3,4,5],INS:5,NCS:[1,4,5],NOT:1,Not:[4,5],One:[1,3,4,5],SAS:3,SUCH:1,Such:[1,5],THE:1,The:[0,1,3,4,5],Then:[0,4,5],There:[1,3,4,5],These:[0,1,3,4,5],USE:1,Use:[0,1,2,3,5],Used:[1,5],Uses:5,Using:[2,3,5],WGS:5,WITH:1,Will:1,With:[0,1,3,4,5],_____27:1,_indel:5,_renam:5,a10:1,a7da:4,aagtacttcttagttcaattactatcatcatcttacctaattactact:1,aat:1,aatacttttcattctttactattacttacttattcttacttacttact:1,abbrevi:5,abc:1,aberr:[3,5],abi:1,abil:[0,3,4,5],abl:[1,4,5],abnorm:[4,5],about:[1,3,4,5],abov:[0,1,4,5],abp:[1,4],abs:5,absenc:5,absent:5,absolut:5,abund:[1,2,4,5],acaryochloris_marina:1,accacct:1,accept:[1,3,4,5],access:[0,2,3,4,5],accessor:1,accg:1,accgttgactctgtgacgctgcacgtacgt:1,accommod:[3,4],accompani:[1,3,5],accomplish:[1,3,4,5],accord:[3,4,5],accordingli:5,account:[1,4,5],accumul:[1,3],accur:[1,4,5],accuraci:[3,4,5],acgc:5,acgt:1,achiev:[4,5],acholeplasma_laidlawii:1,acid:[1,5],acidiphilium_cryptum:1,acidobacteria_bacterium:1,acidothermus_cellulolyticu:1,acidovorax_avena:1,across:[1,3,4,5],act:5,action:1,actual:[1,3,4,5],adam:1,adapt:[1,4],adaptor:5,add:[0,1,5],added:5,adding:[0,1,3,5],addit:[0,2,3,4],addition:[0,4,5],addpacbio:2,address:5,adequ:4,adf1:1,adf2:1,adf:1,adjac:[1,4,5],adjust:[1,3,4,5],administr:[1,2,3],adr1:1,adr2:1,adr:1,advanc:2,advantag:[3,5],advers:4,advic:[3,5],advis:1,affect:[1,4,5],affin:5,afflict:[4,5],after:[0,1,3,4,5],agaggagagaacnggtttggaaccattc:1,against:[1,2,3,5],age:1,aggcgtctgcagccgacgcg:5,aggreg:5,aggress:3,agre:[1,5],agreement:[1,5],aim:[4,5],aka:5,alan:[1,5],algorithm:[1,3,4,5],alia:5,align:[2,4,5],alignments1:5,alignments2:5,alignments_renam:5,all:[0,1,3,4,5],allel:[1,4],allevi:5,alloc:[0,1,3],allosom:1,allow:[1,3,4,5],alon:1,along:[1,3,4,5],alongsid:5,alphanumer:1,alreadi:[1,4,5],also:[0,1,3,4,5],alt:5,altdepth:5,alter:[0,1,3,4,5],altern:[1,2,3,4,5],although:[0,1,4,5],altogeth:5,alwai:[1,3,4,5],ambigu:[1,3,4,5],amino:[1,5],amongst:4,amount:[0,4,5],amplif:4,amplifi:3,amqv00000000:1,amqv01000000:1,amqv01000002:1,amqv01000004:1,amqv01000006:1,anagaacnggaaccattcatggaaggccagagtga:1,anagaactgg_____aaccattcatggaaggccagagtga:1,anagaactggaaccattcatggaaggccagtga:1,analys:5,analysi:[0,1,2,4,5],analyt:[3,5],analyz:[3,5],anchor:5,ancillari:3,ani:[0,1,3,4,5],anim:1,ann:5,annot:[1,3,4],announc:[1,3],anomali:4,anonym:4,anoth:[0,1,4,5],ansi:0,ansicon:0,ant:1,anywher:1,apach:1,api:[2,5],appear:[1,5],append:5,appendix:[2,3,5],appl:[1,3],appli:[0,1,4,5],applic:[0,1,3,4,5],approach:[2,3,4,5],appropri:[0,1,3,4,5],approxim:[4,5],arbitrari:[4,5],arch:0,archiv:4,area:[1,3,5],arg:5,argument:[0,1,3,5],aris:[1,3,4,5],arithmet:4,arm:[1,3,5],around:[1,5],arrai:[1,5],arrang:5,artifact:5,ascend:5,ascii:[1,3,5],ask:0,assembl:[2,4],assert:5,assign:[0,1,3,5],assist:[1,2,4,5],associ:[1,3,4,5],assum:[0,1,3,4,5],assumpt:5,assur:3,ata:0,atcgtaaaataaatgca:5,atcgtaaataaaatgca:5,atgc:5,atgg:5,att:5,attach:5,attempt:[1,5],attract:5,attribut:[1,3,4,5],atttt:5,aug:4,augment:[0,5],australia:[1,5],author:[1,5],auto:[0,5],autom:3,automat:[0,1,3,4,5],autosom:[1,4,5],avail:[0,1,3,4,5],averag:[1,4,5],aview:2,avoid:[1,5],avr:[0,1,2,5],avrbuild:[2,4],avrpredict:[2,4],avrstat:[2,4],awai:[1,5],awar:[1,3,4,5],awk:[4,5],axes:5,axi:5,b06:0,b14:4,b1f96b37:1,b37:4,b472:1,b6318de1:1,b68c:1,b7baa85ebf66:0,b7ed:4,bac:1,bac_map:1,bac_reads_sdf:1,bac_ref_sdf:1,back:[1,5],background:5,backstep:1,bact:5,bact_db:5,bact_read:5,bact_sampl:5,bacteri:[2,3],bacteria:[1,4],bacteriophage_kvp40:5,bad:[1,3,4,5],bai:4,balanc:[3,4,5],bam:[2,4,5],band:5,bang:1,banner:5,bar:5,bare:1,barrier:5,base:[0,1,3,4],baselin:[2,3,5],baseline_sampl:5,basenam:4,bash:[1,3,5],basi:[1,3,4,5],basic:[1,3,4],bat:[0,1,3],batch:4,battel:1,bayesian:[1,3,4,5],baz:1,bdd9:1,be70:0,beagl:1,becaus:[1,3,4,5],becom:[4,5],bed:[2,3,4,5],bedgraph:[1,5],bedtool:4,been:[1,3,4,5],befor:[1,5],beforehand:5,begin:[3,5],behav:5,behavior:[0,4,5],being:[1,3,4,5],belong:1,below:[1,3,4,5],benchmark:[0,2],bergman:1,best:[1,3,4,5],better:[1,3,4,5],between:[1,3,4,5],beyond:4,bf9f:1,bgzip:[1,2,4],bherer:1,bherer_etal_sexualdimorphismrecombin:1,bia:[1,4,5],biallel:5,bias:5,bidirect:5,billion:1,bin:[1,3,5],binari:[1,3,4,5],biodefens:1,bioinformat:3,biolog:3,biologi:[1,5],biorxiv:5,bioscienc:5,biostat:1,bit:[1,3,5],blacklist:5,blade:0,blank:1,blast:[1,5],blastp:5,blastx:[3,5],blind:5,blind_13:5,blind_15:5,blind_8:5,block:[4,5],blosum45:5,blosum62:[3,5],blosum80:5,bnbi:1,bnd:[1,5],bndeval:2,board:0,bochet:1,bodi:3,border:5,boston:1,both:[1,3,4,5],bound:[1,3,5],boundari:[1,4,5],braithwait:[1,5],branch:5,brand:1,breadth:[1,3,4],break_out:5,breakdown:[2,5],breakend:[1,4,5],breakpoint:[1,4,5],brewer_acc:5,brewer_dark2:5,brewer_pair:5,brewer_pastel1:5,brewer_pastel2:5,brewer_set1:5,brewer_set2:5,brewer_set3:5,brian:[1,5],bring:5,broad:[1,4],broadinstitut:4,broadli:5,broken:1,browser:[4,5],bruijn:5,bubbl:5,bucket:[4,5],bui:5,build37:5,build:[0,1,2,3,5],builder:5,built:[1,3,4,5],bundl:4,busi:1,button:5,bz2:5,bzip2:[1,5],c0561a1d:1,c477b940:4,c_sampl:5,cach:0,cad2cc3c476a:1,calcul:[1,3,4,5],calibr:[1,2,3,4],call:[0,1,2,3,5],callabl:4,caller:[1,2,4,5],calls_sampl:5,came:5,can:[0,1,3,4,5],cancer:[1,2,3,5],candid:[1,5],cannot:5,cap:5,capabl:[0,1,3,4,5],capac:[2,3],captur:[4,5],card:5,care:[4,5],carri:[4,5],cat:[1,4],categor:[1,5],categori:[1,5],caus:[1,5],causal:3,caution:5,caveat:4,cbherer:1,ccaaaaataagt:1,cccccca:1,ccctcca:1,cctcctagcggtacatctccagccccttcctagna:1,cctggagg:1,ceil:5,cell:[1,5],cellular:1,center:[0,1,3],centimorgan:1,central:[0,1],ceph:[4,5],ceph_pedigre:5,certain:[1,5],certainli:5,ceu:4,ceu_trio:5,cfg:[0,1,3],cftr:1,cg1:[4,5],cg2:[4,5],cg2sdf:[2,3,4],cg_3x_readst:5,cg_map:5,cg_read:5,cg_source_fil:5,cggaggggagggcgcggagcggagg:5,cggaggggagggcgcggagcggaggggagggcgcggagcggagg:5,cgi:[1,4,5],cgmap:[2,3,4],cgmap_sample_na12878:4,cgsim:[2,3],cgt:1,chain:1,chanc:[4,5],chang:[1,3,4,5],chapter:[1,3,4,5],charact:[0,1,4,5],characterist:[1,3,4,5],charg:1,chart:[1,4,5],check:[1,2,5],checkbox:5,child:[1,4,5],children:[4,5],childsim:[1,2,3],chines:5,choic:[4,5],choos:[0,4,5],chosen:[1,4,5],chr10:[1,4,5],chr11:[1,4],chr12:[1,4],chr13:[1,4],chr14:[1,4],chr15:[1,4],chr16:[1,4],chr17:[1,4],chr18:[1,4],chr19:[1,4],chr1:[1,4,5],chr1_ki270706v1_random:4,chr1_ki270707v1_random:4,chr1_ki270708v1_random:4,chr20:[1,4],chr21:[1,4,5],chr22:[1,4],chr2:[1,4],chr3:[1,4],chr4:[1,4],chr5:[1,4],chr6:[1,4],chr7:[1,4],chr8:[1,4],chr9:[1,4],chr:[1,4,5],chrm:[1,4],chrom:5,chrominfopag:1,chromosom:[1,3,4,5],chrstat:2,chrx:[1,4,5],chry:[1,4],chunk:[1,5],cigar:[1,5],cipo:[1,5],circular:[1,4],circumst:5,citat:5,cite:1,clade:5,claim:1,clariti:1,classic:5,classif:5,classifi:[3,5],classpath:1,clear:[1,3,5],cleari:[1,5],cli:[2,3],click:5,clip:[1,5],clist:1,clock:[0,1,3,4],close:[1,5],closer:5,closest:[1,4,5],clu:1,cluster:[0,1,3,4,5],cm000663:4,cmb:[1,5],cmd:5,cmpk:1,cmpkasgnypallrvpgag:1,cnv:[1,2,4],cnv_s1_:4,cnv_s1_s2:4,cnvsim:5,code:[1,4,5],coeffici:1,cohort:5,coli:4,collaps:[4,5],collat:[0,5],colleagu:5,collect:[0,4,5],collis:5,color:[2,5],column:[1,3,4],com:[1,3,4,5],combin:[1,3,4],come:[3,5],comma:[0,1,5],command:[2,4],commandlin:0,commenc:5,comment:[1,4,5],commerci:[0,3],common:[1,3,4],commonli:[0,5],commun:[3,4,5],comp_out:5,compar:[3,4],comparison:[0,1,3,4],compat:5,compens:5,complement:[1,5],complet:[1,3,4,5],complete_genom:5,complete_genomics_2:5,completegenom:[1,4,5],complex:[1,2,4,5],complianc:1,complic:5,compon:[1,3,4,5],composit:[2,3],comprehens:[1,3,5],compress:[0,3,4,5],compris:[1,3,4,5],comput:[0,2,3,4,5],computation:[4,5],con:4,concaten:5,concept:5,conceptu:[3,5],concern:5,conclus:5,concord:5,condit:[0,1,4,5],conemu:0,confid:[1,3,5],confidenti:0,configur:[1,2,3,4,5],conjunct:[4,5],connect:[1,5],consensu:3,consequ:5,consequenti:1,conserv:5,consid:[1,4,5],consider:[4,5],consist:[0,1,3,5],consol:[0,5],constant:1,constitu:5,constitut:4,constrain:5,constraint:[1,3,5],construct:[1,3,4],consult:[1,5],consum:5,consumpt:5,contact:[1,3,4,5],contain:[0,1,3,4,5],contamin:[2,5],content:[0,5],context:[1,5],contig:[1,4,5],contigu:5,continu:[1,5],contract:1,contrari:[1,5],contrast:5,contribut:[1,5],contributor:1,control:[0,3,5],convei:1,conveni:[1,4,5],convent:[1,5],convers:[1,3,4,5],convert:[1,3,4,5],convex:5,coordin:[1,4,5],cope:4,copi:[0,1,2,5],copyright:1,core:[0,1,3,5],correct:[1,3,4,5],correctli:[4,5],correspond:[1,4,5],cosm3805:1,cosmic:[4,5],cost:[1,3,5],could:[1,4,5],count:[1,4,5],countermeasur:1,coupl:5,cours:4,cov_sample_na12878:4,cover:[1,3,4,5],coverag:[0,2],coverage_level:1,coveragetsv:5,cpu:[0,3,5],cram:5,crash:0,creat:[0,1,2,5],creation:[1,4,5],credit:5,criteria:[1,5],criterion:5,crop:3,cross:[3,4,5],crossov:[1,5],ctcatggaga:1,ctt:5,cttaaac:1,cttaac:1,cttt:5,cumul:[1,4],curat:5,current:[0,1,3,4,5],custom:[0,1,3,4],customis:5,customiz:3,cut:5,cutoff:[4,5],cyanobacteria:1,d74f45d:0,d_sampl:5,damag:1,dash:5,data:[0,1,2],databas:[1,2,3,5],dataset:[0,1,5],date:[0,1,4,5],daughter1:5,daughter2:5,daughter:[3,4,5],davi:5,david:[1,5],dbsnp:[4,5],dcoc:[1,5],dcof:[1,5],ddr3:3,deal:[1,4,5],debug:[3,5],decid:[1,5],decim:5,decis:[0,1,5],declar:[1,5],decod:5,decoi:[1,4],decompos:5,decompress:[1,4,5],decreas:[3,4,5],dedic:1,deep:3,deeper:[3,4],def:1,defin:[0,1,3,4,5],definit:[1,5],degre:[4,5],del:5,delet:[1,3,4,5],delimit:[1,5],delin:3,deliv:[1,3,5],delta:[1,5],demand:[0,1,3],demo:1,demonstr:[0,4,5],denot:[1,4,5],denovo:5,denovosim:[2,3],dens:[4,5],densiti:5,depart:[1,5],depend:[0,1,3,4,5],deploy:[0,1,2,5],depth:[1,3,4,5],deriv:[1,3,4,5],descend:[1,5],describ:[0,1,3,4,5],descript:[0,2,4,5],design:[1,3,5],desir:[0,1,3,4,5],destin:[0,5],detail:[1,3,4,5],detect:[0,1,2],determin:[0,1,3,4,5],determinist:5,develop:[1,3,4,5],deviat:[1,5],dh10b:4,diagram:5,dictionari:1,did:[3,4,5],didn:5,differ:[0,1,3,4,5],difficult:5,difficulti:5,dimension:[1,4,5],diploid:[1,3,4],dir:[3,5],dir_map:5,direct:[1,5],directli:[0,1,3,4,5],directori:[0,2,3,4,5],disabl:[0,5],disagre:1,disambigu:5,discard:[1,3,4,5],disclaim:1,disconnect:5,discord:2,discord_pair:1,discord_sample_na12878:4,discordantli:[1,4,5],discov:[1,4],discrep:5,discuss:[1,3,5],diseas:3,disk:[0,3,4,5],displai:[0,1,3,4,5],distanc:[1,3,5],distinct:[1,4],distribut:[2,3,4],divers:[1,3],diversity_index:1,divid:[0,1,5],dna:[1,2,3,5],dnp:[1,5],document:[0,1,4,5],doe:[1,3,4,5],doesn:5,doi:[1,5],doing:[1,4],dokladi:1,domin:5,don:[4,5],done:[1,4,5],dot:[4,5],doubl:[1,5],doubt:5,down:5,download:[1,4,5],downstream:[3,4,5],dp10to20:5,dp20to30:5,dp30to40:5,dpr:[1,4],drag:5,dramat:[1,5],draw:5,drawn:5,drive:0,drop:[4,5],drtg:0,dual:3,due:[1,3,4,5],dump:[1,5],duo:0,dup:[1,5],duplic:[1,4,5],dure:[0,1,3,4,5],duster:5,dynam:[1,5],e9e7:4,each:[0,1,3,4,5],eap2:1,earlier:[1,5],eas:[3,5],easi:[3,5],easier:[1,3,4,5],easili:[1,4,5],ebi:4,echo:1,ecoli:4,ecolog:1,edb9:1,edg:1,edit:[0,1,3,5],editor:4,edu:1,effect:[1,4,5],effici:[1,3,4,5],effort:1,either:[1,3,4,5],elaps:5,elimin:3,ell:5,els:5,elsewher:4,email:3,embark:5,embed:0,emploi:[1,3,4,5],empti:[0,5],enabl:[0,1,3,4,5],encapsul:1,encod:[1,5],encompass:5,encount:[0,1,3,5],end:[3,4],endors:1,engin:[4,5],enhanc:[0,3],enough:5,ensur:[1,3,4,5],ensureformathead:5,enter:[1,3,5],enterpris:3,entir:[1,3,4,5],entireti:5,entri:[1,5],env:[1,3],environ:[0,1,3,5],equal:[1,3,4,5],equilibrium:[1,5],equival:[1,3,4,5],ergonom:3,erron:3,error:[3,4,5],escherichia:4,escherichia_coli_k_12_substr__dh10b_uid58979:4,especi:[3,5],essenti:[1,5],establish:[1,3],estim:[0,1,2,3,5],etc:[1,3,4,5],european:4,eval:5,eval_:5,eval_famili:5,eval_family_roc:5,evalu:[1,2,3],even:[1,5],event:[1,5],everi:[0,1,3,4,5],evid:[1,3,5],evolv:1,exac:5,exact:[1,3,5],exactli:[1,4,5],examin:[3,4,5],exampl:[0,1,3,4],exce:[0,1,5],exceed:[1,5],excel:[3,4],except:[1,2,4,5],excerpt:1,excess:[4,5],exclud:[4,5],exclus:[1,5],execut:[0,1,3,4,5],exemplari:1,exist:[1,4,5],exit:1,exom:[1,4,5],expect:[0,1,3,4,5],expens:[3,5],experi:[3,4,5],experiment:4,expir:5,explan:[3,5],explicit:[4,5],explicitli:[0,1,4,5],explor:5,expr:1,express:1,extend:[1,3,5],extens:[0,2,3,4,5],extern:[1,4,5],extra:[0,1,4,5],extract:[2,4],extrem:[1,5],f1_g_s_1m:1,f1_n_an_1m:1,f1_o_bm_1m:1,f1_o_sp_1m:1,f1_o_td_1m:1,f1_v_pf_1m:1,f8968de308e3:4,f_sampl:5,facil:4,facilit:5,factor:[1,5],fail:[0,1,4,5],fail_val:1,failur:5,fairer:5,fairli:[1,5],fall:[1,5],fals:[0,4,5],falsi:5,fam01:1,fam:[1,4,5],famili:[1,2,3],familiar:[3,5],family1:5,family_sim:5,farther:5,fashion:4,fast:[3,4,5],fasta:[3,4,5],faster:[0,4,5],fastq:[3,4,5],fastqtrim:2,fatal:0,father:[1,3,4,5],father_gt:5,favor:1,fb3b:1,fb8b6b34c5d0:1,featur:[0,1,3,4,5],feb:4,fed:5,feder:1,feedback:0,femal:[1,4,5],few:[1,4,5],fewer:[4,5],field:[0,2,3,4,5],fifth:1,figur:0,file:[2,5],filed:1,fileformat:1,filenam:5,fill:[4,5],filter:2,filtered_sample_na12878:4,find:[1,2,3,5],fine:[0,1,5],finish:[0,4],firefox:4,firmicut:5,first:[0,1,3,4,5],firstli:5,fit:[1,3],five:[1,5],fix:[3,5],flag:[0,1,3,4,5],flatten:1,flexibl:[3,5],flip:5,floor:[1,5],flourish:5,flow:5,fn_ca:5,fna:4,focu:4,focus:[3,5],fold:[1,4,5],follow:[0,1,3,4,5],forc:5,foreach:5,form:[0,1,3,4,5],format:[0,2],former:5,formerli:1,formula:[1,5],fortun:1,forum:[1,3],forward:[1,5],found:[1,4,5],foundat:1,founder:[4,5],four:[1,3],fourth:4,fp_ca:5,frac:5,fraction:[1,3,4,5],fragment:[1,5],frame:1,francisco:[1,5],franklin:1,free:[0,1,3],freememori:0,freq:5,frequenc:[2,3,5],frequent:[1,5],friendli:5,from:[0,1,3,4,5],front:5,ftp:[4,5],full:[0,1,3,4,5],fulli:[1,4,5],fund:1,furnish:1,further:[0,1,3,4,5],g1_samp:5,ga4gh:5,gaastra:[1,5],gac:1,gactctctgacgctgcncgtacgtgccaaaaataagt:1,gagtgctgcaggccgaccagcaactcatggagaagaccaagg:1,gain:5,gap:[2,3,4,5],gc55to60:5,gc60to65:5,gca:4,gca_000001405:4,gcc:1,gccontent:5,gcg:1,gcgcgcgcgcg:5,gena:1,genb:1,gender:1,gene:5,gener:[0,1,2,3,5],genet:[2,3,5],genetic_map:1,genom:[0,2,3],genome_ref:5,genomesim:[2,3],genometest:5,genotyp:[1,4,5],genu:5,genuin:5,germlin:[1,4,5],get:[1,5],ggaaggagtgctgcaggccgaccctcatggaga:1,ggaaggggagtgctgcaggccgacc:1,ggaaggggagtgctgcaggccgaccctcatggaga:1,ggi:4,ghz:0,gigabyt:0,github:[1,3,4,5],give:[0,3,4,5],given:[1,3,4,5],glob:5,global:[1,3,5],gnu:1,gnuplot:3,gold:5,goldstandard:5,good:[1,3,4,5],googl:[1,3],gov:[4,5],govern:[1,5],gqd:[1,4,5],gradient:5,grain:5,grant:1,granular:5,graph:4,graphic:[1,3,5],graphviz:[4,5],grch37_gc55to60_slop50:5,grch37_gc60to65_slop50:5,grch38:4,greater:[1,3,5],greatli:5,grep:5,gridhost:0,gross:5,ground:5,group:[0,2,3,5],gs002290:4,gs00290:4,gsapubftp:4,gsr:1,gsrt:1,gsrtfgi:1,gtct:5,guarante:[3,4,5],guest:5,guid:[1,3],guidelin:3,gunzip:5,gut:4,gzip:[1,5],gzipfix:1,gzipinputstream:1,h1_base:5,h1_cnv:5,h1_coverag:5,h1_read:5,h1_sample_left:5,h1_sample_right:5,h1_test:5,had:[1,5],hair:5,half:[1,3,5],hand:[4,5],handl:[0,1,3,4,5],hap:5,haploid:[1,2,3,5],haplotyp:[4,5],hapmap:2,hapmap_3:4,happen:5,hard:5,hardi:[1,5],hardwar:[0,5],harvard:1,has:[0,1,3,4],hash:5,hashdist:2,hashmap:5,have:[0,1,3,4,5],haven:5,head:4,header:[2,4,5],held:1,help:[1,2,3,4],helper:1,here:[0,3,4,5],herebi:1,herein:1,het:[1,5],heterogen:5,heterozyg:[1,3,5],heterozygos:[1,5],hexaploid:1,hg18:1,hg19:[1,4,5],hgsid:1,hgtrack:1,hide:5,hierarch:1,high:[0,1,3,4,5],higher:[1,3,4,5],highest:[4,5],highli:[0,3,5],highlight:[2,5],hilbush:[1,5],histogram:[3,5],hit:[1,3,4,5],hold:[0,1,4,5],holder:1,hom:[1,5],home:5,homeland:1,homolog:[3,4],homopolym:[1,5],homozyg:[1,3,5],hope:1,host0:1,host1:1,host:[0,1,3,4],hostnam:[0,1,3],hotspot:5,hour:4,how:[1,3,4,5],howev:[0,1,3,4,5],hs37d5:4,hs38d1:4,hs_map:5,hs_refer:5,hs_snp:5,hshqdc:1,hslo:1,hst1:1,html5:[1,4,5],html:[1,3,4,5],hts:[1,3,4],htsjdk:1,http:[0,1,3,4,5],hull:5,human:[0,1,2,3,5],human_protein_read:5,human_reads_sdf:[1,5],human_ref:5,human_ref_sdf:[1,5],human_refer:[4,5],humanfasta_return:5,humanfastq_return:5,humanmapping8:1,humansdf:5,hyper:1,hypercomplex:1,hypothes:[1,4],hypothesi:[1,4,5],i_22:5,i_7:5,idea:[1,4,5],ideal:4,ident:[1,3,4,5],identif:[1,3,5],identifi:[1,3,4,5],ids:[4,5],ign:5,ignor:[1,4,5],igv:5,illumina1:5,illumina:[1,3,4,5],illumina_p:5,illumina_read:5,illumina_s:5,illumina_sdf:5,illustr:5,imag:[4,5],imagemagick:5,imbal:1,immedi:5,immut:1,impact:[0,5],imping:5,implement:3,impli:[1,5],imprecis:1,improv:[0,3,4,5],impur:5,imput:[1,5],inaccur:5,inadequ:4,inappropri:5,inbreed:1,inc:[1,3,5],incident:1,includ:[0,1,3,4,5],inclus:[1,5],incom:5,inconsist:[1,4,5],incorpor:[4,5],incorrect:[4,5],incorrectli:[1,4,5],increas:[1,3,4,5],increment:5,incur:[1,5],ind:[1,4,5],indel:[1,2,4],independ:[0,1,3,4,5],index:[0,2,3,4],indic:[0,1,3,4,5],indirect:1,individu:[1,3,4,5],industri:[3,5],inexactli:5,infer:4,info:[4,5],inform:[0,2,3,5],ingli:[1,5],inherit:[1,3,4,5],initi:[1,3,4,5],initial_assembl:5,inner:1,innov:3,input:[0,2,4,5],input_readgroup_id:5,ins_1:5,ins_a:5,insert:[1,3,4,5],insid:[1,5],insight:5,inspect:[3,4,5],instal:[1,2,5],instanc:[4,5],instead:[0,1,3,4,5],institut:[0,1,4],instruct:[1,2,4,5],insuffici:4,integ:[1,5],integr:[3,5],intel:[0,3],intend:[1,3,5],intens:[1,5],interact:[1,3,4],interest:[1,4,5],interfac:[2,3],interleav:5,intermedi:5,intern:[0,1,3,4,5],internet:0,interpol:5,interpret:[1,3,5],interrupt:1,intersect:[1,3,4,5],interv:[1,4,5],introduc:[1,3,4,5],introduct:[2,5],inv:5,invers:[1,5],inverse_simpson_index:1,invert:5,investig:[0,3,4,5],invok:[4,5],involv:[4,5],ion:[1,2,5],iont:1,iontorr:[1,4,5],irrelev:5,irrespect:5,irvin:[1,5],isn:5,issu:[3,4,5],iter:3,its:[1,3,4,5],itself:[1,5],iupac:4,jackson:[1,5],jar:[0,1,3],java:[0,1,3,5],javascript:2,jivesoftwar:4,job:[0,1,3,4,5],john:[1,5],join:[1,5],joint:[1,3,4,5],jointli:[4,5],journal:[1,5],jre:[1,3],june:[1,5],just:[0,4],justin:5,jvm:[0,3,5],keep:[1,4],kei:[3,5],kept:[4,5],kind:[1,4,5],kmer:5,know:[4,5],knowledg:[1,5],known:[1,3,4,5],krona:1,kurt:[1,5],kvp40_sample1:5,kvp40_sample2:5,label:[1,3,5],lack:5,lal:[1,4,5],lambda:1,lane:[1,4],lane_id:4,languag:1,laptop:[0,3],larg:[0,1,3,4,5],larger:[4,5],largest:[4,5],last:[1,4,5],later:[0,1,4,5],latter:[4,5],launch:5,law:1,layout:5,lead:[1,3,4,5],leaf:5,learn:[4,5],least:[1,3,4,5],leav:[0,4],left:[1,3,4,5],left_fq:4,legaci:5,len:[1,5],length:[0,1,3,4,5],lenient:5,leq:1,less:[1,3,4,5],let:5,level:[0,1,3,4,5],levenshtein:1,leverag:3,liabil:1,liabl:1,librari:[1,5],licens:[0,1,2],lies:5,life:1,lifetech:4,lift:4,ligat:5,lightweight:5,like:[1,3,4,5],likelihood:[1,3,5],limit:[0,1,3,4,5],lin:[1,5],line:[1,2,3,4],lineag:[1,2],linear:[1,4,5],link:5,linkag:[1,5],linux:[1,3],list:[0,1,3,4,5],listen:[0,5],liter:[1,5],littin:[1,5],littl:[0,1],llc:1,load:[1,3,4,5],local:[0,1,5],locat:[1,3,4,5],loci:[3,5],log10:1,log:[2,3,4,5],log_10:1,logic:5,loh:[1,4,5],longer:[3,5],longest:1,look:[1,4,5],lookup:[2,5],loop:[1,4],loss:[1,5],lot:[4,5],low:[1,3,4,5],lower:[1,3,4,5],ls454:[1,4,5],ls454_pe:5,ls454_se:5,m_sampl:5,mac:0,macbook:0,machin:[1,2,3,4,5],maco:[1,3],made:[1,3,4,5],mai:[0,1,3,4,5],main:[4,5],mainindex:3,maintain:3,maize_chr:5,maize_refer:5,major:0,make:[0,1,3,4,5],malakshah:[1,5],male:[1,4,5],mammalian:4,manag:[1,2,5],mandat:5,mani:[0,1,3,4,5],manipul:[1,5],manner:[1,4],manual:[0,1,3,4,5],manufactur:5,map:[0,2],map_out:5,map_popul:4,map_rs:5,map_sample1:4,map_sample_na12878:4,map_temp_sample1:4,map_trio:4,mapf:[2,3,4],mapp:[2,3,4],mapper:5,mapq:[1,5],mapx1:5,mapx2:5,mapx:[2,3,4],mapx_out:5,mapx_result:4,mapxrenam:2,mar:4,mark:[4,5],marker:3,markup:0,mask:[4,5],mat:[1,4,5],match:[1,3,4],mate:[1,3,4,5],materi:[1,4,5],matern:[1,5],math:5,matric:1,matrix:[1,3,4,5],matter:4,max:[1,3,4,5],maxaltdepth:5,maxdel:5,maxim:[3,5],maximis:5,maximum:[0,1,4,5],maxin:5,maxscor:1,mcp:5,mcu:5,mcv:5,mean:[1,4,5],meaning:[1,5],meaningfulli:5,meaningless:5,meanqad:[1,5],meant:3,measur:[4,5],mechan:[0,3,5],med_qual:5,medic:3,medicin:3,meet:[0,1,5],mehul:[1,5],member:[3,4,5],memori:[0,1,3,4,5],mendelian:[1,2,4],menu:5,mer:[1,3,4,5],merchant:1,merg:[1,4],messag:[1,3,4,5],met:[1,4],meta:[2,3],metabol:3,metadata:[3,4,5],metagenom:[0,1,2],method:[0,1,5],metric:[1,5],mgh:1,microbi:[1,3],microsoft:[3,4],midpoint:5,might:[1,3,4,5],million:[1,4],min:[1,4,5],minim:[3,4,5],minimum:[0,1,4,5],minor:1,mis:5,mislabel:5,mismatch:[1,3,5],miss:[1,4,5],mit:1,mitochondria:1,mix:[3,5],mixtur:[1,3],mkdir:4,mnp:[1,3,4,5],mode:[2,3],model:[0,1,2,3,5],modif:[2,3,5],modifi:[1,3,4,5],modul:[0,1],molecular:1,monitor:3,month:0,more:[0,1,3,4,5],mosaic:5,most:[1,3,4,5],mostli:3,mother:[1,3,4,5],mother_gt:5,mount:0,move:[4,5],ms_8399:4,ms_auto_b14:4,much:[3,4,5],multi:[1,2,3,4,5],multiallel:5,multipl:[1,2,3,4,5],multipli:5,must:[0,1,3,4,5],mutat:[1,3,5],mylan:0,mypedigre:5,myregion:1,mysamrg:1,mysdf:5,n_sampl:5,na12877:[1,4],na12878:[1,4,5],na12878_gs002290:4,na12878_l001:4,na12878_l001_1:4,na12878_l001_2:4,na12878_map:5,na12878model:4,na12878trio:4,na12879:4,na12880:4,na12881:4,na12882:4,na12883:4,na12884:4,na12885:4,na12886:4,na12887:4,na12888:4,na12889:[4,5],na12890:[4,5],na12891:[4,5],na12892:[4,5],na12893:4,na19238:1,na19239:1,na19240:[1,4,5],na24143:5,na24149:5,na24385:5,na24631:5,na24694:5,na24695:5,naa:[1,5],name:[0,1,2,3,5],namedata0:3,nameindex0:3,namepointer0:3,namespac:5,nation:1,nativ:4,natur:[1,4,5],nbacc:1,nc_010473:4,ncbi2tax:[1,2],ncbi:[1,4,5],ncbitaxdir:5,nearbi:5,nearest:[3,4,5],necessari:[1,4,5],necessarili:[1,5],need:[0,1,3,4,5],needleman:1,neg:[4,5],negat:1,neglig:1,neighbor:[3,4,5],neither:[1,5],neq:5,net:[0,1],network:[0,4,5],new_human:4,new_human_snp:4,newer:[0,5],newick:[1,3,4],newick_format:1,newli:5,next:[4,5],ngsparam:0,nichola:1,nicngsrtfgilcipkkpgkypallrvpgagvr:1,nih:[4,5],nirqgsrtfgi:1,nirqgsrtfgifcmpkasgnypallrvpgaggr:1,nirqgsrtfgilcmpkasgnypallrvpgagvr:1,nlm:[4,5],node:[0,1,3,4,5],nohzadeh:[1,5],nois:5,nomenclatur:3,non:[0,1,3,4],non_snp_roc:5,none:[0,1,4,5],noninfring:1,nonneg:5,nonspecif:1,nor:1,norank:5,normal:[1,2,3,5],normal_:4,normal_map_:4,normal_reads_:4,normalis:5,note:[0,1,4,5],notic:[2,4],notif:0,notion:1,novel:[1,3,4,5],novo:[1,3,5],now:[0,1,4,5],nref:1,nuccor:4,nuclear:5,nucleotid:[1,3,4,5],num:5,number:[0,1,2,5],numer:[1,5],nvrpgsrtygilcmpkkegkypallrvpgagir:1,object:[1,3,4,5],observ:[1,4,5],obtain:[1,4,5],obviat:5,obviou:5,obvious:1,occasion:[1,5],occupi:5,occur:[1,3,4,5],ococ:[1,5],ocof:[1,5],oct:4,off:[1,4,5],offic:3,offspr:4,often:5,old:5,omit:[1,4,5],omni:[4,5],onc:[1,4,5],ondov:1,one:[0,1,3,4,5],ones:[4,5],onli:[0,1,3,4],onlin:[1,3,5],onto:5,open:[1,3,5],openjdk:1,oper:[0,1,3,5],oppos:4,opt:0,optic:5,optim:[1,2,5],option:[0,1,2,3,5],oracl:1,order:[1,3,4,5],ordinari:5,ordinarili:5,org:[1,4,5],organ:[0,1,3,5],orient:[1,4,5],origin:[1,3,4,5],orl:5,orp:5,other:[0,1,3,4,5],otherwis:[0,1,4,5],our:[1,3,4,5],out:[1,4,5],output:[0,2,4],output_readgroup_id:5,outset:5,outsid:[1,4,5],over:[1,3,4,5],overal:[3,4,5],overlai:5,overlap:[2,4,5],overrid:[1,3,5],overridden:[1,3,5],overview:[2,4],overwrit:5,own:[0,1,4,5],owner:1,ownership:3,pac_bio:5,pacbio:[1,5],pacif:5,packag:[3,5],pad:5,pai:0,pair:[1,3,4],pairwis:5,palett:5,pane:5,par1:1,par2:1,par:[1,4],parallel:[0,2,4,5],paramet:[0,1,3,4,5],parent:[1,4,5],parentag:5,parid:1,parkwai:1,pars:4,parseint:5,part:[1,4,5],parti:[1,4,5],partial:5,particular:[1,3,4,5],particularli:[4,5],partit:[4,5],partition1:4,partition2:4,partition3:4,pass:[1,5],past:[1,5],pat:[1,4,5],patent:[1,3,5],patern:[1,5],path:[0,1,4,5],pathwai:3,patient:4,pattern:4,pca:[1,4],pcr:5,pdf:[1,3,4,5],ped:[2,3,4,5],ped_vcf_head:5,pedfilt:[1,2],pedigre:[2,5],pedsamplesim:[1,2],pedstat:[1,2,4],peel:5,penal:5,penalti:[1,5],pend:[1,5],pentaploid:1,per:[0,1,3,4,5],percent:[1,5],percentag:[1,3,5],perform:[1,2,3],perl:5,perman:5,permiss:[0,1,5],permit:[1,3,4,5],person1:5,person2:5,person3:5,person:[1,3],persona:5,personb:5,pertain:4,petrim:2,pf3:5,pflow:0,pfread:0,pftemplat:0,pgm:4,phase2_reference_assembly_sequ:4,phase:[1,3,4,5],phen:[1,4,5],phenotyp:[1,5],phillippi:1,phred:[1,5],phylogenet:[1,5],phyloxml:[1,3,4],phylum:[1,5],physic:1,pick:5,pie:[1,4,5],piec:3,pielou:1,pileup:[3,5],pipelin:[0,1,2,4],place:[1,3,4,5],placement:[3,5],plain:5,plan:[1,2,3,4],plant:[1,3],plasmid:1,platform:[1,3,4,5],platinum:4,platinumgenom:4,plausibl:5,pleas:[1,3,5],plink:1,ploidi:[1,4],plot:[1,3,4,5],plu:[1,3,5],pnext:[1,5],png:[4,5],pngu:1,point:[1,4,5],poisson:5,polymorph:[1,3,5],polymutt2:1,polyploid:[1,4],poor:[1,3,4,5],pop:5,pop_vari:4,popsim:[2,3],popul:[1,2,3],popular:5,population_prior:4,popvar:5,port:[0,5],portabl:[4,5],portion:1,pos:[1,4,5],posit:[1,3,4],possess:4,possibl:[0,1,4,5],post:[1,3,5],posterior:[1,3,5],potenti:[1,4,5],power:5,ppb:1,practic:[1,4,5],pragmat:5,pre:[1,4,5],prebuilt:4,preced:1,precis:1,predict:[1,3,4,5],predictor:5,prefer:[3,4,5],prefix:5,prepar:[0,1,2,3,5],preprocess:5,prerequisit:[4,5],presenc:[3,4,5],present:[1,3,4,5],preserv:5,presum:5,prevent:[1,4,5],previou:[1,4,5],previous:5,primari:[4,5],primarili:[1,4,5],princip:[1,3,4,5],principl:5,print:[4,5],prior:[1,2,3],prioriti:5,privileg:[0,1,3],pro:4,probabl:[1,3,4,5],probe:5,problem:[0,1,5],problemat:5,procedur:[4,5],proceed:1,process:[0,2,4,5],processor:[0,1,3,5],procur:1,produc:[1,2,3,5],product:[0,1,2,3,5],profit:1,program:[1,3,4,5],progress:[0,2,3,5],project:[1,4,5],promot:1,prompt:[1,3,5],proper:[1,5],properli:1,properti:[0,1,5],proport:[1,4,5],proprietari:1,protein:[1,2],protein_db:5,proteobacteria:5,prototyp:1,prove:4,provid:[0,1,3,4,5],proxi:0,prune:5,pseudo:1,pseudoautosom:[1,4],pub:5,publish:1,pur:1,purcel:1,purchas:3,pure:5,puriti:1,purpos:[1,3,4,5],push:[1,5],put:[1,3,4,5],qname:[1,5],quad:3,qual:[4,5],qualiti:[0,1,3,4],qualti:5,quantiti:4,quarantin:[1,3],queri:[1,3,5],query_seq:5,querylength:1,question:[1,3,5],quick:[1,2,5],quickli:4,quit:5,quot:1,r121336:4,r_2011_07_19_20_05_38_user_b14:4,rack:[0,3],rais:[4,5],ram:[0,1,3,4,5],random:[4,5],randomli:5,rang:[1,3,4,5],rank:[1,5],ranknam:1,rapid:3,rate:[1,3,5],rather:[1,3,4,5],rathod:[1,5],ratio:[1,3,4,5],raw:[1,4,5],rce:1,rcequiv:1,rdefault:5,reach:[1,5],read:[0,2],read_data:1,readabl:[3,5],readcount:5,readgroup1:5,readgroup:[1,5],readi:[4,5],readm:[2,3],reads_1:4,reads_2:4,reads_sd:5,reads_shuffl:5,readsim:[2,3],readsimev:2,real:[0,1,3,4,5],realign:1,realist:0,realiti:4,realli:5,realtimegenom:[1,3,4,5],reason:[1,4,5],recal:[4,5],recalibr:[4,5],receiv:[1,4,5],receiver_operating_characterist:5,recip:4,recogn:[4,5],recombin:5,recommend:[1,3,4,5],recomput:1,reconstruct:1,record:[0,2,3,4],recreat:5,redirect:5,redistribut:1,reduc:[1,3,4,5],reduct:[1,5],redund:[4,5],redwood:1,ref:[4,5],refer:[0,2,3],referenc:1,refin:5,reflect:[1,5],refseq:4,regard:[1,3,4,5],regardless:[1,5],regener:5,region:[2,3,4],regist:1,registr:4,regular:5,reject:5,rel:[1,4,5],relabel:[1,5],relat:[1,3,4,5],related:4,relationship:[1,2,4,5],relax:5,releas:[1,3,5],relev:[4,5],reli:5,reliabl:[3,5],remain:[1,5],remap:4,remot:1,remov:[1,3,4,5],renam:[4,5],reorder:5,repeat:[1,4,5],repetit:5,replac:[1,4,5],replic:5,report:[0,1,2,3,5],repres:[1,3,4,5],represent:[1,4,5],reproduc:1,request:0,requir:[0,1,3,4,5],requisit:5,rerun:[4,5],rescor:[1,4],research:[1,3,4,5],reserv:1,reset:5,resid:[4,5],residu:[1,4,5],resolut:5,resolv:5,resourc:4,respect:[1,3,4],restor:5,restrict:[1,3,4,5],result:[0,2,3,4,5],retain:[1,4,5],retriev:[1,3,5],reus:4,reusabl:4,revers:[1,5],review:[2,3],rg1:5,rgstat:[1,4,5],richard:[1,5],right:[1,3,4,5],right_fq:4,rightarrow:5,rname:1,rnext:[1,5],roch:1,rocplot:2,root:[1,3,4,5],ross:[1,5],rough:5,roughli:5,row:4,rpb:[1,4],rpm:[0,3],rs23987382:1,rsh:1,rtg:[0,2],rtg_default_thread:0,rtg_jar:0,rtg_java:0,rtg_java_opt:0,rtg_mem:[0,1,3,5],rtg_models_dir:0,rtg_proxi:0,rtg_references_dir:[0,5],rtg_talk_back:0,rtg_talkback:0,rtg_taxonomi:5,rtg_usag:0,rtg_usage_dir:0,rtg_usage_host:0,rtg_usage_opt:0,rtgcustom:5,rtgv2:1,rule:0,run:[1,2,3,5],runtim:[0,1],s12_r1:5,s12_r2:5,s12_trim:5,s12_trimmed_r1:5,s_sampl:5,sahar:[1,5],sai:5,sam2bam:2,sam:[2,4,5],same:[0,1,3,4],samfil:5,sammerg:2,sampl:[0,2],sample1:[4,5],sample1_1:4,sample2:4,sample2_2:4,sample3:4,sample4:4,sample5:4,sample_1:4,sample_2:4,sample_id:4,sample_na12878:4,sample_nam:5,sampleread:5,samplereadssdf:5,samplereplai:[2,3],samplesim:[2,3],samrenam:[1,2,3],samstat:[2,4],samtool:[1,3,4,5],samv1:[1,3],sanger:[4,5],sars_coronaviru:5,sars_sample1:5,sars_sample2:5,satisfi:[1,5],save:[0,1,5],sbp:[1,4],scale:[0,1,3,5],scan:[3,5],scenario:[3,4,5],scheme:5,scienc:1,scont:5,score:[0,2,3,5],screen:[1,4,5],script:[0,1,3,4],sdf2cg:2,sdf2fasta:[2,3],sdf2fastq:[2,3],sdf2sam:2,sdf:[1,3,4,5],sdf_proteinref:5,sdf_read:5,sdfsplit:[2,3],sdfstat:[1,2,4],sdfsubseq:2,sdfsubset:2,sean:[1,5],search:[1,2],search_out:5,second:[0,1,3,4,5],secondari:5,secondli:5,section:[1,3,4,5],secur:1,see:[1,3,4,5],seed:5,seem:1,seen:5,segment:[1,3,4,5],segreg:4,select:[1,3,4,5],self:3,sell:1,semant:[1,4,5],semi:[1,3,5],semicolon:1,send:0,sens:[1,5],sensit:[0,2,4],sensitivity_and_specif:5,sent:0,sep:4,separ:[0,1,3,4,5],seq:[1,4],seqdata0:3,seqpointer0:3,seqs_for_alignment_pipelin:4,sequenc:[1,2,5],sequence_nam:5,sequenceindex0:3,seri:[3,5],serial:0,server:[0,1,3,4,5],servic:[1,5],session:5,set:[0,1,2,3,5],setup:5,sever:[0,1,3,4,5],sex:[1,2,3,5],shadow:5,shall:1,shannon:1,shannon_index:1,shape:1,share:[0,1,5],shell:[1,4,5],shift:[1,5],shore:1,shorter:[3,5],should:[1,4,5],show:[1,3,4,5],shown:[1,3,4,5],shtml:1,shuffl:5,side:[1,5],sidepan:5,sign:4,signal:[1,5],signific:[3,5],significantli:3,sim:5,sim_read:5,simil_out:5,similar:[2,3],similarli:[3,4,5],simpl:[0,1,3,4],simpli:[4,5],simpson:1,simul:[1,2,3],simulatedsequence1:1,simulatedsequencen:5,simultan:[1,4,5],sinc:[1,4,5],singapor:[1,5],singl:[1,2,3,5],site:[1,2,3,5],situat:[1,3,4,5],six:[1,3],size:[0,1,3,4,5],skew:5,skip:[1,5],slice:5,slider:5,slightli:[1,5],slow:[4,5],sm_base:1,sm_father:1,sm_mother:1,sm_normal:4,sm_son:1,sm_tumor:[1,4],small:[2,3,4,5],smaller:[0,1,3,4,5],smith:1,smooth:[1,3,4,5],snp1:5,snp2:5,snp:[1,2,4],snp_chr5:5,snp_roc:5,snp_sample_na12878:4,snp_sample_na12878_chr:4,snp_sample_na12891:4,snps_biallel:5,snps_cov5:5,soft:[1,5],softwar:[0,1,2,4,5],solari:3,sole:5,solexa:[1,4,5],solut:[3,5],som:5,somat:[1,2],somatic_out:4,some:[0,1,3,4,5],someth:[1,5],sometim:[3,5],somewhat:[4,5],somewher:5,son1:5,son2:5,son:[3,4,5],son_gt:5,sort:[1,3,4,5],sourc:[1,3,4,5],sourceforg:1,soviet:1,sp_out:5,space:[1,3,4,5],span:5,spars:5,speak:5,spec:[1,3,4],speci:[2,3],special:[1,4,5],specialist:3,species_even:1,species_genom:5,species_result:4,specif:[0,1,2,3,5],specifi:[0,1,3,4,5],speed:[0,3,5],sph:1,split:[1,4],split_read:5,spot:5,spotti:4,spread:5,spreadsheet:[3,4,5],spuriou:5,sqrt:5,squar:5,srr002978:1,srr005490:5,ssc:[1,4,5],stage:[1,4,5],stand:1,standard:[0,1,2,4,5],start:[0,2,4,5],startup:5,stat:[1,5],statist:[1,2,3,5],statu:[0,1,4,5],stdin:5,stdout:5,step:[1,3,4,5],still:[1,4,5],storag:[0,3],store:[0,1,3,4,5],straight:[1,5],strain:[3,4,5],strain_map:5,strain_read:5,strain_ref:5,strand:[1,4],strategi:[4,5],stratifi:5,streamlin:4,strength:[1,4,5],stretch:5,strict:[1,5],stricter:5,strictli:5,string:5,stringenc:5,strl:1,strong:[1,5],strongli:4,stru:1,structur:[1,2,3,5],stuart:[1,5],studi:5,style:5,sub:[4,5],subclass:5,subdirectori:[1,4,5],subfamili:5,subgenu:5,subgroup:5,subject:[1,3,5],sublicens:1,submiss:0,submit:0,subord:5,subphylum:5,subsampl:5,subscrib:1,subsequ:[1,3,4,5],subset:[3,5],subset_read:5,subspeci:5,substanti:1,substitut:[1,3,4,5],subtleti:5,subtli:5,subtre:5,succeed:0,success:[1,3,5],successfulli:[3,5],suffic:1,suffici:[1,4,5],suffix:0,suggest:[1,3,4,5],suit:[3,4],suitabl:[1,4,5],sum:[1,5],sum_:5,summar:5,summari:[1,3,4,5],superkingdom:[1,5],superphylum:5,suppli:[0,1,3,4,5],support:[0,1,2,4,5],suppress:5,sure:[3,4],suspect:5,sv_bayesian:[1,4,5],sv_interest:[1,5],sv_out:5,sv_sample_na12878:4,sv_simpl:1,svdecompos:2,svg:5,svprep:2,svtype:[1,5],sweep:5,symbol:[3,4,5],synonym:5,synopsi:5,syntax:[2,3],synthet:[3,5],system:[0,1,3,4,5],tab:[1,3,4,5],tabix:[1,4,5],tabl:[1,3,4,5],tabular:[4,5],tacttactttcttcttacttatgtggtaataagctactcggttgggca:1,tag:[1,5],take:[1,3,4,5],taken:[1,3,4,5],talkback:2,tandem:[1,5],tar:5,target:[1,4,5],task:[1,2,3,5],taxa:[1,3],taxdump:5,taxfilt:[1,2],taxid:1,taxon:[1,2,5],taxonom:[2,3,5],taxonomi:[2,4,5],taxonomy_lookup:1,taxstat:[1,2],tbi:4,tcca:1,tcctcca:1,tccttca:1,tcount:5,tdrwgsrfygvlcvpkkegkypallrvpgagir:1,team:5,technic:[2,4,5],technolog:[1,3,4,5],tell:5,temp:5,tempdir:[4,5],templat:[1,5],temporari:[0,4,5],temporarili:5,ten:5,term:[1,5],termin:[0,1,3,4,5],terminolog:5,test:[0,2,3,4,5],tetraploid:[1,5],text:[0,1,3,4,5],textual:5,tgacgcctctgctcttgcaagtcnttcacattca:1,tgagctgtgtt:1,tggaaggccag:1,than:[1,3,4,5],thei:[0,1,4,5],them:[1,3,4,5],themselv:[3,4,5],theori:1,thereof:1,thi:[0,1,3,4,5],thing:4,think:5,third:[1,3,4,5],thirdli:5,thorough:[1,5],those:[1,3,4,5],though:0,thread:[0,1,5],three:[1,4,5],threshold:[0,1,3,4,5],through:[1,3,4,5],throughout:4,throughput:[1,3,4,5],thu:[1,4,5],thumb:0,tid:[1,4,5],tie:1,tied:4,time:[1,2,3,4,5],tip:[1,5],tissu:4,titl:5,tlen:[4,5],tmp:[4,5],tofix:5,togeth:[1,3,4,5],toler:5,too:[1,3,5],tool:[1,2,3,5],top:[1,4,5],topequ:5,topn:[0,5],torrent:[1,2],tort:1,total:[1,3,4,5],totalmemori:0,tpl:[1,4,5],tpng:[4,5],trace:4,track:[1,4,5],trade:[4,5],trademark:1,tradeoff:5,tradit:5,traffic:[1,3],trail:5,train:[0,2,5],transbord:5,transform:[1,3,5],transit:5,translat:[1,2,3,5],transvers:5,trap:0,tre:[1,4],treat:[1,5],tree:[1,3,4,5],triallel:5,tribe:5,trigg:[1,5],trigger:5,trim:4,trio:[4,5],trio_map:5,trio_vari:4,triploid:1,trivial:5,truncat:[0,5],truth:[4,5],truthi:5,tsm:[1,4,5],tsv:[1,3,4,5],tta:1,ttgg:5,tttaaat:1,tttg:5,tttgcgcgcttgcgcgttt:5,tttt:5,tttttttttctttctttctttctttctttctttctttctttctttctttctttc:5,tumor:[2,3,5],tumor_:4,tumor_map_:4,tumor_reads_:4,tumoronli:[1,2,3,4],tumoronly_out:4,tune:[2,4,5],turn:[1,4,5],two:[0,1,3,4,5],txt:[0,2,3,4,5],type:[1,3,4,5],typic:[0,1,3,4,5],ucsc:[1,4],ucsc_id:4,umich:1,unaffect:[1,5],unalign:5,unambigu:5,unavail:[4,5],unchang:5,unclassifi:1,uncompress:5,undecid:5,undefin:[1,5],under:[1,5],undergo:5,undergon:3,underli:0,underneath:[1,5],undescrib:1,undesir:[4,5],undo:5,unduli:5,unexpect:[4,5],unfilt:5,unfiltered_fin:5,unflatten:5,uniform:[1,5],uniformli:5,uninform:5,union:5,uniqu:[0,1,3,4,5],unit:[1,4,5],unix:[0,3,5],unknown:[1,4,5],unless:[1,4,5],unlik:5,unmap:[1,3,4,5],unmat:[1,3,4,5],unmerg:5,unnam:5,unnecessari:4,unpair:[1,5],unphas:5,unplac:[1,5],unpreced:3,unrel:[3,4],unreli:1,unset:[1,5],unsign:[1,3],until:1,untransl:[1,3,5],unus:5,unusu:4,unwant:3,unwieldi:[1,4],unzip:[1,3],uon:5,updat:[1,3,4,5],upload:1,upon:4,upper:[1,3,5],url:[0,1],usa:1,usag:[1,2,3,5],usageserv:[0,2],use:[0,1,2,3,5],used:[0,1,3,4,5],useful:[0,1,3,5],user:[1,2,3,4,5],usernam:0,uses:[0,1,3,4,5],using:[0,2,3],usr:[1,3],usual:[1,3,5],utah:4,util:[1,2,4],vaf1:[1,5],vaf:[1,5],valid:[1,3,5],valu:[0,1,3,4,5],valuabl:5,vari:[0,1,3,4,5],variabl:[0,1,3,5],varianc:5,variant:2,variat:[0,1,2,5],varieti:[3,4,5],variou:[1,3,5],vcf2rocplot:2,vcf:[2,3,4],vcfannot:[2,4],vcfdecompos:2,vcfeval:[2,4],vcffilter:[1,2,4],vcfmerg:[2,4],vcfsplit:2,vcfstat:[2,4],vcfsubset:[2,4],vcfv4:[1,3,4],vega:[1,5],vendor:[4,5],verbos:5,veri:[0,1,3,4,5],verif:5,verifi:[1,3,4,5],version1:1,version:[0,1,2,3,4],versu:1,via:[0,1,3,4,5],view:[1,2,3,5],viewer:[3,5],viewpoint:5,violat:5,virtual:[1,3,5],visibl:3,visit:1,visual:[0,1,3,4,5],vof:4,vol1:4,volum:3,vulner:4,wai:[1,4,5],wall:[1,3,4],want:[4,5],ware:[1,5],warn:[4,5],warranti:1,washington:1,waterman:1,web:[4,5],websit:[1,4,5],wedg:[1,5],weight:[4,5],weighted_roc:5,weinberg:[1,5],well:[1,3,4,5],were:[1,5],wget:5,wgs:[4,5],what:[1,4,5],when:[0,1,3,4,5],whenev:[3,5],where:[0,1,3,4,5],wherea:[4,5],whether:[0,1,4,5],which:[0,1,3,4,5],whichev:[3,5],white:1,whole:[1,4,5],whom:1,whose:5,why:3,wide:[3,4,5],widget:5,width:5,wiki:[1,5],wikipedia:[1,5],wild:[1,5],window:[0,1,3,5],wise:4,wish:[0,4,5],within:[0,1,3,4,5],without:[0,1,3,5],word:[1,3,4,5],work:[0,1,4,5],workflow:[4,5],workspac:1,would:[1,3,4,5],wrapper:[1,3],write:[0,1,3,4,5],written:[0,1,3,4,5],wunsch:1,www:[1,4,5],x86_64:0,xattr:[1,3],xmax:5,xmin:5,xml:[1,4],xrx:[1,4],year:5,yes:[1,4],yet:[3,5],yield:[3,4,5],ymax:5,ymin:5,you:[0,1,3,4,5],your:[0,1,3,4,5],yourself:5,ypallrvpgag:1,yyyi:0,zcat:[4,5],zealand:[1,5],zero:[1,4,5],zip:[1,3],zless:4,zook:5,zoom:5,zp_03299218:1,zp_03678041:1,zp_05285664:1,zp_05759216:1,zxf:5,zygos:[1,4,5]},titles:["Administration &amp; Capacity Planning","Appendix","Table Of Contents","Overview","RTG product usage - baseline progressions","RTG Command Reference"],titleterms:{"function":[1,3,5],POS:1,Use:4,Using:[1,4],abund:3,access:1,adapt:5,addit:[1,5],addpacbio:5,administr:0,advanc:[0,5],against:4,align:[1,3],allel:5,alt:1,altern:0,analysi:3,annot:5,api:1,appendix:1,approach:1,assembl:5,assist:3,aview:5,avr:4,avrbuild:5,avrpredict:5,avrstat:5,bacteri:4,bam:[1,3],base:5,baselin:4,bed:1,benchmark:[3,5],bgzip:5,bndeval:5,breakdown:3,build:4,calibr:5,call:4,caller:3,cancer:4,capac:0,cg2sdf:5,cgmap:[1,5],cgsim:5,check:4,checkminvers:1,childsim:5,chrom:1,chrstat:5,cli:5,cnv:[3,5],color:0,column:5,combin:5,command:[0,1,3,5],common:5,compar:5,comparison:5,complex:3,composit:5,comput:1,configur:0,consensu:5,construct:5,contamin:[3,4],content:[1,2],copi:[3,4],coverag:[1,3,4,5],creat:[3,4],curv:5,custom:5,data:[3,4,5],databas:4,decomposit:5,denovosim:5,deploy:3,descript:[1,3],detect:[3,4,5],diploid:5,directori:1,discord:[1,4,5],distribut:[1,5],dna:4,enclos:1,end:[1,5],ensurefilterhead:1,ensureformathead:1,ensureinfohead:1,error:1,estim:4,evalu:[4,5],exampl:5,except:0,expr:5,express:5,extens:1,extract:5,famili:[4,5],fastqtrim:5,field:1,file:[0,1,3,4],filenam:1,filter:[1,3,4,5],filter_header_str:1,find:4,fly:5,format:[1,3,4,5],format_field:1,format_header_str:1,frequenc:4,fromb:1,fromvcf:1,gap:1,gener:4,genet:1,genom:[1,4,5],genomesim:5,graph:5,group:[1,4],gui:5,haploid:4,hapmap:4,has:5,hashdist:5,header:1,help:5,highlight:0,human:4,indel:[3,5],index:[1,5],info:1,info_field:1,info_header_str:1,inform:[1,4],input:[1,3],instal:[0,3,4],instruct:3,interact:5,interfac:5,introduct:3,ion:4,javascript:[1,5],keep:5,licens:[3,5],line:[0,5],lineag:5,log:0,lookup:1,machin:0,manag:[0,3,4],map:[1,3,4,5],mapf:5,mapp:[1,5],mapx:[1,5],mapxrenam:5,match:5,mendelian:[3,5],merg:5,meta:5,metagenom:[3,4,5],mode:[4,5],model:4,modif:1,multi:0,multipl:0,name:4,ncbi2tax:5,non:5,normal:4,notic:1,number:[3,4],onli:5,optim:[0,3],option:4,output:[1,3,5],overlap:1,overview:3,pair:5,parallel:[1,3],ped:1,pedfilt:5,pedigre:[1,3,4],pedsamplesim:5,pedstat:5,perform:[0,4,5],petrim:5,pipelin:[3,5],plan:0,ploidi:5,popsim:5,popul:[4,5],posit:5,precis:5,prepar:4,preset:5,print:1,prior:[4,5],process:[1,3],produc:4,product:4,progress:4,protein:[3,4,5],qual:1,qualiti:5,quick:3,read:[1,3,4,5],readm:1,readsim:5,readsimev:5,record:[1,5],ref:1,refer:[1,4,5],region:[1,5],regions_object:1,relationship:3,report:4,rescor:5,respect:5,result:1,review:4,roc:5,rocplot:5,rtg:[1,3,4,5],rtg_minimum_vers:1,run:[0,4],sam2bam:5,sam:[1,3],same:5,sammerg:5,sampl:[1,3,4,5],sample_nam:1,samplereplai:5,samplesim:5,samrenam:5,samstat:5,score:[1,4],script:5,sdf2cg:5,sdf2fasta:5,sdf2fastq:5,sdf2sam:5,sdfsplit:5,sdfstat:5,sdfsubseq:5,sdfsubset:5,search:[3,4,5],sensit:[3,5],sequenc:[3,4],set:4,sex:4,similar:[1,4,5],simpl:5,simul:5,singl:[0,4],site:4,small:1,snp:[3,5],softwar:3,somat:[3,4,5],speci:[1,4,5],specif:4,split:5,squash:5,standard:3,start:[1,3],statist:4,stratif:5,string:1,structur:4,support:3,svdecompos:5,svprep:5,syntax:5,tabl:2,talkback:0,task:4,taxfilt:5,taxon:3,taxonom:1,taxonomi:1,taxstat:5,technic:[1,3],test:1,time:0,tool:4,torrent:4,train:4,translat:4,trim:5,tumor:4,tumoronli:5,tune:3,txt:1,usag:[0,4],usageserv:5,use:4,user:0,using:[1,4,5],util:[3,5],variant:[1,3,4,5],variat:[3,4],vcf2rocplot:5,vcf:[1,5],vcfannot:5,vcfdecompos:5,vcfeval:5,vcffilter:5,vcfmerg:5,vcfsplit:5,vcfstat:5,vcfsubset:5,version:5,versu:5,view:4}})
\ No newline at end of file