Implementation detail
549209
def _remove_rule(self, group, role, value=None):
        """"""
        if role not in group:
            return

        if value is None:
            group.pop(role, None)
        else:
            group[role].remove(value)

        self.invalidate()
1253083
public function main()
    {
        $this->setup();
        while (!$this->eos()) {
            $p = $this->pos();
            $state = $this->stateName();

            $this->loadTransitions();
            list($nextPatternData, $nextPatternIndex, $nextPatternMatches) = $this->nextStartData();
            list($endIndex, $endMatches) = $this->nextEndData();

            if (($nextPatternIndex <= $endIndex || $endIndex === -1) && $nextPatternIndex !== -1) {
                // we're pushing a new state
                if ($p < $nextPatternIndex) {
                    $this->recordRange($p, $nextPatternIndex);
                }
                $newPos = $nextPatternIndex;
                $this->pos($newPos);
                $tok = $nextPatternData[0];
                if (isset($this->overrides[$tok])) {
                    // call override
                    $ret = call_user_func($this->overrides[$tok], $nextPatternMatches);
                    if ($ret === true) {
                        break;
                    }
                    if ($this->stateName() === $state && $this->pos() <= $newPos) {
                        throw new Exception('Override failed to either advance the pointer or change the state');
                    }
                } else {
                    // no override
                    $this->posShift(strlen($nextPatternMatches[0]));
                    $this->pushState($nextPatternData);
                    $this->record($nextPatternMatches[0]);
                    if ($nextPatternData[2] === null) {
                        // state was a full pattern, so pop now
                        $this->popState();
                    }
                }
            } elseif ($endIndex !== -1) {
                // we're at the end of a state, record what's left and pop it
                $to = $endIndex + strlen($endMatches[0]);
                $this->recordRange($this->pos(), $to);
                $this->pos($to);
                $this->popState();
            } else {
                // no more matches, consume the rest of the stirng and break
                $this->record($this->rest());
                $this->terminate();
                break;
            }
            if ($this->stateName() === $state && $this->pos() <= $p) {
                throw new Exception('Failed to advance pointer in state' . $this->stateName());
            }
        }

        // unterminated states will have left some tokens open, we need to
        // close these so there's just the root node on the stack
        assert(count($this->tokenTreeStack) >= 1);
        while (count($this->tokenTreeStack) > 1) {
            $this->popState();
        }

        return $this->tokenTreeStack[0];
    }
796411
@Override
    public void sawOpcode(int seen) {
        Integer size = null;
        boolean sizeSet = false;
        try {
            stack.precomputation(this);

            switch (seen) {
                case Const.ICONST_0:
                case Const.ICONST_1:
                case Const.ICONST_2:
                case Const.ICONST_3:
                case Const.ICONST_4:
                case Const.ICONST_5:
                    size = Integer.valueOf(seen - Const.ICONST_0);
                    sizeSet = true;
                break;

                case Const.ILOAD:
                case Const.ILOAD_0:
                case Const.ILOAD_1:
                case Const.ILOAD_2:
                case Const.ILOAD_3: {
                    int reg = RegisterUtils.getLoadReg(this, seen);
                    if (modifyRegs.get(reg)) {
                        modifyRegs.clear(reg);
                        sizeSet = true;
                    }
                }
                break;

                case Const.BIPUSH:
                case Const.SIPUSH:
                    size = Integer.valueOf(getIntConstant());
                    sizeSet = true;
                break;

                case Const.IINC:
                    modifyRegs.set(getRegisterOperand());
                break;

                case Const.IADD:
                case Const.ISUB:
                case Const.IMUL:
                case Const.IDIV:
                case Const.F2I:
                case Const.D2I:
                case Const.L2I:
                    sizeSet = true;
                break;

                case Const.ISTORE:
                case Const.ISTORE_0:
                case Const.ISTORE_1:
                case Const.ISTORE_2:
                case Const.ISTORE_3:
                    if (stack.getStackDepth() > 0) {
                        OpcodeStack.Item item = stack.getStackItem(0);
                        if (item.getUserValue() == null) {
                            modifyRegs.set(getRegisterOperand());
                        }
                    }
                break;

                case Const.LDC:
                    Constant c = getConstantRefOperand();
                    if (c instanceof ConstantInteger) {
                        size = Integer.valueOf(((ConstantInteger) c).getBytes());
                        sizeSet = true;
                    }
                break;

                case Const.NEWARRAY:
                case Const.ANEWARRAY:
                    if (stack.getStackDepth() >= 1) {
                        OpcodeStack.Item item = stack.getStackItem(0);
                        size = (Integer) item.getUserValue();
                        sizeSet = true;
                    }
                break;

                case Const.IASTORE:
                case Const.LASTORE:
                case Const.FASTORE:
                case Const.DASTORE:
                case Const.AASTORE:
                case Const.BASTORE:
                case Const.CASTORE:
                case Const.SASTORE:
                    processArrayStore();
                break;

                case Const.IALOAD:
                case Const.LALOAD:
                case Const.FALOAD:
                case Const.DALOAD:
                case Const.AALOAD:
                case Const.BALOAD:
                case Const.CALOAD:
                case Const.SALOAD:
                    processArrayLoad();
                break;

                case Const.ASTORE_0:
                case Const.ASTORE_1:
                case Const.ASTORE_2:
                case Const.ASTORE_3:
                case Const.ASTORE:
                    if (stack.getStackDepth() > 0) {
                        OpcodeStack.Item value = stack.getStackItem(0);
                        if (!value.isNull()) {
                            initializedRegs.set(getRegisterOperand());
                        }
                    } else {
                        initializedRegs.set(getRegisterOperand());
                    }
                break;

                case Const.IFEQ:
                case Const.IFNE:
                case Const.IFLT:
                case Const.IFGE:
                case Const.IFGT:
                case Const.IFLE:
                case Const.IF_ICMPEQ:
                case Const.IF_ICMPNE:
                case Const.IF_ICMPLT:
                case Const.IF_ICMPGE:
                case Const.IF_ICMPGT:
                case Const.IF_ICMPLE:
                case Const.IF_ACMPEQ:
                case Const.IF_ACMPNE:
                case Const.GOTO:
                case Const.GOTO_W:
                    int branchTarget = getBranchTarget();
                    Iterator<Map.Entry<Integer, Integer>> it = nullStoreToLocation.entrySet().iterator();
                    while (it.hasNext()) {
                        Map.Entry<Integer, Integer> entry = it.next();
                        int pc = entry.getValue().intValue();
                        if ((branchTarget < pc) && initializedRegs.get(entry.getKey().intValue())) {
                            it.remove();
                        }
                    }
                break;
            }

        } finally {
            stack.sawOpcode(this, seen);
            if (sizeSet && (stack.getStackDepth() >= 1)) {
                OpcodeStack.Item item = stack.getStackItem(0);
                item.setUserValue(size);
            }
        }
    }
572749
@Override
  protected void process(DBIDRef id, ArrayDBIDs ids, DBIDArrayIter it, int n, WritableDBIDDataStore pi, WritableDoubleDataStore lambda, WritableDoubleDataStore m) {
    clinkstep3(id, it, n, pi, lambda, m);
    clinkstep4567(id, ids, it, n, pi, lambda, m);
    clinkstep8(id, it, n, pi, lambda, m);
  }
384726
@Override
    public void sawOpcode(int seen) {
        try {
            stack.precomputation(this);

            if (unsafeCallOccurred && OpcodeUtils.isAStore(seen)) {
                int storeReg = RegisterUtils.getAStoreReg(this, seen);
                if (storeReg >= 0) {
                    unsafeAliases.set(storeReg);
                }
            }

            if ((seen == Const.INVOKEVIRTUAL) || (seen == Const.INVOKESPECIAL) || (seen == Const.INVOKEINTERFACE) || (seen == Const.INVOKEDYNAMIC)) {
                String methodSig = getSigConstantOperand();

                MethodInfo mi = Statistics.getStatistics().getMethodStatistics(getClassConstantOperand(), getNameConstantOperand(), methodSig);
                if (mi.getModifiesState()) {
                    unsafeCallOccurred = true;
                } else {
                    if (!Values.SIG_VOID.equals(SignatureUtils.getReturnSignature(methodSig))) {
                        int parmCount = SignatureUtils.getNumParameters(methodSig);
                        if (stack.getStackDepth() > parmCount) {
                            OpcodeStack.Item itm = stack.getStackItem(parmCount);
                            unsafeCallOccurred = unsafeAliases.get(itm.getRegisterNumber());
                        } else {
                            unsafeCallOccurred = false;
                        }
                    } else {
                        unsafeCallOccurred = false;
                    }
                }
            } else if (seen == Const.INVOKESTATIC) {
                unsafeCallOccurred = getDottedClassConstantOperand().equals(this.getClassContext().getJavaClass().getClassName());
            } else if (((seen >= Const.IFEQ) && (seen <= Const.GOTO)) || (seen == Const.GOTO_W)) {
                Integer from = Integer.valueOf(getPC());
                Integer to = Integer.valueOf(getBranchTarget());
                branchInfo.put(from, to);
                unsafeCallOccurred = false;
            } else {
                unsafeCallOccurred = false;
            }

            if (seen == Const.MONITORENTER) {
                if (syncPC < 0) {
                    syncPC = getPC();
                    if (stack.getStackDepth() > 0) {
                        OpcodeStack.Item itm = stack.getStackItem(0);
                        int monitorReg = itm.getRegisterNumber();
                        if (monitorReg >= 0) {
                            unsafeAliases.set(monitorReg);
                        }
                    }
                }
            } else if (seen == Const.MONITOREXIT) {
                syncPC = -1;
            } else if (syncPC >= 0) {
                processSyncBlockInstruction(seen);
            }
        } finally {
            stack.sawOpcode(this, seen);
        }
    }
1371940
public void process(Trace trace, Node node, Direction direction,
            Map<String, ?> headers, Object... values) {

        if (log.isLoggable(Level.FINEST)) {
            log.finest("ProcessManager: process trace=" + trace + " node=" + node
                    + " direction=" + direction + " headers=" + headers + " values=" + values
                    + " : available processors=" + processors);
        }

        if (trace.getTransaction() != null) {
            List<ProcessorWrapper> procs = null;

            synchronized (processors) {
                procs = processors.get(trace.getTransaction());
            }

            if (log.isLoggable(Level.FINEST)) {
                log.finest("ProcessManager: trace name=" + trace.getTransaction() + " processors=" + procs);
            }

            if (procs != null) {
                for (int i = 0; i < procs.size(); i++) {
                    procs.get(i).process(trace, node, direction, headers, values);
                }
            }
        }
    }
925334
@Override
    public void sawOpcode(int seen) {
        boolean sawResource = false;
        try {
            stack.precomputation(this);

            if (seen == Const.INVOKEVIRTUAL) {
                sawResource = processInvokeVirtual();
            } else if (seen == Const.INVOKESPECIAL) {
                sawResource = processInvokeSpecial();
            }

        } finally {
            stack.sawOpcode(this, seen);
            if (sawResource && (stack.getStackDepth() > 0)) {
                OpcodeStack.Item item = stack.getStackItem(0);
                item.setUserValue(Boolean.TRUE);
            }
        }
    }
363253
private void reflect(IntStack stack, IAtom beg, IAtom end) {
        Point2d begP = beg.getPoint2d();
        Point2d endP = end.getPoint2d();
        reflect(stack, begP, endP);
    }
318484
private void processIntegerReturn() {
        if ((sawConstant == null) && (stack.getStackDepth() == 0)) {
            throw new StopOpcodeParsingException();
        }

        Integer returnValue = null;
        if (sawConstant == null) {
            OpcodeStack.Item item = stack.getStackItem(0);
            returnValue = (Integer) item.getConstant();
        } else {
            returnValue = sawConstant;
        }

        if (returnValue == null) {
            throw new StopOpcodeParsingException();
        }
        int v = returnValue.intValue();
        if (v < 0) {
            seenNegative = true;
            if (getPC() > furthestBranchTarget) {
                seenUnconditionalNonZero = true;
            }
        } else if (v > 0) {
            seenPositive = true;
            if (getPC() > furthestBranchTarget) {
                seenUnconditionalNonZero = true;
            }
        } else {
            seenZero = true;
        }

        sawConstant = null;
    }
70570
void insertIntoList(BlockInfo head, int headIndex, BlockInfo tail, int tailIndex, int count) {
    if (head == null)
      return;
    
    // connect tail to now-head
    tail.setNext(tailIndex, blockList);
    if (blockList != null)
      blockList.setPrevious(blockList.findDatanode(this), tail);
    
    // create new head
    blockList = head;
    blockList.setPrevious(headIndex, null);
    
    // add new blocks to the count
    numOfBlocks += count;
  }
436659
@Bench(dataProvider = "generateData")
    void benchFastIntPush(final List<Integer> intData) {
        fastInt = new FastIntStack();
        for (final Object i : intData) {
            fastInt.push((Integer) i);
        }
    }
168113
@Override
  public void aggregate()
  {
    final IndexedInts keys = keySelector.getRow();
    for (int i = 0; i < valueSelectors.length; i++) {
      values[i] = valueSelectors[i].getDouble();
    }
    synchronized (this) {
      for (int i = 0, keysSize = keys.size(); i < keysSize; i++) {
        final String key = keySelector.lookupName(keys.get(i));
        sketch.update(key, values);
      }
    }
  }
26029
@Override
  public void update(final long value) {
    count.incrementAndGet();
    int index = (int) (value / binWidth);
    if (index >= numBins) {
      index = numBins - 1;
    }
    values.incrementAndGet(index);
  }
1348062
void radbg(final int ido, final int ip, final int l1, final int idl1, final double in[], final int in_off, final double out[], final int out_off, final int offset) {
		int idij, ipph, j2, ic, jc, lc, is;
		double dc2, ai1, ai2, ar1, ar2, ds2, w1r, w1i;
		int nbd;
		double dcp, arg, dsp, ar1h, ar2h;
		int iw1 = offset;

		arg = TWO_PI / (double) ip;
		dcp = Math.cos(arg);
		dsp = Math.sin(arg);
		nbd = (ido - 1) / 2;
		ipph = (ip + 1) / 2;
		int idx0 = ip * ido;
		if (ido >= l1) {
			for (int k = 0; k < l1; k++) {
				int idx1 = k * ido;
				int idx2 = k * idx0;
				for (int i = 0; i < ido; i++) {
					out[out_off + i + idx1] = in[in_off + i + idx2];
				}
			}
		} else {
			for (int i = 0; i < ido; i++) {
				int idx1 = out_off + i;
				int idx2 = in_off + i;
				for (int k = 0; k < l1; k++) {
					out[idx1 + k * ido] = in[idx2 + k * idx0];
				}
			}
		}
		int iidx0 = in_off + ido - 1;
		for (int j = 1; j < ipph; j++) {
			jc = ip - j;
			j2 = 2 * j;
			int idx1 = j * l1 * ido;
			int idx2 = jc * l1 * ido;
			int idx3 = j2 * ido;
			for (int k = 0; k < l1; k++) {
				int idx4 = k * ido;
				int idx5 = idx4 * ip;
				int iidx1 = iidx0 + idx3 + idx5 - ido;
				int iidx2 = in_off + idx3 + idx5;
				double i1r = in[iidx1];
				double i2r = in[iidx2];

				out[out_off + idx4 + idx1] = i1r + i1r;
				out[out_off + idx4 + idx2] = i2r + i2r;
			}
		}

		if (ido != 1) {
			if (nbd >= l1) {
				for (int j = 1; j < ipph; j++) {
					jc = ip - j;
					int idx1 = j * l1 * ido;
					int idx2 = jc * l1 * ido;
					int idx3 = 2 * j * ido;
					for (int k = 0; k < l1; k++) {
						int idx4 = k * ido + idx1;
						int idx5 = k * ido + idx2;
						int idx6 = k * ip * ido + idx3;
						for (int i = 2; i < ido; i += 2) {
							ic = ido - i;
							int idx7 = out_off + i;
							int idx8 = in_off + ic;
							int idx9 = in_off + i;
							int oidx1 = idx7 + idx4;
							int oidx2 = idx7 + idx5;
							int iidx1 = idx9 + idx6;
							int iidx2 = idx8 + idx6 - ido;
							double a1i = in[iidx1 - 1];
							double a1r = in[iidx1];
							double a2i = in[iidx2 - 1];
							double a2r = in[iidx2];

							out[oidx1 - 1] = a1i + a2i;
							out[oidx2 - 1] = a1i - a2i;
							out[oidx1] = a1r - a2r;
							out[oidx2] = a1r + a2r;
						}
					}
				}
			} else {
				for (int j = 1; j < ipph; j++) {
					jc = ip - j;
					int idx1 = j * l1 * ido;
					int idx2 = jc * l1 * ido;
					int idx3 = 2 * j * ido;
					for (int i = 2; i < ido; i += 2) {
						ic = ido - i;
						int idx7 = out_off + i;
						int idx8 = in_off + ic;
						int idx9 = in_off + i;
						for (int k = 0; k < l1; k++) {
							int idx4 = k * ido + idx1;
							int idx5 = k * ido + idx2;
							int idx6 = k * ip * ido + idx3;
							int oidx1 = idx7 + idx4;
							int oidx2 = idx7 + idx5;
							int iidx1 = idx9 + idx6;
							int iidx2 = idx8 + idx6 - ido;
							double a1i = in[iidx1 - 1];
							double a1r = in[iidx1];
							double a2i = in[iidx2 - 1];
							double a2r = in[iidx2];

							out[oidx1 - 1] = a1i + a2i;
							out[oidx2 - 1] = a1i - a2i;
							out[oidx1] = a1r - a2r;
							out[oidx2] = a1r + a2r;
						}
					}
				}
			}
		}

		ar1 = 1;
		ai1 = 0;
		int idx01 = (ip - 1) * idl1;
		for (int l = 1; l < ipph; l++) {
			lc = ip - l;
			ar1h = dcp * ar1 - dsp * ai1;
			ai1 = dcp * ai1 + dsp * ar1;
			ar1 = ar1h;
			int idx1 = l * idl1;
			int idx2 = lc * idl1;
			for (int ik = 0; ik < idl1; ik++) {
				int idx3 = in_off + ik;
				int idx4 = out_off + ik;
				in[idx3 + idx1] = out[idx4] + ar1 * out[idx4 + idl1];
				in[idx3 + idx2] = ai1 * out[idx4 + idx01];
			}
			dc2 = ar1;
			ds2 = ai1;
			ar2 = ar1;
			ai2 = ai1;
			for (int j = 2; j < ipph; j++) {
				jc = ip - j;
				ar2h = dc2 * ar2 - ds2 * ai2;
				ai2 = dc2 * ai2 + ds2 * ar2;
				ar2 = ar2h;
				int idx5 = j * idl1;
				int idx6 = jc * idl1;
				for (int ik = 0; ik < idl1; ik++) {
					int idx7 = in_off + ik;
					int idx8 = out_off + ik;
					in[idx7 + idx1] += ar2 * out[idx8 + idx5];
					in[idx7 + idx2] += ai2 * out[idx8 + idx6];
				}
			}
		}
		for (int j = 1; j < ipph; j++) {
			int idx1 = j * idl1;
			for (int ik = 0; ik < idl1; ik++) {
				int idx2 = out_off + ik;
				out[idx2] += out[idx2 + idx1];
			}
		}
		for (int j = 1; j < ipph; j++) {
			jc = ip - j;
			int idx1 = j * l1 * ido;
			int idx2 = jc * l1 * ido;
			for (int k = 0; k < l1; k++) {
				int idx3 = k * ido;
				int oidx1 = out_off + idx3;
				int iidx1 = in_off + idx3 + idx1;
				int iidx2 = in_off + idx3 + idx2;
				double i1r = in[iidx1];
				double i2r = in[iidx2];

				out[oidx1 + idx1] = i1r - i2r;
				out[oidx1 + idx2] = i1r + i2r;
			}
		}

		if (ido == 1)
			return;
		if (nbd >= l1) {
			for (int j = 1; j < ipph; j++) {
				jc = ip - j;
				int idx1 = j * l1 * ido;
				int idx2 = jc * l1 * ido;
				for (int k = 0; k < l1; k++) {
					int idx3 = k * ido;
					for (int i = 2; i < ido; i += 2) {
						int idx4 = out_off + i;
						int idx5 = in_off + i;
						int oidx1 = idx4 + idx3 + idx1;
						int oidx2 = idx4 + idx3 + idx2;
						int iidx1 = idx5 + idx3 + idx1;
						int iidx2 = idx5 + idx3 + idx2;
						double i1i = in[iidx1 - 1];
						double i1r = in[iidx1];
						double i2i = in[iidx2 - 1];
						double i2r = in[iidx2];

						out[oidx1 - 1] = i1i - i2r;
						out[oidx2 - 1] = i1i + i2r;
						out[oidx1] = i1r + i2i;
						out[oidx2] = i1r - i2i;
					}
				}
			}
		} else {
			for (int j = 1; j < ipph; j++) {
				jc = ip - j;
				int idx1 = j * l1 * ido;
				int idx2 = jc * l1 * ido;
				for (int i = 2; i < ido; i += 2) {
					int idx4 = out_off + i;
					int idx5 = in_off + i;
					for (int k = 0; k < l1; k++) {
						int idx3 = k * ido;
						int oidx1 = idx4 + idx3 + idx1;
						int oidx2 = idx4 + idx3 + idx2;
						int iidx1 = idx5 + idx3 + idx1;
						int iidx2 = idx5 + idx3 + idx2;
						double i1i = in[iidx1 - 1];
						double i1r = in[iidx1];
						double i2i = in[iidx2 - 1];
						double i2r = in[iidx2];

						out[oidx1 - 1] = i1i - i2r;
						out[oidx2 - 1] = i1i + i2r;
						out[oidx1] = i1r + i2i;
						out[oidx2] = i1r - i2i;
					}
				}
			}
		}
		System.arraycopy(out, out_off, in, in_off, idl1);
		for (int j = 1; j < ip; j++) {
			int idx1 = j * l1 * ido;
			for (int k = 0; k < l1; k++) {
				int idx2 = k * ido + idx1;
				in[in_off + idx2] = out[out_off + idx2];
			}
		}
		if (nbd <= l1) {
			is = -ido;
			for (int j = 1; j < ip; j++) {
				is += ido;
				idij = is - 1;
				int idx1 = j * l1 * ido;
				for (int i = 2; i < ido; i += 2) {
					idij += 2;
					int idx2 = idij + iw1;
					w1r = wtable_r[idx2 - 1];
					w1i = wtable_r[idx2];
					int idx4 = in_off + i;
					int idx5 = out_off + i;
					for (int k = 0; k < l1; k++) {
						int idx3 = k * ido + idx1;
						int iidx1 = idx4 + idx3;
						int oidx1 = idx5 + idx3;
						double o1i = out[oidx1 - 1];
						double o1r = out[oidx1];

						in[iidx1 - 1] = w1r * o1i - w1i * o1r;
						in[iidx1] = w1r * o1r + w1i * o1i;
					}
				}
			}
		} else {
			is = -ido;
			for (int j = 1; j < ip; j++) {
				is += ido;
				int idx1 = j * l1 * ido;
				for (int k = 0; k < l1; k++) {
					idij = is - 1;
					int idx3 = k * ido + idx1;
					for (int i = 2; i < ido; i += 2) {
						idij += 2;
						int idx2 = idij + iw1;
						w1r = wtable_r[idx2 - 1];
						w1i = wtable_r[idx2];
						int idx4 = in_off + i;
						int idx5 = out_off + i;
						int iidx1 = idx4 + idx3;
						int oidx1 = idx5 + idx3;
						double o1i = out[oidx1 - 1];
						double o1r = out[oidx1];

						in[iidx1 - 1] = w1r * o1i - w1i * o1r;
						in[iidx1] = w1r * o1r + w1i * o1i;

					}
				}
			}
		}
	}
557511
function hup(mode, target, system, containerDef, container, newConfig, out, cb) {
    var executor = prepareAndGetExecutor(target, out, 'hup');
    executor.hup(mode, target, system, containerDef, container, out, newConfig, function(err) {
      cb(err);
    });
  }
661535
public function process()
    {
        $this->initializeStorageNode($this->storageNodeNodePath, $this->storageNodeTitle);
        $this->initializeNodeTemplates();

        $nodeTemplate = new NodeTemplate();
        $this->processBatch($nodeTemplate);
    }
29277
@Override
    public void process(byte b) {
        if (b == END_SYSEX) {
            byte[] buffer = convertI2CBuffer(getBuffer());
            byte address = buffer[0];
            byte register = buffer[1];
            byte[] message = new byte[buffer.length - 2];
            System.arraycopy(buffer, 2, message, 0, buffer.length - 2);
            Event event = new Event(I2C_MESSAGE);
            event.setBodyItem(I2C_ADDRESS, address);
            event.setBodyItem(I2C_REGISTER, register);
            event.setBodyItem(I2C_MESSAGE, message);
            transitTo(WaitingForMessageState.class);
            publish(event);
        } else {
            bufferize(b);
        }
    }