}

// withNotStmt returns a lico for the same location, but not a statement
func (x lico) withNotStmt() lico {
	return x.withStmt(PosNotStmt)
}

// withDefaultStmt returns a lico for the same location, with default isStmt
func (x lico) withDefaultStmt() lico {
	return x.withStmt(PosDefaultStmt)
}

// withIsStmt returns a lico for the same location, tagged as definitely a statement
func (x lico) withIsStmt() lico {

	n, m := p.index, q.index
	return n > m || n == m && p.lico > q.lico
}

// WithNotStmt returns the same location to be marked with DWARF is_stmt=0
func (p XPos) WithNotStmt() XPos {
	p.lico = p.lico.withNotStmt()
	return p
}

// WithDefaultStmt returns the same location with undetermined is_stmt
func (p XPos) WithDefaultStmt() XPos {
	p.lico = p.lico.withDefaultStmt()
	return p
}

			} else if scanner.Text() != "waiting" {
				t.Fatal("unexpected output:", scanner.Text())
			}

			for _, fifo := range fifos {
				if _, err := fifo.file.WriteString(fifo.path + "\n"); err != nil {
					t.Fatal(err)
				}
				if !scanner.Scan() {
					t.Fatal("expected line:", scanner.Err())
				} else if scanner.Text() != fifo.path {
					t.Fatal("unexpected line:", scanner.Text())
				}
			}

func TestFIFONonBlockingEOF(t *testing.T) {
	fifoName := filepath.Join(t.TempDir(), "issue-66239-fifo")
	if err := syscall.Mkfifo(fifoName, 0600); err != nil {
		t.Fatalf("Error creating fifo: %v", err)
	}

	r, err := os.OpenFile(fifoName, os.O_RDONLY|syscall.O_NONBLOCK, os.ModeNamedPipe)
	if err != nil {
		t.Fatalf("Error opening fifo for read: %v", err)
	}
	defer r.Close()

fifo file The quick brown fox jumped over the lazy dog! hardlink null sda symlink badlink fifo The quick brown fox jumped over the lazy dog! hardlink sda symli badlink...

// walkFunc may remove the given request from the fifo,
// but may not mutate the fifo in any othe way.
type walkFunc func(*request) (ok bool)

// Internal interface to abstract out the implementation details
// of the underlying list used to maintain the requests.
//
// Note that a fifo, including the removeFromFIFOFuncs returned from Enqueue,
// is not safe for concurrent use by multiple goroutines.
type fifo interface {

def LiftVariablesInvalidSessionTestPass : Pass<"tf-saved-model-lift-variables-invalid-session-test", "ModuleOp"> {
  let summary = "Lift variables and save them as global tensors with an invalid "
           "session";
  let constructor = "mlir::tf_test::CreateLiftVariablesInvalidSessionTestPass()";
}

def LiftVariablesTestPass : Pass<"tf-saved-model-lift-variables-test", "ModuleOp"> {
  let summary = "Lift variables and save them as global tensors";

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Run the game of life in C using Go for parallelization.

package main

import (
	"flag"
	"fmt"
	"plugin"
)

const MAXDIM = 100

var dim = flag.Int("dim", 16, "board dimensions")
var gen = flag.Int("gen", 10, "generations")

func main() {
	flag.Parse()

	}
	if !quotaCfg.IsValid() {
		if quotaCfg.Type == "fifo" {
			internalLogIf(GlobalContext, errors.New("Detected older 'fifo' quota config, 'fifo' feature is removed and not supported anymore. Please clear your quota configs using 'mc admin bucket quota alias/bucket --clear' and use 'mc ilm add' for expiration of objects"), logger.WarningKind)
			return quotaCfg, fmt.Errorf("invalid quota type 'fifo'")
		}

	if ifi != nil {
		name = ifi.Name
	}
	as, err := lif.Addrs(syscall.AF_UNSPEC, name)
	if err != nil {
		return nil, err
	}
	var ifat []Addr
	for _, a := range as {
		var ip IP
		var mask IPMask
		switch a := a.(type) {
		case *lif.Inet4Addr:
			ip = IPv4(a.IP[0], a.IP[1], a.IP[2], a.IP[3])
			mask = CIDRMask(a.PrefixLen, 8*IPv4len)
		case *lif.Inet6Addr:
			ip = make(IP, IPv6len)
			copy(ip, a.IP[:])