diff --git a/Cargo.toml b/Cargo.toml
index 135feae..3a1ccc2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "kicad_parse_gen"
-version = "7.0.2"
+version = "7.0.3"
 authors = ["Joost Damad <joost@productize.be>", "Adam Heinrich <adam@productize.be>"]
 license = "MIT/Apache-2.0"
 repository = "https://github.com/productize/kicad-parse-gen"
diff --git a/src/footprint/data.rs b/src/footprint/data.rs
index a701e10..05bb337 100644
--- a/src/footprint/data.rs
+++ b/src/footprint/data.rs
@@ -113,7 +113,6 @@ impl Module {
         self.get_text_mut("value")
     }
 
-
     /// check if the module has the "smd" attribute
     pub fn has_smd_attr(&self) -> bool {
         for element in &self.elements {
@@ -331,18 +330,18 @@ impl BoundingBox for Element {
             Element::FpCircle(ref x) => x.bounding_box(),
             Element::FpText(ref x) => x.bounding_box(),
             Element::FpArc(ref x) => x.bounding_box(),
-            Element::At(_) |
-            Element::Layer(_) |
-            Element::TEdit(_) |
-            Element::Descr(_) |
-            Element::Path(_) |
-            Element::Model(_) |
-            Element::Attr(_) |
-            Element::SolderMaskMargin(_) |
-            Element::Clearance(_) |
-            Element::Tags(_) |
-            Element::Locked |
-            Element::TStamp(_) => Bound::default(),
+            Element::At(_)
+            | Element::Layer(_)
+            | Element::TEdit(_)
+            | Element::Descr(_)
+            | Element::Path(_)
+            | Element::Model(_)
+            | Element::Attr(_)
+            | Element::SolderMaskMargin(_)
+            | Element::Clearance(_)
+            | Element::Tags(_)
+            | Element::Locked
+            | Element::TStamp(_) => Bound::default(),
         }
     }
 }
@@ -383,16 +382,16 @@ impl Flip for Element {
             Element::FpText(ref mut p) => p.flip(),
             Element::At(ref mut p) => p.flip(),
             Element::Layer(ref mut p) => p.flip(),
-            Element::TEdit(_) |
-            Element::Descr(_) |
-            Element::Path(_) |
-            Element::Model(_) |
-            Element::TStamp(_) |
-            Element::SolderMaskMargin(_) |
-            Element::Clearance(_) |
-            Element::Tags(_) |
-            Element::Attr(_) |
-            Element::Locked => (),
+            Element::TEdit(_)
+            | Element::Descr(_)
+            | Element::Path(_)
+            | Element::Model(_)
+            | Element::TStamp(_)
+            | Element::SolderMaskMargin(_)
+            | Element::Clearance(_)
+            | Element::Tags(_)
+            | Element::Attr(_)
+            | Element::Locked => (),
         }
     }
 }
@@ -403,21 +402,21 @@ impl Rotate for Element {
             Element::Pad(ref mut p) => p.rotate(rot),
             Element::FpText(ref mut p) => p.rotate(rot),
             Element::At(ref mut p) => p.rotate(rot),
-            Element::FpPoly(_) |
-            Element::FpLine(_) |
-            Element::FpCircle(_) |
-            Element::FpArc(_) |
-            Element::Layer(_) |
-            Element::TEdit(_) |
-            Element::Descr(_) |
-            Element::Path(_) |
-            Element::Model(_) |
-            Element::TStamp(_) |
-            Element::SolderMaskMargin(_) |
-            Element::Clearance(_) |
-            Element::Tags(_) |
-            Element::Attr(_) |
-            Element::Locked => (),
+            Element::FpPoly(_)
+            | Element::FpLine(_)
+            | Element::FpCircle(_)
+            | Element::FpArc(_)
+            | Element::Layer(_)
+            | Element::TEdit(_)
+            | Element::Descr(_)
+            | Element::Path(_)
+            | Element::Model(_)
+            | Element::TStamp(_)
+            | Element::SolderMaskMargin(_)
+            | Element::Clearance(_)
+            | Element::Tags(_)
+            | Element::Attr(_)
+            | Element::Locked => (),
         }
     }
 }
@@ -425,24 +424,24 @@ impl Rotate for Element {
 impl Element {
     fn is_graphics(&self) -> bool {
         match *self {
-            Element::Pad(_) |
-            Element::FpPoly(_) |
-            Element::FpLine(_) |
-            Element::FpCircle(_) |
-            Element::FpArc(_) => true,
-            Element::FpText(_) |
-            Element::At(_) |
-            Element::Layer(_) |
-            Element::TEdit(_) |
-            Element::Descr(_) |
-            Element::Path(_) |
-            Element::Model(_) |
-            Element::TStamp(_) |
-            Element::SolderMaskMargin(_) |
-            Element::Clearance(_) |
-            Element::Tags(_) |
-            Element::Attr(_) |
-            Element::Locked => false,
+            Element::Pad(_)
+            | Element::FpPoly(_)
+            | Element::FpLine(_)
+            | Element::FpCircle(_)
+            | Element::FpArc(_) => true,
+            Element::FpText(_)
+            | Element::At(_)
+            | Element::Layer(_)
+            | Element::TEdit(_)
+            | Element::Descr(_)
+            | Element::Path(_)
+            | Element::Model(_)
+            | Element::TStamp(_)
+            | Element::SolderMaskMargin(_)
+            | Element::Clearance(_)
+            | Element::Tags(_)
+            | Element::Attr(_)
+            | Element::Locked => false,
         }
     }
 
@@ -452,20 +451,20 @@ impl Element {
             Element::FpLine(ref e) => e.is_fab(),
             Element::FpCircle(ref e) => e.is_fab(),
             Element::FpArc(ref e) => e.is_fab(),
-            Element::Pad(_) |
-            Element::FpText(_) |
-            Element::At(_) |
-            Element::Layer(_) |
-            Element::TEdit(_) |
-            Element::Descr(_) |
-            Element::Path(_) |
-            Element::Model(_) |
-            Element::TStamp(_) |
-            Element::SolderMaskMargin(_) |
-            Element::Clearance(_) |
-            Element::Tags(_) |
-            Element::Attr(_) |
-            Element::Locked => false,
+            Element::Pad(_)
+            | Element::FpText(_)
+            | Element::At(_)
+            | Element::Layer(_)
+            | Element::TEdit(_)
+            | Element::Descr(_)
+            | Element::Path(_)
+            | Element::Model(_)
+            | Element::TStamp(_)
+            | Element::SolderMaskMargin(_)
+            | Element::Clearance(_)
+            | Element::Tags(_)
+            | Element::Attr(_)
+            | Element::Locked => false,
         }
     }
 
@@ -795,7 +794,7 @@ pub enum PadType {
 
 impl PadType {
     /// convert a &str to a pad type
-    pub fn from_string(s: &str) -> Result<PadType,SexpError> {
+    pub fn from_string(s: &str) -> Result<PadType, SexpError> {
         match s {
             "smd" => Ok(PadType::Smd),
             "thru_hole" => Ok(PadType::Pth),
@@ -854,6 +853,10 @@ pub enum LayerSide {
     In1,
     /// Inner layer 2
     In2,
+    /// Inner layer 3
+    In3,
+    /// Inner layer 4
+    In4,
     /// no side
     None,
 }
@@ -945,6 +948,8 @@ impl Layer {
                 "Edge" => LayerSide::Edge,
                 "In1" => LayerSide::In1,
                 "In2" => LayerSide::In2,
+                "In3" => LayerSide::In3,
+                "In4" => LayerSide::In4,
                 "*" => LayerSide::Both,
                 x => return Err(format!("unknown layer side {}", x).into()),
             };
@@ -1136,7 +1141,8 @@ impl BoundingBox for Pad {
     fn bounding_box(&self) -> Bound {
         let x = self.at.x;
         let y = self.at.y;
-        let (dx, dy) = if (self.at.rot - 90.0).abs() < 0.1 || (self.at.rot + 90.0).abs() < 0.1
+        let (dx, dy) = if (self.at.rot - 90.0).abs() < 0.1
+            || (self.at.rot + 90.0).abs() < 0.1
             || (self.at.rot - 270.0).abs() < 0.1
             || (self.at.rot + 270.0).abs() < 0.1
         {
diff --git a/src/footprint/mod.rs b/src/footprint/mod.rs
index 771a7e6..b6e4810 100644
--- a/src/footprint/mod.rs
+++ b/src/footprint/mod.rs
@@ -7,9 +7,9 @@ use std::fmt;
 use std::result;
 
 // get from parent
+use formatter::KicadFormatter;
 use symbolic_expressions;
 use symbolic_expressions::IntoSexp;
-use formatter::KicadFormatter;
 use KicadError;
 
 // pub use footprint;
@@ -34,6 +34,8 @@ impl fmt::Display for Layer {
             LayerSide::Edge => write!(f, "Edge."),
             LayerSide::In1 => write!(f, "In1."),
             LayerSide::In2 => write!(f, "In2."),
+            LayerSide::In3 => write!(f, "In3."),
+            LayerSide::In4 => write!(f, "In4."),
             LayerSide::Both => write!(f, "*."),
             LayerSide::None => Ok(()),
         }?;
@@ -61,5 +63,5 @@ pub fn parse(s: &str) -> Result<Module, KicadError> {
 }
 
 mod data;
-mod ser;
 mod de;
+mod ser;
diff --git a/src/layout/data.rs b/src/layout/data.rs
index 8a7b6ce..b19f0a1 100644
--- a/src/layout/data.rs
+++ b/src/layout/data.rs
@@ -1,12 +1,12 @@
 // (c) 2016-2017 Productize SPRL <joost@productize.be>
 
 // from parent
-use str_error;
 use footprint;
-use Sexp;
 use layout::{Adjust, Bound, BoundingBox};
 use std::{fmt, result};
+use str_error;
 use KicadError;
+use Sexp;
 
 /// a Kicad layout
 #[derive(Debug)]
@@ -443,6 +443,8 @@ pub struct GrCircle {
     pub width: f64,
     /// timestamp
     pub tstamp: Option<String>,
+    /// fill
+    pub fill: Option<String>,
 }
 
 impl Adjust for GrCircle {
@@ -663,16 +665,20 @@ impl Layout {
                 Element::Net(ref mut net) => {
                     update(&mut net.name)?;
                 }
-                Element::NetClass(ref mut nc) => for name in &mut nc.nets {
-                    update(name)?;
-                },
-                Element::Module(ref mut module) => for m_e in &mut module.elements {
-                    if let footprint::Element::Pad(ref mut pad) = *m_e {
-                        if let Some(ref mut net) = pad.net {
-                            update(&mut net.name)?;
+                Element::NetClass(ref mut nc) => {
+                    for name in &mut nc.nets {
+                        update(name)?;
+                    }
+                }
+                Element::Module(ref mut module) => {
+                    for m_e in &mut module.elements {
+                        if let footprint::Element::Pad(ref mut pad) = *m_e {
+                            if let Some(ref mut net) = pad.net {
+                                update(&mut net.name)?;
+                            }
                         }
                     }
-                },
+                }
                 Element::Zone(ref mut zone) => {
                     update(&mut zone.net_name)?;
                 }
@@ -697,20 +703,22 @@ impl Layout {
     pub fn get_module(&self, reference: &str) -> Option<&footprint::Module> {
         for x in &self.elements[..] {
             match *x {
-                Element::Module(ref m) => if m.is_reference_with_name(reference) {
-                    return Some(m);
-                },
-                Element::Via(_) |
-                Element::Segment(_) |
-                Element::Net(_) |
-                Element::NetClass(_) |
-                Element::GrText(_) |
-                Element::GrLine(_) |
-                Element::GrArc(_) |
-                Element::GrCircle(_) |
-                Element::Dimension(_) |
-                Element::Zone(_) |
-                Element::Other(_) => (),
+                Element::Module(ref m) => {
+                    if m.is_reference_with_name(reference) {
+                        return Some(m);
+                    }
+                }
+                Element::Via(_)
+                | Element::Segment(_)
+                | Element::Net(_)
+                | Element::NetClass(_)
+                | Element::GrText(_)
+                | Element::GrLine(_)
+                | Element::GrArc(_)
+                | Element::GrCircle(_)
+                | Element::Dimension(_)
+                | Element::Zone(_)
+                | Element::Other(_) => (),
             }
         }
         None
@@ -734,20 +742,22 @@ impl Layout {
     {
         for x in &mut self.elements {
             match *x {
-                Element::Module(ref mut m) => if m.is_reference_with_name(reference) {
-                    return Ok(fun(m));
-                },
-                Element::Via(_) |
-                Element::Segment(_) |
-                Element::Net(_) |
-                Element::NetClass(_) |
-                Element::GrText(_) |
-                Element::GrLine(_) |
-                Element::GrArc(_) |
-                Element::GrCircle(_) |
-                Element::Dimension(_) |
-                Element::Zone(_) |
-                Element::Other(_) => (),
+                Element::Module(ref mut m) => {
+                    if m.is_reference_with_name(reference) {
+                        return Ok(fun(m));
+                    }
+                }
+                Element::Via(_)
+                | Element::Segment(_)
+                | Element::Net(_)
+                | Element::NetClass(_)
+                | Element::GrText(_)
+                | Element::GrLine(_)
+                | Element::GrArc(_)
+                | Element::GrCircle(_)
+                | Element::Dimension(_)
+                | Element::Zone(_)
+                | Element::Other(_) => (),
             }
         }
         str_error(format!("did not find module with reference {}", reference))
diff --git a/src/layout/de.rs b/src/layout/de.rs
index eaca0e1..7c1eaa9 100644
--- a/src/layout/de.rs
+++ b/src/layout/de.rs
@@ -5,10 +5,10 @@
 
 // from parent
 use footprint;
-use wrap;
-use Sexp;
 use symbolic_expressions::iteratom::*;
 use symbolic_expressions::SexpError;
+use wrap;
+use Sexp;
 
 use layout::data::*;
 
@@ -307,12 +307,12 @@ impl FromSexp for GrCircle {
         c.layer = i.t("layer")?;
         c.width = i.maybe_f_in_list("width").unwrap_or(0.0);
         c.tstamp = i.maybe_s_in_list("tstamp");
+        c.fill = i.maybe_s_in_list("fill");
         // TODO: status field?
         i.close(c)
     }
 }
 
-
 impl FromSexp for Dimension {
     fn from_sexp(s: &Sexp) -> Result<Dimension, SexpError> {
         let mut d = Dimension::default();