return !attr || attr.getValue() == "NDHWC";
}

// Returns true if the given `op`
//   * has an attribute with the given `name`,
//   * and the attribute is an integer list of the form [1, X, Y, 1],
// and writes X, Y as 32-bit integer attribute to `x`, `y`.
bool TFIntListIs1XY1(Operation *op, StringRef name, IntegerAttr *x,
                     IntegerAttr *y);

                            SavedModel* saved_model_proto);

// Writes the SavedModel proto to a file or to string. If the proto is < the
// protobuf maximum size, then it will be serialized as a `.pb` proto binary.
// When larger than the maximum size, the SavedModel proto is destructively
// separated into chunks and written to
// `.cpb` (chunked proto).
//
// Write SavedModel to {file_prefix}{.pb|.cpb}.

			buf.WriteByte(upperhex[b&0x0f])
		}
	}
}

// openWord writes the beginning of an encoded-word into buf.
func (e WordEncoder) openWord(buf *strings.Builder, charset string) {
	buf.WriteString("=?")
	buf.WriteString(charset)
	buf.WriteByte('?')
	buf.WriteByte(byte(e))
	buf.WriteByte('?')
}

// closeWord writes the end of an encoded-word into buf.
func closeWord(buf *strings.Builder) {

        lockFileReaderWriter = new LockFileReaderWriter(resolver, context, lockFile, listener)
    }

    def 'writes a unique lock file'() {
        when:
        lockDir.deleteDir()
        lockFileReaderWriter.writeUniqueLockfile([a: ['foo', 'bar'], b: ['foo'], c: []])

        then:

	}
	return true
}

// writeString writes the given string to dst.
func (c *context) writeString(s string) bool {
	if len(c.dst)-c.pDst < len(s) {
		c.err = transform.ErrShortDst
		return false
	}
	// This loop is faster than using copy.
	for i := 0; i < len(s); i++ {
		c.dst[c.pDst] = s[i]
		c.pDst++
	}
	return true
}

// copy writes the current rune to dst.
func (c *context) copy() bool {

    final StringWriter writer = new StringWriter()
    final PrintWriter printWriter = new PrintWriter(writer, true)
    final ArgWriter argWriter = ArgWriter.unixStyle(printWriter)

    def "writes single argument to line"() {
        when:
        argWriter.args("-nologo")

        then:
        writer.toString() == toPlatformLineSeparators("-nologo\n")
    }

	r.isFull = false
	return b, r.readErr(true)
}

// Write writes len(p) bytes from p to the underlying buf.
// It returns the number of bytes written from p (0 <= n <= len(p))
// and any error encountered that caused the write to stop early.
// If blocking n < len(p) will be returned only if an error occurred.
// Write returns a non-nil error if it returns n < len(p).
// Write will not modify the slice data, even temporarily.

     */
    public abstract List<SourceFile> getFiles();

    /**
     * Returns the source set name to write the source into, using the Gradle convention for source layout.
     */
    public String getSourceSetName() {
        return "main";
    }

    /**
     * Writes the source files of this element to the given project, using the Gradle convention for source layout.
     */

  // XLA clusters force all reads to happen before all writes.  Moreover the set
  // of reads are executed as one atomic operation, and the set of writes are as
  // another atomic operation.  This means we can faithfully represent the
  // following edges: Read->*, *->Write.

  return from == XlaResourceOpKind::kRead || to == XlaResourceOpKind::kWrite;
}

using ResourceOp = std::pair<int, XlaResourceOpKind>;

type TextWriter struct {
	w io.Writer
	v version.Version
}

// NewTextWriter creates a new write for the trace text format.
func NewTextWriter(w io.Writer, v version.Version) (*TextWriter, error) {
	_, err := fmt.Fprintf(w, "Trace Go1.%d\n", v)
	if err != nil {
		return nil, err
	}
	return &TextWriter{w: w, v: v}, nil
}

// WriteEvent writes a single event to the stream.