diff --git a/DESCRIPTION b/DESCRIPTION
index 55d9a67..fbb9a6e 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Package: kableExtra
 Type: Package
 Title: Construct Complex Table with 'kable' and Pipe Syntax
-Version: 1.2.1.9000
+Version: 1.3.0
 Authors@R: c(
     person('Hao', 'Zhu', email = 'haozhu233@gmail.com', role = c('aut', 'cre'),
     comment = c(ORCID = '0000-0002-3386-6076')),
diff --git a/NAMESPACE b/NAMESPACE
index 8f9df81..723e534 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -48,6 +48,7 @@
 export(spec_hist)
 export(spec_image)
 export(spec_plot)
+export(spec_pointrange)
 export(spec_popover)
 export(spec_tooltip)
 export(text_spec)
@@ -82,6 +83,8 @@
 importFrom(stats,ave)
 importFrom(stats,density)
 importFrom(stats,median)
+importFrom(stats,na.omit)
+importFrom(stats,setNames)
 importFrom(stringr,fixed)
 importFrom(stringr,str_count)
 importFrom(stringr,str_detect)
diff --git a/R/graphics_helpers.R b/R/graphics_helpers.R
index 993a9c3..b74d439 100644
--- a/R/graphics_helpers.R
+++ b/R/graphics_helpers.R
@@ -183,7 +183,7 @@
       function(L, nm) {
         if (is.null(L)) return(list(NULL))
         if (!is.list(L)) return(list(L))
-        if (is.na(lengths) || length(L) %in% lengths) return(L)
+        if ((length(lengths) == 1 && is.na(lengths)) || length(L) %in% lengths) return(L)
         stop("length of '", nm, "' must be one of: ", paste(lengths, collapse = " or "))
       }, indots[ nms ], nms))
   }
@@ -197,7 +197,7 @@
         if (is.null(L)) return(list(NULL))
         if (!length(L)) return(list(list()))
         if (!is.list(L[[1]])) return (list(L))
-        if (is.na(lengths) || length(L) %in% lengths) return(L)
+        if ((length(lengths) == 1 && is.na(lengths)) || length(L) %in% lengths) return(L)
         stop("length of '", nm, "' must be one of: ", paste(lengths, collapse = " or "))
       }, indots[ nms ], nms))
   }
@@ -210,7 +210,7 @@
       function(V, nm) {
         if (is.null(V)) return(list(NULL))
         if (is.function(V)) return(list(V))
-        if (is.na(lengths) || length(V) %in% lengths) return(V)
+        if ((length(lengths) == 1 && is.na(lengths)) || length(V) %in% lengths) return(V)
         stop("length of '", nm, "' must be one of: ", paste(lengths, collapse = " or "))
       }, indots[ nms ], nms))
   }
diff --git a/R/kableExtra-package.R b/R/kableExtra-package.R
index 799dac1..48543e2 100644
--- a/R/kableExtra-package.R
+++ b/R/kableExtra-package.R
@@ -68,7 +68,7 @@
 #' @importFrom utils read.csv head capture.output
 #' @importFrom scales rescale
 #' @importFrom viridisLite viridis
-#' @importFrom stats ave density median
+#' @importFrom stats ave density median na.omit setNames
 #' @importFrom grDevices col2rgb svg png
 #' @importFrom rstudioapi isAvailable viewer
 #' @importFrom glue glue
diff --git a/R/mini_plots.R b/R/mini_plots.R
index fc8e031..cef8c5e 100644
--- a/R/mini_plots.R
+++ b/R/mini_plots.R
@@ -2,14 +2,17 @@
 #'
 #' @description These functions helps you quickly generate sets of sparkline
 #' style plots using base R plotting system. Currently, we support histogram,
-#' boxplot, and line. You can use them together with `column_spec` to
-#' generate inline plot in tables. By default, this function will save images
-#' in a folder called "kableExtra" and return the address of the file.
+#' boxplot, line, scatter and pointrange plots. You can use them together with
+#' `column_spec` to generate inline plot in tables. By default, this function
+#' will save images in a folder called "kableExtra" and return the address of
+#' the file.
 #'
 #' @param x Vector of values or List of vectors of values.
 #' @param width The width of the plot in pixel
 #' @param height The height of the plot in pixel
 #' @param res The resolution of the plot. Default is 300.
+#' @param breaks The `break` option in `hist`. Default is "Sturges" but you can
+#' also provide a vector to manually specify break points.
 #' @param same_lim T/F. If x is a list of vectors, should all the plots be
 #' plotted in the same range? Default is True.
 #' @param lim Manually specify plotting range in the form of
@@ -88,9 +91,10 @@
 #'
 #' @description These functions helps you quickly generate sets of sparkline
 #' style plots using base R plotting system. Currently, we support histogram,
-#' boxplot, and line. You can use them together with `column_spec` to
-#' generate inline plot in tables. By default, this function will save images
-#' in a folder called "kableExtra" and return the address of the file.
+#' boxplot, line, scatter and pointrange plots. You can use them together with
+#' `column_spec` to generate inline plot in tables. By default, this function
+#' will save images in a folder called "kableExtra" and return the address of
+#' the file.
 #'
 #' @param x Vector of values or List of vectors of values.
 #' @param width The width of the plot in pixel
@@ -101,9 +105,8 @@
 #' Default is 2.
 #' @param same_lim T/F. If x is a list of vectors, should all the plots be
 #' plotted in the same range? Default is True.
-#' @param lim,xlim,ylim Manually specify plotting range in the form of
-#' `c(0, 10)`. `lim` is used in `spec_hist` and `spec_boxplot`; `xlim`
-#' and `ylim` are used in `spec_plot`.
+#' @param lim Manually specify plotting range in the form of
+#' `c(0, 10)`.
 #' @param xaxt On/Off for xaxis text
 #' @param yaxt On/Off for yaxis text
 #' @param ann On/Off for annotations (titles and axis titles)
@@ -170,10 +173,10 @@
   graphics::par(mar = c(0, 0, 0, 0))
 
   graphics::boxplot(x, horizontal = TRUE, ann = ann, frame = FALSE, bty = 'n', ylim = lim,
-          col = col, border = border,
-          boxlty = boxlty, medcol = medcol, medlwd = medlwd,
-          axes = FALSE, outcex = 0.2, whisklty = 1,
-          ...)
+                    col = col, border = border,
+                    boxlty = boxlty, medcol = medcol, medlwd = medlwd,
+                    axes = FALSE, outcex = 0.2, whisklty = 1,
+                    ...)
   if (add_label) {
     x_median <- round(median(x, na.rm = T), label_digits)
     x_min <- round(min(x, na.rm = T), label_digits)
@@ -207,9 +210,10 @@
 #'
 #' @description These functions helps you quickly generate sets of sparkline
 #' style plots using base R plotting system. Currently, we support histogram,
-#' boxplot, and line. You can use them together with `column_spec` to
-#' generate inline plot in tables. By default, this function will save images
-#' in a folder called "kableExtra" and return the address of the file.
+#' boxplot, line, scatter and pointrange plots. You can use them together with
+#' `column_spec` to generate inline plot in tables. By default, this function
+#' will save images in a folder called "kableExtra" and return the address of
+#' the file.
 #'
 #' @param x,y Vector of values or List of vectors of values. y is optional.
 #' @param width The width of the plot in pixel
@@ -349,7 +353,7 @@
 
   if (!is.na(polymin)) {
     lty <- if ("lty" %in% names(dots)) dots$lty else graphics::par("lty")
-    polygon(c(x[1], x, x[length(x)]), c(polymin, y, polymin),
+    graphics::polygon(c(x[1], x, x[length(x)]), c(polymin, y, polymin),
             border = NA, col = col, angle = angle, lty = lty,
             xpd = if ("xpd" %in% names(dots)) dots$xpd else NA)
   }
@@ -374,3 +378,109 @@
     del = TRUE)
   return(out)
 }
+
+
+#' Helper functions to generate inline sparklines
+#'
+#' @description These functions helps you quickly generate sets of sparkline
+#' style plots using base R plotting system. Currently, we support histogram,
+#' boxplot, line, scatter and pointrange plots. You can use them together with
+#' `column_spec` to generate inline plot in tables. By default, this function
+#' will save images in a folder called "kableExtra" and return the address of
+#' the file.
+#'
+#' @param x,xmin,xmax A scalar value or List of scalar values for dot, left
+#' and right errorbar.
+#' @param vline A scalar value for where to draw a vertical line.
+#' @param width The width of the plot in pixel
+#' @param height The height of the plot in pixel
+#' @param res The resolution of the plot. Default is 300.
+#' @param same_lim T/F. If x is a list of vectors, should all the plots be
+#' plotted in the same range? Default is True.
+#' @param lim Manually specify plotting range in the form of
+#' `c(0, 10)`.
+#' @param xaxt On/Off for xaxis text
+#' @param yaxt On/Off for yaxis text
+#' @param ann On/Off for annotations (titles and axis titles)
+#' @param col Color for the fill of the histogram bar/boxplot box.
+#' @param cex size of the mean dot and error bar size.
+#' @param frame.plot T/F for whether to plot the plot frames.
+#' @param dir Directory of where the images will be saved.
+#' @param file File name. If not provided, a random name will be used
+#' @param file_type Graphic device. Can be character (e.g., `"pdf"`)
+#'   or a graphics device function (`grDevices::pdf`). This defaults
+#'   to `"pdf"` if the rendering is in LaTeX and `"svg"` otherwise.
+#' for HTML output
+#' @param ... extra parameters sending to `hist()`
+#'
+#' @export
+spec_pointrange <- function(
+  x, xmin, xmax, vline = NULL,
+  width = 200, height = 50, res = 300,
+  same_lim = TRUE, lim = NULL,
+  xaxt = 'n', yaxt = 'n', ann = FALSE,
+  col = "red", cex = 0.3, frame.plot = FALSE,
+  dir = if (is_latex()) rmd_files_dir() else tempdir(),
+  file = NULL,
+  file_type = if (is_latex()) "pdf" else "svg", ...) {
+  if (length(x) > 1) {
+    if (same_lim & is.null(lim)) {
+      all_range <- c(unlist(xmin), unlist(xmax))
+      lim <- base::range(all_range, na.rm=TRUE)
+      lim <- lim + c(-0.04 * diff(lim), 0.04 * diff(lim))
+    }
+
+    dots <- listify_args(
+      x = as.list(x), xmin = as.list(xmin), xmax = as.list(xmax), vline,
+      width, height, res,
+      lim, xaxt, yaxt, ann, col, cex, frame.plot,
+      dir, file, file_type,
+      lengths = c(1, length(x)),
+      passthru = c("x", "xmin", "xmax"))
+    return(do.call(Map, c(list(f = spec_pointrange), dots)))
+  }
+
+  if (is.null(x)) return(NULL)
+
+  if (is.null(lim)) {
+    one_range <- unlist(c(xmin, xmax))
+    lim <- base::range(one_range, na.rm=TRUE)
+    lim <- lim + c(-0.04 * diff(lim), 0.04 * diff(lim))
+  }
+
+  if (!dir.exists(dir)) {
+    dir.create(dir)
+  }
+
+  file_ext <- dev_chr(file_type)
+  if (is.null(file)) {
+    file <- normalizePath(
+      tempfile(pattern = "pointrange_", tmpdir = dir, fileext = paste0(".", file_ext)),
+      winslash = "/", mustWork = FALSE)
+  }
+
+  graphics_dev(filename = file, dev = file_type,
+               width = width, height = height, res = res,
+               bg = "transparent")
+  curdev <- grDevices::dev.cur()
+  on.exit(grDevices::dev.off(curdev), add = TRUE)
+
+  graphics::par(mar = c(0, 0, 0.2, 0), lwd=1,
+                ann = ann, xaxt = xaxt, yaxt = yaxt)
+
+  graphics::plot(x, 0, type = "p", pch = ".",
+                 xlim = lim, frame.plot = frame.plot)
+  graphics::arrows(xmin, 0, xmax, 0, cex / 15, angle = 90, code = 3)
+  graphics::points(x, 0, col = col, type = "p", pch = 15, cex = cex)
+  if (!is.null(vline)) {
+    graphics::abline(v = vline, lty = 3)
+  }
+
+  grDevices::dev.off(curdev)
+
+  out <- make_inline_plot(
+    file, file_ext, file_type,
+    width, height, res,
+    del = TRUE)
+  return(out)
+}
diff --git a/R/save_kable.R b/R/save_kable.R
index fe80d8f..c8b7185 100644
--- a/R/save_kable.R
+++ b/R/save_kable.R
@@ -188,7 +188,7 @@
   output <- normalizePath(output)
   template <- tempfile(fileext = ".html")
   on.exit(unlink(template), add = TRUE)
-  rmarkdown:::write_utf8("$body$", template)
+  write_utf8("$body$", template)
   from <- if (rmarkdown::pandoc_available("1.17")) "markdown_strict" else "markdown"
   rmarkdown::pandoc_convert(
     input = input, from = from, output = output,
@@ -197,6 +197,13 @@
   invisible(output)
 }
 
+# Local version of rmarkdown:::write_utf8
+write_utf8 <- function (text, con, ...) {
+  opts <- options(encoding = "native.enc")
+  on.exit(options(opts), add = TRUE)
+  writeLines(enc2utf8(text), con, ..., useBytes = TRUE)
+}
+
 
 
 remove_html_doc <- function(x){
diff --git a/docs/awesome_table_in_html.Rmd b/docs/awesome_table_in_html.Rmd
index a98ae10..843cea5 100644
--- a/docs/awesome_table_in_html.Rmd
+++ b/docs/awesome_table_in_html.Rmd
@@ -255,6 +255,30 @@
   column_spec(8, image = spec_plot(mpg_list, polymin = 5))
 ```
 
+There is also a `spec_pointrange` function specifically designed for forest plots in regression tables. Of course, feel free to use it for other purposes. 
+
+```{r}
+coef_table <- data.frame(
+  Variables = c("var 1", "var 2", "var 3"),
+  Coefficients = c(1.6, 0.2, -2.0),
+  Conf.Lower = c(1.3, -0.4, -2.5),
+  Conf.Higher = c(1.9, 0.6, -1.4)
+) 
+
+data.frame(
+  Variable = coef_table$Variables,
+  Visualization = ""
+) %>%
+  kbl(booktabs = T) %>%
+  kable_classic(full_width = FALSE) %>%
+  column_spec(2, image = spec_pointrange(
+    x = coef_table$Coefficients, 
+    xmin = coef_table$Conf.Lower, 
+    xmax = coef_table$Conf.Higher, 
+    vline = 0)
+    )
+```
+
 ## Row spec
 Similar with `column_spec`, you can define specifications for rows. Currently, you can either bold or italicize an entire row. Note that, similar with other row-related functions in `kableExtra`, for the position of the target row, you don't need to count in header rows or the group labeling rows.
 
diff --git a/docs/awesome_table_in_html.html b/docs/awesome_table_in_html.html
index dbb0f4e..11174eb 100644
--- a/docs/awesome_table_in_html.html
+++ b/docs/awesome_table_in_html.html
@@ -11,7 +11,7 @@
 
 <meta name="author" content="Hao Zhu" />
 
-<meta name="date" content="2020-10-06" />
+<meta name="date" content="2020-10-21" />
 
 <title>Create Awesome HTML Table with knitr::kable and kableExtra</title>
 
@@ -6333,7 +6333,7 @@
 
 <h1 class="title toc-ignore">Create Awesome HTML Table with knitr::kable and kableExtra</h1>
 <h4 class="author">Hao Zhu</h4>
-<h4 class="date">2020-10-06</h4>
+<h4 class="date">2020-10-21</h4>
 
 </div>
 
@@ -9307,29 +9307,39 @@
 4
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlMSI+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoODIuNzQ1MDk4JSw4Mi43NDUwOTglLDgyLjc0NTA5OCUpO2ZpbGwtb3BhY2l0eToxOyIgZD0iTSAyNS4yMzA0NjkgOC4yMjI2NTYgTCAyNS4yMzA0NjkgMy43NzczNDQgTCAzOS42MDE1NjIgMy43NzczNDQgTCAzOS42MDE1NjIgOC4yMjI2NTYgWiBNIDI1LjIzMDQ2OSA4LjIyMjY1NiAiLz4KPHBhdGggc3R5bGU9ImZpbGw6bm9uZTtzdHJva2Utd2lkdGg6MC43NTtzdHJva2UtbGluZWNhcDpidXR0O3N0cm9rZS1saW5lam9pbjpyb3VuZDtzdHJva2U6cmdiKDEwMCUsMCUsMCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDMxLjI4MTI1IDguMjIyNjU2IEwgMzEuMjgxMjUgMy43NzczNDQgIi8+CjxwYXRoIHN0eWxlPSJmaWxsOm5vbmU7c3Ryb2tlLXdpZHRoOjAuNzU7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZTpyZ2IoMCUsMCUsMCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDIyLjU4MjAzMSA2IEwgMjUuMjMwNDY5IDYgIi8+CjxwYXRoIHN0eWxlPSJmaWxsOm5vbmU7c3Ryb2tlLXdpZHRoOjAuNzU7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZTpyZ2IoMCUsMCUsMCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDQ2LjIyMjY1NiA2IEwgMzkuNjAxNTYyIDYgIi8+CjxwYXRoIHN0eWxlPSJmaWxsOm5vbmU7c3Ryb2tlLXdpZHRoOjAuNzU7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZTpyZ2IoMCUsMCUsMCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDIyLjU4MjAzMSA3LjEwOTM3NSBMIDIyLjU4MjAzMSA0Ljg5MDYyNSAiLz4KPHBhdGggc3R5bGU9ImZpbGw6bm9uZTtzdHJva2Utd2lkdGg6MC43NTtzdHJva2UtbGluZWNhcDpyb3VuZDtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlOnJnYigwJSwwJSwwJSk7c3Ryb2tlLW9wYWNpdHk6MTtzdHJva2UtbWl0ZXJsaW1pdDoxMDsiIGQ9Ik0gNDYuMjIyNjU2IDcuMTA5Mzc1IEwgNDYuMjIyNjU2IDQuODkwNjI1ICIvPgo8L2c+Cjwvc3ZnPgo=" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface1"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 25.230469 8.222656 L 25.230469 3.777344 L 39.601562 3.777344 L 39.601562 8.222656 Z M 25.230469 8.222656 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:round;stroke:rgb(100%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 31.28125 8.222656 L 31.28125 3.777344 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 22.582031 6 L 25.230469 6 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 46.222656 6 L 39.601562 6 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 22.582031 7.109375 L 22.582031 4.890625 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 46.222656 7.109375 L 46.222656 4.890625 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,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" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface16"><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 19.933594 11.664062 L 23.714844 11.664062 L 23.714844 3.21875 L 19.933594 3.21875 Z M 19.933594 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 23.714844 11.664062 L 27.496094 11.664062 L 27.496094 3.21875 L 23.714844 3.21875 Z M 23.714844 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 27.5 11.664062 L 31.28125 11.664062 L 31.28125 3.21875 L 27.5 3.21875 Z M 27.5 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 31.28125 11.664062 L 35.0625 11.664062 L 35.0625 7.441406 L 31.28125 7.441406 Z M 31.28125 11.664062 "></path><path style="fill:none;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 35.0625 11.664062 L 38.84375 11.664062 Z M 35.0625 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 38.847656 11.664062 L 42.628906 11.664062 L 42.628906 3.21875 L 38.847656 3.21875 Z M 38.847656 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 42.628906 11.664062 L 46.410156 11.664062 L 46.410156 3.21875 L 42.628906 3.21875 Z M 42.628906 11.664062 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlMzEiPgo8cGF0aCBzdHlsZT0iZmlsbDpub25lO3N0cm9rZS13aWR0aDoxLjU7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZTpyZ2IoODIuNzQ1MDk4JSw4Mi43NDUwOTglLDgyLjc0NTA5OCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDMuNDI1NzgxIDUuNzE0ODQ0IEwgNy41MzkwNjIgNS4wMTU2MjUgTCAxMS42NTYyNSA1LjcxNDg0NCBMIDE1Ljc2OTUzMSAxLjUxMTcxOSBMIDE5Ljg4NjcxOSAyLjM4NjcxOSBMIDI0IDAuODU1NDY5IEwgMjguMTEzMjgxIDYuMjg1MTU2IEwgMzIuMjMwNDY5IDMuNzQ2MDk0IEwgMzYuMzQzNzUgNC4zMTY0MDYgTCA0MC40NjA5MzggMi4zODY3MTkgTCA0NC41NzQyMTkgNi4zMjgxMjUgIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDQzLjg1NTQ2OSA1LjYwOTM3NSBMIDQ1LjI5Njg3NSA1LjYwOTM3NSBMIDQ1LjI5Njg3NSA3LjA1MDc4MSBMIDQzLjg1NTQ2OSA3LjA1MDc4MSBaIE0gNDMuODU1NDY5IDUuNjA5Mzc1ICIvPgo8cGF0aCBzdHlsZT0iIHN0cm9rZTpub25lO2ZpbGwtcnVsZTpub256ZXJvO2ZpbGw6cmdiKDEwMCUsMCUsMCUpO2ZpbGwtb3BhY2l0eToxOyIgZD0iTSAyMy4yODEyNSAwLjEzNjcxOSBMIDI0LjcyMjY1NiAwLjEzNjcxOSBMIDI0LjcyMjY1NiAxLjU3ODEyNSBMIDIzLjI4MTI1IDEuNTc4MTI1IFogTSAyMy4yODEyNSAwLjEzNjcxOSAiLz4KPC9nPgo8L3N2Zz4K" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface31"><path style="fill:none;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(82.745098%,82.745098%,82.745098%);stroke-opacity:1;stroke-miterlimit:10;" d="M 3.425781 5.714844 L 7.539062 5.015625 L 11.65625 5.714844 L 15.769531 1.511719 L 19.886719 2.386719 L 24 0.855469 L 28.113281 6.285156 L 32.230469 3.746094 L 36.34375 4.316406 L 40.460938 2.386719 L 44.574219 6.328125 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 43.855469 5.609375 L 45.296875 5.609375 L 45.296875 7.050781 L 43.855469 7.050781 Z M 43.855469 5.609375 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 23.28125 0.136719 L 24.722656 0.136719 L 24.722656 1.578125 L 23.28125 1.578125 Z M 23.28125 0.136719 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlNDYiPgo8cGF0aCBzdHlsZT0iZmlsbDpub25lO3N0cm9rZS13aWR0aDoxLjU7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZTpyZ2IoODIuNzQ1MDk4JSw4Mi43NDUwOTglLDgyLjc0NTA5OCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDMuNDI1NzgxIDkuOTkyMTg4IEwgNy41MzkwNjIgOC42NzU3ODEgTCAxMS42NTYyNSA5Ljk5MjE4OCBMIDE1Ljc2OTUzMSAyLjA4OTg0NCBMIDE5Ljg4NjcxOSAzLjczODI4MSBMIDI0IDAuODU1NDY5IEwgMjguMTEzMjgxIDExLjA2MjUgTCAzMi4yMzA0NjkgNi4yODkwNjIgTCAzNi4zNDM3NSA3LjM1OTM3NSBMIDQwLjQ2MDkzOCAzLjczODI4MSBMIDQ0LjU3NDIxOSAxMS4xNDQ1MzEgIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDQzLjg1NTQ2OSAxMC40MjU3ODEgTCA0NS4yOTY4NzUgMTAuNDI1NzgxIEwgNDUuMjk2ODc1IDExLjg2NzE4OCBMIDQzLjg1NTQ2OSAxMS44NjcxODggWiBNIDQzLjg1NTQ2OSAxMC40MjU3ODEgIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDIzLjI4MTI1IDAuMTM2NzE5IEwgMjQuNzIyNjU2IDAuMTM2NzE5IEwgMjQuNzIyNjU2IDEuNTc4MTI1IEwgMjMuMjgxMjUgMS41NzgxMjUgWiBNIDIzLjI4MTI1IDAuMTM2NzE5ICIvPgo8L2c+Cjwvc3ZnPgo=" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface46"><path style="fill:none;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(82.745098%,82.745098%,82.745098%);stroke-opacity:1;stroke-miterlimit:10;" d="M 3.425781 9.992188 L 7.539062 8.675781 L 11.65625 9.992188 L 15.769531 2.089844 L 19.886719 3.738281 L 24 0.855469 L 28.113281 11.0625 L 32.230469 6.289062 L 36.34375 7.359375 L 40.460938 3.738281 L 44.574219 11.144531 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 43.855469 10.425781 L 45.296875 10.425781 L 45.296875 11.867188 L 43.855469 11.867188 Z M 43.855469 10.425781 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 23.28125 0.136719 L 24.722656 0.136719 L 24.722656 1.578125 L 23.28125 1.578125 Z M 23.28125 0.136719 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,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" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface61"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 2.703125 4.996094 L 4.144531 4.996094 L 4.144531 6.4375 L 2.703125 6.4375 Z M 2.703125 4.996094 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 6.820312 4.296875 L 8.261719 4.296875 L 8.261719 5.738281 L 6.820312 5.738281 Z M 6.820312 4.296875 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 10.933594 4.996094 L 12.375 4.996094 L 12.375 6.4375 L 10.933594 6.4375 Z M 10.933594 4.996094 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 15.050781 0.792969 L 16.492188 0.792969 L 16.492188 2.234375 L 15.050781 2.234375 Z M 15.050781 0.792969 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 19.164062 1.667969 L 20.605469 1.667969 L 20.605469 3.109375 L 19.164062 3.109375 Z M 19.164062 1.667969 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 23.28125 0.136719 L 24.722656 0.136719 L 24.722656 1.578125 L 23.28125 1.578125 Z M 23.28125 0.136719 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 27.394531 5.566406 L 28.835938 5.566406 L 28.835938 7.007812 L 27.394531 7.007812 Z M 27.394531 5.566406 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 31.511719 3.023438 L 32.953125 3.023438 L 32.953125 4.464844 L 31.511719 4.464844 Z M 31.511719 3.023438 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 35.625 3.59375 L 37.066406 3.59375 L 37.066406 5.035156 L 35.625 5.035156 Z M 35.625 3.59375 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 39.742188 1.667969 L 41.183594 1.667969 L 41.183594 3.109375 L 39.742188 3.109375 Z M 39.742188 1.667969 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 43.855469 5.609375 L 45.296875 5.609375 L 45.296875 7.050781 L 43.855469 7.050781 Z M 43.855469 5.609375 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 43.855469 5.609375 L 45.296875 5.609375 L 45.296875 7.050781 L 43.855469 7.050781 Z M 43.855469 5.609375 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 23.28125 0.136719 L 24.722656 0.136719 L 24.722656 1.578125 L 23.28125 1.578125 Z M 23.28125 0.136719 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,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" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface76"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 24.417969 9.476562 L 25.859375 9.476562 L 25.859375 10.917969 L 24.417969 10.917969 Z M 24.417969 9.476562 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 27.21875 8.484375 L 28.660156 8.484375 L 28.660156 9.925781 L 27.21875 9.925781 Z M 27.21875 8.484375 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 24.417969 8.636719 L 25.859375 8.636719 L 25.859375 10.078125 L 24.417969 10.078125 Z M 24.417969 8.636719 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 41.230469 10.230469 L 42.671875 10.230469 L 42.671875 11.671875 L 41.230469 11.671875 Z M 41.230469 10.230469 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 37.726562 10.304688 L 39.167969 10.304688 L 39.167969 11.746094 L 37.726562 11.746094 Z M 37.726562 10.304688 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 43.855469 10.425781 L 45.296875 10.425781 L 45.296875 11.867188 L 43.855469 11.867188 Z M 43.855469 10.425781 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 22.140625 9.167969 L 23.582031 9.167969 L 23.582031 10.609375 L 22.140625 10.609375 Z M 22.140625 9.167969 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 32.296875 10.222656 L 33.738281 10.222656 L 33.738281 11.664062 L 32.296875 11.664062 Z M 32.296875 10.222656 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 30.023438 9.160156 L 31.464844 9.160156 L 31.464844 10.601562 L 30.023438 10.601562 Z M 30.023438 9.160156 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 37.726562 9.808594 L 39.167969 9.808594 L 39.167969 11.25 L 37.726562 11.25 Z M 37.726562 9.808594 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 21.964844 9.144531 L 23.40625 9.144531 L 23.40625 10.585938 L 21.964844 10.585938 Z M 21.964844 9.144531 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 43.855469 10.425781 L 45.296875 10.425781 L 45.296875 11.867188 L 43.855469 11.867188 Z M 43.855469 10.425781 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 27.21875 8.484375 L 28.660156 8.484375 L 28.660156 9.925781 L 27.21875 9.925781 Z M 27.21875 8.484375 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<html>
-<body>
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlOTEiPgo8cGF0aCBzdHlsZT0iIHN0cm9rZTpub25lO2ZpbGwtcnVsZTpub256ZXJvO2ZpbGw6cmdiKDgyLjc0NTA5OCUsODIuNzQ1MDk4JSw4Mi43NDUwOTglKTtmaWxsLW9wYWNpdHk6MTsiIGQ9Ik0gMy40MjU3ODEgMTEuMTQ0NTMxIEwgMy40MjU3ODEgNC44MDg1OTQgTCA3LjUzOTA2MiA0LjIzODI4MSBMIDExLjY1NjI1IDQuODA4NTk0IEwgMTUuNzY5NTMxIDEuMzkwNjI1IEwgMTkuODg2NzE5IDIuMTAxNTYyIEwgMjQgMC44NTU0NjkgTCAyOC4xMTMyODEgNS4yNjk1MzEgTCAzMi4yMzA0NjkgMy4yMDcwMzEgTCAzNi4zNDM3NSAzLjY2Nzk2OSBMIDQwLjQ2MDkzOCAyLjEwMTU2MiBMIDQ0LjU3NDIxOSA1LjMwNDY4OCBMIDQ0LjU3NDIxOSAxMS4xNDQ1MzEgWiBNIDMuNDI1NzgxIDExLjE0NDUzMSAiLz4KPHBhdGggc3R5bGU9IiBzdHJva2U6bm9uZTtmaWxsLXJ1bGU6bm9uemVybztmaWxsOnJnYigxMDAlLDAlLDAlKTtmaWxsLW9wYWNpdHk6MTsiIGQ9Ik0gNDMuODU1NDY5IDQuNTg1OTM4IEwgNDUuMjk2ODc1IDQuNTg1OTM4IEwgNDUuMjk2ODc1IDYuMDI3MzQ0IEwgNDMuODU1NDY5IDYuMDI3MzQ0IFogTSA0My44NTU0NjkgNC41ODU5MzggIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDIzLjI4MTI1IDAuMTM2NzE5IEwgMjQuNzIyNjU2IDAuMTM2NzE5IEwgMjQuNzIyNjU2IDEuNTc4MTI1IEwgMjMuMjgxMjUgMS41NzgxMjUgWiBNIDIzLjI4MTI1IDAuMTM2NzE5ICIvPgo8L2c+Cjwvc3ZnPgo=" width="64" height="16">
-</body>
-</html>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewBox="0 0 48 12" version="1.1">
+<g id="surface91"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 3.425781 11.144531 L 3.425781 4.808594 L 7.539062 4.238281 L 11.65625 4.808594 L 15.769531 1.390625 L 19.886719 2.101562 L 24 0.855469 L 28.113281 5.269531 L 32.230469 3.207031 L 36.34375 3.667969 L 40.460938 2.101562 L 44.574219 5.304688 L 44.574219 11.144531 Z M 3.425781 11.144531 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 43.855469 4.585938 L 45.296875 4.585938 L 45.296875 6.027344 L 43.855469 6.027344 Z M 43.855469 4.585938 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 23.28125 0.136719 L 24.722656 0.136719 L 24.722656 1.578125 L 23.28125 1.578125 Z M 23.28125 0.136719 "></path></g>
+</svg>
 </td>
 </tr>
 <tr>
@@ -9337,29 +9347,39 @@
 6
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlNiI+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoODIuNzQ1MDk4JSw4Mi43NDUwOTglLDgyLjc0NTA5OCUpO2ZpbGwtb3BhY2l0eToxOyIgZD0iTSAxNy4zNzg5MDYgOC4yMjI2NTYgTCAxNy4zNzg5MDYgMy43NzczNDQgTCAyMS44MjQyMTkgMy43NzczNDQgTCAyMS44MjQyMTkgOC4yMjI2NTYgWiBNIDE3LjM3ODkwNiA4LjIyMjY1NiAiLz4KPHBhdGggc3R5bGU9ImZpbGw6bm9uZTtzdHJva2Utd2lkdGg6MC43NTtzdHJva2UtbGluZWNhcDpidXR0O3N0cm9rZS1saW5lam9pbjpyb3VuZDtzdHJva2U6cmdiKDEwMCUsMCUsMCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDE5LjM2NzE4OCA4LjIyMjY1NiBMIDE5LjM2NzE4OCAzLjc3NzM0NCAiLz4KPHBhdGggc3R5bGU9ImZpbGw6bm9uZTtzdHJva2Utd2lkdGg6MC43NTtzdHJva2UtbGluZWNhcDpyb3VuZDtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlOnJnYigwJSwwJSwwJSk7c3Ryb2tlLW9wYWNpdHk6MTtzdHJva2UtbWl0ZXJsaW1pdDoxMDsiIGQ9Ik0gMTUuNzczNDM4IDYgTCAxNy4zNzg5MDYgNiAiLz4KPHBhdGggc3R5bGU9ImZpbGw6bm9uZTtzdHJva2Utd2lkdGg6MC43NTtzdHJva2UtbGluZWNhcDpyb3VuZDtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlOnJnYigwJSwwJSwwJSk7c3Ryb2tlLW9wYWNpdHk6MTtzdHJva2UtbWl0ZXJsaW1pdDoxMDsiIGQ9Ik0gMjIuNTgyMDMxIDYgTCAyMS44MjQyMTkgNiAiLz4KPHBhdGggc3R5bGU9ImZpbGw6bm9uZTtzdHJva2Utd2lkdGg6MC43NTtzdHJva2UtbGluZWNhcDpyb3VuZDtzdHJva2UtbGluZWpvaW46cm91bmQ7c3Ryb2tlOnJnYigwJSwwJSwwJSk7c3Ryb2tlLW9wYWNpdHk6MTtzdHJva2UtbWl0ZXJsaW1pdDoxMDsiIGQ9Ik0gMTUuNzczNDM4IDcuMTA5Mzc1IEwgMTUuNzczNDM4IDQuODkwNjI1ICIvPgo8cGF0aCBzdHlsZT0iZmlsbDpub25lO3N0cm9rZS13aWR0aDowLjc1O3N0cm9rZS1saW5lY2FwOnJvdW5kO3N0cm9rZS1saW5lam9pbjpyb3VuZDtzdHJva2U6cmdiKDAlLDAlLDAlKTtzdHJva2Utb3BhY2l0eToxO3N0cm9rZS1taXRlcmxpbWl0OjEwOyIgZD0iTSAyMi41ODIwMzEgNy4xMDkzNzUgTCAyMi41ODIwMzEgNC44OTA2MjUgIi8+CjwvZz4KPC9zdmc+Cg==" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface6"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 17.378906 8.222656 L 17.378906 3.777344 L 21.824219 3.777344 L 21.824219 8.222656 Z M 17.378906 8.222656 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:round;stroke:rgb(100%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 19.367188 8.222656 L 19.367188 3.777344 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 15.773438 6 L 17.378906 6 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 22.582031 6 L 21.824219 6 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 15.773438 7.109375 L 15.773438 4.890625 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 22.582031 7.109375 L 22.582031 4.890625 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,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" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface21"><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 14.261719 11.664062 L 16.152344 11.664062 L 16.152344 7.441406 L 14.261719 7.441406 Z M 14.261719 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 16.152344 11.664062 L 18.042969 11.664062 L 18.042969 7.441406 L 16.152344 7.441406 Z M 16.152344 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 18.042969 11.664062 L 19.933594 11.664062 L 19.933594 3.21875 L 18.042969 3.21875 Z M 18.042969 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 19.933594 11.664062 L 21.824219 11.664062 L 21.824219 3.21875 L 19.933594 3.21875 Z M 19.933594 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 21.824219 11.664062 L 23.714844 11.664062 L 23.714844 7.441406 L 21.824219 7.441406 Z M 21.824219 11.664062 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlMzYiPgo8cGF0aCBzdHlsZT0iZmlsbDpub25lO3N0cm9rZS13aWR0aDoxLjU7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZTpyZ2IoODIuNzQ1MDk4JSw4Mi43NDUwOTglLDgyLjc0NTA5OCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDMuNDI1NzgxIDYuNTAzOTA2IEwgMTAuMjgxMjUgNi41MDM5MDYgTCAxNy4xNDA2MjUgNi4zMjgxMjUgTCAyNCA3Ljc3MzQzOCBMIDMwLjg1OTM3NSA3LjI5Mjk2OSBMIDM3LjcxODc1IDcuOTA2MjUgTCA0NC41NzQyMTkgNy4wNzQyMTkgIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDM2Ljk5NjA5NCA3LjE4MzU5NCBMIDM4LjQzNzUgNy4xODM1OTQgTCAzOC40Mzc1IDguNjI1IEwgMzYuOTk2MDk0IDguNjI1IFogTSAzNi45OTYwOTQgNy4xODM1OTQgIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDE2LjQyMTg3NSA1LjYwOTM3NSBMIDE3Ljg2MzI4MSA1LjYwOTM3NSBMIDE3Ljg2MzI4MSA3LjA1MDc4MSBMIDE2LjQyMTg3NSA3LjA1MDc4MSBaIE0gMTYuNDIxODc1IDUuNjA5Mzc1ICIvPgo8L2c+Cjwvc3ZnPgo=" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface36"><path style="fill:none;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(82.745098%,82.745098%,82.745098%);stroke-opacity:1;stroke-miterlimit:10;" d="M 3.425781 6.503906 L 10.28125 6.503906 L 17.140625 6.328125 L 24 7.773438 L 30.859375 7.292969 L 37.71875 7.90625 L 44.574219 7.074219 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 36.996094 7.183594 L 38.4375 7.183594 L 38.4375 8.625 L 36.996094 8.625 Z M 36.996094 7.183594 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 16.421875 5.609375 L 17.863281 5.609375 L 17.863281 7.050781 L 16.421875 7.050781 Z M 16.421875 5.609375 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlNTEiPgo8cGF0aCBzdHlsZT0iZmlsbDpub25lO3N0cm9rZS13aWR0aDoxLjU7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZTpyZ2IoODIuNzQ1MDk4JSw4Mi43NDUwOTglLDgyLjc0NTA5OCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDMuNDI1NzgxIDIgTCAxMC4yODEyNSAyIEwgMTcuMTQwNjI1IDAuODU1NDY5IEwgMjQgMTAuMjg1MTU2IEwgMzAuODU5Mzc1IDcuMTQ0NTMxIEwgMzcuNzE4NzUgMTEuMTQ0NTMxIEwgNDQuNTc0MjE5IDUuNzE0ODQ0ICIvPgo8cGF0aCBzdHlsZT0iIHN0cm9rZTpub25lO2ZpbGwtcnVsZTpub256ZXJvO2ZpbGw6cmdiKDEwMCUsMCUsMCUpO2ZpbGwtb3BhY2l0eToxOyIgZD0iTSAzNi45OTYwOTQgMTAuNDI1NzgxIEwgMzguNDM3NSAxMC40MjU3ODEgTCAzOC40Mzc1IDExLjg2NzE4OCBMIDM2Ljk5NjA5NCAxMS44NjcxODggWiBNIDM2Ljk5NjA5NCAxMC40MjU3ODEgIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDE2LjQyMTg3NSAwLjEzNjcxOSBMIDE3Ljg2MzI4MSAwLjEzNjcxOSBMIDE3Ljg2MzI4MSAxLjU3ODEyNSBMIDE2LjQyMTg3NSAxLjU3ODEyNSBaIE0gMTYuNDIxODc1IDAuMTM2NzE5ICIvPgo8L2c+Cjwvc3ZnPgo=" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface51"><path style="fill:none;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(82.745098%,82.745098%,82.745098%);stroke-opacity:1;stroke-miterlimit:10;" d="M 3.425781 2 L 10.28125 2 L 17.140625 0.855469 L 24 10.285156 L 30.859375 7.144531 L 37.71875 11.144531 L 44.574219 5.714844 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 36.996094 10.425781 L 38.4375 10.425781 L 38.4375 11.867188 L 36.996094 11.867188 Z M 36.996094 10.425781 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 16.421875 0.136719 L 17.863281 0.136719 L 17.863281 1.578125 L 16.421875 1.578125 Z M 16.421875 0.136719 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,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" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface66"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 2.703125 5.785156 L 4.144531 5.785156 L 4.144531 7.226562 L 2.703125 7.226562 Z M 2.703125 5.785156 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 9.5625 5.785156 L 11.003906 5.785156 L 11.003906 7.226562 L 9.5625 7.226562 Z M 9.5625 5.785156 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 16.421875 5.609375 L 17.863281 5.609375 L 17.863281 7.050781 L 16.421875 7.050781 Z M 16.421875 5.609375 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 23.28125 7.054688 L 24.722656 7.054688 L 24.722656 8.496094 L 23.28125 8.496094 Z M 23.28125 7.054688 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 30.140625 6.570312 L 31.582031 6.570312 L 31.582031 8.011719 L 30.140625 8.011719 Z M 30.140625 6.570312 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 36.996094 7.183594 L 38.4375 7.183594 L 38.4375 8.625 L 36.996094 8.625 Z M 36.996094 7.183594 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 43.855469 6.351562 L 45.296875 6.351562 L 45.296875 7.792969 L 43.855469 7.792969 Z M 43.855469 6.351562 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 36.996094 7.183594 L 38.4375 7.183594 L 38.4375 8.625 L 36.996094 8.625 Z M 36.996094 7.183594 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 16.421875 5.609375 L 17.863281 5.609375 L 17.863281 7.050781 L 16.421875 7.050781 Z M 16.421875 5.609375 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,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" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface81"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 21.265625 8.144531 L 22.707031 8.144531 L 22.707031 9.585938 L 21.265625 9.585938 Z M 21.265625 8.144531 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 21.265625 8.144531 L 22.707031 8.144531 L 22.707031 9.585938 L 21.265625 9.585938 Z M 21.265625 8.144531 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 21.964844 5.628906 L 23.40625 5.628906 L 23.40625 7.070312 L 21.964844 7.070312 Z M 21.964844 5.628906 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 16.1875 6.472656 L 17.628906 6.472656 L 17.628906 7.914062 L 16.1875 7.914062 Z M 16.1875 6.472656 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 18.113281 7.949219 L 19.554688 7.949219 L 19.554688 9.390625 L 18.113281 9.390625 Z M 18.113281 7.949219 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 15.664062 7.949219 L 17.105469 7.949219 L 17.105469 9.390625 L 15.664062 9.390625 Z M 15.664062 7.949219 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 18.988281 8.527344 L 20.429688 8.527344 L 20.429688 9.96875 L 18.988281 9.96875 Z M 18.988281 8.527344 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 18.988281 8.527344 L 20.429688 8.527344 L 20.429688 9.96875 L 18.988281 9.96875 Z M 18.988281 8.527344 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 21.964844 5.628906 L 23.40625 5.628906 L 23.40625 7.070312 L 21.964844 7.070312 Z M 21.964844 5.628906 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<html>
-<body>
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlOTYiPgo8cGF0aCBzdHlsZT0iIHN0cm9rZTpub25lO2ZpbGwtcnVsZTpub256ZXJvO2ZpbGw6cmdiKDgyLjc0NTA5OCUsODIuNzQ1MDk4JSw4Mi43NDUwOTglKTtmaWxsLW9wYWNpdHk6MTsiIGQ9Ik0gMy40MjU3ODEgMTEuMTQ0NTMxIEwgMy40MjU3ODEgNS40NDkyMTkgTCAxMC4yODEyNSA1LjQ0OTIxOSBMIDE3LjE0MDYyNSA1LjMwNDY4OCBMIDI0IDYuNDgwNDY5IEwgMzAuODU5Mzc1IDYuMDg5ODQ0IEwgMzcuNzE4NzUgNi41ODU5MzggTCA0NC41NzQyMTkgNS45MTAxNTYgTCA0NC41NzQyMTkgMTEuMTQ0NTMxIFogTSAzLjQyNTc4MSAxMS4xNDQ1MzEgIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDM2Ljk5NjA5NCA1Ljg2NzE4OCBMIDM4LjQzNzUgNS44NjcxODggTCAzOC40Mzc1IDcuMzA4NTk0IEwgMzYuOTk2MDk0IDcuMzA4NTk0IFogTSAzNi45OTYwOTQgNS44NjcxODggIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDE2LjQyMTg3NSA0LjU4NTkzOCBMIDE3Ljg2MzI4MSA0LjU4NTkzOCBMIDE3Ljg2MzI4MSA2LjAyNzM0NCBMIDE2LjQyMTg3NSA2LjAyNzM0NCBaIE0gMTYuNDIxODc1IDQuNTg1OTM4ICIvPgo8L2c+Cjwvc3ZnPgo=" width="64" height="16">
-</body>
-</html>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewBox="0 0 48 12" version="1.1">
+<g id="surface96"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 3.425781 11.144531 L 3.425781 5.449219 L 10.28125 5.449219 L 17.140625 5.304688 L 24 6.480469 L 30.859375 6.089844 L 37.71875 6.585938 L 44.574219 5.910156 L 44.574219 11.144531 Z M 3.425781 11.144531 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 36.996094 5.867188 L 38.4375 5.867188 L 38.4375 7.308594 L 36.996094 7.308594 Z M 36.996094 5.867188 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 16.421875 4.585938 L 17.863281 4.585938 L 17.863281 6.027344 L 16.421875 6.027344 Z M 16.421875 4.585938 "></path></g>
+</svg>
 </td>
 </tr>
 <tr>
@@ -9367,29 +9387,103 @@
 8
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,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" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface11"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 9.152344 8.222656 L 9.152344 3.777344 L 13.125 3.777344 L 13.125 8.222656 Z M 9.152344 8.222656 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:butt;stroke-linejoin:round;stroke:rgb(100%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 10.855469 8.222656 L 10.855469 3.777344 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 7.261719 6 L 9.152344 6 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 18.421875 6 L 13.125 6 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 7.261719 7.109375 L 7.261719 4.890625 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 18.421875 7.109375 L 18.421875 4.890625 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 2.316406 6 C 2.316406 6.71875 1.238281 6.71875 1.238281 6 C 1.238281 5.28125 2.316406 5.28125 2.316406 6 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 2.316406 6 C 2.316406 6.71875 1.238281 6.71875 1.238281 6 C 1.238281 5.28125 2.316406 5.28125 2.316406 6 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,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" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface26"><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 1.019531 11.664062 L 4.800781 11.664062 L 4.800781 9.25 L 1.019531 9.25 Z M 1.019531 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 4.804688 11.664062 L 8.585938 11.664062 L 8.585938 10.457031 L 4.804688 10.457031 Z M 4.804688 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 8.585938 11.664062 L 12.367188 11.664062 L 12.367188 3.21875 L 8.585938 3.21875 Z M 8.585938 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 12.367188 11.664062 L 16.148438 11.664062 L 16.148438 9.25 L 12.367188 9.25 Z M 12.367188 11.664062 "></path><path style="fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;stroke-width:0.375;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 16.152344 11.664062 L 19.933594 11.664062 L 19.933594 9.25 L 16.152344 9.25 Z M 16.152344 11.664062 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlNDEiPgo8cGF0aCBzdHlsZT0iZmlsbDpub25lO3N0cm9rZS13aWR0aDoxLjU7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZTpyZ2IoODIuNzQ1MDk4JSw4Mi43NDUwOTglLDgyLjc0NTA5OCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDMuNDI1NzgxIDcuNTExNzE5IEwgNi41ODk4NDQgOS40Mzc1IEwgOS43NTM5MDYgOC41MTU2MjUgTCAxMi45MjE4NzUgOC4xMjUgTCAxNi4wODU5MzggOS4wNDI5NjkgTCAxOS4yNSAxMS4xNDQ1MzEgTCAyMi40MTc5NjkgMTEuMTQ0NTMxIEwgMjUuNTgyMDMxIDkuMjYxNzE5IEwgMjguNzUgOC45MTAxNTYgTCAzMS45MTQwNjIgOS4wNDI5NjkgTCAzNS4wNzgxMjUgOS44NzUgTCAzOC4yNDYwOTQgNy4yOTI5NjkgTCA0MS40MTAxNTYgOC43ODEyNSBMIDQ0LjU3NDIxOSA5LjEyODkwNiAiLz4KPHBhdGggc3R5bGU9IiBzdHJva2U6bm9uZTtmaWxsLXJ1bGU6bm9uemVybztmaWxsOnJnYigxMDAlLDAlLDAlKTtmaWxsLW9wYWNpdHk6MTsiIGQ9Ik0gMTguNTMxMjUgMTAuNDI1NzgxIEwgMTkuOTcyNjU2IDEwLjQyNTc4MSBMIDE5Ljk3MjY1NiAxMS44NjcxODggTCAxOC41MzEyNSAxMS44NjcxODggWiBNIDE4LjUzMTI1IDEwLjQyNTc4MSAiLz4KPHBhdGggc3R5bGU9IiBzdHJva2U6bm9uZTtmaWxsLXJ1bGU6bm9uemVybztmaWxsOnJnYigxMDAlLDAlLDAlKTtmaWxsLW9wYWNpdHk6MTsiIGQ9Ik0gMzcuNTIzNDM4IDYuNTcwMzEyIEwgMzguOTY0ODQ0IDYuNTcwMzEyIEwgMzguOTY0ODQ0IDguMDExNzE5IEwgMzcuNTIzNDM4IDguMDExNzE5IFogTSAzNy41MjM0MzggNi41NzAzMTIgIi8+CjwvZz4KPC9zdmc+Cg==" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface41"><path style="fill:none;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(82.745098%,82.745098%,82.745098%);stroke-opacity:1;stroke-miterlimit:10;" d="M 3.425781 7.511719 L 6.589844 9.4375 L 9.753906 8.515625 L 12.921875 8.125 L 16.085938 9.042969 L 19.25 11.144531 L 22.417969 11.144531 L 25.582031 9.261719 L 28.75 8.910156 L 31.914062 9.042969 L 35.078125 9.875 L 38.246094 7.292969 L 41.410156 8.78125 L 44.574219 9.128906 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 18.53125 10.425781 L 19.972656 10.425781 L 19.972656 11.867188 L 18.53125 11.867188 Z M 18.53125 10.425781 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 37.523438 6.570312 L 38.964844 6.570312 L 38.964844 8.011719 L 37.523438 8.011719 Z M 37.523438 6.570312 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlNTYiPgo8cGF0aCBzdHlsZT0iZmlsbDpub25lO3N0cm9rZS13aWR0aDoxLjU7c3Ryb2tlLWxpbmVjYXA6cm91bmQ7c3Ryb2tlLWxpbmVqb2luOnJvdW5kO3N0cm9rZTpyZ2IoODIuNzQ1MDk4JSw4Mi43NDUwOTglLDgyLjc0NTA5OCUpO3N0cm9rZS1vcGFjaXR5OjE7c3Ryb2tlLW1pdGVybGltaXQ6MTA7IiBkPSJNIDMuNDI1NzgxIDEuNDQxNDA2IEwgNi41ODk4NDQgNi41ODU5MzggTCA5Ljc1MzkwNiA0LjEyODkwNiBMIDEyLjkyMTg3NSAzLjA3ODEyNSBMIDE2LjA4NTkzOCA1LjUzMTI1IEwgMTkuMjUgMTEuMTQ0NTMxIEwgMjIuNDE3OTY5IDExLjE0NDUzMSBMIDI1LjU4MjAzMSA2LjExNzE4OCBMIDI4Ljc1IDUuMTc5Njg4IEwgMzEuOTE0MDYyIDUuNTMxMjUgTCAzNS4wNzgxMjUgNy43NTM5MDYgTCAzOC4yNDYwOTQgMC44NTU0NjkgTCA0MS40MTAxNTYgNC44MzIwMzEgTCA0NC41NzQyMTkgNS43NjU2MjUgIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDE4LjUzMTI1IDEwLjQyNTc4MSBMIDE5Ljk3MjY1NiAxMC40MjU3ODEgTCAxOS45NzI2NTYgMTEuODY3MTg4IEwgMTguNTMxMjUgMTEuODY3MTg4IFogTSAxOC41MzEyNSAxMC40MjU3ODEgIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDM3LjUyMzQzOCAwLjEzNjcxOSBMIDM4Ljk2NDg0NCAwLjEzNjcxOSBMIDM4Ljk2NDg0NCAxLjU3ODEyNSBMIDM3LjUyMzQzOCAxLjU3ODEyNSBaIE0gMzcuNTIzNDM4IDAuMTM2NzE5ICIvPgo8L2c+Cjwvc3ZnPgo=" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface56"><path style="fill:none;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(82.745098%,82.745098%,82.745098%);stroke-opacity:1;stroke-miterlimit:10;" d="M 3.425781 1.441406 L 6.589844 6.585938 L 9.753906 4.128906 L 12.921875 3.078125 L 16.085938 5.53125 L 19.25 11.144531 L 22.417969 11.144531 L 25.582031 6.117188 L 28.75 5.179688 L 31.914062 5.53125 L 35.078125 7.753906 L 38.246094 0.855469 L 41.410156 4.832031 L 44.574219 5.765625 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 18.53125 10.425781 L 19.972656 10.425781 L 19.972656 11.867188 L 18.53125 11.867188 Z M 18.53125 10.425781 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 37.523438 0.136719 L 38.964844 0.136719 L 38.964844 1.578125 L 37.523438 1.578125 Z M 37.523438 0.136719 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,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" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface71"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 2.703125 6.789062 L 4.144531 6.789062 L 4.144531 8.230469 L 2.703125 8.230469 Z M 2.703125 6.789062 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 5.871094 8.714844 L 7.3125 8.714844 L 7.3125 10.15625 L 5.871094 10.15625 Z M 5.871094 8.714844 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 9.035156 7.796875 L 10.476562 7.796875 L 10.476562 9.238281 L 9.035156 9.238281 Z M 9.035156 7.796875 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 12.199219 7.402344 L 13.640625 7.402344 L 13.640625 8.84375 L 12.199219 8.84375 Z M 12.199219 7.402344 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 15.367188 8.324219 L 16.808594 8.324219 L 16.808594 9.765625 L 15.367188 9.765625 Z M 15.367188 8.324219 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 18.53125 10.425781 L 19.972656 10.425781 L 19.972656 11.867188 L 18.53125 11.867188 Z M 18.53125 10.425781 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 21.695312 10.425781 L 23.136719 10.425781 L 23.136719 11.867188 L 21.695312 11.867188 Z M 21.695312 10.425781 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 24.863281 8.542969 L 26.304688 8.542969 L 26.304688 9.984375 L 24.863281 9.984375 Z M 24.863281 8.542969 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 28.027344 8.191406 L 29.46875 8.191406 L 29.46875 9.632812 L 28.027344 9.632812 Z M 28.027344 8.191406 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 31.195312 8.324219 L 32.636719 8.324219 L 32.636719 9.765625 L 31.195312 9.765625 Z M 31.195312 8.324219 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 34.359375 9.15625 L 35.800781 9.15625 L 35.800781 10.597656 L 34.359375 10.597656 Z M 34.359375 9.15625 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 37.523438 6.570312 L 38.964844 6.570312 L 38.964844 8.011719 L 37.523438 8.011719 Z M 37.523438 6.570312 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 40.691406 8.058594 L 42.132812 8.058594 L 42.132812 9.5 L 40.691406 9.5 Z M 40.691406 8.058594 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 43.855469 8.410156 L 45.296875 8.410156 L 45.296875 9.851562 L 43.855469 9.851562 Z M 43.855469 8.410156 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 18.53125 10.425781 L 19.972656 10.425781 L 19.972656 11.867188 L 18.53125 11.867188 Z M 18.53125 10.425781 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 37.523438 6.570312 L 38.964844 6.570312 L 38.964844 8.011719 L 37.523438 8.011719 Z M 37.523438 6.570312 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<img src="data:image/svg+xml;base64,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" width="64" height="16">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewbox="0 0 48 12" version="1.1">
+<g id="surface86"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 17.238281 3.011719 L 18.679688 3.011719 L 18.679688 4.453125 L 17.238281 4.453125 Z M 17.238281 3.011719 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 9.535156 3.011719 L 10.976562 3.011719 L 10.976562 4.453125 L 9.535156 4.453125 Z M 9.535156 3.011719 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 13.210938 5.171875 L 14.652344 5.171875 L 14.652344 6.613281 L 13.210938 6.613281 Z M 13.210938 5.171875 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 14.785156 5.171875 L 16.226562 5.171875 L 16.226562 6.613281 L 14.785156 6.613281 Z M 14.785156 5.171875 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 11.109375 5.171875 L 12.550781 5.171875 L 12.550781 6.613281 L 11.109375 6.613281 Z M 11.109375 5.171875 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 2.703125 0.136719 L 4.144531 0.136719 L 4.144531 1.578125 L 2.703125 1.578125 Z M 2.703125 0.136719 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 2.703125 0.445312 L 4.144531 0.445312 L 4.144531 1.886719 L 2.703125 1.886719 Z M 2.703125 0.445312 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 10.234375 0.957031 L 11.675781 0.957031 L 11.675781 2.398438 L 10.234375 2.398438 Z M 10.234375 0.957031 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 11.636719 4.089844 L 13.078125 4.089844 L 13.078125 5.53125 L 11.636719 5.53125 Z M 11.636719 4.089844 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 11.109375 4.445312 L 12.550781 4.445312 L 12.550781 5.886719 L 11.109375 5.886719 Z M 11.109375 4.445312 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 7.78125 3.265625 L 9.222656 3.265625 L 9.222656 4.707031 L 7.78125 4.707031 Z M 7.78125 3.265625 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 18.113281 1.984375 L 19.554688 1.984375 L 19.554688 3.425781 L 18.113281 3.425781 Z M 18.113281 1.984375 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 12.160156 3.242188 L 13.601562 3.242188 L 13.601562 4.683594 L 12.160156 4.683594 Z M 12.160156 3.242188 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 10.757812 4.523438 L 12.199219 4.523438 L 12.199219 5.964844 L 10.757812 5.964844 Z M 10.757812 4.523438 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 13.210938 5.171875 L 14.652344 5.171875 L 14.652344 6.613281 L 13.210938 6.613281 Z M 13.210938 5.171875 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 2.703125 0.136719 L 4.144531 0.136719 L 4.144531 1.578125 L 2.703125 1.578125 Z M 2.703125 0.136719 "></path></g>
+</svg>
 </td>
 <td style="text-align:left;">
-<html>
-<body>
-<img src="data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iNDhwdCIgaGVpZ2h0PSIxMnB0IiB2aWV3Qm94PSIwIDAgNDggMTIiIHZlcnNpb249IjEuMSI+CjxnIGlkPSJzdXJmYWNlMTAxIj4KPHBhdGggc3R5bGU9IiBzdHJva2U6bm9uZTtmaWxsLXJ1bGU6bm9uemVybztmaWxsOnJnYig4Mi43NDUwOTglLDgyLjc0NTA5OCUsODIuNzQ1MDk4JSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDMuNDI1NzgxIDExLjE0NDUzMSBMIDMuNDI1NzgxIDYuMjY1NjI1IEwgNi41ODk4NDQgNy44MzIwMzEgTCA5Ljc1MzkwNiA3LjA4NTkzOCBMIDEyLjkyMTg3NSA2Ljc2NTYyNSBMIDE2LjA4NTkzOCA3LjUxMTcxOSBMIDE5LjI1IDkuMjIyNjU2IEwgMjIuNDE3OTY5IDkuMjIyNjU2IEwgMjUuNTgyMDMxIDcuNjkxNDA2IEwgMjguNzUgNy40MDYyNSBMIDMxLjkxNDA2MiA3LjUxMTcxOSBMIDM1LjA3ODEyNSA4LjE4NzUgTCAzOC4yNDYwOTQgNi4wODk4NDQgTCA0MS40MTAxNTYgNy4zMDA3ODEgTCA0NC41NzQyMTkgNy41ODU5MzggTCA0NC41NzQyMTkgMTEuMTQ0NTMxIFogTSAzLjQyNTc4MSAxMS4xNDQ1MzEgIi8+CjxwYXRoIHN0eWxlPSIgc3Ryb2tlOm5vbmU7ZmlsbC1ydWxlOm5vbnplcm87ZmlsbDpyZ2IoMTAwJSwwJSwwJSk7ZmlsbC1vcGFjaXR5OjE7IiBkPSJNIDE4LjUzMTI1IDguNSBMIDE5Ljk3MjY1NiA4LjUgTCAxOS45NzI2NTYgOS45NDE0MDYgTCAxOC41MzEyNSA5Ljk0MTQwNiBaIE0gMTguNTMxMjUgOC41ICIvPgo8cGF0aCBzdHlsZT0iIHN0cm9rZTpub25lO2ZpbGwtcnVsZTpub256ZXJvO2ZpbGw6cmdiKDEwMCUsMCUsMCUpO2ZpbGwtb3BhY2l0eToxOyIgZD0iTSAzNy41MjM0MzggNS4zNjcxODggTCAzOC45NjQ4NDQgNS4zNjcxODggTCAzOC45NjQ4NDQgNi44MDg1OTQgTCAzNy41MjM0MzggNi44MDg1OTQgWiBNIDM3LjUyMzQzOCA1LjM2NzE4OCAiLz4KPC9nPgo8L3N2Zz4K" width="64" height="16">
-</body>
-</html>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewBox="0 0 48 12" version="1.1">
+<g id="surface101"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(82.745098%,82.745098%,82.745098%);fill-opacity:1;" d="M 3.425781 11.144531 L 3.425781 6.265625 L 6.589844 7.832031 L 9.753906 7.085938 L 12.921875 6.765625 L 16.085938 7.511719 L 19.25 9.222656 L 22.417969 9.222656 L 25.582031 7.691406 L 28.75 7.40625 L 31.914062 7.511719 L 35.078125 8.1875 L 38.246094 6.089844 L 41.410156 7.300781 L 44.574219 7.585938 L 44.574219 11.144531 Z M 3.425781 11.144531 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 18.53125 8.5 L 19.972656 8.5 L 19.972656 9.941406 L 18.53125 9.941406 Z M 18.53125 8.5 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 37.523438 5.367188 L 38.964844 5.367188 L 38.964844 6.808594 L 37.523438 6.808594 Z M 37.523438 5.367188 "></path></g>
+</svg>
+</td>
+</tr>
+</tbody>
+</table>
+<p>There is also a <code>spec_pointrange</code> function specifically designed for forest plots in regression tables. Of course, feel free to use it for other purposes.</p>
+<pre class="r"><code>coef_table &lt;- data.frame(
+  Variables = c(&quot;var 1&quot;, &quot;var 2&quot;, &quot;var 3&quot;),
+  Coefficients = c(1.6, 0.2, -2.0),
+  Conf.Lower = c(1.3, -0.4, -2.5),
+  Conf.Higher = c(1.9, 0.6, -1.4)
+) 
+
+data.frame(
+  Variable = coef_table$Variables,
+  Visualization = &quot;&quot;
+) %&gt;%
+  kbl(booktabs = T) %&gt;%
+  kable_classic(full_width = FALSE) %&gt;%
+  column_spec(2, image = spec_pointrange(
+    x = coef_table$Coefficients, 
+    xmin = coef_table$Conf.Lower, 
+    xmax = coef_table$Conf.Higher, 
+    vline = 0)
+    )</code></pre>
+<table class=" lightable-classic" style="font-family: &quot;Arial Narrow&quot;, &quot;Source Sans Pro&quot;, sans-serif; width: auto !important; margin-left: auto; margin-right: auto;">
+<thead>
+<tr>
+<th style="text-align:left;">
+Variable
+</th>
+<th style="text-align:left;">
+Visualization
+</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td style="text-align:left;">
+var 1
+</td>
+<td style="text-align:left;">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewBox="0 0 48 12" version="1.1">
+<defs><clipPath id="clip1"><path d="M 26 2.878906 L 28 2.878906 L 28 12 L 26 12 Z M 26 2.878906 "></path></clipPath></defs><g id="surface106"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(0%,0%,0%);fill-opacity:1;" d="M 41.269531 6.941406 L 42.269531 6.941406 L 42.269531 7.941406 L 41.269531 7.941406 Z M 41.269531 6.941406 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 38.964844 7.441406 L 44.574219 7.441406 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 38.964844 6 L 38.964844 8.878906 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 44.574219 8.878906 L 44.574219 6 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 40.960938 8.25 L 42.582031 8.25 L 42.582031 6.628906 L 40.960938 6.628906 Z M 40.960938 8.25 "></path><g clip-path="url(#clip1)" clip-rule="nonzero"><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-dasharray:0.75,2.25;stroke-miterlimit:10;" d="M 26.804688 12 L 26.804688 2.878906 "></path></g></g>
+</svg>
+</td>
+</tr>
+<tr>
+<td style="text-align:left;">
+var 2
+</td>
+<td style="text-align:left;">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewBox="0 0 48 12" version="1.1">
+<defs><clipPath id="clip1"><path d="M 26 2.878906 L 28 2.878906 L 28 12 L 26 12 Z M 26 2.878906 "></path></clipPath></defs><g id="surface111"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(0%,0%,0%);fill-opacity:1;" d="M 28.175781 6.941406 L 29.175781 6.941406 L 29.175781 7.941406 L 28.175781 7.941406 Z M 28.175781 6.941406 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 23.066406 7.441406 L 32.417969 7.441406 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 23.066406 6 L 23.066406 8.878906 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 32.417969 8.878906 L 32.417969 6 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 27.867188 8.25 L 29.488281 8.25 L 29.488281 6.628906 L 27.867188 6.628906 Z M 27.867188 8.25 "></path><g clip-path="url(#clip1)" clip-rule="nonzero"><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-dasharray:0.75,2.25;stroke-miterlimit:10;" d="M 26.804688 12 L 26.804688 2.878906 "></path></g></g>
+</svg>
+</td>
+</tr>
+<tr>
+<td style="text-align:left;">
+var 3
+</td>
+<td style="text-align:left;">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="48pt" height="12pt" viewBox="0 0 48 12" version="1.1">
+<defs><clipPath id="clip1"><path d="M 26 2.878906 L 28 2.878906 L 28 12 L 26 12 Z M 26 2.878906 "></path></clipPath></defs><g id="surface116"><path style=" stroke:none;fill-rule:nonzero;fill:rgb(0%,0%,0%);fill-opacity:1;" d="M 7.601562 6.941406 L 8.601562 6.941406 L 8.601562 7.941406 L 7.601562 7.941406 Z M 7.601562 6.941406 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 3.425781 7.441406 L 13.710938 7.441406 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 3.425781 6 L 3.425781 8.878906 "></path><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-miterlimit:10;" d="M 13.710938 8.878906 L 13.710938 6 "></path><path style=" stroke:none;fill-rule:nonzero;fill:rgb(100%,0%,0%);fill-opacity:1;" d="M 7.289062 8.25 L 8.910156 8.25 L 8.910156 6.628906 L 7.289062 6.628906 Z M 7.289062 8.25 "></path><g clip-path="url(#clip1)" clip-rule="nonzero"><path style="fill:none;stroke-width:0.75;stroke-linecap:round;stroke-linejoin:round;stroke:rgb(0%,0%,0%);stroke-opacity:1;stroke-dasharray:0.75,2.25;stroke-miterlimit:10;" d="M 26.804688 12 L 26.804688 2.878906 "></path></g></g>
+</svg>
 </td>
 </tr>
 </tbody>
@@ -11344,7 +11438,7 @@
 3
 </td>
 <td style="text-align:center;">
-0
+1
 </td>
 </tr>
 <tr>
@@ -11395,7 +11489,7 @@
 9
 </td>
 <td style="text-align:center;">
-0
+1
 </td>
 </tr>
 <tr>
@@ -11403,7 +11497,7 @@
 10
 </td>
 <td style="text-align:center;">
-1
+0
 </td>
 </tr>
 <tr>
@@ -11417,7 +11511,7 @@
 11
 </td>
 <td style="text-align:center;">
-1
+0
 </td>
 </tr>
 <tr>
@@ -11425,7 +11519,7 @@
 12
 </td>
 <td style="text-align:center;">
-0
+1
 </td>
 </tr>
 <tr>
@@ -16746,8 +16840,8 @@
 <pre class="r"><code># Not evaluated
 library(sparkline)
 sparkline(0)</code></pre>
-<span id="htmlwidget-6114469567685ebe0b50" class="sparkline html-widget"></span>
-<script type="application/json" data-for="htmlwidget-6114469567685ebe0b50">{"x":{"values":0,"options":{"height":20,"width":60},"width":60,"height":20},"evals":[],"jsHooks":[]}</script>
+<span id="htmlwidget-9185d2c0a8d1fd21477f" class="sparkline html-widget"></span>
+<script type="application/json" data-for="htmlwidget-9185d2c0a8d1fd21477f">{"x":{"values":0,"options":{"height":20,"width":60},"width":60,"height":20},"evals":[],"jsHooks":[]}</script>
 <pre class="r"><code>spk_dt &lt;- data.frame(
   var = c(&quot;mpg&quot;, &quot;wt&quot;),
   sparkline = c(spk_chr(mtcars$mpg), spk_chr(mtcars$wt))
@@ -16772,8 +16866,8 @@
 mpg
 </td>
 <td style="text-align:left;">
-<span id="htmlwidget-926649ac136aa8f3326f" class="sparkline html-widget"></span>
-<script type="application/json" data-for="htmlwidget-926649ac136aa8f3326f">{"x":{"values":[21,21,22.8,21.4,18.7,18.1,14.3,24.4,22.8,19.2,17.8,16.4,17.3,15.2,10.4,10.4,14.7,32.4,30.4,33.9,21.5,15.5,15.2,13.3,19.2,27.3,26,30.4,15.8,19.7,15,21.4],"options":{"height":20,"width":60},"width":60,"height":20},"evals":[],"jsHooks":[]}</script>
+<span id="htmlwidget-02a068fa03b770f7ac9f" class="sparkline html-widget"></span>
+<script type="application/json" data-for="htmlwidget-02a068fa03b770f7ac9f">{"x":{"values":[21,21,22.8,21.4,18.7,18.1,14.3,24.4,22.8,19.2,17.8,16.4,17.3,15.2,10.4,10.4,14.7,32.4,30.4,33.9,21.5,15.5,15.2,13.3,19.2,27.3,26,30.4,15.8,19.7,15,21.4],"options":{"height":20,"width":60},"width":60,"height":20},"evals":[],"jsHooks":[]}</script>
 </td>
 </tr>
 <tr>
@@ -16781,8 +16875,8 @@
 wt
 </td>
 <td style="text-align:left;">
-<span id="htmlwidget-42f9c5dad4ac6b3ba181" class="sparkline html-widget"></span>
-<script type="application/json" data-for="htmlwidget-42f9c5dad4ac6b3ba181">{"x":{"values":[2.62,2.875,2.32,3.215,3.44,3.46,3.57,3.19,3.15,3.44,3.44,4.07,3.73,3.78,5.25,5.424,5.345,2.2,1.615,1.835,2.465,3.52,3.435,3.84,3.845,1.935,2.14,1.513,3.17,2.77,3.57,2.78],"options":{"height":20,"width":60},"width":60,"height":20},"evals":[],"jsHooks":[]}</script>
+<span id="htmlwidget-9e1d84a352ac0607ef3d" class="sparkline html-widget"></span>
+<script type="application/json" data-for="htmlwidget-9e1d84a352ac0607ef3d">{"x":{"values":[2.62,2.875,2.32,3.215,3.44,3.46,3.57,3.19,3.15,3.44,3.44,4.07,3.73,3.78,5.25,5.424,5.345,2.2,1.615,1.835,2.465,3.52,3.435,3.84,3.845,1.935,2.14,1.513,3.17,2.77,3.57,2.78],"options":{"height":20,"width":60},"width":60,"height":20},"evals":[],"jsHooks":[]}</script>
 </td>
 </tr>
 </tbody>
diff --git a/docs/awesome_table_in_pdf.Rmd b/docs/awesome_table_in_pdf.Rmd
index dabc955..043e8a7 100644
--- a/docs/awesome_table_in_pdf.Rmd
+++ b/docs/awesome_table_in_pdf.Rmd
@@ -283,6 +283,30 @@
   column_spec(8, image = spec_plot(mpg_list, polymin = 5))
 ```
 
+There is also a `spec_pointrange` function specifically designed for forest plots in regression tables. Of course, feel free to use it for other purposes. 
+
+```{r}
+coef_table <- data.frame(
+  Variables = c("var 1", "var 2", "var 3"),
+  Coefficients = c(1.6, 0.2, -2.0),
+  Conf.Lower = c(1.3, -0.4, -2.5),
+  Conf.Higher = c(1.9, 0.6, -1.4)
+) 
+
+data.frame(
+  Variable = coef_table$Variables,
+  Visualization = ""
+) %>%
+  kbl(booktabs = T) %>%
+  kable_classic(full_width = FALSE) %>%
+  column_spec(2, image = spec_pointrange(
+    x = coef_table$Coefficients, 
+    xmin = coef_table$Conf.Lower, 
+    xmax = coef_table$Conf.Higher, 
+    vline = 0)
+    )
+```
+
 ## Row spec
 Similar with `column_spec`, you can define specifications for rows. Currently, you can either bold or italicize an entire row. Note that, similar to other row-related functions in `kableExtra`, for the position of the target row, you don't need to count in header rows or the group labeling rows.
 
diff --git a/docs/awesome_table_in_pdf.pdf b/docs/awesome_table_in_pdf.pdf
index 58ee6d6..605a3e1 100644
--- a/docs/awesome_table_in_pdf.pdf
+++ b/docs/awesome_table_in_pdf.pdf
Binary files differ
diff --git a/docs/awesome_table_in_pdf.toc b/docs/awesome_table_in_pdf.toc
index 82ddd4c..ca565b0 100644
--- a/docs/awesome_table_in_pdf.toc
+++ b/docs/awesome_table_in_pdf.toc
@@ -17,22 +17,22 @@
 \contentsline {subsection}{Column spec}{10}{section*.18}%
 \contentsline {subsection}{Insert Images into Columns}{11}{section*.19}%
 \contentsline {subsection}{Row spec}{13}{section*.20}%
-\contentsline {subsection}{Header Rows}{13}{section*.21}%
-\contentsline {section}{Cell/Text Specification}{13}{section*.22}%
+\contentsline {subsection}{Header Rows}{14}{section*.21}%
+\contentsline {section}{Cell/Text Specification}{14}{section*.22}%
 \contentsline {subsection}{Conditional logic}{14}{section*.23}%
 \contentsline {subsection}{Visualize data with Viridis Color}{15}{section*.24}%
-\contentsline {subsection}{Text Specification}{15}{section*.25}%
-\contentsline {section}{Grouped Columns / Rows}{16}{section*.26}%
-\contentsline {subsection}{Add header rows to group columns}{16}{section*.27}%
+\contentsline {subsection}{Text Specification}{16}{section*.25}%
+\contentsline {section}{Grouped Columns / Rows}{17}{section*.26}%
+\contentsline {subsection}{Add header rows to group columns}{17}{section*.27}%
 \contentsline {subsection}{Group rows via labeling}{17}{section*.28}%
-\contentsline {subsection}{Row indentation}{18}{section*.29}%
+\contentsline {subsection}{Row indentation}{19}{section*.29}%
 \contentsline {subsection}{Group rows via multi-row cell}{19}{section*.30}%
-\contentsline {section}{Table Footnote}{22}{section*.31}%
-\contentsline {section}{LaTeX Only Features}{25}{section*.32}%
-\contentsline {subsection}{Linebreak processor}{25}{section*.33}%
-\contentsline {subsection}{Table on a Landscape Page}{25}{section*.34}%
-\contentsline {subsection}{Decimal Alignment}{27}{section*.35}%
-\contentsline {subsection}{Use LaTeX table in HTML or Word}{27}{section*.36}%
-\contentsline {section}{From other packages}{27}{section*.37}%
-\contentsline {subsection}{\texttt {tables}}{27}{section*.38}%
-\contentsline {subsection}{\texttt {xtable}}{28}{section*.39}%
+\contentsline {section}{Table Footnote}{23}{section*.31}%
+\contentsline {section}{LaTeX Only Features}{26}{section*.32}%
+\contentsline {subsection}{Linebreak processor}{26}{section*.33}%
+\contentsline {subsection}{Table on a Landscape Page}{26}{section*.34}%
+\contentsline {subsection}{Decimal Alignment}{28}{section*.35}%
+\contentsline {subsection}{Use LaTeX table in HTML or Word}{28}{section*.36}%
+\contentsline {section}{From other packages}{28}{section*.37}%
+\contentsline {subsection}{\texttt {tables}}{28}{section*.38}%
+\contentsline {subsection}{\texttt {xtable}}{29}{section*.39}%
diff --git a/docs/plots_in_tables.Rmd b/docs/plots_in_tables.Rmd
index 95766c8..b33305a 100644
--- a/docs/plots_in_tables.Rmd
+++ b/docs/plots_in_tables.Rmd
@@ -9,7 +9,7 @@
 knitr::opts_chunk$set(warning = F, message = F)
 ```
 
-Sometimes it's a delight to see plots in a table. Here we provide some examples and recipes on some common tasks. We will use the following packages.
+Sometimes it's a delight to see plots in a table. Here we provide some examples and recipes on some common situation. We will use the following packages.
 
 
 ```{r}
diff --git a/man/spec_boxplot.Rd b/man/spec_boxplot.Rd
index 820ade8..2c5dab6 100644
--- a/man/spec_boxplot.Rd
+++ b/man/spec_boxplot.Rd
@@ -44,9 +44,8 @@
 \item{same_lim}{T/F. If x is a list of vectors, should all the plots be
 plotted in the same range? Default is True.}
 
-\item{lim, xlim, ylim}{Manually specify plotting range in the form of
-\code{c(0, 10)}. \code{lim} is used in \code{spec_hist} and \code{spec_boxplot}; \code{xlim}
-and \code{ylim} are used in \code{spec_plot}.}
+\item{lim}{Manually specify plotting range in the form of
+\code{c(0, 10)}.}
 
 \item{xaxt}{On/Off for xaxis text}
 
@@ -77,7 +76,8 @@
 \description{
 These functions helps you quickly generate sets of sparkline
 style plots using base R plotting system. Currently, we support histogram,
-boxplot, and line. You can use them together with \code{column_spec} to
-generate inline plot in tables. By default, this function will save images
-in a folder called "kableExtra" and return the address of the file.
+boxplot, line, scatter and pointrange plots. You can use them together with
+\code{column_spec} to generate inline plot in tables. By default, this function
+will save images in a folder called "kableExtra" and return the address of
+the file.
 }
diff --git a/man/spec_hist.Rd b/man/spec_hist.Rd
index 899dcaa..5c74fd4 100644
--- a/man/spec_hist.Rd
+++ b/man/spec_hist.Rd
@@ -32,6 +32,9 @@
 
 \item{res}{The resolution of the plot. Default is 300.}
 
+\item{breaks}{The \code{break} option in \code{hist}. Default is "Sturges" but you can
+also provide a vector to manually specify break points.}
+
 \item{same_lim}{T/F. If x is a list of vectors, should all the plots be
 plotted in the same range? Default is True.}
 
@@ -62,7 +65,8 @@
 \description{
 These functions helps you quickly generate sets of sparkline
 style plots using base R plotting system. Currently, we support histogram,
-boxplot, and line. You can use them together with \code{column_spec} to
-generate inline plot in tables. By default, this function will save images
-in a folder called "kableExtra" and return the address of the file.
+boxplot, line, scatter and pointrange plots. You can use them together with
+\code{column_spec} to generate inline plot in tables. By default, this function
+will save images in a folder called "kableExtra" and return the address of
+the file.
 }
diff --git a/man/spec_plot.Rd b/man/spec_plot.Rd
index 829bae8..191cbf2 100644
--- a/man/spec_plot.Rd
+++ b/man/spec_plot.Rd
@@ -94,7 +94,8 @@
 \description{
 These functions helps you quickly generate sets of sparkline
 style plots using base R plotting system. Currently, we support histogram,
-boxplot, and line. You can use them together with \code{column_spec} to
-generate inline plot in tables. By default, this function will save images
-in a folder called "kableExtra" and return the address of the file.
+boxplot, line, scatter and pointrange plots. You can use them together with
+\code{column_spec} to generate inline plot in tables. By default, this function
+will save images in a folder called "kableExtra" and return the address of
+the file.
 }
diff --git a/man/spec_pointrange.Rd b/man/spec_pointrange.Rd
new file mode 100644
index 0000000..6b8c313
--- /dev/null
+++ b/man/spec_pointrange.Rd
@@ -0,0 +1,77 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/mini_plots.R
+\name{spec_pointrange}
+\alias{spec_pointrange}
+\title{Helper functions to generate inline sparklines}
+\usage{
+spec_pointrange(
+  x,
+  xmin,
+  xmax,
+  vline = NULL,
+  width = 200,
+  height = 50,
+  res = 300,
+  same_lim = TRUE,
+  lim = NULL,
+  xaxt = "n",
+  yaxt = "n",
+  ann = FALSE,
+  col = "red",
+  cex = 0.3,
+  frame.plot = FALSE,
+  dir = if (is_latex()) rmd_files_dir() else tempdir(),
+  file = NULL,
+  file_type = if (is_latex()) "pdf" else "svg",
+  ...
+)
+}
+\arguments{
+\item{x, xmin, xmax}{A scalar value or List of scalar values for dot, left
+and right errorbar.}
+
+\item{vline}{A scalar value for where to draw a vertical line.}
+
+\item{width}{The width of the plot in pixel}
+
+\item{height}{The height of the plot in pixel}
+
+\item{res}{The resolution of the plot. Default is 300.}
+
+\item{same_lim}{T/F. If x is a list of vectors, should all the plots be
+plotted in the same range? Default is True.}
+
+\item{lim}{Manually specify plotting range in the form of
+\code{c(0, 10)}.}
+
+\item{xaxt}{On/Off for xaxis text}
+
+\item{yaxt}{On/Off for yaxis text}
+
+\item{ann}{On/Off for annotations (titles and axis titles)}
+
+\item{col}{Color for the fill of the histogram bar/boxplot box.}
+
+\item{cex}{size of the mean dot and error bar size.}
+
+\item{frame.plot}{T/F for whether to plot the plot frames.}
+
+\item{dir}{Directory of where the images will be saved.}
+
+\item{file}{File name. If not provided, a random name will be used}
+
+\item{file_type}{Graphic device. Can be character (e.g., \code{"pdf"})
+or a graphics device function (\code{grDevices::pdf}). This defaults
+to \code{"pdf"} if the rendering is in LaTeX and \code{"svg"} otherwise.
+for HTML output}
+
+\item{...}{extra parameters sending to \code{hist()}}
+}
+\description{
+These functions helps you quickly generate sets of sparkline
+style plots using base R plotting system. Currently, we support histogram,
+boxplot, line, scatter and pointrange plots. You can use them together with
+\code{column_spec} to generate inline plot in tables. By default, this function
+will save images in a folder called "kableExtra" and return the address of
+the file.
+}
diff --git a/vignettes/awesome_table_in_html.Rmd b/vignettes/awesome_table_in_html.Rmd
index a98ae10..843cea5 100644
--- a/vignettes/awesome_table_in_html.Rmd
+++ b/vignettes/awesome_table_in_html.Rmd
@@ -255,6 +255,30 @@
   column_spec(8, image = spec_plot(mpg_list, polymin = 5))
 ```
 
+There is also a `spec_pointrange` function specifically designed for forest plots in regression tables. Of course, feel free to use it for other purposes. 
+
+```{r}
+coef_table <- data.frame(
+  Variables = c("var 1", "var 2", "var 3"),
+  Coefficients = c(1.6, 0.2, -2.0),
+  Conf.Lower = c(1.3, -0.4, -2.5),
+  Conf.Higher = c(1.9, 0.6, -1.4)
+) 
+
+data.frame(
+  Variable = coef_table$Variables,
+  Visualization = ""
+) %>%
+  kbl(booktabs = T) %>%
+  kable_classic(full_width = FALSE) %>%
+  column_spec(2, image = spec_pointrange(
+    x = coef_table$Coefficients, 
+    xmin = coef_table$Conf.Lower, 
+    xmax = coef_table$Conf.Higher, 
+    vline = 0)
+    )
+```
+
 ## Row spec
 Similar with `column_spec`, you can define specifications for rows. Currently, you can either bold or italicize an entire row. Note that, similar with other row-related functions in `kableExtra`, for the position of the target row, you don't need to count in header rows or the group labeling rows.
 
diff --git a/vignettes/awesome_table_in_pdf.Rmd b/vignettes/awesome_table_in_pdf.Rmd
index 0c7791a..043e8a7 100644
--- a/vignettes/awesome_table_in_pdf.Rmd
+++ b/vignettes/awesome_table_in_pdf.Rmd
@@ -283,6 +283,30 @@
   column_spec(8, image = spec_plot(mpg_list, polymin = 5))
 ```
 
+There is also a `spec_pointrange` function specifically designed for forest plots in regression tables. Of course, feel free to use it for other purposes. 
+
+```{r}
+coef_table <- data.frame(
+  Variables = c("var 1", "var 2", "var 3"),
+  Coefficients = c(1.6, 0.2, -2.0),
+  Conf.Lower = c(1.3, -0.4, -2.5),
+  Conf.Higher = c(1.9, 0.6, -1.4)
+) 
+
+data.frame(
+  Variable = coef_table$Variables,
+  Visualization = ""
+) %>%
+  kbl(booktabs = T) %>%
+  kable_classic(full_width = FALSE) %>%
+  column_spec(2, image = spec_pointrange(
+    x = coef_table$Coefficients, 
+    xmin = coef_table$Conf.Lower, 
+    xmax = coef_table$Conf.Higher, 
+    vline = 0)
+    )
+```
+
 ## Row spec
 Similar with `column_spec`, you can define specifications for rows. Currently, you can either bold or italicize an entire row. Note that, similar to other row-related functions in `kableExtra`, for the position of the target row, you don't need to count in header rows or the group labeling rows.
 
@@ -326,7 +350,7 @@
   background = factor(cs_dt$cyl, c(4, 6, 8), c("#666666", "#999999", "#BBBBBB")))
 cs_dt <- cs_dt[c("car", "mpg", "cyl")]
 
-kbl(cs_dt, escape = F) %>%
+kbl(cs_dt, booktabs = T, escape = F) %>%
   kable_paper("striped", full_width = F)
 
 # You can also do this with dplyr and use one pipe from top to bottom
@@ -355,7 +379,7 @@
 })
 vs_dt[5] <- cell_spec(vs_dt[[5]], color = "white", bold = T,
     background = spec_color(1:10, end = 0.9, option = "A", direction = -1))
-kbl(vs_dt, escape = F, align = "c") %>%
+kbl(vs_dt, booktabs = T, escape = F, align = "c") %>%
   kable_classic("striped", full_width = F)
 # Or dplyr ver
 # iris[1:10, ] %>%
