Considering object completion on:
  rl < O1 : Wrapper | contents : X > to O1 from O2 get => < O1 : Wrapper |
    contents : X > to O2 from O1 answer(X) .
Transformed rule:
  rl < O1 : V:Wrapper | contents : X, Atts:AttributeSet > to O1 from O2 get =>
    < O1 : V:Wrapper | contents : X, Atts:AttributeSet > to O2 from O1 answer(
    X) .

Considering object completion on:
  rl [add] : < O : List{X} | first : null > O add O' at 0 => aux1(< O : List{X}
    | first : null >, O add O' at 0, counter) .
Transformed rule:
  rl [add] : < O : V:List{X} | first : null, Atts:AttributeSet > O add O' at 0
    => aux1(< O : V:List{X} | first : null, Atts:AttributeSet >, O add O' at 0,
    counter) .

Considering object completion on:
  eq aux1(< O : List{X} | first : null >, O add O' at 0, N) = < O : List{X} |
    first : o(O, N), last : o(O, N), size : 1 > < o(O, N) : Node{X} | next :
    null, previous : null, value : O' > .
Transformed equation:
  eq aux1(< O : V:List{X} | first : null, last : A:[Maybe{Oid}], size : A2:[
    Int], Atts:AttributeSet >, O add O' at 0, N) = < O : V:List{X} | first : o(
    O, N), last : o(O, N), size : 1, Atts:AttributeSet > < o(O, N) : Node{X} |
    next : null, previous : null, value : O' > .

Considering object completion on:
  rl [add] : < O : List{X} | first : F, size : S > < F : Node{X} | previous :
    null > O add O' at 0 => aux2(< O : List{X} | first : F, size : S > < F :
    Node{X} | previous : null >, O add O' at 0, counter) .
Transformed rule:
  rl [add] : < O : V:List{X} | first : F, size : S, Atts:AttributeSet > < F :
    V2:Node{X} | previous : null, Atts2:AttributeSet > O add O' at 0 => aux2(<
    O : V:List{X} | first : F, size : S, Atts:AttributeSet > < F : V2:Node{X} |
    previous : null, Atts2:AttributeSet >, O add O' at 0, counter) .

Considering object completion on:
  eq aux2(< O : List{X} | first : F, size : S > < F : Node{X} | previous : null
    >, O add O' at 0, N) = < O : List{X} | first : o(O, N), size : s S > < F :
    Node{X} | previous : o(O, N) > < o(O, N) : Node{X} | next : F, previous :
    null, value : O' > .
Transformed equation:
  eq aux2(< O : V:List{X} | first : F, size : S, Atts:AttributeSet > < F :
    V2:Node{X} | previous : null, Atts2:AttributeSet >, O add O' at 0, N) = < O
    : V:List{X} | first : o(O, N), size : s S, Atts:AttributeSet > < F :
    V2:Node{X} | previous : o(O, N), Atts2:AttributeSet > < o(O, N) : Node{X} |
    next : F, previous : null, value : O' > .

Considering object completion on:
  rl [add] : < O : List{X} | last : L, size : S > < L : Node{X} | next : null >
    O add O' at S => aux3(< O : List{X} | last : L, size : S > < L : Node{X} |
    next : null >, O add O' at S, counter) .
Transformed rule:
  rl [add] : < O : V2:List{X} | last : L, size : S, Atts2:AttributeSet > < L :
    V:Node{X} | next : null, Atts:AttributeSet > O add O' at S => aux3(< O :
    V2:List{X} | last : L, size : S, Atts2:AttributeSet > < L : V:Node{X} |
    next : null, Atts:AttributeSet >, O add O' at S, counter) .

Considering object completion on:
  eq aux3(< O : List{X} | last : L, size : S > < L : Node{X} | next : null >, O
    add O' at S, N) = < O : List{X} | last : o(O, N), size : s S > < L : Node{
    X} | next : o(O, N) > < o(O, N) : Node{X} | next : null, previous : L,
    value : O' > .
Transformed equation:
  eq aux3(< O : V2:List{X} | last : L, size : S, Atts2:AttributeSet > < L :
    V:Node{X} | next : null, Atts:AttributeSet >, O add O' at S, N) = < O :
    V2:List{X} | last : o(O, N), size : s S, Atts2:AttributeSet > < L : V:Node{
    X} | next : o(O, N), Atts:AttributeSet > < o(O, N) : Node{X} | next : null,
    previous : L, value : O' > .

Considering object completion on:
  crl [add] : < O : List{X} | first : F, size : S > O add O' at s P =>
    add-blocked(< O : List{X} | none >) F add' O' at P if s P < S = true .
Transformed rule:
  crl [add] : < O : V:List{X} | first : F, size : S, Atts:AttributeSet > O add
    O' at s P => add-blocked(< O : V:List{X} | first : F, size : S,
    Atts:AttributeSet >) F add' O' at P if s P < S = true .

Considering object completion on:
  rl [add] : < O : Node{X} | next : O' > < O' : Node{X} | previous : O > (O
    add' O'' at P) add-blocked(< L : List{X} | size : S >) => aux4(< O : Node{
    X} | next : O' > < O' : Node{X} | previous : O >, (O add' O'' at P)
    add-blocked(< L : List{X} | size : S >), counter) .
Transformed rule:
  rl [add] : < O : V2:Node{X} | next : O', Atts2:AttributeSet > < O' : V3:Node{
    X} | previous : O, Atts3:AttributeSet > (O add' O'' at P) add-blocked(< L :
    V:List{X} | size : S, Atts:AttributeSet >) => aux4(< O : V2:Node{X} | next
    : O', Atts2:AttributeSet > < O' : V3:Node{X} | previous : O,
    Atts3:AttributeSet >, (O add' O'' at P) add-blocked(< L : V:List{X} | size
    : S, Atts:AttributeSet >), counter) .

Considering object completion on:
  eq aux4(< O : Node{X} | next : O' > < O' : Node{X} | previous : O >, (O add'
    O'' at P) add-blocked(< L : List{X} | size : S >), N) = if P == 0 then < O
    : Node{X} | next : o(O, N) > < O' : Node{X} | previous : o(O, N) > < o(O,
    N) : Node{X} | previous : O, next : O', value : O'' > < L : List{X} | size
    : s S > else < O : Node{X} | none > < O' : Node{X} | none > (O' add' O'' at
    P - 1) add-blocked(< L : List{X} | size : S >) fi .
Transformed equation:
  eq aux4(< O : V2:Node{X} | next : O', Atts2:AttributeSet > < O' : V3:Node{X}
    | previous : O, Atts3:AttributeSet >, (O add' O'' at P) add-blocked(< L :
    V:List{X} | size : S, Atts:AttributeSet >), N) = if P == 0 then < O :
    V2:Node{X} | next : o(O, N), Atts2:AttributeSet > < O' : V3:Node{X} |
    previous : o(O, N), Atts3:AttributeSet > < o(O, N) : Node{X} | previous :
    O, next : O', value : O'' > < L : V:List{X} | size : s S, Atts:AttributeSet
    > else < O : V2:Node{X} | next : O', Atts2:AttributeSet > < O' : V3:Node{X}
    | previous : O, Atts3:AttributeSet > (O' add' O'' at P - 1) add-blocked(< L
    : V:List{X} | size : S, Atts:AttributeSet >) fi .

Considering object completion on:
  crl [get] : < O : List{X} | first : F, size : S > O get at P from O' =>
    get-blocked(< O : List{X} | none >, P, O') F in O get at P if s P < S =
    true .
Transformed rule:
  crl [get] : < O : V:List{X} | first : F, size : S, Atts:AttributeSet > O get
    at P from O' => get-blocked(< O : V:List{X} | first : F, size : S,
    Atts:AttributeSet >, P, O') F in O get at P if s P < S = true .

Considering object completion on:
  crl [get] : < O : List{X} | last : L, size : s S > < L : Node{X} | value : O'
    > O get at P from O'' => get-blocked(< O : List{X} | none >, P, O'') < L :
    Node{X} | none > to O' from O get if S = P .
Transformed rule:
  crl [get] : < O : V2:List{X} | last : L, size : s S, Atts2:AttributeSet > < L
    : V:Node{X} | value : O', Atts:AttributeSet > O get at P from O'' =>
    get-blocked(< O : V2:List{X} | last : L, size : s S, Atts2:AttributeSet >,
    P, O'') < L : V:Node{X} | value : O', Atts:AttributeSet > to O' from O get
    if S = P .

Considering object completion on:
  rl [get] : < O : Node{X} | next : O', value : O'' > O in O''' get at P => < O
    : Node{X} | none > if P == 0 then to O'' from O''' get else O' in O''' get
    at P - 1 fi .
Transformed rule:
  rl [get] : < O : V:Node{X} | next : O', value : O'', Atts:AttributeSet > O in
    O''' get at P => < O : V:Node{X} | next : O', value : O'',
    Atts:AttributeSet > if P == 0 then to O'' from O''' get else O' in O''' get
    at P - 1 fi .

Considering object completion on:
  rl [get] : get-blocked(< O : List{X} | none >, P, O') to O from O'' answer(X)
    => < O : List{X} | none > to O' from O elt at pos P is X .
Transformed rule:
  rl [get] : get-blocked(< O : V:List{X} | Atts:AttributeSet >, P, O') to O
    from O'' answer(X) => < O : V:List{X} | Atts:AttributeSet > to O' from O
    elt at pos P is X .

Considering object completion on:
  rl < O1 : NatWrapper | value : N > to O1 get from O2 => < O1 : NatWrapper |
    none > to O2 answer N from O1 .
Transformed rule:
  rl < O1 : V:NatWrapper | value : N, Atts:AttributeSet > to O1 get from O2 =>
    < O1 : V:NatWrapper | value : N, Atts:AttributeSet > to O2 answer N from O1
    .

op _`,_ left-identity collapse from AttributeSet to Attribute is unequal.
op __ left-identity collapse from Configuration to Object is unequal.
==========================================
rewrite in NAT-LIST : create-list(l) ((((((((((l add w(4) at 4) l get at 3 from
    l) l add w(3) at 3) l add w(2) at 2) l add w(1) at 1) l add w(0) at 0) < w(
    4) : NatWrapper | value : 4 >) < w(3) : NatWrapper | value : 3 >) < w(2) :
    NatWrapper | value : 2 >) < w(1) : NatWrapper | value : 1 >) < w(0) :
    NatWrapper | value : 0 > .
rewrites: 28
result Configuration: < l : List{NatW} | first : o(l, 0), last : o(l, 4), size
    : 5 > < w(0) : NatWrapper | value : 0 > < w(1) : NatWrapper | value : 1 > <
    w(2) : NatWrapper | value : 2 > < w(3) : NatWrapper | value : 3 > < w(4) :
    NatWrapper | value : 4 > < o(l, 0) : Node{NatW} | next : o(l, 1), previous
    : null, value : w(0) > < o(l, 1) : Node{NatW} | next : o(l, 2), previous :
    o(l, 0), value : w(1) > < o(l, 2) : Node{NatW} | next : o(l, 3), previous :
    o(l, 1), value : w(2) > < o(l, 3) : Node{NatW} | next : o(l, 4), previous :
    o(l, 2), value : w(3) > < o(l, 4) : Node{NatW} | next : null, previous : o(
    l, 3), value : w(4) > to l from l elt at pos 3 is 3
Bye.
