},
	}
}

var trees [16]*node
var ballast *[16]*[1024]*node
var sink [][]byte

func main() {
	for i := range trees {
		trees[i] = makeTree(6)
	}
	ballast = new([16]*[1024]*node)
	for i := range ballast {
		ballast[i] = new([1024]*node)
		for j := range ballast[i] {
			ballast[i][j] = &node{
				data: [128]byte{1, 2, 3, 4},
			}
		}
	}

	procs := runtime.GOMAXPROCS(-1)

		// need to be split.
		if inUseIndex > 0 {
			need = need.subtract(addrRangeToSumAddrRange(l, p.inUse.ranges[inUseIndex-1]))
		}
		if inUseIndex < len(p.inUse.ranges) {
			need = need.subtract(addrRangeToSumAddrRange(l, p.inUse.ranges[inUseIndex]))
		}
		// It's possible that after our pruning above, there's nothing new to map.
		if need.size() == 0 {
			continue
		}

    CONSTANT_EXPECTED_TYPE_MISMATCH      text ranges: [(68,69)]
      PSI: KtConstantExpression at (5,12-13)
  for PSI element of type KtNameReferenceExpression at (4,9-10)
    TYPE_MISMATCH      text ranges: [(54,55)]
      PSI: KtNameReferenceExpression at (4,9-10)
  for PSI element of type KtStringTemplateExpression at (1,14-16)
    TYPE_MISMATCH      text ranges: [(13,15)]
      PSI: KtStringTemplateExpression at (1,14-16)

  // output multipliers
  double real_multiplier = scale_product / o_spec.getScale();
  output_multipliers->push_back(QuantizeMultiplier(real_multiplier));

  // output ranges
  auto min = rop->getAttrOfType<FloatAttr>("min");
  auto max = rop->getAttrOfType<FloatAttr>("max");
  output_ranges->push_back(CalculateQuantizedRange(
      o_spec.getScale(), o_spec.getZeroPoint(),

# Build state model

The Gradle daemon tracks state for various elements. These are arranged in a hierarchy:

```mermaid
  graph TD

  process["build process"]
  
  session["build session"]
  process --> session
  
  build_tree["build tree"]
  session --> build_tree
  
  build1["root build"]
  build_tree --> build1
  
  project1["root project"]
  build1 --> project1
  
  project2["project"]
  build1 --> project2

            equalTo(
                """
                buildscript {
                    // line 2
                }""".replaceIndent()
            )
        )
    }

    @Test
    fun `given ranges linePreservingBlankRange should blank lines`() {
        val original = """
            |// line 1
            |// line 2
            |buildscript {
            |    // line 4
            |}
            |// line 6

	// APIPA/"link-local" IP.
	//
	// It doesn't matter what this IP is, so long as it's not routable and doesn't collide with anything else.
	//
	// IPv6 link local ranges are designed to be collision-resistant by default, and so probably never need to be overridden
	DefaultHostProbeSNATIP   = "169.254.7.127"
	DefaultHostProbeSNATIPV6 = "fd16:9254:7127:1337:ffff:ffff:ffff:ffff"
)

    ARGUMENT_TYPE_MISMATCH      text ranges: [(54,55)]
      PSI: KtNameReferenceExpression at (4,9-10)
  for PSI element of type KtProperty at (1,1-16)
    INITIALIZER_TYPE_MISMATCH      text ranges: [(13,15)]
      PSI: KtProperty at (1,1-16)
  for PSI element of type KtConstantExpression at (5,12-13)
    RETURN_TYPE_MISMATCH      text ranges: [(68,69)]

    ABSTRACT_MEMBER_NOT_IMPLEMENTED      text ranges: [(110,116)]
      PSI: KtObjectDeclaration at (7,14-48)
  for PSI element of type KtConstantExpression at (4,9-10)
    ARGUMENT_TYPE_MISMATCH      text ranges: [(88,89)]
      PSI: KtConstantExpression at (4,9-10)
  for PSI element of type KtConstantExpression at (10,38-39)
    RETURN_TYPE_MISMATCH      text ranges: [(230,231)]

  /**
   * Returns the range containing this key and its associated value, if such a range is present in
   * the range map, or {@code null} otherwise.
   */
  @CheckForNull
  Entry<Range<K>, V> getEntry(K key);

  /**
   * Returns the minimal range {@linkplain Range#encloses(Range) enclosing} the ranges in this
   * {@code RangeMap}.
   *
   * @throws NoSuchElementException if this range map is empty
   */
  Range<K> span();

  /**