One step of execution.
962736
def execute_once(self):
        """"""
        symbol = self.tape.get(self.head, self.EMPTY_SYMBOL)

        index = self.alphabet.index(symbol)
        rule = self.states[self.state][index]

        if rule is None:
            raise RuntimeError('Unexpected symbol: ' + symbol)

        self.tape[self.head] = rule[0]

        if rule[1] == 'L':
            self.head -= 1
        elif rule[1] == 'R':
            self.head += 1

        self.state = rule[2]
791583
protected function r1()
    {
        list($this->r1Index, $this->r1) = $this->rx($this->word);
    }
1291759
function step1c(token) {
    var r1 = getR1(token);

    if (!r1) {
        return token;
    }

    if (r1.match(/(erte|ert)$/)) {
        return token.replace(/(erte|ert)$/, 'er');
    }

    return token;
}
502164
public function ExecuteStep()
    {
        if ($this->ProcessStep()) {
            $this->ProcessStepSuccessHook();
            $oBasket = TShopBasket::GetInstance();
            $oBasket->aCompletedOrderStepList[$this->fieldSystemname] = true;
            $oNextStep = $this->GetNextStep();
            $this->JumpToStep($oNextStep);
        }
    }
549074
function step ({tick}) {
  setFBO({ framebuffer: FIELDS[0] }, () => {
    regl.clear({ color: [0, 0, 0, 1] })
    splatMouse()
    splatVerts({
      vertexState: VERTEX_STATE[(tick + 1) % 2]
    })
  })
  for (let i = 0; i < 2 * BLUR_PASSES; ++i) {
    blurPass({
      dest: FIELDS[(i + 1) % 2],
      src: FIELDS[i % 2],
      axis: (i % 2)
    })
  }
  gradPass({
    dest: FIELDS[1],
    src: FIELDS[0]
  })
  applySpringForces({
    dest: VERTEX_STATE[(tick + 1) % 2],
    src: VERTEX_STATE[tick % 2]
  })
  integrateVerts({
    dest: VERTEX_STATE[tick % 2],
    src: VERTEX_STATE[(tick + 1) % 2],
    field: FIELDS[1]
  })
}
585663
public function execute()
    {
        // step 1 - 5
        $this->startStemmingProcess();

        // step 6
        if ($this->dictionary->contains($this->getCurrentWord())) {
            $this->result = $this->getCurrentWord();
        } else {
            $this->result = $this->originalWord;
        }
    }
372886
@Override
    public void step(SimState simulation) {
        this.simulation = (ShanksSimulation) simulation;
        this.checkMail();
        this.executeReasoningCycle((ShanksSimulation) simulation);
    }
1133082
def in_single_path(self):
        
        return len(self.successor) == 1 and not self.successor[0].in_or_out and \
               len(self.precedence) == 1 and len(self.precedence[0].successor) <= 1
737461
function step(){

        var time;

        window.requestAnimationFrame( step );

        if (!active){
            return;
        }

        time = now();

        if (!time){
            return;
        }

        ps.emit( 'tick', time );
    }
1096908
public function onEmit()
    {
        if (!$this->duration) {
            $time = microtime(true);
            $this->duration = round($time - $this->start, 6);
        }
    }
90305
def _euler_step(self, dt):
        
        self.state = self.state + self.ddt() * dt
11481
def handle(self):
        """"""
        self.close_connection = 1

        self.handle_one_request()
        while not self.close_connection:
            self.handle_one_request()
994784
function step(x, a, p, q) {
      var temp, w;

      temp = p <= 0.5 ? gratio(a)(x) - p : q - gratioc(a)(x);
      temp /= r(a, x);
      w = (a - 1 - x) / 2;
      if (Math.max(Math.abs(temp), Math.abs(w * temp)) <= 0.1) {
         return x * (1 - (temp + w * temp * temp));
      }
      return x * (1 - temp);
   }
991244
def transition_to_execute(self):
        """"""
        assert self.state in [AQStateMachineStates.add]
        self.state = AQStateMachineStates.execute
1022710
private final void step5() {
        if (k == 0) {
            return;
        }
        
        switch (b[k - 1]) {
            case 'a':
                if (endWith("al")) {
                    break;
                }
                return;
            case 'c':
                if (endWith("ance")) {
                    break;
                }
                if (endWith("ence")) {
                    break;
                }
                return;
            case 'e':
                if (endWith("er")) {
                    break;
                }
                return;
            case 'i':
                if (endWith("ic")) {
                    break;
                }
                return;
            case 'l':
                if (endWith("able")) {
                    break;
                }
                if (endWith("ible")) {
                    break;
                }
                return;
            case 'n':
                if (endWith("ant")) {
                    break;
                }
                if (endWith("ement")) {
                    break;
                }
                if (endWith("ment")) {
                    break;
                }
                /* element etc. not stripped before the m */
                if (endWith("ent")) {
                    break;
                }
                return;
            case 'o':
                if (endWith("ion") && j >= 0 && (b[j] == 's' || b[j] == 't')) {
                    break;
                }
                if (endWith("ou")) {
                    break;
                }
                return;
            /* takes care of -ous */
            case 's':
                if (endWith("ism")) {
                    break;
                }
                return;
            case 't':
                if (endWith("ate")) {
                    break;
                }
                if (endWith("iti")) {
                    break;
                }
                return;
            case 'u':
                if (endWith("ous")) {
                    break;
                }
                return;
            case 'v':
                if (endWith("ive")) {
                    break;
                }
                return;
            case 'z':
                if (endWith("ize")) {
                    break;
                }
                return;
            default:
                return;
        }
        if (m() > 1) {
            k = j;
        }
    }
762082
function one (state, eventName, handler) {
  state.emitter.once(eventName, handler)

  return state.api
}
359505
def stepBy(self, steps):
        
        self.setValue(self.value() + steps*self.singleStep())