! continues with the instruction following the Jcc instruction.
508124
public final void j(CONDITION cc, Label label, int hint)
  {
    _emitJcc(conditionToJCC(cc), label, hint);
  }
250791
function continueIntent(){
        $this->waitAnswer();

        $audioPlayerContext = $this->request->getAudioPlayerContext();
        $videoPlayerContext = $this->request->getVideoPlayerContext();

        if($audioPlayerContext){
            $audioToken = isset($audioPlayerContext['token']) ? $audioPlayerContext['token'] : '';
            $audioTokenArr = $this->decodeToken($audioToken);      
            $id = $audioTokenArr['id'];
            $directives = $this->getAudioPlay($id);
            return [
                'directives' => $directives
            ];
        }
        if($videoPlayerContext){
            $videoToken = isset($videoPlayerContext['token']) ? $videoPlayerContext['token'] : '';
            $videoTokenArr = $this->decodeToken($videoToken);

            $id = $videoTokenArr['id'];
            $directives = $this->getVideoPlay($id);
            return [
                'directives' => $directives
            ];
        }
        return $this->defaultRes();
    }
42320
private function _continue() {
    $node = new ContinueStatementNode();
    $this->mustMatch(T_CONTINUE, $node);
    if ($this->tryMatch(';', $node, NULL, TRUE, TRUE) || $this->currentType === T_CLOSE_TAG) {
      return $node;
    }
    $this->parseLevel($node);
    $this->endStatement($node);
    return $node;
  }
149999
private void advance() {
        try {
            if (tok == null)
                tok = source.token();
        } catch (LexerException e) {
            throw new IllegalStateException(e);
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }
1040991
def _next(self):
        
        c = self._get()
        if c == '/':
            p = self._peek()
            if p == '/':
                c = self._get()
                while c > '\n':
                    c = self._get()
                return c
            if p == '*':
                c = self._get()
                while 1:
                    c = self._get()
                    if c == '*':
                        if self._peek() == '/':
                            self._get()
                            return ' '
                    if c == '\000':
                        raise UnterminatedComment()

        return c
5029
public function next()
    {
        if (is_null($this->current)) {
            $this->current = current($this->children);

            return;
        }
        if ($this->current instanceof RecursiveLeafInterface) {
            $this->current->next();
            if ($this->current->valid()) {
                return;
            }
        }
        $this->current = next($this->children);
    }
578368
void advance() {
    if (tc.isEntryEnabled())
      tc.entry(this,cclass, "advance");
    if (!prefixDone) {
      Pattern.Clause prefix = pattern.getPrefix();
      if (prefix == null || next >= prefix.items.length) {
        Pattern.Clause suffix = pattern.getSuffix();
        if (suffix != null && suffix != prefix) {
          // SWITCH_TO_SUFFIX
          prefixDone = true;
          next = suffix.items.length-1;
        }
        // else in one of the FINAL_ states, so do nothing
      }
      else
        // somewhere in the body of the prefix, so advance by incrementing
        next++;
    }
    else
      // somewhere in the suffix, so advance by decrementing
      next--;
    if (tc.isEntryEnabled())
      tc.exit(this,cclass, "advance");
  }
204915
def do_continue(self, args):
        
        self._do_print_from_last_cmd = True
        self._interp.cont()
        return True
407928
final Node succ(Node p) {
        Node next = p.next;
        return (p == next) ? head : next;
    }
678084
function followReference(model, root, nodeArg, referenceContainerArg,
                         referenceArg, seed, isJSONG) {

    var node = nodeArg;
    var reference = referenceArg;
    var referenceContainer = referenceContainerArg;
    var depth = 0;
    var k, next;

    while (true) {
        if (depth === 0 && referenceContainer.$_context) {
            depth = reference.length;
            next = referenceContainer.$_context;
        } else {
            k = reference[depth++];
            next = node[k];
        }
        if (next) {
            var type = next.$type;
            var value = type && next.value || next;

            if (depth < reference.length) {
                if (type) {
                    node = next;
                    break;
                }

                node = next;
                continue;
            }

            // We need to report a value or follow another reference.
            else {

                node = next;

                if (type && isExpired(next)) {
                    break;
                }

                if (!referenceContainer.$_context) {
                    createHardlink(referenceContainer, next);
                }

                // Restart the reference follower.
                if (type === $ref) {

                    // Nulls out the depth, outerResults,
                    if (isJSONG) {
                        onValue(model, next, seed, null, null, null, null,
                                reference, reference.length, isJSONG);
                    } else {
                        promote(model._root, next);
                    }

                    depth = 0;
                    reference = value;
                    referenceContainer = next;
                    node = root;
                    continue;
                }

                break;
            }
        } else {
            node = void 0;
        }
        break;
    }


    if (depth < reference.length && node !== void 0) {
        var ref = [];
        for (var i = 0; i < depth; i++) {
            ref[i] = reference[i];
        }
        reference = ref;
    }

    return [node, reference, referenceContainer];
}
317590
public void advance() {
        String s = null;
        if (baseIterator.hasNext())
            next = baseIterator.next();
        else
            next = null;
    }
633367
private void nextSegment() {
        assert(checkDir > 0 && seq == rawSeq && pos != limit);
        // The input text [segmentStart..pos[ passes the FCD check.
        int p = pos;
        int prevCC = 0;
        for(;;) {
            // Fetch the next character's fcd16 value.
            int q = p;
            int c = Character.codePointAt(seq, p);
            p += Character.charCount(c);
            int fcd16 = nfcImpl.getFCD16(c);
            int leadCC = fcd16 >> 8;
            if(leadCC == 0 && q != pos) {
                // FCD boundary before the [q, p[ character.
                limit = segmentLimit = q;
                break;
            }
            if(leadCC != 0 && (prevCC > leadCC || CollationFCD.isFCD16OfTibetanCompositeVowel(fcd16))) {
                // Fails FCD check. Find the next FCD boundary and normalize.
                do {
                    q = p;
                    if(p == rawLimit) { break; }
                    c = Character.codePointAt(seq, p);
                    p += Character.charCount(c);
                } while(nfcImpl.getFCD16(c) > 0xff);
                normalize(pos, q);
                pos = start;
                break;
            }
            prevCC = fcd16 & 0xff;
            if(p == rawLimit || prevCC == 0) {
                // FCD boundary after the last character.
                limit = segmentLimit = p;
                break;
            }
        }
        assert(pos != limit);
        checkDir = 0;
    }
980176
public function next()
    {
        do {
            ++$this->position;
        } while (($this->onlyExistingCells) &&
            (!$this->subject->cellExistsByColumnAndRow($this->columnIndex, $this->position)) &&
            ($this->position <= $this->endRow));
    }
561093
def continues(method):
        '''
        '''
        @functools.wraps(method)
        def wrapped(self, *args, **kwargs):
            yield method(self, *args, **kwargs)
            raise self.Continue()
        return wrapped
354317
def _write_continue(self, value):
        
        self._FITS.write_continue(self._ext+1, str(value))
1052153
private static int follow(int i, int[] partitions) {
    int next = partitions[i], tmp;
    while(i != next) {
      tmp = next;
      next = partitions[i] = partitions[next];
      i = tmp;
    }
    return i;
  }
900781
public synchronized void succeed (I impl) {
    this.impl = impl;
    setVolumeImpl(volume);
    setLoopingImpl(looping);
    if (playing) playImpl();
    ((RPromise<Sound>)state).succeed(this);
  }