Run with the original PDA, states {q0, q1}.  |  Run with the 1-state PDA, states {u}.
                                             |  
                                             |  Note that this machine has an extra step for
                                             |  installing the simulated empty-stack symbol.
                                             |  
Trying: b b a a b b                          |  Trying: b b a a b b
                                             |  
                                             |  input:  b b a a b b
                                             |  state:  u
                                             |  stack:  x
                                             |  
                                             |  rule:   u, x, [] -> u, [q0, s, q1]
                                             |  
input:  b b a a b b                          |  input:  b b a a b b
state:  q0                                   |  state:  u
stack:  s                                    |  stack:  [q0, s, q1]
                                             |  
rule:   q0, s, b -> q0, b s                  |  rule:   u, [q0, s, q1], b -> u, [q0, b, q1] [q1, s, q1]
                                             |  
input:  b a a b b                            |  input:  b a a b b
state:  q0                                   |  state:  u
stack:  b s                                  |  stack:  [q0, b, q1] [q1, s, q1]
                                             |  
rule:   q0, b, b -> q0, b b                  |  rule:   u, [q0, b, q1], b -> u, [q0, b, q1] [q1, b, q1]
                                             |  
input:  a a b b                              |  input:  a a b b
state:  q0                                   |  state:  u
stack:  b b s                                |  stack:  [q0, b, q1] [q1, b, q1] [q1, s, q1]
                                             |  
rule:   q0, b, a -> q0, a b                  |  rule:   u, [q0, b, q1], a -> u, [q0, a, q1] [q1, b, q1]
                                             |  
input:  a b b                                |  input:  a b b
state:  q0                                   |  state:  u
stack:  a b b s                              |  stack:  [q0, a, q1] [q1, b, q1] [q1, b, q1] [q1, s, q1]
                                             |  
rule:   q0, a, [] -> q1, a                   |  rule:   u, [q0, a, q1], [] -> u, [q1, a, q1]
                                             |  
input:  a b b                                |  input:  a b b
state:  q1                                   |  state:  u
stack:  a b b s                              |  stack:  [q1, a, q1] [q1, b, q1] [q1, b, q1] [q1, s, q1]
                                             |  
rule:   q1, a, a -> q1, []                   |  rule:   u, [q1, a, q1], a -> u, []
                                             |  
input:  b b                                  |  input:  b b
state:  q1                                   |  state:  u
stack:  b b s                                |  stack:  [q1, b, q1] [q1, b, q1] [q1, s, q1]
                                             |  
rule:   q1, b, b -> q1, []                   |  rule:   u, [q1, b, q1], b -> u, []
                                             |  
input:  b                                    |  input:  b
state:  q1                                   |  state:  u
stack:  b s                                  |  stack:  [q1, b, q1] [q1, s, q1]
                                             |  
rule:   q1, b, b -> q1, []                   |  rule:   u, [q1, b, q1], b -> u, []
                                             |  
input:  []                                   |  input:  []
state:  q1                                   |  state:  u
stack:  s                                    |  stack:  [q1, s, q1]
                                             |  
rule:   q1, s, [] -> q1, []                  |  rule:   u, [q1, s, q1], [] -> u, []
                                             |  
input:  []                                   |  input:  []
state:  q1                                   |  state:  u
stack:  []                                   |  stack:  []
                                             |  
rule:   empty stack                          |  rule:   empty stack
                                             |  
Success with: b b a a b b                    |  Success with: b b a a b b