package main

import "fmt"

type A struct {
	K int
	S string
	M map[string]string
}

func newA(k int, s string) (a A) {
	a.K = k
	a.S = s
	a.M = make(map[string]string)
	a.M[s] = s
	return
}

func proxy() (x int, a A) {
	return 1, newA(2, "3")
}

func consume(x int, a interface{}) {
	fmt.Println(x)
	fmt.Println(a) // used to panic here
}

func main() {

}

type R struct {
	cM *CM
}

type CM int

type A string

func (m *CM) NewA(ctx context.Context, cN string, nn *nAO, opts ...NAO) (*A, error) {
	for _, o := range opts {
		o(nn)
	}
	s := A("foo")
	return &s, nil
}

func (r *R) CA(ctx context.Context, cN string, nn *nAO) (*int, error) {
	cA, err := r.cM.NewA(ctx, cN, nn, WEA(), WEA())
	if err == nil {
		return nil, err
	}
	println(cA)
	x := int(42)

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package b

import "./a"

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type A struct {
	New func() any
}

func NewA(i int) *A {
	return &A{
		New: func() any {
			_ = i
			return nil
		},
	}

package p

// examples from the issue

type (
	e = f
	f = g
	g = []h
	h i
	i = j
	j = e
)

type (
	e1 = []h1
	h1 e1
)

type (
	P = *T
	T P
)

func newA(c funcAlias) A {
	return A{c: c}
}

type B struct {
	a *A
}

type A struct {
	c funcAlias
}

func (j *Array[T]) Value() []T {
	if j.val == nil {
		j.val = j.p.newA(10)
	}
	return j.val
}

// Append a value to the underlying array.
// The returned Array is always the same as the one called.
func (j *Array[T]) Append(v ...T) *Array[T] {
	if j.val == nil {
		j.val = j.p.newA(uint32(len(v)))
	}
	j.val = append(j.val, v...)
	return j
}

var Modi <type 1>;
var Mongolian <type 1>;
var Mro <type 1>;
var Multani <type 1>;
var Myanmar <type 1>;
var N <type 1>;
var Nabataean <type 1>;
var Nd <type 1>;
var New_Tai_Lue <type 1>;
var Newa <type 1>;
var Nko <type 1>;
var Nl <type 1>;
var No <type 1>;
var Noncharacter_Code_Point <type 1>;
var Number <type 1>;
var Ogham <type 1>;
var Ol_Chiki <type 1>;
var Old_Hungarian <type 1>;

pkg testing, type InternalExample struct, Unordered bool
pkg unicode, const Version = "9.0.0"
pkg unicode, var Adlam *RangeTable
pkg unicode, var Bhaiksuki *RangeTable
pkg unicode, var Marchen *RangeTable
pkg unicode, var Newa *RangeTable
pkg unicode, var Osage *RangeTable
pkg unicode, var Prepended_Concatenation_Mark *RangeTable
pkg unicode, var Sentence_Terminal *RangeTable

	New_Tai_Lue            = _New_Tai_Lue            // New_Tai_Lue is the set of Unicode characters in script New_Tai_Lue.
	Newa                   = _Newa                   // Newa is the set of Unicode characters in script Newa.
	Nko                    = _Nko                    // Nko is the set of Unicode characters in script Nko.

11400..1144A  ; valid                                  # 9.0  NEWA LETTER A..NEWA SIDDHI
1144B..1144F  ; valid                  ;      ; NV8    # 9.0  NEWA DANDA..NEWA ABBREVIATION SIGN
11450..11459  ; valid                                  # 9.0  NEWA DIGIT ZERO..NEWA DIGIT NINE
1145A         ; valid                  ;      ; NV8    # 13.0 NEWA DOUBLE COMMA
1145B         ; valid                  ;      ; NV8    # 9.0  NEWA PLACEHOLDER MARK