if (visited.add(step)) {
            step.predecessors.forEach(ch -> {
                if (ch.executions().findAny().isPresent()) {
                    preds.add(ch);
                } else {
                    nonEmptyPredecessors(ch, preds, visited);
                }
            });
        }
    }

     *
     * @param ctype2
     *            The array of character types.
     * @param ch
     *            The character code.
     */
    protected static void ordinaryChar(final byte[] ctype2, final int ch) {
        if (ch >= 0 && ch < ctype2.length) {
            ctype2[ch] = 0;
        }
    }

    /**
     * Returns the value of the string.
     *

		case <-ctx.Done():
			// Refreshing is canceled
			return false, ctx.Err()
		}
		if done {
			break
		}
	}

	// We may have some unused results in ch, release them async.
	go func() {
		wg.Wait()
		xioutil.SafeClose(ch)
		for range ch {
		}
	}()

	noQuorum := lockNotFound > len(restClnts)-quorum
	return noQuorum, nil
}

}

// Create a clone of the entry.
func (e dataUsageEntry) clone() dataUsageEntry {
	// We operate on a copy from the receiver.
	if e.Children != nil {
		ch := make(dataUsageHashMap, len(e.Children))
		maps.Copy(ch, e.Children)
		e.Children = ch
	}

	if e.AllTierStats != nil {
		e.AllTierStats = e.AllTierStats.clone()
	}
	return e
}

// find a path in the cache.
// Returns nil if not found.

    user = session.get(User, user_id)
    if not user:
        raise HTTPException(status_code=403, detail="Not authorized")
    session.close()


def generate_stream(query: str):
    for ch in query:
        yield ch
        time.sleep(0.1)


@app.get("/generate", dependencies=[Depends(get_user)])
def generate(query: str):

// The context both allows returning errors on writes and to ensure that
// this isn't abandoned if the channel is no longer being read from.
func WriterToChannel(ctx context.Context, ch chan<- []byte) io.Writer {
	return &writerWrapper{ch: ch, ctx: ctx}
}

// bytesOrLength returns small (<=100b) byte slices as string, otherwise length.
func bytesOrLength(b []byte) string {
	if len(b) > 100 {

	"sync/atomic"
)

// GetByteBuffer returns a byte buffer from the pool.
var GetByteBuffer = func() []byte {
	return make([]byte, 0, 4096)
}

// Sub - subscriber entity.
type Sub[T Maskable] struct {
	ch     chan T
	types  Mask
	filter func(entry T) bool
}

// PubSub holds publishers and subscribers
type PubSub[T Maskable, M Maskable] struct {
	// atomics, keep at top:
	types          uint64

        state = mark = si = 0;
        do {
            final char ch = arr[si];

            switch (state) {
            case 0:
                if (ch == ':') {
                    proto = str.substring(mark, si);
                    mark = si + 1;
                    state = 1;
                }
                break;
            case 1:
                if (ch == '\\') {
                    mark = si + 1;

    }
    return fromBytesNoCopy(bytes);
  }

  private static int decode(char ch) {
    if (ch >= '0' && ch <= '9') {
      return ch - '0';
    }
    if (ch >= 'a' && ch <= 'f') {
      return ch - 'a' + 10;
    }
    throw new IllegalArgumentException("Illegal hexadecimal character: " + ch);
  }

  /**

	creds            auth.Credentials
}

// Get the max throughput and iops numbers.
func objectSpeedTest(ctx context.Context, opts speedTestOpts) chan madmin.SpeedTestResult {
	ch := make(chan madmin.SpeedTestResult, 1)
	go func() {
		defer xioutil.SafeClose(ch)

		concurrency := opts.concurrencyStart

		if opts.autotune {
			// if we have less drives than concurrency then choose