UNRESOLVED_REFERENCE      text ranges: [(23,35)]
      PSI: KtNameReferenceExpression at (2,15-27)
  for PSI element of type KtNameReferenceExpression at (3,10-20)
    UNRESOLVED_REFERENCE      text ranges: [(45,55)]
      PSI: KtNameReferenceExpression at (3,10-20)
  for PSI element of type KtNameReferenceExpression at (4,10-20)
    UNRESOLVED_REFERENCE      text ranges: [(65,75)]
      PSI: KtNameReferenceExpression at (4,10-20)

    ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED      text ranges: [(62,69)]
      PSI: KtClass at (6,1-11)
  for PSI element of type KtNamedFunction at (4,3-21)
    ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS      text ranges: [(41,49)]
      PSI: KtNamedFunction at (4,3-21)
  for PSI element of type KtTypeReference at (6,10-11)
    FINAL_SUPERTYPE      text ranges: [(71,72)]
      PSI: KtTypeReference at (6,10-11)

    UNRESOLVED_REFERENCE      text ranges: [(17,20)]
      PSI: KtNameReferenceExpression at (2,5-8)
  for PSI element of type KtNameReferenceExpression at (3,5-8)
    UNRESOLVED_REFERENCE      text ranges: [(28,31)]
      PSI: KtNameReferenceExpression at (3,5-8)
  for PSI element of type KtNameReferenceExpression at (3,9-12)
    UNRESOLVED_REFERENCE      text ranges: [(32,35)]
      PSI: KtNameReferenceExpression at (3,9-12)

    NONE_APPLICABLE      text ranges: [(89,92)]
      PSI: KtNameReferenceExpression at (6,5-8)
  for PSI element of type KtNameReferenceExpression at (7,5-8)
    NONE_APPLICABLE      text ranges: [(100,103)]
      PSI: KtNameReferenceExpression at (7,5-8)
  for PSI element of type KtNameReferenceExpression at (8,5-8)
    NONE_APPLICABLE      text ranges: [(115,118)]
      PSI: KtNameReferenceExpression at (8,5-8)

		},
	}
}

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