{-% DrIFT (Automatic class derivations for Haskell) v1.1 %-}
module CNCTypes where

import Text.XML.HaXml.Haskell2Xml hiding (Name)

-- data types for a simple test program

data Cncprog = Cncprog Machine_id Body {-! derive :Haskell2Xml !-}
newtype Prog_start_char = Prog_start_char String 	{-! derive :Haskell2Xml !-}
newtype Machine_id = Machine_id String			{-! derive :Haskell2Xml !-}
data Body = Body (Maybe Remark_p) [Block]		{-! derive :Haskell2Xml !-}
newtype Remark_p = Remark_p String			{-! derive :Haskell2Xml !-}
data Block = Block (Maybe Remark) (Maybe Blocknum)	
		   (Instruction)			{-! derive :Haskell2Xml !-}
newtype Remark = Remark String				{-! derive :Haskell2Xml !-}
data Blocknum = Blocknum String		{-! derive :Haskell2Xml !-}
data Blocknum_Attrs = Blocknum_Attrs
    { blocknumSequence_number_w :: String
    }							{-! derive :Haskell2Xml !-}
data Instruction = Instruction Preparatory_word (Maybe DmwX)
			       (Maybe DmwY) (Maybe DmwZ) (Maybe DmwU) (Maybe DmwV) (Maybe DmwW)
			       (Maybe DmwP) (Maybe DmwQ) (Maybe DmwR) (Maybe DmwA) (Maybe DmwB)
			       (Maybe DmwC) (Maybe ItcwI) (Maybe ItcwJ) (Maybe ItcwK)
			       (Maybe Feed_funct) (Maybe Spindle_sf) (Maybe Tool_funct)
			       (Maybe Miscel_funct) (Maybe Offset_funct) {-! derive :Haskell2Xml !-}
data Preparatory_word = Preparatory_word  String  {-! derive :Haskell2Xml !-}
data Preparatory_word_Attrs = Preparatory_word_Attrs	
    { preparatory_wordP_word :: String
    }							{-! derive :Haskell2Xml !-}
data DmwX = DmwX DmwX_Attrs String			{-! derive :Haskell2Xml !-}
data DmwX_Attrs = DmwX_Attrs
    { dmwXXd_word :: String
    }							{-! derive :Haskell2Xml !-}
data DmwY = DmwY DmwY_Attrs String			{-! derive :Haskell2Xml !-}
data DmwY_Attrs = DmwY_Attrs
    { dmwYYd_word ::  String
    }							{-! derive :Haskell2Xml !-}
data DmwZ = DmwZ DmwZ_Attrs String			{-! derive :Haskell2Xml !-}
data DmwZ_Attrs = DmwZ_Attrs
    { dmwZZd_word ::  String
    }							{-! derive :Haskell2Xml !-}
data DmwU = DmwU DmwU_Attrs String			{-! derive :Haskell2Xml !-}
data DmwU_Attrs = DmwU_Attrs
    { dmwUUd_word ::  String
    }							{-! derive :Haskell2Xml !-}
data DmwV = DmwV DmwV_Attrs String			{-! derive :Haskell2Xml !-}
data DmwV_Attrs = DmwV_Attrs
    { dmwVVd_word :: String
    }							{-! derive :Haskell2Xml !-}
data DmwW = DmwW DmwW_Attrs String			{-! derive :Haskell2Xml !-}
data DmwW_Attrs = DmwW_Attrs
    { dmwWWd_word :: String
    }							{-! derive :Haskell2Xml !-}
data DmwP = DmwP DmwP_Attrs String			{-! derive :Haskell2Xml !-}
data DmwP_Attrs = DmwP_Attrs
    { dmwPPd_word ::  String
    }							{-! derive :Haskell2Xml !-}
data DmwQ = DmwQ DmwQ_Attrs String			{-! derive :Haskell2Xml !-}
data DmwQ_Attrs = DmwQ_Attrs
    { dmwQQd_word ::  String
    }							{-! derive :Haskell2Xml !-}
data DmwR = DmwR DmwR_Attrs String			{-! derive :Haskell2Xml !-}
data DmwR_Attrs = DmwR_Attrs
    { dmwRRd_word ::  String
    }							{-! derive :Haskell2Xml !-}
data DmwA = DmwA DmwA_Attrs String			{-! derive :Haskell2Xml !-}
data DmwA_Attrs = DmwA_Attrs
    { dmwAAd_word ::  String
    }							{-! derive :Haskell2Xml !-}
data DmwB = DmwB DmwB_Attrs String			{-! derive :Haskell2Xml !-}
data DmwB_Attrs = DmwB_Attrs
    { dmwBBd_word :: String
    }							{-! derive :Haskell2Xml !-}
data DmwC = DmwC DmwC_Attrs String			{-! derive :Haskell2Xml !-}
data DmwC_Attrs = DmwC_Attrs
    { dmwCCd_word :: String
    }							{-! derive :Haskell2Xml !-}
data ItcwI = ItcwI ItcwI_Attrs String			{-! derive :Haskell2Xml !-}
data ItcwI_Attrs = ItcwI_Attrs
    { itcwII_word :: String
    }							{-! derive :Haskell2Xml !-}
data ItcwJ = ItcwJ ItcwJ_Attrs String			{-! derive :Haskell2Xml !-}
data ItcwJ_Attrs = ItcwJ_Attrs
    { itcwJJ_word :: String
    }							{-! derive :Haskell2Xml !-}
data ItcwK = ItcwK ItcwK_Attrs String                   {-! derive :Haskell2Xml !-}
data ItcwK_Attrs = ItcwK_Attrs
    { itcwKK_word ::  String
    }							{-! derive :Haskell2Xml !-}
data Feed_funct = Feed_funct Feed_funct_Attrs String	{-! derive :Haskell2Xml !-}
data Feed_funct_Attrs = Feed_funct_Attrs
    { feed_functFf_word ::  String
    }							{-! derive :Haskell2Xml !-}
data Spindle_sf = Spindle_sf Spindle_sw (Maybe CW_misc_funct) {-! derive :Haskell2Xml !-}
data Spindle_sw = Spindle_sw Spindle_sw_Attrs String	{-! derive :Haskell2Xml !-}
data Spindle_sw_Attrs = Spindle_sw_Attrs
    { spindle_swSw_word :: String
    }							{-! derive :Haskell2Xml !-}
data CW_misc_funct = CW_misc_funct CW_misc_funct_Attrs String {-! derive :Haskell2Xml !-}
data CW_misc_funct_Attrs = CW_misc_funct_Attrs
    { cW_misc_functCw_word ::  String
    }							{-! derive :Haskell2Xml !-}
data Tool_funct = Tool_funct Tool_funct_Attrs String	{-! derive :Haskell2Xml !-}
data Tool_funct_Attrs = Tool_funct_Attrs
    { tool_functTf_word :: String
    }							{-! derive :Haskell2Xml !-}
data Miscel_funct = Miscel_funct Miscel_funct_Attrs String {-! derive :Haskell2Xml !-}
data Miscel_funct_Attrs = Miscel_funct_Attrs
    { miscel_functMf_word ::  String
    }							{-! derive :Haskell2Xml !-}
data Offset_funct = Offset_funct Offset_funct_Attrs String {-! derive :Haskell2Xml !-}
data Offset_funct_Attrs = Offset_funct_Attrs
    { offset_functOffset_word ::  String
    }							{-! derive :Haskell2Xml !-}
                               					 			       
{-* Generated by DrIFT-v1.0 : Look, but Don't Touch. *-}
instance Haskell2Xml Cncprog where
    toHType v =
	Defined "Cncprog" [] [Constr "Cncprog" [] [toHType aa,toHType ab]]
      where
	(Cncprog aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Cncprog" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (Cncprog aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(Cncprog aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml Prog_start_char where
    toHType v =
	Defined "Prog_start_char" []
		[Constr "Prog_start_char" [] [toHType aa]]
      where
	(Prog_start_char aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Prog_start_char" `isPrefixOf` constr =
	    (\(aa,_)-> (Prog_start_char aa, etc)) (fromContents cs)
    toContents v@(Prog_start_char aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Machine_id where
    toHType v =
	Defined "Machine_id" [] [Constr "Machine_id" [] [toHType aa]]
      where
	(Machine_id aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Machine_id" `isPrefixOf` constr =
	    (\(aa,_)-> (Machine_id aa, etc)) (fromContents cs)
    toContents v@(Machine_id aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Body where
    toHType v =
	Defined "Body" [] [Constr "Body" [] [toHType aa,toHType ab]]
      where
	(Body aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Body" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (Body aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(Body aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml Remark_p where
    toHType v =
	Defined "Remark_p" [] [Constr "Remark_p" [] [toHType aa]]
      where
	(Remark_p aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Remark_p" `isPrefixOf` constr =
	    (\(aa,_)-> (Remark_p aa, etc)) (fromContents cs)
    toContents v@(Remark_p aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Block where
    toHType v =
	Defined "Block" []
		[Constr "Block" [] [toHType aa,toHType ab,toHType ac]]
      where
	(Block aa ab ac) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Block" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,cs01)-> (\(ac,_)-> (Block aa ab ac, etc))
					(fromContents cs01))
			  (fromContents cs00))
	    (fromContents cs)
    toContents v@(Block aa ab ac) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab,toContents ac])]

instance Haskell2Xml Remark where
    toHType v =
	Defined "Remark" [] [Constr "Remark" [] [toHType aa]]
      where
	(Remark aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Remark" `isPrefixOf` constr =
	    (\(aa,_)-> (Remark aa, etc)) (fromContents cs)
    toContents v@(Remark aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Blocknum where
    toHType v =
	Defined "Blocknum" [] [Constr "Blocknum" [] [toHType aa]]
      where
	(Blocknum aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Blocknum" `isPrefixOf` constr =
	    (\(aa,_)-> (Blocknum aa, etc)) (fromContents cs)
    toContents v@(Blocknum aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Blocknum_Attrs where
    toHType v =
	Defined "Blocknum_Attrs" []
		[Constr "Blocknum_Attrs" [] [toHType aa]]
      where
	(Blocknum_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Blocknum_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (Blocknum_Attrs aa, etc)) (fromContents cs)
    toContents v@(Blocknum_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Instruction where
    toHType v =
	Defined "Instruction" []
		[Constr "Instruction" []
			[toHType aa,toHType ab,toHType ac,toHType ad,toHType ae,toHType af,
			 toHType ag,toHType ah,toHType ai,toHType aj,toHType ak,toHType al,
			 toHType am,toHType an,toHType ao,toHType ap,toHType aq,toHType ar,
			 toHType as,toHType at,toHType au]]
      where
	(Instruction aa ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as at au) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Instruction" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,cs01)-> (\(ac,cs02)-> (\(ad,cs03)-> (\(ae,
								       cs04)-> (\(af,cs05)-> (\(ag,
												cs06)-> (\(ah
													   ,
													   cs07)-> (\(ai
														      ,
														      cs08)-> (\(aj
																 ,
																 cs09)-> (\(ak
																	    ,
																	    cs10)-> (\(al
																		       ,
																		       cs11)-> (\(am
																				  ,
																				  cs12)-> (\(an
																					     ,
																					     cs13)-> (\(ao
																							,
																							cs14)-> (\(ap
																								   ,
																								   cs15)-> (\(aq
																									      ,
																									      cs16)-> (\(ar
																											 ,
																											 cs17)-> (\(as
																												    ,
																												    cs18)-> (\(at
																													       ,
																													       cs19)-> (\(au
																															  ,
																															  _)-> (Instruction aa ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as at au, etc))
																														       (fromContents cs19))
																													    (fromContents cs18))
																												 (fromContents cs17))
																										      (fromContents cs16))
																									   (fromContents cs15))
																								(fromContents cs14))
																						     (fromContents cs13))
																					  (fromContents cs12))
																			       (fromContents cs11))
																		    (fromContents cs10))
																	 (fromContents cs09))
															      (fromContents cs08))
														   (fromContents cs07))
													(fromContents cs06))
											     (fromContents cs05))
									       (fromContents cs04))
								    (fromContents cs03))
						      (fromContents cs02))
					(fromContents cs01))
			  (fromContents cs00))
	    (fromContents cs)
    toContents v@(Instruction aa ab ac ad ae af ag ah ai aj ak al am an ao ap aq ar as at au) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab,toContents ac,toContents ad,
						     toContents ae,toContents af,toContents ag,
						     toContents ah,toContents ai,toContents aj,
						     toContents ak,toContents al,toContents am,
						     toContents an,toContents ao,toContents ap,
						     toContents aq,toContents ar,toContents as,
						     toContents at,toContents au])]

instance Haskell2Xml Preparatory_word where
    toHType v =
	Defined "Preparatory_word" []
		[Constr "Preparatory_word" [] [toHType aa]]
      where
	(Preparatory_word aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Preparatory_word" `isPrefixOf` constr =
	    (\(aa,_)-> (Preparatory_word aa, etc)) (fromContents cs)
    toContents v@(Preparatory_word aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Preparatory_word_Attrs where
    toHType v =
	Defined "Preparatory_word_Attrs" []
		[Constr "Preparatory_word_Attrs" [] [toHType aa]]
      where
	(Preparatory_word_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Preparatory_word_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (Preparatory_word_Attrs aa, etc)) (fromContents cs)
    toContents v@(Preparatory_word_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwX where
    toHType v =
	Defined "DmwX" [] [Constr "DmwX" [] [toHType aa,toHType ab]]
      where
	(DmwX aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwX" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwX aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwX aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwX_Attrs where
    toHType v =
	Defined "DmwX_Attrs" [] [Constr "DmwX_Attrs" [] [toHType aa]]
      where
	(DmwX_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwX_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwX_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwX_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwY where
    toHType v =
	Defined "DmwY" [] [Constr "DmwY" [] [toHType aa,toHType ab]]
      where
	(DmwY aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwY" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwY aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwY aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwY_Attrs where
    toHType v =
	Defined "DmwY_Attrs" [] [Constr "DmwY_Attrs" [] [toHType aa]]
      where
	(DmwY_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwY_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwY_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwY_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwZ where
    toHType v =
	Defined "DmwZ" [] [Constr "DmwZ" [] [toHType aa,toHType ab]]
      where
	(DmwZ aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwZ" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwZ aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwZ aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwZ_Attrs where
    toHType v =
	Defined "DmwZ_Attrs" [] [Constr "DmwZ_Attrs" [] [toHType aa]]
      where
	(DmwZ_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwZ_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwZ_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwZ_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwU where
    toHType v =
	Defined "DmwU" [] [Constr "DmwU" [] [toHType aa,toHType ab]]
      where
	(DmwU aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwU" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwU aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwU aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwU_Attrs where
    toHType v =
	Defined "DmwU_Attrs" [] [Constr "DmwU_Attrs" [] [toHType aa]]
      where
	(DmwU_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwU_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwU_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwU_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwV where
    toHType v =
	Defined "DmwV" [] [Constr "DmwV" [] [toHType aa,toHType ab]]
      where
	(DmwV aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwV" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwV aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwV aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwV_Attrs where
    toHType v =
	Defined "DmwV_Attrs" [] [Constr "DmwV_Attrs" [] [toHType aa]]
      where
	(DmwV_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwV_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwV_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwV_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwW where
    toHType v =
	Defined "DmwW" [] [Constr "DmwW" [] [toHType aa,toHType ab]]
      where
	(DmwW aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwW" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwW aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwW aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwW_Attrs where
    toHType v =
	Defined "DmwW_Attrs" [] [Constr "DmwW_Attrs" [] [toHType aa]]
      where
	(DmwW_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwW_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwW_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwW_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwP where
    toHType v =
	Defined "DmwP" [] [Constr "DmwP" [] [toHType aa,toHType ab]]
      where
	(DmwP aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwP" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwP aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwP aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwP_Attrs where
    toHType v =
	Defined "DmwP_Attrs" [] [Constr "DmwP_Attrs" [] [toHType aa]]
      where
	(DmwP_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwP_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwP_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwP_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwQ where
    toHType v =
	Defined "DmwQ" [] [Constr "DmwQ" [] [toHType aa,toHType ab]]
      where
	(DmwQ aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwQ" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwQ aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwQ aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwQ_Attrs where
    toHType v =
	Defined "DmwQ_Attrs" [] [Constr "DmwQ_Attrs" [] [toHType aa]]
      where
	(DmwQ_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwQ_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwQ_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwQ_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwR where
    toHType v =
	Defined "DmwR" [] [Constr "DmwR" [] [toHType aa,toHType ab]]
      where
	(DmwR aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwR" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwR aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwR aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwR_Attrs where
    toHType v =
	Defined "DmwR_Attrs" [] [Constr "DmwR_Attrs" [] [toHType aa]]
      where
	(DmwR_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwR_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwR_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwR_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwA where
    toHType v =
	Defined "DmwA" [] [Constr "DmwA" [] [toHType aa,toHType ab]]
      where
	(DmwA aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwA" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwA aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwA aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwA_Attrs where
    toHType v =
	Defined "DmwA_Attrs" [] [Constr "DmwA_Attrs" [] [toHType aa]]
      where
	(DmwA_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwA_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwA_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwA_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwB where
    toHType v =
	Defined "DmwB" [] [Constr "DmwB" [] [toHType aa,toHType ab]]
      where
	(DmwB aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwB" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwB aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwB aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwB_Attrs where
    toHType v =
	Defined "DmwB_Attrs" [] [Constr "DmwB_Attrs" [] [toHType aa]]
      where
	(DmwB_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwB_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwB_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwB_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml DmwC where
    toHType v =
	Defined "DmwC" [] [Constr "DmwC" [] [toHType aa,toHType ab]]
      where
	(DmwC aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwC" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (DmwC aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(DmwC aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml DmwC_Attrs where
    toHType v =
	Defined "DmwC_Attrs" [] [Constr "DmwC_Attrs" [] [toHType aa]]
      where
	(DmwC_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "DmwC_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (DmwC_Attrs aa, etc)) (fromContents cs)
    toContents v@(DmwC_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml ItcwI where
    toHType v =
	Defined "ItcwI" [] [Constr "ItcwI" [] [toHType aa,toHType ab]]
      where
	(ItcwI aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "ItcwI" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (ItcwI aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(ItcwI aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml ItcwI_Attrs where
    toHType v =
	Defined "ItcwI_Attrs" [] [Constr "ItcwI_Attrs" [] [toHType aa]]
      where
	(ItcwI_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "ItcwI_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (ItcwI_Attrs aa, etc)) (fromContents cs)
    toContents v@(ItcwI_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml ItcwJ where
    toHType v =
	Defined "ItcwJ" [] [Constr "ItcwJ" [] [toHType aa,toHType ab]]
      where
	(ItcwJ aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "ItcwJ" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (ItcwJ aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(ItcwJ aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml ItcwJ_Attrs where
    toHType v =
	Defined "ItcwJ_Attrs" [] [Constr "ItcwJ_Attrs" [] [toHType aa]]
      where
	(ItcwJ_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "ItcwJ_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (ItcwJ_Attrs aa, etc)) (fromContents cs)
    toContents v@(ItcwJ_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml ItcwK where
    toHType v =
	Defined "ItcwK" [] [Constr "ItcwK" [] [toHType aa,toHType ab]]
      where
	(ItcwK aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "ItcwK" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (ItcwK aa ab, etc)) (fromContents cs00))
	    (fromContents cs)
    toContents v@(ItcwK aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml ItcwK_Attrs where
    toHType v =
	Defined "ItcwK_Attrs" [] [Constr "ItcwK_Attrs" [] [toHType aa]]
      where
	(ItcwK_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "ItcwK_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (ItcwK_Attrs aa, etc)) (fromContents cs)
    toContents v@(ItcwK_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Feed_funct where
    toHType v =
	Defined "Feed_funct" []
		[Constr "Feed_funct" [] [toHType aa,toHType ab]]
      where
	(Feed_funct aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Feed_funct" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (Feed_funct aa ab, etc))
			  (fromContents cs00))
	    (fromContents cs)
    toContents v@(Feed_funct aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml Feed_funct_Attrs where
    toHType v =
	Defined "Feed_funct_Attrs" []
		[Constr "Feed_funct_Attrs" [] [toHType aa]]
      where
	(Feed_funct_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Feed_funct_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (Feed_funct_Attrs aa, etc)) (fromContents cs)
    toContents v@(Feed_funct_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Spindle_sf where
    toHType v =
	Defined "Spindle_sf" []
		[Constr "Spindle_sf" [] [toHType aa,toHType ab]]
      where
	(Spindle_sf aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Spindle_sf" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (Spindle_sf aa ab, etc))
			  (fromContents cs00))
	    (fromContents cs)
    toContents v@(Spindle_sf aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml Spindle_sw where
    toHType v =
	Defined "Spindle_sw" []
		[Constr "Spindle_sw" [] [toHType aa,toHType ab]]
      where
	(Spindle_sw aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Spindle_sw" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (Spindle_sw aa ab, etc))
			  (fromContents cs00))
	    (fromContents cs)
    toContents v@(Spindle_sw aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml Spindle_sw_Attrs where
    toHType v =
	Defined "Spindle_sw_Attrs" []
		[Constr "Spindle_sw_Attrs" [] [toHType aa]]
      where
	(Spindle_sw_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Spindle_sw_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (Spindle_sw_Attrs aa, etc)) (fromContents cs)
    toContents v@(Spindle_sw_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml CW_misc_funct where
    toHType v =
	Defined "CW_misc_funct" []
		[Constr "CW_misc_funct" [] [toHType aa,toHType ab]]
      where
	(CW_misc_funct aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "CW_misc_funct" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (CW_misc_funct aa ab, etc))
			  (fromContents cs00))
	    (fromContents cs)
    toContents v@(CW_misc_funct aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml CW_misc_funct_Attrs where
    toHType v =
	Defined "CW_misc_funct_Attrs" []
		[Constr "CW_misc_funct_Attrs" [] [toHType aa]]
      where
	(CW_misc_funct_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "CW_misc_funct_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (CW_misc_funct_Attrs aa, etc)) (fromContents cs)
    toContents v@(CW_misc_funct_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Tool_funct where
    toHType v =
	Defined "Tool_funct" []
		[Constr "Tool_funct" [] [toHType aa,toHType ab]]
      where
	(Tool_funct aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Tool_funct" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (Tool_funct aa ab, etc))
			  (fromContents cs00))
	    (fromContents cs)
    toContents v@(Tool_funct aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml Tool_funct_Attrs where
    toHType v =
	Defined "Tool_funct_Attrs" []
		[Constr "Tool_funct_Attrs" [] [toHType aa]]
      where
	(Tool_funct_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Tool_funct_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (Tool_funct_Attrs aa, etc)) (fromContents cs)
    toContents v@(Tool_funct_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Miscel_funct where
    toHType v =
	Defined "Miscel_funct" []
		[Constr "Miscel_funct" [] [toHType aa,toHType ab]]
      where
	(Miscel_funct aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Miscel_funct" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (Miscel_funct aa ab, etc))
			  (fromContents cs00))
	    (fromContents cs)
    toContents v@(Miscel_funct aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml Miscel_funct_Attrs where
    toHType v =
	Defined "Miscel_funct_Attrs" []
		[Constr "Miscel_funct_Attrs" [] [toHType aa]]
      where
	(Miscel_funct_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Miscel_funct_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (Miscel_funct_Attrs aa, etc)) (fromContents cs)
    toContents v@(Miscel_funct_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

instance Haskell2Xml Offset_funct where
    toHType v =
	Defined "Offset_funct" []
		[Constr "Offset_funct" [] [toHType aa,toHType ab]]
      where
	(Offset_funct aa ab) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Offset_funct" `isPrefixOf` constr =
	    (\(aa,cs00)-> (\(ab,_)-> (Offset_funct aa ab, etc))
			  (fromContents cs00))
	    (fromContents cs)
    toContents v@(Offset_funct aa ab) =
	[mkElemC (showConstr 0 (toHType v)) (concat [toContents aa,
						     toContents ab])]

instance Haskell2Xml Offset_funct_Attrs where
    toHType v =
	Defined "Offset_funct_Attrs" []
		[Constr "Offset_funct_Attrs" [] [toHType aa]]
      where
	(Offset_funct_Attrs aa) = v
    fromContents (CElem (Elem constr [] cs):etc)
	| "Offset_funct_Attrs" `isPrefixOf` constr =
	    (\(aa,_)-> (Offset_funct_Attrs aa, etc)) (fromContents cs)
    toContents v@(Offset_funct_Attrs aa) =
	[mkElemC (showConstr 0 (toHType v)) (toContents aa)]

--  Imported from other files :-