Prevent overwriting of blocks with same name in Go html/template

I'm having difficulty in rendering the correct content using templates in Go.

I have a base template (base.tmpl) and 2 child templates (a.tmpl and b.tmpl).

// base.tmpl
{{ define "base" }}
  {{ template "header" . }}
  {{ template "content" . }}
  {{ template "footer" . }}
{{ end }}

// a.tmpl
{{ template "base" . }}
{{ define "content" }}
  This is a.tmpl
{{ end }}

// b.tmpl
{{ template "base" . }}
{{ define "content" }}
  This is b.tmpl
{{ end }}

When executing a.tmpl the contents of the content block in b.tmpl are inserted.

For example, rendering a.tmpl results in a page displaying:

This is b.tmpl

I am parsing the templates (see below) and returning and assigning the result to a variable x so I may call x.ExecuteTemplate(w, "a.tmpl", nil)

func parseTemplates() *template.Template {
	templ := template.New("")
	err := filepath.Walk("./templates", func(path string, info os.FileInfo, err error) error {
		if strings.Contains(path, ".tmpl") {
			_, err = templ.ParseFiles(path)
			if err != nil {
				log.Println(err)
			}
		}

		return err
	})

	if err != nil {
		panic(err)
	}

	return templ
}

I am assuming this is because when parsing the templates, Go keeps b.tmpl's content block definition as the most recent.

I'm wondering if there's a way where I can parse all templates at run time and simply call the template I want to execute without having to re-parse the header, content, footer etc. each time I execute the page.

Parse the templates for a and b separately.

atmpl, err := template.ParseFiles("base.tmpl", "a.tmpl")
if err != nil { /* handle error */ }

btmpl, err := template.ParseFiles("base.tmpl", "b.tmpl")
if err != nil { /* handle error */ }