diff --git a/src/rstd/collections/stack.rs b/src/rstd/collections/stack.rs
index 2b89a67..f718c04 100644
--- a/src/rstd/collections/stack.rs
+++ b/src/rstd/collections/stack.rs
@@ -205,16 +205,16 @@ where
     }
 }
 
-impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx> + InliningFactory<'a, Ctx>> QInliningFactory<'a, Ctx>
+impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx> + InliningFactory<'a, Ctx>> CInliningFactory<'a, Ctx>
     for StackNodeFactory<F>
 where
     F::Mtbl: MentionableTop<'a, Ctx>,
 {
-    fn qextension_error(&self, tail: &[u8]) -> Self::ParseError {
+    fn cextension_error(&self, tail: &[u8]) -> Self::ParseError {
         StackParseError::Element(self.element_factory.extension_error(tail))
     }
 
-    fn qideserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> IParseResult<'a, Ctx, Self, I> {
+    fn cideserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> IParseResult<'a, Ctx, Self, I> {
         let (rest, inctx) = self.parse_point(inctx)?;
         let (element, inctx) = self
             .element_factory
diff --git a/src/rstd/collections/tree.rs b/src/rstd/collections/tree.rs
index ce182ad..6137cb5 100644
--- a/src/rstd/collections/tree.rs
+++ b/src/rstd/collections/tree.rs
@@ -172,12 +172,12 @@ impl<F> ImplMode for TreeFactory<F> {
     type Mode = InliningMode;
 }
 
-impl<'a, Ctx: Context<'a>, F: FactoryParse<'a, Ctx>> QInliningFactory<'a, Ctx> for TreeFactory<F> {
-    fn qextension_error(&self, tail: &[u8]) -> Self::ParseError {
+impl<'a, Ctx: Context<'a>, F: FactoryParse<'a, Ctx>> CInliningFactory<'a, Ctx> for TreeFactory<F> {
+    fn cextension_error(&self, tail: &[u8]) -> Self::ParseError {
         u64::a_extension_error(tail).into()
     }
 
-    fn qideserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> IParseResult<'a, Ctx, Self, I> {
+    fn cideserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> IParseResult<'a, Ctx, Self, I> {
         let (node, inctx) = self.0.ideserialize(inctx)?;
         let (height, inctx) = u64::a_ideserialize(inctx)?;
         let tree = Tree { node, height };
diff --git a/src/rstd/inlining.rs b/src/rstd/inlining.rs
index 958cba1..fcc893a 100644
--- a/src/rstd/inlining.rs
+++ b/src/rstd/inlining.rs
@@ -14,12 +14,12 @@ pub use self::modes::InliningMode;
 
 pub type IParseResult<'a, Ctx, F, I> = Result<(Mtbl<'a, Ctx, F>, I), ParseError<'a, Ctx, F>>;
 
-pub trait QInliningFactory<'a, Ctx: Context<'a>>:
+pub trait CInliningFactory<'a, Ctx: Context<'a>>:
     FactoryBase<'a, Ctx> + ImplMode<Mode = InliningMode>
 {
-    fn qextension_error(&self, tail: &[u8]) -> Self::ParseError;
+    fn cextension_error(&self, tail: &[u8]) -> Self::ParseError;
 
-    fn qideserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> IParseResult<'a, Ctx, Self, I>;
+    fn cideserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> IParseResult<'a, Ctx, Self, I>;
 }
 
 /// This factory should return an error on EOF.
diff --git a/src/rstd/inlining/modes.rs b/src/rstd/inlining/modes.rs
index 6e8b32c..ac48de6 100644
--- a/src/rstd/inlining/modes.rs
+++ b/src/rstd/inlining/modes.rs
@@ -66,13 +66,13 @@ impl Mode for InliningMode {
     }
 }
 
-impl<'a, Ctx: Context<'a>, F: QInliningFactory<'a, Ctx>> FactoryModeProxy<'a, Ctx>
+impl<'a, Ctx: Context<'a>, F: CInliningFactory<'a, Ctx>> FactoryModeProxy<'a, Ctx>
     for WithMode<F, InliningMode>
 {
     type F = F;
 
     fn pmdeserialize<I: InCtx<'a, Ctx>>(f: &Self::F, inctx: I) -> ModeResultM<'a, Ctx, F, I> {
-        f.qideserialize(inctx)
+        f.cideserialize(inctx)
     }
 
     fn pmextend(
@@ -80,7 +80,7 @@ impl<'a, Ctx: Context<'a>, F: QInliningFactory<'a, Ctx>> FactoryModeProxy<'a, Ct
         _mentionable: ExtensionSourceM<'a, Ctx, F>,
         tail: &[u8],
     ) -> ExtensionResultM<'a, Ctx, F> {
-        f.qextension_error(tail)
+        f.cextension_error(tail)
     }
 }
 
diff --git a/src/rstd/nullable.rs b/src/rstd/nullable.rs
index e0b8499..b073c58 100644
--- a/src/rstd/nullable.rs
+++ b/src/rstd/nullable.rs
@@ -107,14 +107,14 @@ impl<'a, Ctx: Context<'a>, A: MentionableBase<'a, Ctx>> Clone for Nullable<'a, C
     }
 }
 
-impl<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> QInliningFactory<'a, Ctx>
+impl<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> CInliningFactory<'a, Ctx>
     for NullableFactory<F>
 {
-    fn qextension_error(&self, tail: &[u8]) -> Self::ParseError {
+    fn cextension_error(&self, tail: &[u8]) -> Self::ParseError {
         PointParseError::WrongLength(HASH_SIZE + tail.len())
     }
 
-    fn qideserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> IParseResult<'a, Ctx, Self, I> {
+    fn cideserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> IParseResult<'a, Ctx, Self, I> {
         let factory = self.factory.clone();
         let (address, inctx) = inctx.icnext_address(|slice| PointParseError::from(slice))?;
         Ok((
diff --git a/src/rstd/point.rs b/src/rstd/point.rs
index a37ab2d..d8398b9 100644
--- a/src/rstd/point.rs
+++ b/src/rstd/point.rs
@@ -83,12 +83,12 @@ impl<F> ImplMode for PointFactory<F> {
     type Mode = InliningMode;
 }
 
-impl<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> QInliningFactory<'a, Ctx> for PointFactory<F> {
-    fn qextension_error(&self, tail: &[u8]) -> Self::ParseError {
+impl<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> CInliningFactory<'a, Ctx> for PointFactory<F> {
+    fn cextension_error(&self, tail: &[u8]) -> Self::ParseError {
         PointParseError::WrongLength(HASH_SIZE + tail.len())
     }
 
-    fn qideserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> IParseResult<'a, Ctx, Self, I> {
+    fn cideserialize<I: InCtx<'a, Ctx>>(&self, inctx: I) -> IParseResult<'a, Ctx, Self, I> {
         inctx.icnext_point(self.inner(), |slice| PointParseError::from(slice))
     }
 }