// Skip sets the optional parameter "skip":
191581
func (c *AppPackageListCall) Skip(skip int64) *AppPackageListCall {
	c.urlParams_.Set("skip", fmt.Sprint(skip))
	return c
}
61171
func (c *Cursor) Skip() {
	if c == nil {
		return
	}

	c.mu.Lock()
	defer c.mu.Unlock()
	c.pendingSkips++
}
544304
func (c *ServiceWorker) SkipWaitingWithParams(v *ServiceWorkerSkipWaitingParams) (*gcdmessage.ChromeResponse, error) {
	return gcdmessage.SendDefaultRequest(c.target, c.target.GetSendCh(), &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: "ServiceWorker.skipWaiting", Params: v})
}
719868
func skip(value, prefix string) (string, error) {
	for len(prefix) > 0 {
		if prefix[0] == ' ' {
			if len(value) > 0 && value[0] != ' ' {
				return value, errBad
			}
			prefix = cutspace(prefix)
			value = cutspace(value)
			continue
		}
		if len(value) == 0 || value[0] != prefix[0] {
			return value, errBad
		}
		prefix = prefix[1:]
		value = value[1:]
	}
	return value, nil
}
152102
func (*RetryRequest) skipRetry(httpMethod string, response *http.Response) bool {
	return httpMethod == http.MethodPost ||
		response != nil &&
			response.StatusCode != http.StatusInternalServerError &&
			response.StatusCode != http.StatusBadGateway &&
			response.StatusCode != http.StatusServiceUnavailable &&
			response.StatusCode != http.StatusGatewayTimeout
}
529987
func SkipBatch() func(Call) error {
	return func(c Call) error {
		if b, ok := c.(Batchable); ok {
			b.setSkipBatch(true)
			return nil
		}
		return errors.New("'SkipBatch' option only works with Get and Mutate requests")
	}
}
486521
func (z *Tokenizer) skipWhiteSpace() {
	if z.err != nil {
		return
	}
	for {
		c := z.readByte()
		if z.err != nil {
			return
		}
		switch c {
		case ' ', '\n', '\r', '\t', '\f':
			// No-op.
		default:
			z.raw.end--
			return
		}
	}
}
553868
func (c *FakeExamples) Delete(name string, options *v1.DeleteOptions) error {
	_, err := c.Fake.
		Invokes(testing.NewDeleteAction(examplesResource, c.ns, name), &crv1.Example{})

	return err
}
478258
func (r *View) Skip(count int64) {
	for count > 0 {
		if r.cur == nil {
			panic(errors.New("cannot skip past end buffer"))
		}

		amount := r.chunkRemaining()
		if count < int64(amount) {
			amount = int(count)
			r.cidx += amount
		} else {
			// Finished consuming this chunk, move on to the next.
			r.cur = r.cur.next
			r.cidx = 0
		}

		count -= int64(amount)
		r.consumed += int64(amount)
		r.size -= int64(amount)
	}
}
265796
func Skip(source http.FileSystem, skip Func) http.FileSystem {
	keep := func(path string, fi os.FileInfo) bool {
		return !skip(path, fi)
	}
	return &filterFS{source: source, keep: keep}
}
473707
func (s *scanner) skip() {
	l := s.buf[:s.pos-1]
	r := s.buf[s.pos:]
	s.buf = l + r
}
190415
func skipLengthEncodedString(b []byte) (int, error) {
	// Get length
	num, _, n := readLengthEncodedInteger(b)
	if num < 1 {
		return n, nil
	}

	n += int(num)

	// Check data length
	if len(b) >= n {
		return n, nil
	}
	return n, io.EOF
}
928103
func (c *Conn) SkipUntil(delims ...string) error {
	_, _, err := c.readUntil(false, delims...)
	return err
}
518222
func SkipHeaders(headers ...string) SkipHeaderFunc {
	skipHeader := make(map[string]struct{})
	for _, h := range headers {
		skipHeader[h] = struct{}{}
	}
	return func(h string) bool {
		_, ok := skipHeader[h]
		return ok
	}
}
1303914
func (c *Compiler) SkipBindCompile(ctx context.Context, node ast.StmtNode) (*ExecStmt, error) {
	return c.compile(ctx, node, true)
}
920121
func (it *Skip) Next(ctx context.Context) bool {
	graph.NextLogIn(it)
	for ; it.skipped < it.skip; it.skipped++ {
		if !it.primaryIt.Next(ctx) {
			return graph.NextLogOut(it, false)
		}
	}
	if it.primaryIt.Next(ctx) {
		return graph.NextLogOut(it, true)
	}
	return graph.NextLogOut(it, false)
}
762135
func (f *Flow) Skip(pkts ...packet.Generic) *Flow {
	f.add(action{
		kind:    actionSkip,
		packets: pkts,
	})

	return f
}