TF_Operation* neg = Neg(feed, func_graph_, s_, "neg");
  Define(-1, {}, {feed}, {neg}, {"negation"});

  // Use, run, and verify
  TF_Operation* func_feed = Placeholder(host_graph_, s_);
  TF_Operation* func_op = Use({func_feed});
  Run({{func_feed, Int32Tensor(3)}}, func_op, -3);
  VerifyFDef({"neg"}, {{"negation_0", DT_INT32}}, {{"negation", DT_INT32}},

        !spec.isSatisfiedBy("")
        spec.isSatisfiedBy([1,2,3])
    }

    def "negation of all is none"() {
        expect:
        Specs.negate(Specs.satisfyAll()) == Specs.satisfyNone()
    }

    def "negation of none is all"() {
        expect:
        Specs.negate(Specs.satisfyNone()) == Specs.satisfyAll()
    }

    def "negation of spec is !spec"() {
        def spec = Stub(Spec)

        expect:

    is AnalysisStatementFilter.NamedCallFilter -> statement is FunctionCall && statement.name == callName
    is AnalysisStatementFilter.NotFilter -> !negationOf.shouldAnalyzeStatement(statement, scopes)
    is AnalysisStatementFilter.TopLevelElementFilter -> scopes.last().receiver is ObjectOrigin.TopLevelReceiver
}


internal
object AnalysisStatementFiltersImplementations {

					clause += ","
				}
				clause += lit.String()
			}
			line += " " + clause
		}
		lines = append(lines, line)
	}

	return lines, nil
}

// pushNot applies DeMorgan's law to push negations down the expression,
// so that only tags are negated in the result.
// (It applies the rewrites !(X && Y) => (!X || !Y) and !(X || Y) => (!X && !Y).)
func pushNot(x Expr, not bool) Expr {
	switch x := x.(type) {

}

// Matches an operation that has a StringAttr whose name is `name` and value
// matches `value_matcher`.
MATCHER_P2(HasStringAttr, name, value_matcher,
           absl::StrCat(negation ? "doesn't have" : "has",
                        "string attribute: ", name, ", with desirable value")) {
  auto non_const_arg = const_cast<std::remove_const_t<decltype(arg)>>(arg);

        val right: AnalysisStatementFilter

        interface AndFilter : CompositionFilter
        interface OrFilter : CompositionFilter
    }

    interface NotFilter : AnalysisStatementFilter {
        val negationOf: AnalysisStatementFilter
    }

    interface ConfiguringCallFilter : AnalysisStatementFilter
    interface TopLevelElementFilter : AnalysisStatementFilter
    interface NamedCallFilter : AnalysisStatementFilter {

        contentsDir.eachFileRecurse {
            if (it.absolutePath.endsWith(generatedSourceName)) {
                foundGeneratedSources = true
            }
        }

        then:
        // TODO: remove negation when fixed
        !foundGeneratedSources
    }

func (xh *xxhash64) reset() {
	xh.len = 0

	// Separate addition for awkward constant overflow.
	xh.v[0] = xxhPrime64c1
	xh.v[0] += xxhPrime64c2

	xh.v[1] = xxhPrime64c2
	xh.v[2] = 0

	// Separate negation for awkward constant overflow.
	xh.v[3] = xxhPrime64c1
	xh.v[3] = -xh.v[3]

	for i := range xh.buf {
		xh.buf[i] = 0
	}
	xh.cnt = 0
}

// update adds a buffer to the has.

	NonGreedy                       // make repetition operators default to non-greedy
	PerlX                           // allow Perl extensions
	UnicodeGroups                   // allow \p{Han}, \P{Han} for Unicode group and negation
	WasDollar                       // regexp OpEndText was $, not \z
	Simple                          // regexp contains no counted repetition

	MatchNL = ClassNL | DotNL

// Since a larger level means a more severe event, a logger that accepts events
// with smaller (or more negative) level means a more verbose logger. Logger
// verbosity is thus the negation of event severity, and the default verbosity
// of 0 accepts all events at least as severe as INFO.
//
// Third, we wanted some room between levels to accommodate schemes with named