writer.println(node)
        }

        fun node(node: String, builder: NodeWriter.() -> Unit) {
            writer.print(indent)
            writer.println(node)
            builder(NodeWriter(writer, "$indent    "))
        }
    }
}

/**
 * Defines a top-level architecture module.
 */
fun module(moduleName: String, moduleConfiguration: ArchitectureModuleBuilder.() -> Unit) {

func (m *muxClient) response(seq uint32, r Response) {
	if debugReqs {
		fmt.Println(m.MuxID, m.parent.String(), "RESP")
	}
	if debugPrint {
		fmt.Printf("mux %d: got msg seqid %d, payload length: %d, err:%v\n", m.MuxID, seq, len(r.Msg), r.Err)
	}
	if !m.checkSeq(seq) {
		if debugReqs {
			fmt.Println(m.MuxID, m.parent.String(), "CHECKSEQ FAIL", m.RecvSeq, seq)
		}
		PutByteBuffer(r.Msg)
		r.Msg = nil

        given:
        buildFile << """
            println "running build script"

            class SomeTask extends DefaultTask {
                SomeTask() {
                    println("create task")
                }
            }
            task a(type: SomeTask) {
                println("configure task")
            }
            task b {
                dependsOn a

                ${type} value = ${reference}
                bean.value = ${reference}
                gradle.lifecycle.beforeProject {
                    println "this.value = " + value
                    println "bean.value = " + bean.value
                }
            }

            configureGradleLifecycle()
        """

                out.style(Header);
                out.println();
                out.println();
                out.text("---------------------").println();
                out.text("Unselected Variant(s)").println();
                out.text("---------------------");
                out.println();
                out.style(Normal);

                    target.getTasks().register("print${implementationTypeClassName}Configuration", DefaultTask.class, task -> {
                        task.doLast("print restricted extension content", t -> {
                            System.out.println(extension);
                        });
                    });
                    System.out.println(getFoo());
                }
            }
        """
    }

                }

                @TaskAction
                void run() {
                    println "this.reference = " + badReference?.toString()
                    println "bean.reference = " + bean.badReference?.toString()
                    println "beanWithSameType.reference = " + beanWithSameType.badReference?.toString()
                }
            }

	return hex.EncodeToString(hh.Sum(nil))
}

// LogAlwaysIf prints a detailed error message during
// the execution of the server.
func LogAlwaysIf(ctx context.Context, subsystem string, err error, errKind ...interface{}) {
	if err == nil {
		return
	}
	logIf(ctx, subsystem, err, errKind...)
}

// LogIf prints a detailed error message during
// the execution of the server, if it is not an

                    class Greeter { String toString() { 'Greetings from One!' } }
                    greet.doLast() { println new Greeter() }
                ''')

                'two.gradle'('''
                    class Greeter { String toString() { 'Greetings from Two!' } }
                    greet.doLast() { println new Greeter() }
                ''')
            }
        }

        when:
        run 'greet'

        println "verifyAll(receivedProblem($index)) {"
        println "    fqid == '${problem.definition.id.fqid}'"
        if (problem.contextualLabel != null) {
            println "    contextualLabel == '${problem.contextualLabel.replaceAll("'", "\\\\'")}'"
        }
        if (problem.details != null) {
            println "    details == '${problem.details.replaceAll("'", "\\\\'")}'"