ds022.hs:22: 
    Warning: Pattern match(es) completely overlapped
	in the definition of function `i'
ds022.hs:23: 
    Warning: Pattern match(es) completely overlapped
	in the definition of function `i'
ds022.hs:20: 
    Warning: Possibly incomplete patterns
	in the definition of function `i'
ds022.hs:15: 
    Warning: Possibly incomplete patterns
	in the definition of function `h'
ds022.hs:10: 
    Warning: Possibly incomplete patterns
	in the definition of function `g'
ds022.hs:5: 
    Warning: Possibly incomplete patterns
	in the definition of function `f'


================================================================================
Desugared:
Rec {
d.Eq_a13W  :: 
    {PrelBase.Eq{-23,p-} PrelBase.Char{-38,p-}}
{-# L #-}
d.Eq_a13W =
    PrelBase.$d33{-rbH,p-}
d.Eq_a13U  :: 
    {PrelBase.Eq{-23,p-} [PrelBase.Char{-38,p-}]}
{-# L #-}
d.Eq_a13U =
    PrelBase.$d27{-rbA,p-}
	_@_ PrelBase.Char{-38,p-} d.Eq_a13W
==_a1pN  :: 
    [PrelBase.Char{-38,p-}]
    -> [PrelBase.Char{-38,p-}]
    -> PrelBase.Bool{-34,p-}
{-# L #-}
==_a1pN =
    PrelBase.=={-8Y,p-}
	_@_ [PrelBase.Char{-38,p-}] d.Eq_a13U
i{-r3E,x-}  :: 
    _forall_
    [t{-a11b-} t{-a11f-} t{-a11j-}]
    =>
    {PrelNum.Fractional{-26,p-} t{-a11f-}}
    -> {PrelBase.Num{-2c,p-} t{-a11b-}}
    -> t{-a11b-}
    -> t{-a11f-}
    -> [t{-a11j-}]
{-# L #-}
i{-r3E,x-} =
    _/\_ t{-a11b-} t{-a11f-} t{-a11j-} -> \ d.Fractional_a11r  :: 
						{PrelNum.Fractional{-26,p-} t{-a11f-}}
					    {-# L #-}
					    d.Fractional_a11r d.Num_a11m  :: 
								  {PrelBase.Num{-2c,p-} t{-a11b-}}
							      {-# L #-}
							      d.Num_a11m ->
	let {
	  d.Eq_a11o  :: 
	      {PrelBase.Eq{-23,p-} t{-a11b-}}
	  {-# L #-}
	  d.Eq_a11o =
	      PrelBase.scsel_NumPrelBaseEq{-a1rD,p-}
		  _@_ t{-a11b-} d.Num_a11m } in
	let {
	  d.Num_a13X  :: 
	      {PrelBase.Num{-2c,p-} t{-a11f-}}
	  {-# L #-}
	  d.Num_a13X =
	      PrelNum.scsel_FractionalPrelBaseNum{-a1rM,p-}
		  _@_ t{-a11f-} d.Fractional_a11r } in
	let {
	  d.Eq_a11t  :: 
	      {PrelBase.Eq{-23,p-} t{-a11f-}}
	  {-# L #-}
	  d.Eq_a11t =
	      PrelBase.scsel_NumPrelBaseEq{-a1rD,p-}
		  _@_ t{-a11f-} d.Num_a13X } in
	let {
	  fromInt_a1rt  :: 
	      PrelBase.Int{-3g,p-} -> t{-a11b-}
	  {-# L #-}
	  fromInt_a1rt =
	      PrelBase.fromInt{-8R,p-}
		  _@_ t{-a11b-} d.Num_a11m } in
	let { lit_a1rs  :: 
		  t{-a11b-}
	      {-# L #-}
	      lit_a1rs =
	  let {
	    ds_d1s9  :: 
		PrelBase.Int{-3g,p-}
	    {-# L #-}
	    ds_d1s9 =
		PrelBase.I#{-5b,p-}{i}
		    1
	  } in 
	    fromInt_a1rt
		ds_d1s9
	} in
	let {
	  ==_a1rr  :: 
	      t{-a11b-} -> t{-a11b-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1rr =
	      PrelBase.=={-8Y,p-}
		  _@_ t{-a11b-} d.Eq_a11o } in
	let {
	  fromRational_a1rq  :: 
	      PrelNum.Rational{-3r,p-} -> t{-a11f-}
	  {-# L #-}
	  fromRational_a1rq =
	      PrelNum.fromRational{-8T,p-}
		  _@_ t{-a11f-} d.Fractional_a11r } in
	let {
	  lit_a1rp  :: 
	      t{-a11f-}
	  {-# L #-}
	  lit_a1rp =
	      fromRational_a1rq
		  _rational_  11 10 } in
	let {
	  ==_a1ro  :: 
	      t{-a11f-} -> t{-a11f-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1ro =
	      PrelBase.=={-8Y,p-}
		  _@_ t{-a11f-} d.Eq_a11t } in
	let {
	  fromInt_a1rn  :: 
	      PrelBase.Int{-3g,p-} -> t{-a11b-}
	  {-# L #-}
	  fromInt_a1rn =
	      fromInt_a1rt } in
	let { lit_a1rm  :: 
		  t{-a11b-}
	      {-# L #-}
	      lit_a1rm =
	  let {
	    ds_d1sR  :: 
		PrelBase.Int{-3g,p-}
	    {-# L #-}
	    ds_d1sR =
		PrelBase.I#{-5b,p-}{i}
		    2
	  } in 
	    fromInt_a1rn
		ds_d1sR
	} in
	let {
	  ==_a1rl  :: 
	      t{-a11b-} -> t{-a11b-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1rl =
	      ==_a1rr } in
	let {
	  fromRational_a1rk  :: 
	      PrelNum.Rational{-3r,p-} -> t{-a11f-}
	  {-# L #-}
	  fromRational_a1rk =
	      fromRational_a1rq } in
	let {
	  lit_a1rj  :: 
	      t{-a11f-}
	  {-# L #-}
	  lit_a1rj =
	      fromRational_a1rk
		  _rational_  11 5 } in
	let {
	  ==_a1ri  :: 
	      t{-a11f-} -> t{-a11f-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1ri =
	      ==_a1ro } in
	let {
	  lit_a1rh  :: 
	      t{-a11b-}
	  {-# L #-}
	  lit_a1rh =
	      lit_a1rs } in
	let {
	  ==_a1rg  :: 
	      t{-a11b-} -> t{-a11b-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1rg =
	      ==_a1rr } in
	let {
	  lit_a1rf  :: 
	      t{-a11f-}
	  {-# L #-}
	  lit_a1rf =
	      lit_a1rp } in
	let {
	  ==_a1re  :: 
	      t{-a11f-} -> t{-a11f-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1re =
	      ==_a1ro } in
	let {
	  lit_a1rd  :: 
	      t{-a11b-}
	  {-# L #-}
	  lit_a1rd =
	      lit_a1rm } in
	let {
	  ==_a1rc  :: 
	      t{-a11b-} -> t{-a11b-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1rc =
	      ==_a1rr } in
	let {
	  lit_a1rb  :: 
	      t{-a11f-}
	  {-# L #-}
	  lit_a1rb =
	      lit_a1rj } in
	let {
	  ==_a1ra  :: 
	      t{-a11f-} -> t{-a11f-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1ra =
	      ==_a1ro
	} in 
	  \ ds_d1tC  :: 
		t{-a11b-}
	    {-# L #-}
	    ds_d1tC ds_d1tF  :: 
			t{-a11f-}
		    {-# L #-}
		    ds_d1tF ->
	      let {
		fail_d1tG  :: 
		    [t{-a11j-}]
		{-# L #-}
		fail_d1tG =
		    GHCerr.patError{-8r,p-}
			_@_ [t{-a11j-}] _string_ "ds022.hs:20|function `i'" } in
	      let {
		fail_d1uo  :: 
		    [t{-a11j-}]
		{-# L #-}
		fail_d1uo =
		    case
			==_a1rl
			    lit_a1rm ds_d1tC
		    of {
		      PrelBase.True{-5E,p-}{i} ->
			  case
			      ==_a1ri
				  lit_a1rj ds_d1tF
			  of {
			    PrelBase.True{-5E,p-}{i} ->
				PrelBase.[]{-5i,p-}{i}
				    _@_ t{-a11j-};
			    PrelBase.False{-58,p-}{i} ->
				fail_d1tG;
			  };
		      PrelBase.False{-58,p-}{i} ->
			  fail_d1tG;
		    }
	      } in 
		case
		    ==_a1rr
			lit_a1rs ds_d1tC
		of {
		  PrelBase.True{-5E,p-}{i} ->
		      case
			  ==_a1ro
			      lit_a1rp ds_d1tF
		      of {
			PrelBase.True{-5E,p-}{i} ->
			    PrelBase.[]{-5i,p-}{i}
				_@_ t{-a11j-};
			PrelBase.False{-58,p-}{i} ->
			    fail_d1uo;
		      };
		  PrelBase.False{-58,p-}{i} ->
		      fail_d1uo;
		}
h{-r3F,x-}  :: 
    _forall_
    [t{-a11Q-}]
    =>
    PrelBase.Char{-38,p-} -> [PrelBase.Char{-38,p-}] -> [t{-a11Q-}]
{-# L #-}
h{-r3F,x-} =
    _/\_ t{-a11Q-} ->
	let {
	  ==_a1v3  :: 
	      [PrelBase.Char{-38,p-}]
	      -> [PrelBase.Char{-38,p-}]
	      -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1v3 =
	      ==_a1pN
	} in 
	  \ ds_d1vj  :: 
		PrelBase.Char{-38,p-}
	    {-# L #-}
	    ds_d1vj ds_d1vk  :: 
			[PrelBase.Char{-38,p-}]
		    {-# L #-}
		    ds_d1vk ->
	      let {
		fail_d1vl  :: 
		    [t{-a11Q-}]
		{-# L #-}
		fail_d1vl =
		    GHCerr.patError{-8r,p-}
			_@_ [t{-a11Q-}] _string_ "ds022.hs:15|function `h'"
	      } in 
		case ds_d1vj of { PrelBase.C#{-54,p-}{i} ds_d1vu  ->
		case# ds_d1vu of {
		  'a' ->
		      case ds_d1vk of {
			PrelBase.:{-55,p-}{i} ds_d1vK ds_d1vJ ->
			    fail_d1vl;
			PrelBase.[]{-5i,p-}{i} ->
			    PrelBase.[]{-5i,p-}{i}
				_@_ t{-a11Q-};
		      };
		  ''' ->
		      case
			  ==_a1v3
			      _string_ "foo" ds_d1vk
		      of {
			PrelBase.True{-5E,p-}{i} ->
			    PrelBase.[]{-5i,p-}{i}
				_@_ t{-a11Q-};
			PrelBase.False{-58,p-}{i} ->
			    fail_d1vl;
		      };
		  '"' ->
		      case ds_d1vk of {
			PrelBase.[]{-5i,p-}{i} ->
			    fail_d1vl;
			PrelBase.:{-55,p-}{i} ds_d1wC ds_d1wD ->
			    case ds_d1wC of { PrelBase.C#{-54,p-}{i} ds_d1wM  ->
			    case# ds_d1wM of {
			      'b' ->
				  case ds_d1wD of {
				    PrelBase.[]{-5i,p-}{i} ->
					fail_d1vl;
				    PrelBase.:{-55,p-}{i} ds_d1x7 ds_d1x8 ->
					case ds_d1x7 of { PrelBase.C#{-54,p-}{i} ds_d1xh  ->
					case# ds_d1xh of {
					  'a' ->
					      case ds_d1x8 of {
						PrelBase.[]{-5i,p-}{i} ->
						    fail_d1vl;
						PrelBase.:{-55,p-}{i} ds_d1xC ds_d1xD ->
						    case
							ds_d1xC
						    of {
						    PrelBase.C#{-54,p-}{i} ds_d1xM  ->
						    case# ds_d1xM of {
						      'r' ->
							  case ds_d1xD of {
							    PrelBase.:{-55,p-}{i} ds_d1y2 ds_d1y1 ->
								fail_d1vl;
							    PrelBase.[]{-5i,p-}{i} ->
								PrelBase.[]{-5i,p-}{i}
								    _@_ t{-a11Q-};
							  };
						      ds_d1yd ->
							  fail_d1vl;
						    };};
					      };
					  ds_d1yg ->
					      fail_d1vl;
					};};
				  };
			      ds_d1yj ->
				  fail_d1vl;
			    };};
		      };
		  '¨' ->
		      let {
			blob_r3D  :: 
			    [PrelBase.Char{-38,p-}]
			{-# L #-}
			blob_r3D =
			    ds_d1vk
		      } in 
			PrelBase.[]{-5i,p-}{i}
			    _@_ t{-a11Q-};
		  ds_d1yx ->
		      fail_d1vl;
		};}
g{-r3G,x-}  :: 
    _forall_
    [t{-a12s-} t{-a12w-} t{-a12A-}]
    =>
    {PrelNum.Fractional{-26,p-} t{-a12w-}}
    -> {PrelBase.Num{-2c,p-} t{-a12s-}}
    -> t{-a12s-}
    -> t{-a12w-}
    -> [t{-a12A-}]
{-# L #-}
g{-r3G,x-} =
    _/\_ t{-a12s-} t{-a12w-} t{-a12A-} -> \ d.Fractional_a12I  :: 
						{PrelNum.Fractional{-26,p-} t{-a12w-}}
					    {-# L #-}
					    d.Fractional_a12I d.Num_a12D  :: 
								  {PrelBase.Num{-2c,p-} t{-a12s-}}
							      {-# L #-}
							      d.Num_a12D ->
	let {
	  d.Eq_a12F  :: 
	      {PrelBase.Eq{-23,p-} t{-a12s-}}
	  {-# L #-}
	  d.Eq_a12F =
	      PrelBase.scsel_NumPrelBaseEq{-a1rD,p-}
		  _@_ t{-a12s-} d.Num_a12D } in
	let {
	  d.Num_a13Y  :: 
	      {PrelBase.Num{-2c,p-} t{-a12w-}}
	  {-# L #-}
	  d.Num_a13Y =
	      PrelNum.scsel_FractionalPrelBaseNum{-a1rM,p-}
		  _@_ t{-a12w-} d.Fractional_a12I } in
	let {
	  d.Eq_a12K  :: 
	      {PrelBase.Eq{-23,p-} t{-a12w-}}
	  {-# L #-}
	  d.Eq_a12K =
	      PrelBase.scsel_NumPrelBaseEq{-a1rD,p-}
		  _@_ t{-a12w-} d.Num_a13Y } in
	let {
	  fromInteger_a1zV  :: 
	      PrelBase.Integer{-3h,p-} -> t{-a12s-}
	  {-# L #-}
	  fromInteger_a1zV =
	      PrelBase.fromInteger{-8S,p-}
		  _@_ t{-a12s-} d.Num_a12D } in
	let {
	  lit_a1zU  :: 
	      t{-a12s-}
	  {-# L #-}
	  lit_a1zU =
	      fromInteger_a1zV
		  _integer_  11111111111111111111111 } in
	let {
	  ==_a1zT  :: 
	      t{-a12s-} -> t{-a12s-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1zT =
	      PrelBase.=={-8Y,p-}
		  _@_ t{-a12s-} d.Eq_a12F } in
	let {
	  fromRational_a1zS  :: 
	      PrelNum.Rational{-3r,p-} -> t{-a12w-}
	  {-# L #-}
	  fromRational_a1zS =
	      PrelNum.fromRational{-8T,p-}
		  _@_ t{-a12w-} d.Fractional_a12I } in
	let {
	  lit_a1zR  :: 
	      t{-a12w-}
	  {-# L #-}
	  lit_a1zR =
	      fromRational_a1zS
		  _rational_  111111111111111111 100000000000000000 } in
	let {
	  ==_a1zQ  :: 
	      t{-a12w-} -> t{-a12w-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1zQ =
	      PrelBase.=={-8Y,p-}
		  _@_ t{-a12w-} d.Eq_a12K } in
	let {
	  fromInteger_a1zP  :: 
	      PrelBase.Integer{-3h,p-} -> t{-a12s-}
	  {-# L #-}
	  fromInteger_a1zP =
	      fromInteger_a1zV } in
	let {
	  lit_a1zO  :: 
	      t{-a12s-}
	  {-# L #-}
	  lit_a1zO =
	      fromInteger_a1zP
		  _integer_  22222222222222222222222 } in
	let {
	  ==_a1zN  :: 
	      t{-a12s-} -> t{-a12s-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1zN =
	      ==_a1zT } in
	let {
	  fromRational_a1zM  :: 
	      PrelNum.Rational{-3r,p-} -> t{-a12w-}
	  {-# L #-}
	  fromRational_a1zM =
	      fromRational_a1zS } in
	let {
	  lit_a1zL  :: 
	      t{-a12w-}
	  {-# L #-}
	  lit_a1zL =
	      fromRational_a1zM
		  _rational_  111111111111111111 50000000000000000 } in
	let {
	  ==_a1zK  :: 
	      t{-a12w-} -> t{-a12w-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1zK =
	      ==_a1zQ } in
	let {
	  fromInteger_a1zJ  :: 
	      PrelBase.Integer{-3h,p-} -> t{-a12s-}
	  {-# L #-}
	  fromInteger_a1zJ =
	      fromInteger_a1zV } in
	let {
	  lit_a1zI  :: 
	      t{-a12s-}
	  {-# L #-}
	  lit_a1zI =
	      fromInteger_a1zJ
		  _integer_  33333333333333333333333 } in
	let {
	  ==_a1zH  :: 
	      t{-a12s-} -> t{-a12s-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1zH =
	      ==_a1zT } in
	let {
	  fromRational_a1zG  :: 
	      PrelNum.Rational{-3r,p-} -> t{-a12w-}
	  {-# L #-}
	  fromRational_a1zG =
	      fromRational_a1zS } in
	let {
	  lit_a1zF  :: 
	      t{-a12w-}
	  {-# L #-}
	  lit_a1zF =
	      fromRational_a1zG
		  _rational_  333333333333333333 100000000000000000 } in
	let {
	  ==_a1zE  :: 
	      t{-a12w-} -> t{-a12w-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1zE =
	      ==_a1zQ } in
	let {
	  fromInteger_a1zD  :: 
	      PrelBase.Integer{-3h,p-} -> t{-a12s-}
	  {-# L #-}
	  fromInteger_a1zD =
	      fromInteger_a1zV } in
	let {
	  lit_a1zC  :: 
	      t{-a12s-}
	  {-# L #-}
	  lit_a1zC =
	      fromInteger_a1zD
		  _integer_  44444444444444444444444 } in
	let {
	  ==_a1zB  :: 
	      t{-a12s-} -> t{-a12s-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1zB =
	      ==_a1zT } in
	let {
	  fromRational_a1zA  :: 
	      PrelNum.Rational{-3r,p-} -> t{-a12w-}
	  {-# L #-}
	  fromRational_a1zA =
	      fromRational_a1zS } in
	let {
	  lit_a1zz  :: 
	      t{-a12w-}
	  {-# L #-}
	  lit_a1zz =
	      fromRational_a1zA
		  _rational_  111111111111111111 25000000000000000 } in
	let {
	  ==_a1zy  :: 
	      t{-a12w-} -> t{-a12w-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1zy =
	      ==_a1zQ
	} in 
	  \ ds_d1Cc  :: 
		t{-a12s-}
	    {-# L #-}
	    ds_d1Cc ds_d1Cf  :: 
			t{-a12w-}
		    {-# L #-}
		    ds_d1Cf ->
	      let {
		fail_d1Cg  :: 
		    [t{-a12A-}]
		{-# L #-}
		fail_d1Cg =
		    GHCerr.patError{-8r,p-}
			_@_ [t{-a12A-}] _string_ "ds022.hs:10|function `g'" } in
	      let { fail_d1Eo  :: 
			[t{-a12A-}]
		    {-# L #-}
		    fail_d1Eo =
		let { fail_d1DG  :: 
			  [t{-a12A-}]
		      {-# L #-}
		      fail_d1DG =
		  let {
		    fail_d1CY  :: 
			[t{-a12A-}]
		    {-# L #-}
		    fail_d1CY =
			case
			    ==_a1zB
				lit_a1zC ds_d1Cc
			of {
			  PrelBase.True{-5E,p-}{i} ->
			      case
				  ==_a1zy
				      lit_a1zz ds_d1Cf
			      of {
				PrelBase.True{-5E,p-}{i} ->
				    PrelBase.[]{-5i,p-}{i}
					_@_ t{-a12A-};
				PrelBase.False{-58,p-}{i} ->
				    fail_d1Cg;
			      };
			  PrelBase.False{-58,p-}{i} ->
			      fail_d1Cg;
			}
		  } in 
		    case
			==_a1zH
			    lit_a1zI ds_d1Cc
		    of {
		      PrelBase.True{-5E,p-}{i} ->
			  case
			      ==_a1zE
				  lit_a1zF ds_d1Cf
			  of {
			    PrelBase.True{-5E,p-}{i} ->
				PrelBase.[]{-5i,p-}{i}
				    _@_ t{-a12A-};
			    PrelBase.False{-58,p-}{i} ->
				fail_d1CY;
			  };
		      PrelBase.False{-58,p-}{i} ->
			  fail_d1CY;
		    }
		} in
		case
		    ==_a1zN
			lit_a1zO ds_d1Cc
		of {
		  PrelBase.True{-5E,p-}{i} ->
		      case
			  ==_a1zK
			      lit_a1zL ds_d1Cf
		      of {
			PrelBase.True{-5E,p-}{i} ->
			    PrelBase.[]{-5i,p-}{i}
				_@_ t{-a12A-};
			PrelBase.False{-58,p-}{i} ->
			    fail_d1DG;
		      };
		  PrelBase.False{-58,p-}{i} ->
		      fail_d1DG;
		}
	      } in
	      case
		  ==_a1zT
		      lit_a1zU ds_d1Cc
	      of {
		PrelBase.True{-5E,p-}{i} ->
		    case
			==_a1zQ
			    lit_a1zR ds_d1Cf
		    of {
		      PrelBase.True{-5E,p-}{i} ->
			  PrelBase.[]{-5i,p-}{i}
			      _@_ t{-a12A-};
		      PrelBase.False{-58,p-}{i} ->
			  fail_d1Eo;
		    };
		PrelBase.False{-58,p-}{i} ->
		    fail_d1Eo;
	      }
f{-r3H,x-}  :: 
    _forall_
    [t{-a13s-} t{-a13w-} t{-a13A-}]
    =>
    {PrelNum.Fractional{-26,p-} t{-a13w-}}
    -> {PrelBase.Num{-2c,p-} t{-a13s-}}
    -> t{-a13s-}
    -> t{-a13w-}
    -> [t{-a13A-}]
{-# L #-}
f{-r3H,x-} =
    _/\_ t{-a13s-} t{-a13w-} t{-a13A-} -> \ d.Fractional_a13I  :: 
						{PrelNum.Fractional{-26,p-} t{-a13w-}}
					    {-# L #-}
					    d.Fractional_a13I d.Num_a13D  :: 
								  {PrelBase.Num{-2c,p-} t{-a13s-}}
							      {-# L #-}
							      d.Num_a13D ->
	let {
	  d.Eq_a13F  :: 
	      {PrelBase.Eq{-23,p-} t{-a13s-}}
	  {-# L #-}
	  d.Eq_a13F =
	      PrelBase.scsel_NumPrelBaseEq{-a1rD,p-}
		  _@_ t{-a13s-} d.Num_a13D } in
	let {
	  d.Num_a13Z  :: 
	      {PrelBase.Num{-2c,p-} t{-a13w-}}
	  {-# L #-}
	  d.Num_a13Z =
	      PrelNum.scsel_FractionalPrelBaseNum{-a1rM,p-}
		  _@_ t{-a13w-} d.Fractional_a13I } in
	let {
	  d.Eq_a13K  :: 
	      {PrelBase.Eq{-23,p-} t{-a13w-}}
	  {-# L #-}
	  d.Eq_a13K =
	      PrelBase.scsel_NumPrelBaseEq{-a1rD,p-}
		  _@_ t{-a13w-} d.Num_a13Z } in
	let {
	  fromInt_a1Gk  :: 
	      PrelBase.Int{-3g,p-} -> t{-a13s-}
	  {-# L #-}
	  fromInt_a1Gk =
	      PrelBase.fromInt{-8R,p-}
		  _@_ t{-a13s-} d.Num_a13D } in
	let { lit_a1Gj  :: 
		  t{-a13s-}
	      {-# L #-}
	      lit_a1Gj =
	  let {
	    ds_d1GY  :: 
		PrelBase.Int{-3g,p-}
	    {-# L #-}
	    ds_d1GY =
		PrelBase.I#{-5b,p-}{i}
		    1
	  } in 
	    fromInt_a1Gk
		ds_d1GY
	} in
	let {
	  ==_a1Gi  :: 
	      t{-a13s-} -> t{-a13s-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1Gi =
	      PrelBase.=={-8Y,p-}
		  _@_ t{-a13s-} d.Eq_a13F } in
	let {
	  fromRational_a1Gh  :: 
	      PrelNum.Rational{-3r,p-} -> t{-a13w-}
	  {-# L #-}
	  fromRational_a1Gh =
	      PrelNum.fromRational{-8T,p-}
		  _@_ t{-a13w-} d.Fractional_a13I } in
	let {
	  lit_a1Gg  :: 
	      t{-a13w-}
	  {-# L #-}
	  lit_a1Gg =
	      fromRational_a1Gh
		  _rational_  11 10 } in
	let {
	  ==_a1Gf  :: 
	      t{-a13w-} -> t{-a13w-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1Gf =
	      PrelBase.=={-8Y,p-}
		  _@_ t{-a13w-} d.Eq_a13K } in
	let {
	  fromInt_a1Ge  :: 
	      PrelBase.Int{-3g,p-} -> t{-a13s-}
	  {-# L #-}
	  fromInt_a1Ge =
	      fromInt_a1Gk } in
	let { lit_a1Gd  :: 
		  t{-a13s-}
	      {-# L #-}
	      lit_a1Gd =
	  let {
	    ds_d1HG  :: 
		PrelBase.Int{-3g,p-}
	    {-# L #-}
	    ds_d1HG =
		PrelBase.I#{-5b,p-}{i}
		    2
	  } in 
	    fromInt_a1Ge
		ds_d1HG
	} in
	let {
	  ==_a1Gc  :: 
	      t{-a13s-} -> t{-a13s-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1Gc =
	      ==_a1Gi } in
	let {
	  fromRational_a1Gb  :: 
	      PrelNum.Rational{-3r,p-} -> t{-a13w-}
	  {-# L #-}
	  fromRational_a1Gb =
	      fromRational_a1Gh } in
	let {
	  lit_a1Ga  :: 
	      t{-a13w-}
	  {-# L #-}
	  lit_a1Ga =
	      fromRational_a1Gb
		  _rational_  11 5 } in
	let {
	  ==_a1G9  :: 
	      t{-a13w-} -> t{-a13w-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1G9 =
	      ==_a1Gf } in
	let {
	  fromInt_a1G8  :: 
	      PrelBase.Int{-3g,p-} -> t{-a13s-}
	  {-# L #-}
	  fromInt_a1G8 =
	      fromInt_a1Gk } in
	let { lit_a1G7  :: 
		  t{-a13s-}
	      {-# L #-}
	      lit_a1G7 =
	  let {
	    ds_d1I3  :: 
		PrelBase.Int{-3g,p-}
	    {-# L #-}
	    ds_d1I3 =
		PrelBase.I#{-5b,p-}{i}
		    3
	  } in 
	    fromInt_a1G8
		ds_d1I3
	} in
	let {
	  ==_a1G6  :: 
	      t{-a13s-} -> t{-a13s-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1G6 =
	      ==_a1Gi } in
	let {
	  fromRational_a1G5  :: 
	      PrelNum.Rational{-3r,p-} -> t{-a13w-}
	  {-# L #-}
	  fromRational_a1G5 =
	      fromRational_a1Gh } in
	let {
	  lit_a1G4  :: 
	      t{-a13w-}
	  {-# L #-}
	  lit_a1G4 =
	      fromRational_a1G5
		  _rational_  33 10 } in
	let {
	  ==_a1G3  :: 
	      t{-a13w-} -> t{-a13w-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1G3 =
	      ==_a1Gf } in
	let {
	  fromInt_a1G2  :: 
	      PrelBase.Int{-3g,p-} -> t{-a13s-}
	  {-# L #-}
	  fromInt_a1G2 =
	      fromInt_a1Gk } in
	let { lit_a1G1  :: 
		  t{-a13s-}
	      {-# L #-}
	      lit_a1G1 =
	  let {
	    ds_d1Iq  :: 
		PrelBase.Int{-3g,p-}
	    {-# L #-}
	    ds_d1Iq =
		PrelBase.I#{-5b,p-}{i}
		    4
	  } in 
	    fromInt_a1G2
		ds_d1Iq
	} in
	let {
	  ==_a1G0  :: 
	      t{-a13s-} -> t{-a13s-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1G0 =
	      ==_a1Gi } in
	let {
	  fromRational_a1FZ  :: 
	      PrelNum.Rational{-3r,p-} -> t{-a13w-}
	  {-# L #-}
	  fromRational_a1FZ =
	      fromRational_a1Gh } in
	let {
	  lit_a1FY  :: 
	      t{-a13w-}
	  {-# L #-}
	  lit_a1FY =
	      fromRational_a1FZ
		  _rational_  22 5 } in
	let {
	  ==_a1FX  :: 
	      t{-a13w-} -> t{-a13w-} -> PrelBase.Bool{-34,p-}
	  {-# L #-}
	  ==_a1FX =
	      ==_a1Gf
	} in 
	  \ ds_d1Jb  :: 
		t{-a13s-}
	    {-# L #-}
	    ds_d1Jb ds_d1Je  :: 
			t{-a13w-}
		    {-# L #-}
		    ds_d1Je ->
	      let {
		fail_d1Jf  :: 
		    [t{-a13A-}]
		{-# L #-}
		fail_d1Jf =
		    GHCerr.patError{-8r,p-}
			_@_ [t{-a13A-}] _string_ "ds022.hs:5|function `f'" } in
	      let { fail_d1Ln  :: 
			[t{-a13A-}]
		    {-# L #-}
		    fail_d1Ln =
		let { fail_d1KF  :: 
			  [t{-a13A-}]
		      {-# L #-}
		      fail_d1KF =
		  let {
		    fail_d1JX  :: 
			[t{-a13A-}]
		    {-# L #-}
		    fail_d1JX =
			case
			    ==_a1G0
				lit_a1G1 ds_d1Jb
			of {
			  PrelBase.True{-5E,p-}{i} ->
			      case
				  ==_a1FX
				      lit_a1FY ds_d1Je
			      of {
				PrelBase.True{-5E,p-}{i} ->
				    PrelBase.[]{-5i,p-}{i}
					_@_ t{-a13A-};
				PrelBase.False{-58,p-}{i} ->
				    fail_d1Jf;
			      };
			  PrelBase.False{-58,p-}{i} ->
			      fail_d1Jf;
			}
		  } in 
		    case
			==_a1G6
			    lit_a1G7 ds_d1Jb
		    of {
		      PrelBase.True{-5E,p-}{i} ->
			  case
			      ==_a1G3
				  lit_a1G4 ds_d1Je
			  of {
			    PrelBase.True{-5E,p-}{i} ->
				PrelBase.[]{-5i,p-}{i}
				    _@_ t{-a13A-};
			    PrelBase.False{-58,p-}{i} ->
				fail_d1JX;
			  };
		      PrelBase.False{-58,p-}{i} ->
			  fail_d1JX;
		    }
		} in
		case
		    ==_a1Gc
			lit_a1Gd ds_d1Jb
		of {
		  PrelBase.True{-5E,p-}{i} ->
		      case
			  ==_a1G9
			      lit_a1Ga ds_d1Je
		      of {
			PrelBase.True{-5E,p-}{i} ->
			    PrelBase.[]{-5i,p-}{i}
				_@_ t{-a13A-};
			PrelBase.False{-58,p-}{i} ->
			    fail_d1KF;
		      };
		  PrelBase.False{-58,p-}{i} ->
		      fail_d1KF;
		}
	      } in
	      case
		  ==_a1Gi
		      lit_a1Gj ds_d1Jb
	      of {
		PrelBase.True{-5E,p-}{i} ->
		    case
			==_a1Gf
			    lit_a1Gg ds_d1Je
		    of {
		      PrelBase.True{-5E,p-}{i} ->
			  PrelBase.[]{-5i,p-}{i}
			      _@_ t{-a13A-};
		      PrelBase.False{-58,p-}{i} ->
			  fail_d1Ln;
		    };
		PrelBase.False{-58,p-}{i} ->
		    fail_d1Ln;
	      }
end Rec }