gtsocial-umbx

go.go (413952B)

---

 // Copyright 2020 The CCGO 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 ccgo // import "modernc.org/ccgo/v3/lib"
 
 import (
 	"bytes"
 	"fmt"
 	"go/scanner"
 	"go/token"
 	"hash/maphash"
 	"io/ioutil"
 	"math"
 	"math/big"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"sort"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
 
 	"modernc.org/cc/v3"
 	"modernc.org/mathutil"
 )
 
 var (
 	idAddOverflow          = cc.String("__builtin_add_overflow") // bool __builtin_add_overflow (type1 a, type2 b, type3 *res)
 	idAlias                = cc.String("alias")
 	idAligned              = cc.String("aligned")          // int __attribute__ ((aligned (8))) foo;
 	idAtomicLoadN          = cc.String("__atomic_load_n")  // type __atomic_load_n (type *ptr, int memorder)
 	idAtomicStoreN         = cc.String("__atomic_store_n") // void __atomic_store_n (type *ptr, type val, int memorder)
 	idBp                   = cc.String("bp")
 	idBuiltinConstantPImpl = cc.String("__builtin_constant_p_impl")
 	idCAPI                 = cc.String("CAPI")
 	idChooseExpr           = cc.String("__builtin_choose_expr")
 	idEnviron              = cc.String("environ")
 	idMain                 = cc.String("main")
 	idMulOverflow          = cc.String("__builtin_mul_overflow") // bool __builtin_mul_overflow (type1 a, type2 b, type3 *res)
 	idPacked               = cc.String("packed")                 // __attribute__((packed))
 	idSubOverflow          = cc.String("__builtin_sub_overflow") // bool __builtin_sub_overflow (type1 a, type2 b, type3 *res)
 	idTls                  = cc.String("tls")
 	idTransparentUnion     = cc.String("__transparent_union__")
 	idTs                   = cc.String("ts")
 	idVa                   = cc.String("va")
 	idVaArg                = cc.String("__ccgo_va_arg")
 	idVaEnd                = cc.String("__ccgo_va_end")
 	idVaList               = cc.String("va_list")
 	idVaStart              = cc.String("__ccgo_va_start")
 	idWcharT               = cc.String("wchar_t")
 	idWinWchar             = cc.String("WCHAR")
 	idWtext                = cc.String("wtext")
 
 	bytesBufferPool = sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
 
 	oTraceG   bool
 	oTraceW   bool
 	oTracePin bool
 )
 
 type exprMode int
 
 const (
 	doNotExport = iota
 	doNotChange
 	exportCapitalize
 	exportPrefix
 )
 
 const (
 	_              exprMode = iota
 	exprAddrOf              // &foo as uinptr (must be static/pinned)
 	exprBool                // foo in foo != 0
 	exprCondInit            // foo or bar in int i = x ? foo : bar;
 	exprCondReturn          // foo or bar in return x ? foo : bar;
 	exprDecay               // &foo[0] in foo for array foo.
 	exprFunc                // foo in foo(bar)
 	exprLValue              // foo in foo = bar
 	exprPSelect             // foo in foo->bar
 	exprSelect              // foo in foo.bar
 	exprValue               // foo in bar = foo
 	exprVoid                //
 	exprGoPtr
 )
 
 const (
 	tooManyErrors = "too many errors"
 )
 
 type opKind int
 
 const (
 	opNormal opKind = iota
 	opArray
 	opArrayParameter
 	opFunction
 	opUnion
 	opBitfield
 	opStruct
 )
 
 type flags byte
 
 const (
 	fForceConv flags = 1 << iota
 	fForceNoConv
 	fForceRuntimeConv
 	fNoCondAssignment
 	fAddrOfFuncPtrOk
 )
 
 type imported struct {
 	path      string              // Eg. "example.com/user/foo".
 	name      string              // Eg. "foo" from "package foo".
 	qualifier string              // Eg. "foo." or "foo2." if renamed due to name conflict.
 	exports   map[string]struct{} // Eg. {"New": {}, "Close": {}, ...}.
 
 	used bool
 }
 
 type taggedStruct struct {
 	ctyp  cc.Type
 	gotyp string
 	name  string
 	node  cc.Node
 
 	conflicts bool
 	emitted   bool
 }
 
 func (s *taggedStruct) emit(p *project, ds *cc.DeclarationSpecifiers) {
 	if s == nil || s.emitted {
 		return
 	}
 
 	s.emitted = true
 	p.w("%stype %s = %s; /* %v */\n\n", tidyComment("\n", ds), s.name, s.gotyp, p.pos(s.node))
 }
 
 // Return first non empty token separator within n or dflt otherwise.
 func comment(dflt string, n cc.Node) string {
 	if s := tokenSeparator(n); s != "" {
 		return s
 	}
 
 	return dflt
 }
 
 // tidyComment is like comment but makes comment more Go-like.
 func tidyComment(dflt string, n cc.Node) (r string) { return tidyCommentString(comment(dflt, n)) }
 
 func tidyCommentString(s string) (r string) {
 	defer func() {
 		if !strings.Contains(r, "// <blockquote><pre>") {
 			return
 		}
 
 		a := strings.Split(r, "\n")
 		in := false
 		for i, v := range a {
 			switch {
 			case in:
 				if strings.HasPrefix(v, "// </pre></blockquote>") {
 					in = false
 					a[i] = "//"
 					break
 				}
 
 				a[i] = fmt.Sprintf("//\t%s", v[3:])
 			default:
 				if strings.HasPrefix(v, "// <blockquote><pre>") {
 					a[i] = "//"
 					in = true
 				}
 			}
 		}
 		r = strings.Join(a, "\n")
 	}()
 
 	s = strings.ReplaceAll(s, "\f", "")
 	b := bytesBufferPool.Get().(*bytes.Buffer)
 	defer func() { b.Reset(); bytesBufferPool.Put(b) }()
 	for len(s) != 0 {
 		c := s[0]
 		s = s[1:]
 		if len(s) == 0 {
 			b.WriteByte(c)
 			break
 		}
 
 		if c != '/' {
 			b.WriteByte(c)
 			continue
 		}
 
 		c2 := s[0]
 		s = s[1:]
 		switch c2 {
 		case '/': // line comment start
 			b.WriteByte(c)
 			b.WriteByte(c2)
 			for {
 				c := s[0]
 				s = s[1:]
 				b.WriteByte(c)
 				if c == '\n' {
 					break
 				}
 			}
 		case '*': // block comment start
 			b2 := bytesBufferPool.Get().(*bytes.Buffer)
 			defer func() { b2.Reset(); bytesBufferPool.Put(b2) }()
 			for {
 				c := s[0]
 				s = s[1:]
 				if c != '*' {
 					b2.WriteByte(c)
 					continue
 				}
 
 			more:
 				c2 := s[0]
 				s = s[1:]
 				if c2 == '*' {
 					b2.WriteByte(c)
 					goto more
 				}
 
 				if c2 != '/' {
 					b2.WriteByte(c)
 					b2.WriteByte(c2)
 					continue
 				}
 
 				break
 			}
 			s2 := b2.String() // comment sans /* prefix and */ suffix
 			a := strings.Split(s2, "\n")
 			nl := len(s) != 0 && s[0] == '\n'
 			if len(a) == 1 { // /* foo */ form
 				if nl {
 					s = s[1:]
 					fmt.Fprintf(b, "//%s\n", s2)
 					break
 				}
 
 				fmt.Fprintf(b, "/*%s*/", s2)
 				break
 			}
 
 			if !nl {
 				fmt.Fprintf(b, "/*%s*/", s2)
 				break
 			}
 
 			// Block comment followed by a newline can be safely replaced by a sequence of
 			// line comments.  Try to enhance the comment.
 			if commentForm1(b, a) ||
 				commentForm2(b, a) ||
 				commentForm3(b, a) {
 				break
 			}
 
 			// No enhancement posibilities detected, use the default form.
 			if a[len(a)-1] == "" {
 				a = a[:len(a)-1]
 			}
 			fmt.Fprintf(b, "//%s", a[0])
 			for _, v := range a[1:] {
 				fmt.Fprintf(b, "\n// %s", v)
 			}
 		default:
 			b.WriteByte(c)
 			b.WriteByte(c2)
 		}
 	}
 	return b.String()
 }
 
 func commentForm1(b *bytes.Buffer, a []string) bool {
 	// Example
 	//
 	//	/*
 	//	** Initialize this module.
 	//	**
 	//	** This Tcl module contains only a single new Tcl command named "sqlite".
 	//	** (Hence there is no namespace.  There is no point in using a namespace
 	//	** if the extension only supplies one new name!)  The "sqlite" command is
 	//	** used to open a new SQLite database.  See the DbMain() routine above
 	//	** for additional information.
 	//	**
 	//	** The EXTERN macros are required by TCL in order to work on windows.
 	//	*/
 	if strings.TrimSpace(a[0]) != "" {
 		return false
 	}
 
 	if strings.TrimSpace(a[len(a)-1]) != "" {
 		return false
 	}
 
 	a = a[1 : len(a)-1]
 	if len(a) == 0 {
 		return false
 	}
 
 	for i, v := range a {
 		v = strings.TrimSpace(v)
 		if !strings.HasPrefix(v, "*") {
 			return false
 		}
 
 		a[i] = strings.TrimLeft(v, "*")
 	}
 
 	fmt.Fprintf(b, "//%s", a[0])
 	for _, v := range a[1:] {
 		fmt.Fprintf(b, "\n//%s", v)
 	}
 	return true
 }
 
 func commentForm2(b *bytes.Buffer, a []string) bool {
 	// Example
 	//
 	//	/**************************** sqlite3_column_  *******************************
 	//	** The following routines are used to access elements of the current row
 	//	** in the result set.
 	//	*/
 	if strings.TrimSpace(a[len(a)-1]) != "" {
 		return false
 	}
 
 	a = a[:len(a)-1]
 	if len(a) == 0 {
 		return false
 	}
 
 	for i, v := range a[1:] {
 		v = strings.TrimSpace(v)
 		if !strings.HasPrefix(v, "*") {
 			return false
 		}
 
 		a[i+1] = strings.TrimLeft(v, "*")
 	}
 
 	fmt.Fprintf(b, "// %s", strings.TrimSpace(a[0]))
 	if strings.HasPrefix(a[0], "**") && strings.HasSuffix(a[0], "**") {
 		fmt.Fprintf(b, "\n//")
 	}
 	for _, v := range a[1:] {
 		fmt.Fprintf(b, "\n//%s", v)
 	}
 	return true
 }
 
 func commentForm3(b *bytes.Buffer, a []string) bool {
 	// Example
 	//
 	//	/* Call sqlite3_shutdown() once before doing anything else. This is to
 	//	** test that sqlite3_shutdown() can be safely called by a process before
 	//	** sqlite3_initialize() is. */
 	for i, v := range a[1:] {
 		v = strings.TrimSpace(v)
 		if !strings.HasPrefix(v, "*") {
 			return false
 		}
 
 		a[i+1] = strings.TrimLeft(v, "*")
 	}
 
 	fmt.Fprintf(b, "// %s", strings.TrimSpace(a[0]))
 	if strings.HasPrefix(a[0], "**") && strings.HasSuffix(a[0], "**") {
 		fmt.Fprintf(b, "\n//")
 	}
 	for _, v := range a[1:] {
 		fmt.Fprintf(b, "\n//%s", v)
 	}
 	return true
 }
 
 // Return the preceding white space, including any comments, of the first token
 // of n.
 func tokenSeparator(n cc.Node) (r string) {
 	if n == nil {
 		return ""
 	}
 
 	var tok cc.Token
 	cc.Inspect(n, func(n cc.Node, _ bool) bool {
 		if x, ok := n.(*cc.Token); ok {
 			if a, b := tok.Seq(), x.Seq(); a == 0 || a > x.Seq() && b != 0 {
 				tok = *x
 			}
 		}
 		return true
 	})
 	return tok.Sep.String()
 }
 
 func source(n ...cc.Node) (r string) {
 	if len(n) == 0 {
 		return "<nil>"
 	}
 
 	var a []*cc.Token
 	for _, v := range n {
 		cc.Inspect(v, func(n cc.Node, _ bool) bool {
 			if x, ok := n.(*cc.Token); ok && x.Seq() != 0 {
 				a = append(a, x)
 			}
 			return true
 		})
 	}
 	sort.Slice(a, func(i, j int) bool {
 		return a[i].Seq() < a[j].Seq()
 	})
 	w := 0
 	seq := -1
 	for _, v := range a {
 		if n := v.Seq(); n != seq {
 			seq = n
 			a[w] = v
 			w++
 		}
 	}
 	a = a[:w]
 	var b strings.Builder
 	for _, v := range a {
 		b.WriteString(v.Sep.String())
 		b.WriteString(v.Src.String())
 	}
 	return b.String()
 }
 
 type initPatch struct {
 	t    cc.Type
 	init *cc.Initializer
 	fld  cc.Field
 }
 
 type tld struct {
 	name    string // Can differ from the original one.
 	patches []initPatch
 }
 
 type block struct {
 	block  *cc.CompoundStatement
 	decls  []*cc.Declaration // What to declare in this block.
 	params []*cc.Parameter
 	parent *block
 	scope  scope
 
 	noDecl  bool // Locals declared in one of the parent scopes.
 	topDecl bool // Declare locals at block start to avoid "jumps over declaration".
 }
 
 func newBlock(parent *block, n *cc.CompoundStatement, decls []*cc.Declaration, params []*cc.Parameter, scope scope, topDecl bool) *block {
 	return &block{
 		block:   n,
 		decls:   decls,
 		params:  params,
 		parent:  parent,
 		scope:   scope,
 		topDecl: topDecl,
 	}
 }
 
 type local struct {
 	name string
 	off  uintptr // If isPinned: bp+off
 
 	forceRead bool // Possibly never read.
 	isPinned  bool // Prevent this local from being placed in Go movable stack.
 }
 
 type switchState int
 
 const (
 	_                 switchState = iota // Not in switch.
 	inSwitchFirst                        // Before seeing "case/default".
 	inSwitchCase                         // Seen "case/default".
 	inSwitchSeenBreak                    // In switch "case/default" and seen "break/return".
 	inSwitchFlat
 )
 
 type function struct {
 	block            *block
 	blocks           map[*cc.CompoundStatement]*block
 	bpName           string
 	breakCtx         int //TODO merge with continueCtx
 	complits         map[*cc.PostfixExpression]uintptr
 	condInitPrefix   func()
 	continueCtx      int
 	flatLabels       int
 	flatSwitchLabels map[*cc.LabeledStatement]int
 	fndef            *cc.FunctionDefinition
 	gen              *project
 	ifCtx            cc.Node
 	ignore           map[*cc.Declarator]bool // Pseudo declarators
 	labelNames       map[cc.StringID]string
 	labels           scope
 	locals           map[*cc.Declarator]*local
 	off              uintptr         // bp+off allocs
 	params           []*cc.Parameter // May differ from what fndef says
 	project          *project
 	rt               cc.Type // May differ from what fndef says
 	scope            scope
 	switchCtx        switchState
 	tlsName          string
 	top              *block
 	unusedLabels     map[cc.StringID]struct{}
 	vaLists          map[*cc.PostfixExpression]uintptr
 	vaName           string
 	vaType           cc.Type
 	vlas             map[*cc.Declarator]struct{}
 
 	hasJumps            bool
 	mainSignatureForced bool
 }
 
 func newFunction(p *project, n *cc.FunctionDefinition) *function {
 	d := n.Declarator
 	t := d.Type()
 	rt := t.Result()
 	params := t.Parameters()
 	var mainSignatureForced bool
 	var ignore map[*cc.Declarator]bool
 	if d.Name() == idMain && d.Linkage == cc.External {
 		if rt.Kind() != cc.Int {
 			rt = p.task.cfg.ABI.Type(cc.Int)
 		}
 		if len(params) != 2 {
 			mainSignatureForced = true
 			d1 := newDeclarator("argc")
 			t1 := p.task.cfg.ABI.Type(cc.Int)
 			d2 := newDeclarator("argv")
 			t2 := p.task.cfg.ABI.Ptr(n, p.task.cfg.ABI.Type(cc.Void))
 			params = []*cc.Parameter{
 				cc.NewParameter(d1, t1),
 				cc.NewParameter(d2, t2),
 			}
 			ignore = map[*cc.Declarator]bool{d1: true, d2: true}
 		}
 	}
 	f := &function{
 		blocks:              map[*cc.CompoundStatement]*block{},
 		complits:            map[*cc.PostfixExpression]uintptr{},
 		fndef:               n,
 		gen:                 p,
 		hasJumps:            n.CompoundStatement.IsJumpTarget(),
 		ignore:              ignore,
 		locals:              map[*cc.Declarator]*local{},
 		mainSignatureForced: mainSignatureForced,
 		params:              params,
 		project:             p,
 		rt:                  rt,
 		scope:               p.newScope(),
 		unusedLabels:        map[cc.StringID]struct{}{},
 		vaLists:             map[*cc.PostfixExpression]uintptr{},
 		vlas:                map[*cc.Declarator]struct{}{},
 	}
 	f.tlsName = f.scope.take(idTls)
 	if t.IsVariadic() {
 		f.vaName = f.scope.take(idVa)
 	}
 	f.layoutLocals(nil, n.CompoundStatement, params)
 	var extern []cc.StringID
 	for _, v := range n.CompoundStatements() { // testdata/gcc-9.1.0/gcc/testsuite/gcc.c-torture/execute/scope-1.c
 		for _, v := range v.Declarations() {
 			for list := v.InitDeclaratorList; list != nil; list = list.InitDeclaratorList {
 				if d := list.InitDeclarator.Declarator; d != nil && d.IsExtern() {
 					extern = append(extern, d.Name())
 				}
 			}
 		}
 	}
 	for _, v := range n.CompoundStatements() {
 		block := f.blocks[v]
 		for _, v := range extern {
 			if tld := f.project.externs[v]; tld != nil {
 				block.scope.take(cc.String(tld.name))
 			}
 		}
 	}
 	for _, v := range n.CompoundStatements() {
 		f.layoutBlocks(v)
 	}
 	f.renameLabels()
 	f.staticAllocsAndPinned(n.CompoundStatement)
 	return f
 }
 
 func (f *function) flatLabel() int {
 	if f.project.pass1 {
 		return 1
 	}
 
 	f.flatLabels++
 	return f.flatLabels
 }
 
 func (f *function) renameLabels() {
 	var a []cc.StringID
 	for _, v := range f.fndef.Labels {
 		if v.Case != cc.LabeledStatementLabel {
 			continue
 		}
 
 		a = append(a, v.Token.Value)
 		f.unusedLabels[v.Token.Value] = struct{}{}
 	}
 	for _, v := range f.fndef.Gotos {
 		delete(f.unusedLabels, v.Token2.Value)
 	}
 	if len(a) == 0 {
 		return
 	}
 	sort.Slice(a, func(i, j int) bool { return a[i].String() < a[j].String() })
 	f.labels = newScope()
 	f.labelNames = map[cc.StringID]string{}
 	for _, id := range a {
 		f.labelNames[id] = f.labels.take(id)
 	}
 }
 
 func (f *function) staticAllocsAndPinned(n *cc.CompoundStatement) {
 	for _, v := range f.params {
 		switch {
 		case v.Type().Kind() == cc.Array && v.Type().IsVLA():
 			// trc("VLA")
 			f.project.err(f.fndef, "variable length arrays not supported")
 		}
 	}
 
 	//TODO use pass1 for this
 	cc.Inspect(n, func(n cc.Node, entry bool) bool {
 		if !entry {
 			return true
 		}
 
 		switch x := n.(type) {
 		case *cc.CastExpression:
 			switch x.Case {
 			case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 				if t := x.TypeName.Type(); t != nil && t.Kind() != cc.Void {
 					break
 				}
 
 				if d := x.CastExpression.Declarator(); d != nil {
 					if local := f.locals[d]; local != nil {
 						local.forceRead = true
 					}
 				}
 			}
 		}
 
 		x, ok := n.(*cc.PostfixExpression)
 		if !ok || x.Case != cc.PostfixExpressionCall {
 			return true
 		}
 
 		if x.PostfixExpression == nil || x.PostfixExpression.Operand == nil || x.PostfixExpression.Operand.Type() == nil {
 			return true
 		}
 
 		ft := funcType(x.PostfixExpression.Operand.Type())
 		if ft.Kind() != cc.Function {
 			return true
 		}
 
 		if !ft.IsVariadic() {
 			return true
 		}
 
 		fixedParams := len(ft.Parameters())
 		iArg := 0
 		var need uintptr
 		for list := x.ArgumentExpressionList; list != nil; list, iArg = list.ArgumentExpressionList, iArg+1 {
 			if iArg < fixedParams {
 				continue
 			}
 
 			t := list.AssignmentExpression.Operand.Type()
 			if t.IsIntegerType() {
 				need += 8
 				continue
 			}
 
 			switch t.Kind() {
 			case cc.Array, cc.Ptr, cc.Double, cc.Float, cc.Function:
 				need += 8
 			default:
 				panic(todo("", f.project.pos(x), t, t.Kind()))
 			}
 		}
 		if need != 0 {
 			//TODO- if f.project.task.mingw {
 			//TODO- 	need += 8 // On windows the va list is prefixed with its length
 			//TODO- }
 			va := roundup(f.off, 8)
 			f.vaLists[x] = va
 			f.off = va + need
 		}
 		return true
 	})
 }
 
 func funcType(t cc.Type) cc.Type {
 	if t.Kind() == cc.Ptr {
 		t = t.Elem()
 	}
 	return t
 }
 
 type declarator interface {
 	Declarator() *cc.Declarator
 	cc.Node
 }
 
 func (p *project) isArrayParameterDeclarator(d *cc.Declarator) bool {
 	if d.Type().Kind() == cc.Array {
 		if d.Type().IsVLA() {
 			return false
 		}
 
 		return d.IsParameter
 	}
 
 	return false
 }
 
 func (p *project) isArrayDeclarator(d *cc.Declarator) bool {
 	if d.Type().Kind() == cc.Array {
 		if d.Type().IsVLA() {
 			return false
 		}
 
 		return !d.IsParameter
 	}
 
 	return false
 }
 
 func (p *project) isArrayParameter(n declarator, t cc.Type) bool {
 	if t.Kind() != cc.Array {
 		return false
 	}
 
 	if t.IsVLA() {
 		return false
 	}
 
 	if d := n.Declarator(); d != nil {
 		return d.IsParameter
 	}
 
 	return false
 }
 
 func (p *project) isArrayOrPinnedArray(f *function, n declarator, t cc.Type) (r bool) {
 	if t.Kind() != cc.Array {
 		return false
 	}
 
 	if t.IsVLA() {
 		return false
 	}
 
 	if d := n.Declarator(); d != nil {
 		return !d.IsParameter
 	}
 
 	return p.detectArray(f, n.(cc.Node), true, true, nil)
 }
 
 func (p *project) detectArray(f *function, n cc.Node, pinnedOk, recursiveOk bool, out **cc.Declarator) bool {
 	switch x := n.(type) {
 	case *cc.AssignmentExpression:
 		switch x.Case {
 		case cc.AssignmentExpressionCond: // ConditionalExpression
 			return p.detectArray(f, x.ConditionalExpression, pinnedOk, recursiveOk, out)
 		case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
 			return p.detectArray(f, x.UnaryExpression, pinnedOk, recursiveOk, out)
 		default:
 			return false
 		}
 	case *cc.ConditionalExpression:
 		switch x.Case {
 		case cc.ConditionalExpressionLOr: // LogicalOrExpression
 			return p.detectArray(f, x.LogicalOrExpression, pinnedOk, recursiveOk, out)
 		case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 			return p.detectArray(f, x.LogicalOrExpression, pinnedOk, recursiveOk, out) ||
 				p.detectArray(f, x.Expression, pinnedOk, recursiveOk, out) ||
 				p.detectArray(f, x.ConditionalExpression, pinnedOk, recursiveOk, out)
 		default:
 			panic(todo("", p.pos(x), x.Case))
 		}
 	case *cc.LogicalOrExpression:
 		switch x.Case {
 		case cc.LogicalOrExpressionLAnd: // LogicalAndExpression
 			return p.detectArray(f, x.LogicalAndExpression, pinnedOk, recursiveOk, out)
 		default:
 			return false
 		}
 	case *cc.LogicalAndExpression:
 		switch x.Case {
 		case cc.LogicalAndExpressionOr: // InclusiveOrExpression
 			return p.detectArray(f, x.InclusiveOrExpression, pinnedOk, recursiveOk, out)
 		default:
 			return false
 		}
 	case *cc.InclusiveOrExpression:
 		switch x.Case {
 		case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression
 			return p.detectArray(f, x.ExclusiveOrExpression, pinnedOk, recursiveOk, out)
 		default:
 			return false
 		}
 	case *cc.ExclusiveOrExpression:
 		switch x.Case {
 		case cc.ExclusiveOrExpressionAnd: // AndExpression
 			return p.detectArray(f, x.AndExpression, pinnedOk, recursiveOk, out)
 		default:
 			return false
 		}
 	case *cc.AndExpression:
 		switch x.Case {
 		case cc.AndExpressionEq: // EqualityExpression
 			return p.detectArray(f, x.EqualityExpression, pinnedOk, recursiveOk, out)
 		default:
 			return false
 		}
 	case *cc.EqualityExpression:
 		switch x.Case {
 		case cc.EqualityExpressionRel: // RelationalExpression
 			return p.detectArray(f, x.RelationalExpression, pinnedOk, recursiveOk, out)
 		default:
 			return false
 		}
 	case *cc.RelationalExpression:
 		switch x.Case {
 		case cc.RelationalExpressionShift: // ShiftExpression
 			return p.detectArray(f, x.ShiftExpression, pinnedOk, recursiveOk, out)
 		default:
 			return false
 		}
 	case *cc.ShiftExpression:
 		switch x.Case {
 		case cc.ShiftExpressionAdd: // AdditiveExpression
 			return p.detectArray(f, x.AdditiveExpression, pinnedOk, recursiveOk, out)
 		default:
 			return false
 		}
 	case *cc.AdditiveExpression:
 		switch x.Case {
 		case cc.AdditiveExpressionMul: // MultiplicativeExpression
 			return p.detectArray(f, x.MultiplicativeExpression, pinnedOk, recursiveOk, out)
 		case
 			cc.AdditiveExpressionSub, // AdditiveExpression '-' MultiplicativeExpression
 			cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
 
 			return p.detectArray(f, x.AdditiveExpression, pinnedOk, recursiveOk, out) || p.detectArray(f, x.MultiplicativeExpression, pinnedOk, recursiveOk, out)
 		default:
 			panic(todo("", p.pos(x), x.Case))
 		}
 	case *cc.MultiplicativeExpression:
 		switch x.Case {
 		case cc.MultiplicativeExpressionCast: // CastExpression
 			return p.detectArray(f, x.CastExpression, pinnedOk, recursiveOk, out)
 		default:
 			return false
 		}
 	case *cc.CastExpression:
 		switch x.Case {
 		case cc.CastExpressionUnary: // UnaryExpression
 			return p.detectArray(f, x.UnaryExpression, pinnedOk, recursiveOk, out)
 		case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 			return p.detectArray(f, x.CastExpression, pinnedOk, recursiveOk, out)
 		default:
 			panic(todo("", p.pos(x), x.Case))
 		}
 	case *cc.UnaryExpression:
 		switch x.Case {
 		case cc.UnaryExpressionPostfix: // PostfixExpression
 			return p.detectArray(f, x.PostfixExpression, pinnedOk, recursiveOk, out)
 		case
 			cc.UnaryExpressionDeref,  // '*' CastExpression
 			cc.UnaryExpressionAddrof: // '&' CastExpression
 
 			return p.detectArray(f, x.CastExpression, pinnedOk, recursiveOk, out)
 		case
 			cc.UnaryExpressionSizeofExpr,  // "sizeof" UnaryExpression
 			cc.UnaryExpressionSizeofType,  // "sizeof" '(' TypeName ')'
 			cc.UnaryExpressionMinus,       // '-' CastExpression
 			cc.UnaryExpressionCpl,         // '~' CastExpression
 			cc.UnaryExpressionAlignofExpr, // "_Alignof" UnaryExpression
 			cc.UnaryExpressionAlignofType, // "_Alignof" '(' TypeName ')'
 			cc.UnaryExpressionNot,         // '!' CastExpression
 			cc.UnaryExpressionInc,         // "++" UnaryExpression
 			cc.UnaryExpressionDec,         // "--" UnaryExpression
 			cc.UnaryExpressionPlus:        // '+' CastExpression
 
 			return false
 		default:
 			panic(todo("", p.pos(x), x.Case))
 		}
 	case *cc.PostfixExpression:
 		switch x.Case {
 		case cc.PostfixExpressionPrimary: // PrimaryExpression
 			return p.detectArray(f, x.PrimaryExpression, pinnedOk, recursiveOk, out)
 		case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
 			return recursiveOk && p.detectArray(f, x.PostfixExpression, pinnedOk, recursiveOk, out)
 		case
 			cc.PostfixExpressionSelect,  // PostfixExpression '.' IDENTIFIER
 			cc.PostfixExpressionDec,     // PostfixExpression "--"
 			cc.PostfixExpressionInc,     // PostfixExpression "++"
 			cc.PostfixExpressionCall,    // PostfixExpression '(' ArgumentExpressionList ')'
 			cc.PostfixExpressionComplit, // '(' TypeName ')' '{' InitializerList ',' '}'
 			cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 
 			return false
 		default:
 			panic(todo("", p.pos(x), x.Case))
 		}
 	case *cc.PrimaryExpression:
 		switch x.Case {
 		case
 			cc.PrimaryExpressionString,  // STRINGLITERAL
 			cc.PrimaryExpressionEnum,    // ENUMCONST
 			cc.PrimaryExpressionChar,    // CHARCONST
 			cc.PrimaryExpressionLChar,   // LONGCHARCONST
 			cc.PrimaryExpressionLString, // LONGSTRINGLITERAL
 			cc.PrimaryExpressionFloat,   // FLOATCONST
 			cc.PrimaryExpressionInt:     // INTCONST
 
 			return false
 		case cc.PrimaryExpressionIdent: // IDENTIFIER
 			d := x.Declarator()
 			if d == nil || d.IsParameter {
 				return false
 			}
 
 			if d.Type().Kind() != cc.Array {
 				return false
 			}
 
 			if d.Type().IsVLA() {
 				return false
 			}
 
 			if pinnedOk {
 				if out != nil {
 					*out = d
 				}
 				return true
 			}
 
 			local := f.locals[d]
 			if local == nil || local.isPinned {
 				return false
 			}
 
 			if out != nil {
 				*out = d
 			}
 			return true
 		case cc.PrimaryExpressionExpr: // '(' Expression ')'
 			return p.detectArray(f, x.Expression, pinnedOk, recursiveOk, out)
 		case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')'
 			p.err(x, "statement expressions not supported")
 			return false
 		default:
 			panic(todo("", p.pos(x), x.Case))
 		}
 	case *cc.Expression:
 		switch x.Case {
 		case cc.ExpressionAssign: // AssignmentExpression
 			return p.detectArray(f, x.AssignmentExpression, pinnedOk, recursiveOk, out)
 		case cc.ExpressionComma: // Expression ',' AssignmentExpression
 			return p.detectArray(f, x.Expression, pinnedOk, recursiveOk, out) || p.detectArray(f, x.AssignmentExpression, pinnedOk, recursiveOk, out)
 		default:
 			panic(todo("", p.pos(x), x.Case))
 		}
 	default:
 		panic(todo("%T", x))
 	}
 }
 
 func (p *project) isArray(f *function, n declarator, t cc.Type) (r bool) {
 	if t.Kind() != cc.Array {
 		return false
 	}
 
 	if t.IsVLA() {
 		return false
 	}
 
 	if f == nil {
 		return true
 	}
 
 	if d := n.Declarator(); d != nil {
 		local := f.locals[d]
 		return !d.IsParameter && (local == nil || !local.isPinned)
 	}
 
 	return p.detectArray(f, n.(cc.Node), false, true, nil)
 }
 
 var home = os.Getenv("HOME")
 
 // Return n's position with path reduced to baseName(path) unless
 // p.task.fullPathComments is true.
 func (p *project) pos(n cc.Node) (r token.Position) {
 	if n == nil {
 		return r
 	}
 
 	if r = token.Position(n.Position()); r.IsValid() {
 		switch {
 		case p.task.fullPathComments:
 			if strings.HasPrefix(r.Filename, home) {
 				r.Filename = "$HOME" + r.Filename[len(home):]
 			}
 		default:
 			r.Filename = filepath.Base(r.Filename)
 		}
 	}
 	return r
 }
 
 // Return n's position with path reduced to baseName(path).
 func pos(n cc.Node) (r token.Position) {
 	if n == nil {
 		return r
 	}
 
 	r = token.Position(n.Position())
 	if r.IsValid() {
 		r.Filename = filepath.Base(r.Filename)
 	}
 	return r
 }
 
 func roundup(n, to uintptr) uintptr {
 	if r := n % to; r != 0 {
 		return n + to - r
 	}
 
 	return n
 }
 
 func (f *function) pin(n cc.Node, d *cc.Declarator) {
 	local := f.locals[d]
 	if local == nil || local.isPinned {
 		return
 	}
 
 	local.isPinned = true
 	if oTracePin || f.project.task.tracePinning {
 		fmt.Printf("%v: %s at %v: is pinned (%v)\n", n.Position(), d.Name(), d.Position(), origin(2))
 	}
 	local.off = roundup(f.off, uintptr(d.Type().Align()))
 	f.off = local.off + paramTypeDecay(d).Size()
 }
 
 func paramTypeDecay(d *cc.Declarator) (r cc.Type) {
 	r = d.Type()
 	if d.IsParameter && r.Kind() == cc.Array {
 		r = r.Decay()
 	}
 	return r
 }
 
 func (f *function) layoutBlocks(n *cc.CompoundStatement) {
 	block := f.blocks[n]
 	type item struct {
 		ds *cc.DeclarationSpecifiers
 		d  *cc.Declarator
 	}
 	var work []item
 	for _, v := range block.params {
 		if v.Type().Kind() == cc.Void {
 			break
 		}
 
 		work = append(work, item{nil, v.Declarator()})
 	}
 	for _, decl := range block.decls {
 		ds := decl.DeclarationSpecifiers
 		for list := decl.InitDeclaratorList; list != nil; list = list.InitDeclaratorList {
 			work = append(work, item{ds, list.InitDeclarator.Declarator})
 		}
 	}
 	block.scope.take(cc.String(f.tlsName))
 	if f.vaName != "" {
 		block.scope.take(cc.String(f.vaName))
 	}
 	for _, item := range work {
 		d := item.d
 		if f.ignore[d] {
 			continue
 		}
 
 		if !f.ignore[d] && d.IsStatic() {
 			continue
 		}
 
 		if d.IsFunctionPrototype() || d.IsExtern() {
 			continue
 		}
 
 		local := &local{forceRead: d.Read == 0}
 		if t := d.Type(); t != nil && t.Name() == idVaList {
 			local.forceRead = true
 		}
 		f.locals[d] = local
 		local.name = block.scope.take(d.Name())
 	}
 }
 
 func (f *function) layoutLocals(parent *block, n *cc.CompoundStatement, params []*cc.Parameter) {
 	block := newBlock(parent, n, n.Declarations(), params, f.project.newScope(), n.IsJumpTarget())
 	f.blocks[n] = block
 	if parent == nil {
 		f.top = block
 		f.top.topDecl = f.hasJumps
 	}
 	for _, ch := range n.Children() {
 		f.layoutLocals(block, ch, nil)
 		if f.hasJumps {
 			chb := f.blocks[ch]
 			chb.noDecl = true
 			f.top.decls = append(f.top.decls, chb.decls...)
 			chb.decls = nil
 		}
 	}
 }
 
 func newDeclarator(name string) *cc.Declarator {
 	return &cc.Declarator{
 		DirectDeclarator: &cc.DirectDeclarator{
 			Case:  cc.DirectDeclaratorIdent,
 			Token: cc.Token{Rune: cc.IDENTIFIER, Value: cc.String(name)},
 		},
 	}
 }
 
 type enumSpec struct {
 	decl *cc.Declaration
 	spec *cc.EnumSpecifier
 
 	emitted bool
 }
 
 func (n *enumSpec) emit(p *project) {
 	if n == nil || p.pass1 || n.emitted {
 		return
 	}
 
 	n.emitted = true
 	ok := false
 	for list := n.spec.EnumeratorList; list != nil; list = list.EnumeratorList {
 		nm := list.Enumerator.Token.Value
 		if _, ok2 := p.emitedEnums[nm]; !ok2 && p.enumConsts[nm] != "" {
 			ok = true
 			break
 		}
 	}
 	if !ok {
 		return
 	}
 
 	p.w("%s", tidyComment("\n", n.decl))
 	p.w("const ( /* %v: */", p.pos(n.decl))
 	for list := n.spec.EnumeratorList; list != nil; list = list.EnumeratorList {
 		en := list.Enumerator
 		nm := en.Token.Value
 		if _, ok := p.emitedEnums[nm]; ok || p.enumConsts[nm] == "" {
 			continue
 		}
 
 		p.emitedEnums[nm] = struct{}{}
 		p.w("%s%s = ", tidyComment("\n", en), p.enumConsts[nm])
 		p.intConst(en, "", en.Operand, en.Operand.Type(), fForceNoConv)
 		p.w(";")
 	}
 	p.w(");")
 }
 
 type typedef struct {
 	sig uint64
 	tld *tld
 }
 
 type define struct {
 	name  string
 	value cc.Value
 }
 
 type project struct {
 	ast                *cc.AST
 	buf                bytes.Buffer
 	capi               []string
 	defines            map[cc.StringID]define
 	defineLines        []string
 	emitedEnums        map[cc.StringID]struct{}
 	enumConsts         map[cc.StringID]string
 	enumSpecs          map[*cc.EnumSpecifier]*enumSpec
 	errors             scanner.ErrorList
 	externs            map[cc.StringID]*tld
 	fn                 string
 	imports            map[string]*imported // C name: import info
 	intType            cc.Type
 	localTaggedStructs []func()
 	mainName           string
 	ptrSize            uintptr
 	ptrType            cc.Type
 	scope              scope
 	sharedFns          map[*cc.FunctionDefinition]struct{}
 	sharedFnsEmitted   map[*cc.FunctionDefinition]struct{}
 	staticQueue        []*cc.InitDeclarator
 	structs            map[cc.StringID]*taggedStruct // key: C tag
 	symtab             map[string]interface{}        // *tld or *imported
 	task               *Task
 	tldScope           scope
 	tlds               map[*cc.Declarator]*tld
 	ts                 bytes.Buffer // Text segment
 	tsName             string
 	tsNameP            string
 	tsOffs             map[cc.StringID]uintptr
 	tsW                []rune // Text segment, wchar_t
 	tsWName            string
 	tsWNameP           string
 	tsWOffs            map[cc.StringID]uintptr
 	typeSigHash        maphash.Hash
 	typedefTypes       map[cc.StringID]*typedef
 	typedefsEmited     map[string]struct{}
 	verifyStructs      map[string]cc.Type
 	wanted             map[*cc.Declarator]struct{}
 	wcharSize          uintptr
 
 	isMain       bool
 	pass1        bool
 	pauseCodegen bool
 }
 
 func newProject(t *Task) (*project, error) {
 	voidType := t.cfg.ABI.Type(cc.Void)
 	ptrType := t.cfg.ABI.Ptr(nil, voidType)
 	intType := t.cfg.ABI.Type(cc.Int)
 	if intType.Size() != 4 { // We're assuming wchar_t is int32.
 		return nil, fmt.Errorf("unsupported C int size: %d", intType.Size())
 	}
 
 	if n := t.cfg.ABI.Types[cc.UChar].Size; n != 1 {
 		return nil, fmt.Errorf("unsupported C unsigned char size: %d", n)
 	}
 
 	if n := t.cfg.ABI.Types[cc.UShort].Size; n != 2 {
 		return nil, fmt.Errorf("unsupported C unsigned short size: %d", n)
 	}
 
 	if n := t.cfg.ABI.Types[cc.UInt].Size; n != 4 {
 		return nil, fmt.Errorf("unsupported C unsigned int size: %d", n)
 	}
 
 	if n := t.cfg.ABI.Types[cc.ULongLong].Size; n != 8 {
 		return nil, fmt.Errorf("unsupported C unsigned long long size: %d", n)
 	}
 
 	p := &project{
 		defines:          map[cc.StringID]define{},
 		emitedEnums:      map[cc.StringID]struct{}{},
 		enumConsts:       map[cc.StringID]string{},
 		enumSpecs:        map[*cc.EnumSpecifier]*enumSpec{},
 		externs:          map[cc.StringID]*tld{},
 		imports:          map[string]*imported{},
 		intType:          intType,
 		ptrSize:          t.cfg.ABI.Types[cc.Ptr].Size,
 		ptrType:          ptrType,
 		scope:            newScope(),
 		sharedFns:        t.cfg.SharedFunctionDefinitions.M,
 		sharedFnsEmitted: map[*cc.FunctionDefinition]struct{}{},
 		symtab:           map[string]interface{}{},
 		task:             t,
 		tlds:             map[*cc.Declarator]*tld{},
 		tsWOffs:          map[cc.StringID]uintptr{},
 		tsOffs:           map[cc.StringID]uintptr{},
 		typedefTypes:     map[cc.StringID]*typedef{},
 		typedefsEmited:   map[string]struct{}{},
 		verifyStructs:    map[string]cc.Type{},
 		wanted:           map[*cc.Declarator]struct{}{},
 		wcharSize:        t.asts[0].WideCharType.Size(),
 	}
 	p.tldScope = p.scope
 	p.scope.take(idCAPI)
 	for _, v := range t.imported {
 		var err error
 		if v.name, v.exports, err = t.capi(v.path); err != nil {
 			return nil, err
 		}
 
 		v.qualifier = p.scope.take(cc.String(v.name)) + "."
 		for k := range v.exports {
 			if p.imports[k] == nil {
 				p.imports[k] = v
 			}
 		}
 	}
 	p.tsNameP = p.scope.take(idTs)
 	p.tsName = p.scope.take(idTs)
 	p.tsWNameP = p.scope.take(idWtext)
 	p.tsWName = p.scope.take(idWtext)
 	if err := p.layout(); err != nil {
 		return nil, err
 	}
 
 	return p, nil
 }
 
 func (p *project) newScope() scope {
 	s := newScope()
 	var a []cc.StringID
 	for k := range p.structs {
 		a = append(a, k)
 	}
 	sort.Slice(a, func(i, j int) bool { return a[i].String() < a[j].String() })
 	for _, k := range a {
 		s.take(cc.String(p.structs[k].name))
 	}
 	return s
 }
 
 func (p *project) err(n cc.Node, s string, args ...interface{}) {
 	if p.task.errTrace || strings.Contains(s, "internal error") {
 		s = s + "(" + origin(2) + ")"
 	}
 	if p.task.traceTranslationUnits {
 		trc("%v: error: %s (%v)", pos(n), fmt.Sprintf(s, args...), origin(2))
 	}
 	if !p.task.allErrors && len(p.errors) >= 10 {
 		return
 	}
 
 	switch {
 	case n == nil:
 		p.errors.Add(token.Position{}, fmt.Sprintf(s, args...))
 	default:
 		p.errors.Add(token.Position(n.Position()), fmt.Sprintf(s, args...))
 		if !p.task.allErrors && len(p.errors) == 10 {
 			p.errors.Add(token.Position(n.Position()), tooManyErrors)
 		}
 	}
 }
 
 func (p *project) o(s string, args ...interface{}) {
 	if oTraceG {
 		fmt.Printf(s, args...)
 	}
 	fmt.Fprintf(p.task.out, s, args...)
 }
 
 func (p *project) w(s string, args ...interface{}) {
 	if p.pass1 || p.pauseCodegen {
 		return
 	}
 
 	if coverExperiment {
 		pc, _, _, ok := runtime.Caller(1)
 		if ok {
 			coverMap[pc] = struct{}{}
 		}
 	}
 	if oTraceW {
 		fmt.Printf(s, args...)
 	}
 	//fmt.Fprintf(&p.buf, "/* %s */", origin(2)) //TODO-
 	fmt.Fprintf(&p.buf, s, args...)
 }
 
 func (p *project) layout() error {
 	if err := p.layoutTLDs(); err != nil {
 		return err
 	}
 
 	if err := p.layoutSymtab(); err != nil {
 		return err
 	}
 
 	if err := p.layoutStructs(); err != nil {
 		return err
 	}
 
 	if err := p.layoutEnums(); err != nil {
 		return err
 	}
 
 	if err := p.layoutDefines(); err != nil {
 		return err
 	}
 
 	return p.layoutStaticLocals()
 }
 
 func (p *project) layoutSymtab() error {
 	var t0 time.Time
 	if p.task.traceTranslationUnits {
 		fmt.Printf("processing symbol table ... ")
 		t0 = time.Now()
 		defer func() { fmt.Println(time.Since(t0)) }()
 	}
 
 	for _, i := range p.task.symSearchOrder {
 		switch {
 		case i < 0:
 			imported := p.task.imported[-i-1]
 			for nm := range imported.exports {
 				if _, ok := p.symtab[nm]; !ok {
 					p.symtab[nm] = imported
 				}
 			}
 		default:
 			ast := p.task.asts[i]
 			for d := range ast.TLD {
 				if d.IsFunctionPrototype() || d.Linkage != cc.External {
 					continue
 				}
 
 				nm := d.Name()
 				name := nm.String()
 				if _, ok := p.symtab[name]; !ok {
 					tld := p.externs[nm]
 					if tld == nil {
 						if d.Type().Kind() != cc.Function && !p.task.header {
 							p.err(d, "back-end: undefined: %s %v %v", d.Name(), d.Type(), d.Type().Kind())
 						}
 						continue
 					}
 
 					p.symtab[name] = tld
 				}
 			}
 		}
 	}
 	return nil
 }
 
 func (p *project) layoutDefines() error {
 	if !p.task.exportDefinesValid {
 		return nil
 	}
 
 	var t0 time.Time
 	if p.task.traceTranslationUnits {
 		fmt.Printf("processing #defines ... ")
 		t0 = time.Now()
 		defer func() { fmt.Println(time.Since(t0)) }()
 	}
 
 	var prefix = p.task.exportDefines
 	taken := map[cc.StringID]struct{}{}
 	for _, ast := range p.task.asts {
 		var a []cc.StringID
 		for nm, m := range ast.Macros {
 			if m.IsFnLike() {
 				continue
 			}
 
 			if strings.HasPrefix(nm.String(), "__") {
 				continue
 			}
 
 			if _, ok := taken[nm]; ok {
 				continue
 			}
 
 			taken[nm] = struct{}{}
 			a = append(a, nm)
 		}
 		sort.Slice(a, func(i, j int) bool { return a[i].String() < a[j].String() })
 		for _, nm := range a {
 			m := ast.Macros[nm]
 			val, src := evalMacro(m, ast)
 			if src == "" {
 				continue
 			}
 
 			name := nm.String()
 			switch {
 			case prefix == "":
 				name = capitalize(name)
 			default:
 				name = prefix + name
 			}
 			name = p.scope.take(cc.String(name))
 			p.defines[nm] = define{name, val}
 			p.defineLines = append(p.defineLines, fmt.Sprintf("%s = %s // %v:", name, src, p.pos(m)))
 		}
 	}
 	return nil
 }
 
 func evalMacro(m *cc.Macro, ast *cc.AST) (cc.Value, string) {
 	toks := m.ReplacementTokens()
 	if len(toks) != 1 {
 		return evalMacro2(m, ast)
 	}
 
 	src := strings.TrimSpace(toks[0].Src.String())
 	if len(src) == 0 {
 		return nil, ""
 	}
 
 	neg := ""
 	switch src[0] {
 	case '"':
 		if _, err := strconv.Unquote(src); err == nil {
 			return cc.StringValue(cc.String(src)), src
 		}
 	case '-':
 		neg = "-"
 		src = src[1:]
 		fallthrough
 	default:
 		src = strings.TrimRight(src, "lLuU")
 		if u64, err := strconv.ParseUint(src, 0, 64); err == nil {
 			switch {
 			case neg == "":
 				return cc.Uint64Value(u64), src
 			default:
 				return cc.Int64Value(-u64), neg + src
 			}
 		}
 
 		src = strings.TrimRight(src, "fF")
 		if f64, err := strconv.ParseFloat(src, 64); err == nil {
 			return cc.Float64Value(f64), neg + src
 		}
 	}
 
 	return evalMacro2(m, ast)
 }
 
 func evalMacro2(m *cc.Macro, ast *cc.AST) (cc.Value, string) {
 	op, err := ast.Eval(m)
 	if err != nil {
 		return nil, ""
 	}
 
 	switch x := op.Value().(type) {
 	case cc.Int64Value:
 		return op.Value(), fmt.Sprintf("%d", int64(x))
 	case cc.Uint64Value:
 		return op.Value(), fmt.Sprintf("%d", uint64(x))
 	default:
 		panic(todo("", pos(m)))
 	}
 }
 
 func (p *project) layoutEnums() error {
 	var t0 time.Time
 	if p.task.traceTranslationUnits {
 		fmt.Printf("processing enum values ... ")
 		t0 = time.Now()
 		defer func() { fmt.Println(time.Since(t0)) }()
 	}
 
 	export := doNotChange
 	if p.task.exportEnumsValid {
 		switch {
 		case p.task.exportEnums != "":
 			export = exportPrefix
 		default:
 			export = exportCapitalize
 		}
 	} else if p.task.defaultUnExport {
 		export = doNotExport
 	}
 
 	var enumList []*cc.EnumSpecifier
 	for _, v := range p.task.asts {
 		for list := v.TranslationUnit; list != nil; list = list.TranslationUnit {
 			decl := list.ExternalDeclaration
 			switch decl.Case {
 			case cc.ExternalDeclarationDecl: // Declaration
 				// ok
 			default:
 				continue
 			}
 
 			cc.Inspect(decl.Declaration.DeclarationSpecifiers, func(n cc.Node, entry bool) bool {
 				if !entry {
 					return true
 				}
 
 				x, ok := n.(*cc.EnumSpecifier)
 				if !ok || x.Case != cc.EnumSpecifierDef {
 					return true
 				}
 
 				if _, ok := p.enumSpecs[x]; !ok {
 					enumList = append(enumList, x)
 					p.enumSpecs[x] = &enumSpec{decl: decl.Declaration, spec: x}
 				}
 				return true
 			})
 		}
 	}
 
 	vals := map[cc.StringID]interface{}{}
 	for _, v := range enumList {
 		for list := v.EnumeratorList; list != nil; list = list.EnumeratorList {
 			en := list.Enumerator
 			nm := en.Token.Value
 			var val int64
 			switch x := en.Operand.Value().(type) {
 			case cc.Int64Value:
 				val = int64(x)
 			case cc.Uint64Value:
 				val = int64(x)
 			default:
 				panic(todo(""))
 			}
 			switch ex, ok := vals[nm]; {
 			case ok:
 				switch {
 				case ex == nil: //
 					continue
 				case ex == val: // same name and same value
 					continue
 				default: // same name, different value
 					vals[nm] = nil
 				}
 			default:
 				vals[nm] = val
 			}
 			p.enumConsts[nm] = ""
 		}
 	}
 	var a []cc.StringID
 	for nm := range p.enumConsts {
 		if val, ok := vals[nm]; ok && val == nil {
 			delete(p.enumConsts, nm)
 			continue
 		}
 
 		a = append(a, nm)
 	}
 	sort.Slice(a, func(i, j int) bool { return a[i].String() < a[j].String() })
 	for _, nm := range a {
 		name := nm.String()
 		switch export {
 		case doNotExport:
 			name = unCapitalize(name)
 		case doNotChange:
 			// nop
 		case exportCapitalize:
 			name = capitalize(name)
 		case exportPrefix:
 			name = p.task.exportEnums + name
 		}
 		name = p.scope.take(cc.String(name))
 		p.enumConsts[nm] = name
 	}
 	return nil
 }
 
 func (p *project) layoutStaticLocals() error {
 	var t0 time.Time
 	if p.task.traceTranslationUnits {
 		fmt.Printf("processing static local declarations ... ")
 		t0 = time.Now()
 		defer func() { fmt.Println(time.Since(t0)) }()
 	}
 	for _, v := range p.task.asts {
 		for list := v.TranslationUnit; list != nil; list = list.TranslationUnit {
 			decl := list.ExternalDeclaration
 			switch decl.Case {
 			case cc.ExternalDeclarationFuncDef: // FunctionDefinition
 				// ok
 			default:
 				continue
 			}
 
 			cc.Inspect(decl.FunctionDefinition.CompoundStatement, func(n cc.Node, entry bool) bool {
 				switch x := n.(type) {
 				case *cc.Declarator:
 					if !entry || !x.IsStatic() || x.Read == 0 || x.IsParameter {
 						break
 					}
 
 					nm := x.Name()
 					if s := p.task.staticLocalsPrefix; s != "" {
 						nm = cc.String(s + nm.String())
 					}
 					p.tlds[x] = &tld{name: p.scope.take(nm)}
 				}
 				return true
 			})
 		}
 	}
 	return nil
 }
 
 func (p *project) layoutStructs() error {
 	var t0 time.Time
 	if p.task.traceTranslationUnits {
 		fmt.Printf("processing struct/union types ... ")
 		t0 = time.Now()
 		defer func() { fmt.Println(time.Since(t0)) }()
 	}
 
 	export := doNotChange
 	if p.task.exportStructsValid {
 		switch {
 		case p.task.exportStructs != "":
 			export = exportPrefix
 		default:
 			export = exportCapitalize
 		}
 	} else if p.task.defaultUnExport {
 		export = doNotExport
 	}
 
 	m := map[cc.StringID]*taggedStruct{}
 	var tags []cc.StringID
 	for _, v := range p.task.asts {
 		cc.Inspect(v.TranslationUnit, func(n cc.Node, entry bool) bool {
 			if entry {
 				switch x := n.(type) {
 				case *cc.Declarator:
 					if nm := x.Name().String(); strings.HasPrefix(nm, "_") {
 						break
 					}
 
 					p.captureStructTags(x, x.Type(), m, &tags)
 				case *cc.Declaration:
 					cc.Inspect(x.DeclarationSpecifiers, func(nn cc.Node, entry bool) bool {
 						switch y := nn.(type) {
 						case *cc.StructOrUnionSpecifier:
 							if tag := y.Token.Value; tag != 0 {
 								p.captureStructTags(y, y.Type(), m, &tags)
 							}
 						}
 						return true
 					})
 				}
 			}
 			return true
 		})
 	}
 	sort.Slice(tags, func(i, j int) bool { return tags[i].String() < tags[j].String() })
 	for _, k := range tags {
 		v := m[k]
 		//TODO rename conflicts
 		if v.conflicts {
 			delete(m, k)
 			continue
 		}
 
 		name := k.String()
 		switch export {
 		case doNotExport:
 			name = unCapitalize(name)
 		case doNotChange:
 			// nop
 		case exportCapitalize:
 			name = capitalize(name)
 		case exportPrefix:
 			name = p.task.exportStructs + name
 		}
 		v.name = p.scope.take(cc.String(name))
 	}
 	for _, k := range tags {
 		v := m[k]
 		if v != nil {
 			v.gotyp = p.structType(nil, v.ctyp)
 		}
 	}
 	p.structs = m
 	return nil
 }
 
 func (p *project) captureStructTags(n cc.Node, t cc.Type, m map[cc.StringID]*taggedStruct, tags *[]cc.StringID) {
 	if t == nil {
 		return
 	}
 
 	t = t.Alias()
 	for t.Kind() == cc.Ptr {
 		t = t.Alias().Elem().Alias()
 	}
 	if t.Kind() == cc.Invalid || t.IsIncomplete() {
 		return
 	}
 
 	switch t.Kind() {
 	case cc.Struct, cc.Union:
 		tag := t.Tag()
 		if tag == 0 {
 			return
 		}
 
 		ex := m[tag]
 		if ex != nil {
 			ts := p.typeSignature(n, t)
 			exs := p.typeSignature(n, ex.ctyp)
 			if ts != exs {
 				ex.conflicts = true
 			}
 			return
 		}
 
 		nf := t.NumField()
 		m[tag] = &taggedStruct{ctyp: t, node: n}
 		for idx := []int{0}; idx[0] < nf; idx[0]++ {
 			p.captureStructTags(n, t.FieldByIndex(idx).Type(), m, tags)
 		}
 		*tags = append(*tags, tag)
 	case cc.Array:
 		p.captureStructTags(n, t.Elem(), m, tags)
 	}
 }
 
 func (p *project) typeSignature(n cc.Node, t cc.Type) (r uint64) {
 	p.typeSigHash.Reset()
 	p.typeSignature2(n, &p.typeSigHash, t)
 	return p.typeSigHash.Sum64()
 }
 
 func (p *project) typeSignature2(n cc.Node, b *maphash.Hash, t cc.Type) {
 	t = t.Alias()
 	if t.IsIntegerType() {
 		if !t.IsSignedType() {
 			b.WriteByte('u')
 		}
 		fmt.Fprintf(b, "int%d", t.Size()*8)
 		return
 	}
 
 	if t.IsArithmeticType() {
 		b.WriteString(t.Kind().String())
 		return
 	}
 
 	structOrUnion := "struct"
 	switch t.Kind() {
 	case cc.Ptr:
 		fmt.Fprintf(b, "*%s", t.Elem())
 	case cc.Array:
 		if t.IsVLA() {
 			// trc("VLA")
 			p.err(n, "variable length arrays not supported: %v", t)
 		}
 
 		fmt.Fprintf(b, "[%d]%s", t.Len(), t.Elem())
 	case cc.Vector:
 		fmt.Fprintf(b, "[%d]%s", t.Len(), t.Elem())
 	case cc.Union:
 		structOrUnion = "union"
 		fallthrough
 	case cc.Struct:
 		b.WriteString(structOrUnion)
 		nf := t.NumField()
 		fmt.Fprintf(b, " %d{", nf)
 		b.WriteByte('{')
 		for idx := []int{0}; idx[0] < nf; idx[0]++ {
 			f := t.FieldByIndex(idx)
 			fmt.Fprintf(b, "%s:%d:%d:%v:%d:%d:",
 				f.Name(), f.BitFieldOffset(), f.BitFieldWidth(), f.IsBitField(), f.Offset(), f.Padding(),
 			)
 			p.typeSignature2(f.Declarator(), b, f.Type())
 			b.WriteByte(';')
 		}
 		b.WriteByte('}')
 	case cc.Void:
 		b.WriteString("void")
 	case cc.Invalid:
 		b.WriteString("invalid") //TODO fix cc/v3
 	default:
 		panic(todo("", p.pos(n), t, t.Kind()))
 	}
 }
 
 func (p *project) structType(n cc.Node, t cc.Type) string {
 	switch t.Kind() {
 	case cc.Struct, cc.Union:
 		tag := t.Tag()
 		if tag != 0 && p.structs != nil {
 			s := p.structs[tag]
 			if s == nil {
 				return p.structLiteral(n, t)
 			}
 
 			if s.gotyp == "" {
 				s.gotyp = p.structLiteral(n, t)
 			}
 			return s.gotyp
 		}
 
 		return p.structLiteral(n, t)
 	default:
 		panic(todo("internal error: %v", t.Kind()))
 	}
 }
 
 func (p *project) padName(n *int) string {
 	if !p.task.exportFieldsValid {
 		return "_"
 	}
 
 	*n++
 	return fmt.Sprintf("%s__ccgo_pad%d", p.task.exportFields, *n)
 }
 
 func (p *project) structLiteral(n cc.Node, t cc.Type) string {
 	var npad int
 	b := bytesBufferPool.Get().(*bytes.Buffer)
 	defer func() { b.Reset(); bytesBufferPool.Put(b) }()
 	switch t.Kind() {
 	case cc.Struct:
 		info := cc.NewStructLayout(t)
 		// trc("%v: %q\n%s", p.pos(n), t.Tag(), info)
 		b.WriteString("struct {")
 		if info.NeedExplicitAlign {
 			fmt.Fprintf(b, "%s [0]uint%d;", p.padName(&npad), 8*p.align(n, t))
 		}
 		var max uintptr
 		for _, off := range info.Offsets {
 			flds := info.OffsetToFields[off]
 			if off < max {
 				var a []string
 				var nmf cc.Field
 				for _, f := range flds {
 					if f.Name() != 0 && nmf == nil {
 						nmf = f
 					}
 					if !f.IsBitField() {
 						panic(todo("internal error %q, off %v max %v\n%s", f.Name(), off, max, info))
 					}
 					a = append(a, fmt.Sprintf("%s %s: %d", f.Type(), f.Name(), f.BitFieldWidth()))
 				}
 				fmt.Fprintf(b, "/* %s */", strings.Join(a, ", "))
 				continue
 			}
 
 			f := flds[0]
 			switch pad := info.PaddingsBefore[f]; {
 			case pad < 0:
 				continue
 			case pad > 0:
 				fmt.Fprintf(b, "%s [%d]byte;", p.padName(&npad), pad)
 			}
 			switch {
 			case f.IsBitField():
 				max += uintptr(f.BitFieldBlockWidth()) >> 3
 				var a []string
 				var nmf cc.Field
 				for _, f := range flds {
 					if f.Name() != 0 && nmf == nil {
 						nmf = f
 					}
 					if !f.IsBitField() {
 						panic(todo("internal error %q\n%s", f.Name(), info))
 					}
 					a = append(a, fmt.Sprintf("%s %s: %d", f.Type(), f.Name(), f.BitFieldWidth()))
 				}
 				if nmf == nil {
 					nmf = f
 				}
 				fmt.Fprintf(b, "%s uint%d /* %s */;", p.bitFieldName(n, nmf), f.BitFieldBlockWidth(), strings.Join(a, ", "))
 			default:
 				ft := f.Type()
 				if ft.Kind() == cc.Array && ft.IsIncomplete() || ft.Size() == 0 {
 					break
 				}
 
 				max += ft.Size()
 				fmt.Fprintf(b, "%s %s;", p.fieldName2(n, f), p.typ(n, ft))
 			}
 		}
 		if info.PaddingAfter != 0 {
 			fmt.Fprintf(b, "%s [%d]byte;", p.padName(&npad), info.PaddingAfter)
 		}
 		b.WriteByte('}')
 	case cc.Union:
 		b.WriteString("struct {")
 		info := cc.NewStructLayout(t)
 		if info.NeedExplicitAlign {
 			fmt.Fprintf(b, "%s [0]uint%d;", p.padName(&npad), 8*p.align(n, t))
 		}
 		al := uintptr(t.Align())
 		sz := t.Size()
 		if al > sz {
 			panic(todo("", p.pos(n)))
 		}
 
 		f := t.FieldByIndex([]int{0})
 		ft := f.Type()
 		al0 := ft.Align()
 		if f.IsBitField() {
 			al0 = f.BitFieldBlockWidth() >> 3
 		}
 		if al != uintptr(al0) {
 			fmt.Fprintf(b, "%s [0]uint%d;", p.padName(&npad), 8*al)
 		}
 		fsz := ft.Size()
 		switch {
 		case f.IsBitField():
 			fmt.Fprintf(b, "%s ", p.fieldName2(n, f))
 			fmt.Fprintf(b, "uint%d;", f.BitFieldBlockWidth())
 			fsz = uintptr(f.BitFieldBlockWidth()) >> 3
 		default:
 			fmt.Fprintf(b, "%s %s;", p.fieldName2(n, f), p.typ(n, ft))
 		}
 		if pad := sz - fsz; pad != 0 {
 			fmt.Fprintf(b, "%s [%d]byte;", p.padName(&npad), pad)
 		}
 		b.WriteByte('}')
 	default:
 		panic(todo("internal error: %v", t.Kind()))
 	}
 	r := b.String()
 	if p.task.verifyStructs {
 		if _, ok := p.verifyStructs[r]; !ok {
 			p.verifyStructs[r] = t
 		}
 	}
 	return r
 }
 
 func (p *project) align(nd cc.Node, t cc.Type) int {
 	switch n := t.Align(); {
 	case n <= 1:
 		return 1
 	case n <= 2:
 		return 2
 	case n <= 4:
 		return 4
 	case n <= 8:
 		return 8
 	default:
 		if !p.task.ignoreUnsupportedAligment {
 			p.err(nd, "unsupported alignment of type %s: %v", t, n)
 		}
 		return 8
 	}
 }
 
 func (p *project) bitFieldName(n cc.Node, f cc.Field) string {
 	if id := f.Name(); id != 0 {
 		return p.fieldName(n, id)
 	}
 
 	return fmt.Sprintf("__%d", f.Offset())
 }
 
 func (p *project) fieldName2(n cc.Node, f cc.Field) string {
 	if f.Name() != 0 {
 		return p.fieldName(n, f.Name())
 	}
 
 	return p.fieldName(n, cc.String(fmt.Sprintf("__%d", f.Offset())))
 }
 
 func (p *project) fieldName(n cc.Node, id cc.StringID) string {
 	if id == 0 {
 		panic(todo("", p.pos(n)))
 	}
 
 	if !p.task.exportFieldsValid {
 		s := id.String()
 		if p.task.defaultUnExport {
 			s = unCapitalize(s)
 		}
 
 		if !reservedNames[s] {
 			return s
 		}
 
 		return "__" + s
 	}
 
 	if s := p.task.exportFields; s != "" {
 		return s + id.String()
 	}
 
 	return capitalize(id.String())
 }
 
 func (p *project) dtyp(d *cc.Declarator) (r string) {
 	t := d.Type()
 	if t.IsIncomplete() {
 		if t.Kind() == cc.Array && d.IsParameter {
 			return "uintptr"
 		}
 
 		panic(todo(""))
 	}
 
 	return p.typ(d, t)
 }
 
 func (p *project) typ(nd cc.Node, t cc.Type) (r string) {
 	if t.IsIncomplete() {
 		panic(todo("", p.pos(nd), t))
 	}
 
 	if t.IsAliasType() {
 		if tld := p.tlds[t.AliasDeclarator()]; tld != nil {
 			return tld.name
 		}
 	}
 
 	b := bytesBufferPool.Get().(*bytes.Buffer)
 	defer func() { b.Reset(); bytesBufferPool.Put(b) }()
 	if t.IsIntegerType() {
 		switch t.Kind() {
 		case cc.Int128:
 			fmt.Fprintf(b, "%sInt128", p.task.crt)
 			return b.String()
 		case cc.UInt128:
 			fmt.Fprintf(b, "%sUint128", p.task.crt)
 			return b.String()
 		}
 
 		if !t.IsSignedType() {
 			b.WriteByte('u')
 		}
 		if t.Size() > 8 {
 			p.err(nd, "unsupported C type: %v", t)
 		}
 		fmt.Fprintf(b, "int%d", 8*t.Size())
 		return b.String()
 	}
 
 	switch t.Kind() {
 	case cc.Ptr, cc.Function:
 		return "uintptr"
 	case cc.Double:
 		return "float64"
 	case cc.Float:
 		return "float32"
 	case cc.Array:
 		n := t.Len()
 		switch {
 		case t.IsVLA():
 			fmt.Fprintf(b, "uintptr")
 		default:
 			fmt.Fprintf(b, "[%d]%s", n, p.typ(nd, t.Elem()))
 		}
 		return b.String()
 	case cc.Vector:
 		n := t.Len()
 		fmt.Fprintf(b, "[%d]%s", n, p.typ(nd, t.Elem()))
 		return b.String()
 	case cc.Struct, cc.Union:
 		if tag := t.Tag(); tag != 0 {
 			if s := p.structs[tag]; s != nil {
 				if s.name == "" {
 					panic(todo("internal error %q", tag))
 				}
 
 				return s.name
 			}
 		}
 
 		return p.structType(nd, t)
 	}
 
 	panic(todo("", p.pos(nd), t.Kind(), t))
 }
 
 func isScalarKind(k cc.Kind) bool {
 	switch k {
 	case
 		cc.Char, cc.SChar, cc.UChar,
 		cc.Short, cc.UShort,
 		cc.Int, cc.UInt,
 		cc.Long, cc.ULong,
 		cc.LongLong, cc.ULongLong,
 		cc.Float, cc.Double,
 		cc.Ptr:
 
 		return true
 	}
 
 	return false
 }
 
 func (p *project) layoutTLDs() error {
 	var t0 time.Time
 	if p.task.traceTranslationUnits {
 		fmt.Printf("processing file scope declarations ... ")
 		t0 = time.Now()
 		defer func() { fmt.Println(time.Since(t0)) }()
 	}
 
 	exportExtern, exportTypedef := doNotChange, doNotChange
 	if p.task.exportExternsValid {
 		switch {
 		case p.task.exportExterns != "":
 			exportExtern = exportPrefix
 		default:
 			exportExtern = exportCapitalize
 		}
 	} else if p.task.defaultUnExport {
 		exportExtern = doNotExport
 	}
 
 	if p.task.exportTypedefsValid {
 		switch {
 		case p.task.exportTypedefs != "":
 			exportTypedef = exportPrefix
 		default:
 			exportTypedef = exportCapitalize
 		}
 	} else if p.task.defaultUnExport {
 		exportTypedef = doNotExport
 	}
 
 	var a []*cc.Declarator
 	if p.task.pkgName == "" || p.task.pkgName == "main" {
 	out:
 		for _, ast := range p.task.asts {
 			if a := ast.Scope[idMain]; len(a) != 0 {
 				switch x := a[0].(type) {
 				case *cc.Declarator:
 					if x.Linkage == cc.External {
 						p.isMain = true
 						p.scope.take(idMain)
 						break out
 					}
 				}
 			}
 		}
 	}
 	sharedFns := map[*cc.FunctionDefinition]struct{}{}
 	for _, ast := range p.task.asts {
 		a = a[:0]
 		for d := range ast.TLD {
 			if d.IsFunctionPrototype() {
 				continue
 			}
 
 			// https://gcc.gnu.org/onlinedocs/gcc/Inline.html
 			//
 			// If you specify both inline and extern in the function definition, then the
 			// definition is used only for inlining. In no case is the function compiled on
 			// its own, not even if you refer to its address explicitly. Such an address
 			// becomes an external reference, as if you had only declared the function, and
 			// had not defined it.
 			//
 			// This combination of inline and extern has almost the effect of a macro. The
 			// way to use it is to put a function definition in a header file with these
 			// keywords, and put another copy of the definition (lacking inline and extern)
 			// in a library file. The definition in the header file causes most calls to
 			// the function to be inlined. If any uses of the function remain, they refer
 			// to the single copy in the library.
 			if d.IsExtern() && d.Type().Inline() {
 				continue
 			}
 
 			if fn := d.FunctionDefinition(); fn != nil {
 				if _, ok := p.sharedFns[fn]; ok {
 					if _, ok := sharedFns[fn]; ok {
 						continue
 					}
 
 					sharedFns[fn] = struct{}{}
 				}
 			}
 
 			a = append(a, d)
 			p.wanted[d] = struct{}{}
 		}
 		sort.Slice(a, func(i, j int) bool {
 			return a[i].NameTok().Seq() < a[j].NameTok().Seq()
 		})
 		for _, d := range a {
 			switch d.Type().Kind() {
 			case cc.Struct, cc.Union:
 				p.checkAttributes(d.Type())
 			}
 			nm := d.Name()
 			name := nm.String()
 
 			switch d.Linkage {
 			case cc.External:
 				if ex := p.externs[nm]; ex != nil {
 					if _, ok := p.task.hide[name]; ok {
 						break
 					}
 
 					if d.Type().Kind() != cc.Function {
 						break
 					}
 
 					p.err(d, "redeclared: %s", d.Name())
 					break
 				}
 
 				isMain := p.isMain && nm == idMain
 				switch exportExtern {
 				case doNotExport:
 					name = unCapitalize(name)
 				case doNotChange:
 					// nop
 				case exportCapitalize:
 					name = capitalize(name)
 				case exportPrefix:
 					name = p.task.exportExterns + name
 				}
 				name = p.scope.take(cc.String(name))
 				if isMain {
 					p.mainName = name
 					d.Read++
 				}
 				tld := &tld{name: name}
 				p.externs[nm] = tld
 				for _, v := range ast.Scope[nm] {
 					if d, ok := v.(*cc.Declarator); ok {
 						p.tlds[d] = tld
 					}
 				}
 				if !isMain {
 					p.capi = append(p.capi, d.Name().String())
 				}
 			case cc.Internal:
 				if token.IsExported(name) && !p.isMain && p.task.exportExternsValid {
 					name = "s" + name
 				}
 				tld := &tld{name: p.scope.take(cc.String(name))}
 				for _, v := range ast.Scope[nm] {
 					if d, ok := v.(*cc.Declarator); ok {
 						p.tlds[d] = tld
 					}
 				}
 			case cc.None:
 				if d.IsTypedefName {
 					if d.Type().IsIncomplete() {
 						break
 					}
 
 					if exportTypedef == doNotChange && strings.HasPrefix(name, "__") {
 						break
 					}
 
 					ex, ok := p.typedefTypes[d.Name()]
 					if ok {
 						sig := p.typeSignature(d, d.Type())
 						if ex.sig == sig {
 							tld := ex.tld
 							for _, v := range ast.Scope[nm] {
 								if d, ok := v.(*cc.Declarator); ok {
 									p.tlds[d] = tld
 								}
 							}
 							break
 						}
 					}
 
 					switch exportTypedef {
 					case doNotExport:
 						name = unCapitalize(name)
 					case doNotChange:
 						// nop
 					case exportCapitalize:
 						name = capitalize(name)
 					case exportPrefix:
 						name = p.task.exportTypedefs + name
 					}
 
 					tld := &tld{name: p.scope.take(cc.String(name))}
 					p.typedefTypes[d.Name()] = &typedef{p.typeSignature(d, d.Type()), tld}
 					for _, v := range ast.Scope[nm] {
 						if d, ok := v.(*cc.Declarator); ok {
 							p.tlds[d] = tld
 						}
 					}
 				}
 			default:
 				panic(todo("", p.pos(d), nm, d.Linkage))
 			}
 		}
 	}
 	for _, ast := range p.task.asts {
 		for list := ast.TranslationUnit; list != nil; list = list.TranslationUnit {
 			decl := list.ExternalDeclaration
 			switch decl.Case {
 			case cc.ExternalDeclarationFuncDef: // FunctionDefinition
 				// ok
 			default:
 				continue
 			}
 
 			cc.Inspect(decl.FunctionDefinition.CompoundStatement, func(n cc.Node, entry bool) bool {
 				switch x := n.(type) {
 				case *cc.Declarator:
 					if x.IsFunctionPrototype() {
 						nm := x.Name()
 						if extern := p.externs[nm]; extern != nil {
 							break
 						}
 
 						tld := &tld{name: nm.String()}
 						for _, nd := range ast.Scope[nm] {
 							if d, ok := nd.(*cc.Declarator); ok {
 								p.tlds[d] = tld
 							}
 						}
 					}
 
 				}
 				return true
 			})
 		}
 	}
 	return nil
 }
 
 func (p *project) checkAttributes(t cc.Type) (r bool) {
 	r = true
 	for _, v := range t.Attributes() {
 		cc.Inspect(v, func(n cc.Node, entry bool) bool {
 			if !entry {
 				return true
 			}
 
 			switch x := n.(type) {
 			case *cc.AttributeValue:
 				if x.Token.Value != idAligned {
 					break
 				}
 
 				//TODO switch v := x.ExpressionList.AssignmentExpression.Operand.Value().(type) {
 				//TODO default:
 				//TODO 	panic(todo("%T(%v)", v, v))
 				//TODO }
 			}
 			return true
 		})
 	}
 	switch t.Kind() {
 	case cc.Struct, cc.Union:
 		for i := []int{0}; i[0] < t.NumField(); i[0]++ {
 			f := t.FieldByIndex(i)
 			if !p.checkAttributes(f.Type()) {
 				return false
 			}
 
 			sd := f.Declarator()
 			if sd == nil {
 				continue
 			}
 
 			cc.Inspect(sd.StructDeclaration().SpecifierQualifierList, func(n cc.Node, entry bool) bool {
 				if !entry {
 					return true
 				}
 
 				switch x := n.(type) {
 				case *cc.AttributeValue:
 					if x.Token.Value == idPacked {
 						p.err(sd, "unsupported attribute: packed")
 						r = false
 						return false
 					}
 
 					if x.Token.Value != idAligned {
 						break
 					}
 
 					switch v := x.ExpressionList.AssignmentExpression.Operand.Value().(type) {
 					case cc.Int64Value:
 						if int(v) != t.Align() {
 							p.err(sd, "unsupported attribute: alignment")
 							r = false
 							return false
 						}
 					default:
 						panic(todo("%T(%v)", v, v))
 					}
 				}
 				return true
 			})
 			if !r {
 				return false
 			}
 		}
 	}
 	return r
 }
 
 func unCapitalize(s string) string {
 	if strings.HasPrefix(s, "_") {
 		return s
 	}
 	a := []rune(s)
 	return strings.ToLower(string(a[0])) + string(a[1:])
 }
 
 func capitalize(s string) string {
 	if strings.HasPrefix(s, "_") {
 		s = "X" + s
 	}
 	a := []rune(s)
 	return strings.ToUpper(string(a[0])) + string(a[1:])
 }
 
 func (p *project) main() error {
 	targs := append([]string(nil), p.task.args...)
 	for i, v := range targs {
 		if v == "" {
 			targs[i] = `""`
 		}
 	}
 	p.o(`// Code generated by '%s %s', DO NOT EDIT.
 
 package %s
 
 `,
 		filepath.Base(p.task.args[0]),
 		strings.Join(targs[1:], " "),
 		p.task.pkgName,
 	)
 	if len(p.defineLines) != 0 {
 		p.w("\nconst (")
 		p.w("%s", strings.Join(p.defineLines, "\n"))
 		p.w("\n)\n\n")
 	}
 	var a []*enumSpec
 	for _, es := range p.enumSpecs {
 		if es.spec.LexicalScope().Parent() == nil && !es.emitted {
 			a = append(a, es)
 		}
 	}
 	sort.Slice(a, func(i, j int) bool {
 		return a[i].decl.Position().String() < a[j].decl.Position().String()
 	})
 	for _, es := range a {
 		es.emit(p)
 	}
 	for i, v := range p.task.asts {
 		var t0 time.Time
 		if p.task.traceTranslationUnits {
 			fmt.Printf("Go back end %v/%v: %s ... ", i+1, len(p.task.asts), filepath.Base(p.task.sources[i].Name))
 			t0 = time.Now()
 		}
 		p.oneAST(v)
 		if p.task.traceTranslationUnits {
 			fmt.Println(time.Since(t0))
 		}
 		p.task.asts[i] = nil
 		memGuard(i, p.task.isScripted)
 	}
 	sort.Slice(p.task.imported, func(i, j int) bool { return p.task.imported[i].path < p.task.imported[j].path })
 	p.o(`import (
 	"math"
 	"reflect"
 	"sync/atomic"
 	"unsafe"
 `)
 	if len(p.verifyStructs) != 0 {
 		p.o("\t\"fmt\"\n")
 	}
 	first := true
 	libc := false
 	for _, v := range p.task.imported {
 		if v.used {
 			if v.path == p.task.crtImportPath {
 				libc = true
 			}
 			if first {
 				p.o("\n")
 				first = false
 			}
 			p.o("\t%q\n", v.path)
 		}
 	}
 	if p.task.crtImportPath != "" {
 		if !libc {
 			p.o("\t%q\n", p.task.crtImportPath)
 		}
 		p.o("\t%q\n", p.task.crtImportPath+"/sys/types")
 	}
 	p.o(`)
 
 var _ = math.Pi
 var _ reflect.Kind
 var _ atomic.Value
 var _ unsafe.Pointer
 `)
 	if p.task.crtImportPath != "" {
 		if libc {
 			p.o("var _ *libc.TLS\n")
 		}
 		p.o("var _ types.Size_t\n")
 	}
 	if p.isMain {
 		p.o(`
 func main() { %sStart(%s) }`, p.task.crt, p.mainName)
 	}
 	p.flushStructs()
 	p.initPatches()
 	p.flushTS()
 	if !p.task.noCapi {
 		p.flushCAPI()
 	}
 	p.doVerifyStructs()
 	if err := p.Err(); err != nil {
 		return err
 	}
 
 	if _, err := p.buf.WriteTo(p.task.out); err != nil {
 		return err
 	}
 
 	return p.Err()
 }
 
 func (p *project) doVerifyStructs() {
 	if len(p.verifyStructs) == 0 {
 		return
 	}
 
 	var a []string
 	for k := range p.verifyStructs {
 		a = append(a, k)
 	}
 	sort.Strings(a)
 	p.w("\n\nfunc init() {")
 	n := 0
 	for _, k := range a {
 		t := p.verifyStructs[k]
 		p.w("\nvar v%d %s", n, k)
 		p.w("\nif g, e := unsafe.Sizeof(v%d), uintptr(%d); g != e { panic(fmt.Sprintf(`invalid struct/union size, got %%v, expected %%v`, g, e))}", n, t.Size())
 		nf := t.NumField()
 		for idx := []int{0}; idx[0] < nf; idx[0]++ {
 			f := t.FieldByIndex(idx)
 			if f.IsFlexible() {
 				break
 			}
 
 			if f.IsBitField() || f.Type().Size() == 0 {
 				continue
 			}
 
 			nm := p.fieldName2(f.Declarator(), f)
 			switch {
 			case t.Kind() == cc.Union:
 				if f.Offset() != 0 {
 					panic(todo(""))
 				}
 
 				if idx[0] != 0 {
 					break
 				}
 
 				fallthrough
 			default:
 				p.w("\nif g, e := unsafe.Offsetof(v%d.%s), uintptr(%d); g != e { panic(fmt.Sprintf(`invalid struct/union field offset, got %%v, expected %%v`, g, e))}", n, nm, f.Offset())
 				p.w("\nif g, e := unsafe.Sizeof(v%d.%s), uintptr(%d); g != e { panic(fmt.Sprintf(`invalid struct/union field size, got %%v, expected %%v`, g, e))}", n, nm, f.Type().Size())
 			}
 		}
 		n++
 	}
 	p.w("\n}\n")
 }
 
 func (p *project) flushCAPI() {
 	if p.isMain {
 		return
 	}
 
 	b := bytes.NewBuffer(nil)
 	fmt.Fprintf(b, `// Code generated by '%s %s', DO NOT EDIT.
 
 package %s
 
 `,
 		filepath.Base(p.task.args[0]),
 		strings.Join(p.task.args[1:], " "),
 		p.task.pkgName,
 	)
 	fmt.Fprintf(b, "\n\nvar CAPI = map[string]struct{}{")
 	sort.Strings(p.capi)
 	for _, nm := range p.capi {
 		fmt.Fprintf(b, "\n%q: {},", nm)
 	}
 	fmt.Fprintf(b, "\n}\n")
 	if err := ioutil.WriteFile(p.task.capif, b.Bytes(), 0644); err != nil {
 		p.err(nil, "%v", err)
 		return
 	}
 
 	if out, err := exec.Command("gofmt", "-r", "(x) -> x", "-l", "-s", "-w", p.task.capif).CombinedOutput(); err != nil {
 		p.err(nil, "%s: %v", out, err)
 	}
 
 	if out, err := exec.Command("gofmt", "-l", "-s", "-w", p.task.capif).CombinedOutput(); err != nil {
 		p.err(nil, "%s: %v", out, err)
 	}
 }
 
 func (p *project) initPatches() {
 	var tlds []*tld
 	for _, tld := range p.tlds {
 		if len(tld.patches) != 0 {
 			tlds = append(tlds, tld)
 		}
 	}
 	if len(tlds) == 0 {
 		return
 	}
 
 	sort.Slice(tlds, func(i, j int) bool { return tlds[i].name < tlds[j].name })
 	p.w("\n\nfunc init() {")
 	for _, tld := range tlds {
 		for _, patch := range tld.patches {
 			var fld string
 			if patch.fld != nil {
 				fld = fmt.Sprintf("/* .%s */", patch.fld.Name())
 			}
 			init := patch.init
 			expr := init.AssignmentExpression
 			d := expr.Declarator()
 			switch {
 			case d != nil && d.Type().Kind() == cc.Function:
 				p.w("\n*(*")
 				p.functionSignature(d, nil, d.Type(), "")
 				p.w(")(unsafe.Pointer(uintptr(unsafe.Pointer(&%s))+%d%s)) = ", tld.name, init.Offset, fld)
 				p.declarator(init, nil, d, d.Type(), exprFunc, 0)
 			default:
 				p.w("\n*(*%s)(unsafe.Pointer(uintptr(unsafe.Pointer(&%s))+%d%s)) = ", p.typ(init, patch.t), tld.name, init.Offset, fld)
 				p.assignmentExpression(nil, expr, patch.t, exprValue, 0)
 			}
 			p.w("// %s:", p.pos(init))
 		}
 	}
 	p.w("\n}\n")
 }
 
 func (p *project) Err() error {
 	if len(p.errors) == 0 {
 		return nil
 	}
 
 	var lpos token.Position
 	w := 0
 	for _, v := range p.errors {
 		if lpos.Filename != "" {
 			if v.Pos.Filename == lpos.Filename && v.Pos.Line == lpos.Line && !strings.HasPrefix(v.Msg, tooManyErrors) {
 				continue
 			}
 		}
 
 		p.errors[w] = v
 		w++
 		lpos = v.Pos
 	}
 	p.errors = p.errors[:w]
 	sort.Slice(p.errors, func(i, j int) bool {
 		a := p.errors[i]
 		if a.Msg == tooManyErrors {
 			return false
 		}
 
 		b := p.errors[j]
 		if b.Msg == tooManyErrors {
 			return true
 		}
 
 		if !a.Pos.IsValid() && b.Pos.IsValid() {
 			return true
 		}
 
 		if a.Pos.IsValid() && !b.Pos.IsValid() {
 			return false
 		}
 
 		if a.Pos.Filename < b.Pos.Filename {
 			return true
 		}
 
 		if a.Pos.Filename > b.Pos.Filename {
 			return false
 		}
 
 		if a.Pos.Line < b.Pos.Line {
 			return true
 		}
 
 		if a.Pos.Line > b.Pos.Line {
 			return false
 		}
 
 		return a.Pos.Column < b.Pos.Column
 	})
 	a := make([]string, 0, len(p.errors))
 	for _, v := range p.errors {
 		a = append(a, v.Error())
 	}
 	return fmt.Errorf("%s", strings.Join(a, "\n"))
 }
 
 func (p *project) flushTS() {
 	b := p.ts.Bytes()
 	if len(b) != 0 {
 		p.w("\n\n")
 		//TODO add cmd line option for this
 		//TODO s := strings.TrimSpace(hex.Dump(b))
 		//TODO a := strings.Split(s, "\n")
 		//TODO p.w("//  %s\n", strings.Join(a, "\n//  "))
 		p.w("var %s = %q\n", p.tsName, b)
 		p.w("var %s = (*reflect.StringHeader)(unsafe.Pointer(&%s)).Data\n", p.tsNameP, p.tsName)
 	}
 	if len(p.tsW) != 0 {
 		p.w("var %s = [...]%s{", p.tsWName, p.typ(nil, p.ast.WideCharType))
 		for _, v := range p.tsW {
 			p.w("%d, ", v)
 		}
 		p.w("}\n")
 		p.w("var %s = uintptr(unsafe.Pointer(&%s[0]))\n", p.tsWNameP, p.tsWName)
 	}
 }
 
 func (p *project) flushStructs() {
 	var a []*taggedStruct
 	for _, v := range p.structs {
 		if !v.emitted {
 			a = append(a, v)
 		}
 	}
 	sort.Slice(a, func(i, j int) bool { return a[i].name < a[j].name })
 	for _, v := range a {
 		v.emit(p, nil)
 	}
 }
 
 func (p *project) oneAST(ast *cc.AST) {
 	p.ast = ast
 	for list := ast.TranslationUnit; list != nil; list = list.TranslationUnit {
 		p.externalDeclaration(list.ExternalDeclaration)
 	}
 	p.w("%s", tidyCommentString(ast.TrailingSeperator.String()))
 }
 
 func (p *project) externalDeclaration(n *cc.ExternalDeclaration) {
 	switch n.Case {
 	case cc.ExternalDeclarationFuncDef: // FunctionDefinition
 		p.functionDefinition(n.FunctionDefinition)
 	case cc.ExternalDeclarationDecl: // Declaration
 		p.declaration(nil, n.Declaration, false)
 	case cc.ExternalDeclarationAsm: // AsmFunctionDefinition
 		// nop
 	case cc.ExternalDeclarationAsmStmt: // AsmStatement
 		panic(todo("", p.pos(n)))
 	case cc.ExternalDeclarationEmpty: // ';'
 		// nop
 	case cc.ExternalDeclarationPragma: // PragmaSTDC
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) declaration(f *function, n *cc.Declaration, topDecl bool) {
 	cc.Inspect(n.DeclarationSpecifiers, func(m cc.Node, entry bool) bool {
 		switch x := m.(type) {
 		case *cc.EnumSpecifier:
 			if f == nil {
 				p.enumSpecs[x].emit(p)
 			}
 		case *cc.StructOrUnionSpecifier:
 			if tag := x.Token.Value; tag != 0 {
 				switch {
 				case f == nil:
 					p.structs[tag].emit(p, n.DeclarationSpecifiers)
 				default:
 					p.localTaggedStructs = append(p.localTaggedStructs, func() {
 						p.structs[tag].emit(p, n.DeclarationSpecifiers)
 					})
 				}
 			}
 		}
 		return true
 	})
 
 	if n.InitDeclaratorList == nil {
 		return
 	}
 
 	// DeclarationSpecifiers InitDeclaratorList ';'
 	sep := tidyComment("\n", n) //TODO repeats
 	for list := n.InitDeclaratorList; list != nil; list = list.InitDeclaratorList {
 		p.initDeclarator(f, list.InitDeclarator, sep, topDecl)
 		sep = "\n"
 	}
 }
 
 func (p *project) initDeclarator(f *function, n *cc.InitDeclarator, sep string, topDecl bool) {
 	if f == nil {
 		p.tld(f, n, sep, false)
 		return
 	}
 
 	d := n.Declarator
 	if d.IsExtern() || d.IsTypedefName {
 		return
 	}
 
 	if tld := p.tlds[d]; tld != nil && !topDecl { // static local
 		if !p.pass1 {
 			p.staticQueue = append(p.staticQueue, n)
 		}
 		return
 	}
 
 	local := f.locals[d]
 	if local == nil { // Dead declaration.
 		return
 	}
 
 	block := f.block
 	t := d.Type()
 	vla := t.Kind() == cc.Array && t.IsVLA()
 	if vla && p.pass1 {
 		f.vlas[d] = struct{}{}
 		return
 	}
 
 	switch n.Case {
 	case cc.InitDeclaratorDecl: // Declarator AttributeSpecifierList
 		if block.noDecl || block.topDecl && !topDecl {
 			return
 		}
 
 		switch {
 		case vla:
 			p.initDeclaratorDeclVLA(f, n, sep)
 		default:
 			p.initDeclaratorDecl(f, n, sep)
 		}
 	case cc.InitDeclaratorInit: // Declarator AttributeSpecifierList '=' Initializer
 		if vla {
 			panic(todo(""))
 		}
 
 		if f.block.topDecl {
 			switch {
 			case topDecl:
 				p.initDeclaratorDecl(f, n, sep)
 				if local.forceRead && !local.isPinned {
 					p.w("_ = %s;", local.name)
 				}
 			default:
 				sv := f.condInitPrefix
 				f.condInitPrefix = func() {
 					p.declarator(d, f, d, d.Type(), exprLValue, 0)
 					p.w(" = ")
 				}
 				switch {
 				case p.isConditionalInitializer(n.Initializer):
 					p.assignmentExpression(f, n.Initializer.AssignmentExpression, d.Type(), exprCondInit, 0)
 				default:
 					f.condInitPrefix()
 					p.initializer(f, n.Initializer, d.Type(), d.StorageClass, nil)
 				}
 				f.condInitPrefix = sv
 				p.w(";")
 			}
 			return
 		}
 
 		p.w("%s", sep)
 		switch {
 		case local.isPinned:
 			sv := f.condInitPrefix
 			f.condInitPrefix = func() {
 				//TODO- p.declarator(d, f, d, d.Type(), exprLValue, 0)
 				//TODO- p.w(" = ")
 				p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */)) = ", p.typ(n, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
 			}
 			switch {
 			case p.isConditionalInitializer(n.Initializer):
 				p.assignmentExpression(f, n.Initializer.AssignmentExpression, d.Type(), exprCondInit, 0)
 			default:
 				f.condInitPrefix()
 				p.initializer(f, n.Initializer, d.Type(), d.StorageClass, nil)
 				p.w(";")
 			}
 			f.condInitPrefix = sv
 			p.w(";")
 		default:
 			var semi string
 			switch {
 			case block.noDecl:
 				semi = ""
 			default:
 				p.w("var %s ", local.name)
 				if !isAggregateTypeOrUnion(d.Type()) {
 					p.w("%s ", p.typ(n, d.Type()))
 				}
 				semi = ";"
 			}
 			switch {
 			case p.isConditionalInitializer(n.Initializer):
 				p.w("%s", semi)
 				sv := f.condInitPrefix
 				f.condInitPrefix = func() { p.w("%s = ", local.name) }
 				p.assignmentExpression(f, n.Initializer.AssignmentExpression, d.Type(), exprCondInit, 0)
 				f.condInitPrefix = sv
 			default:
 				if block.noDecl {
 					p.w("%s", local.name)
 				}
 				p.w(" = ")
 				p.initializer(f, n.Initializer, d.Type(), d.StorageClass, nil)
 			}
 			p.w(";")
 		}
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 	if !block.noDecl && local.forceRead && !local.isPinned {
 		p.w("_ = %s;", local.name)
 	}
 }
 
 func (p *project) isConditionalInitializer(n *cc.Initializer) bool {
 	return n.Case == cc.InitializerExpr && p.isConditionalAssignmentExpr(n.AssignmentExpression)
 }
 
 func (p *project) isConditionalAssignmentExpr(n *cc.AssignmentExpression) bool {
 	return n.Case == cc.AssignmentExpressionCond &&
 		n.ConditionalExpression.Case == cc.ConditionalExpressionCond
 }
 
 func (p *project) initDeclaratorDeclVLA(f *function, n *cc.InitDeclarator, sep string) {
 	d := n.Declarator
 	local := f.locals[d]
 	if strings.TrimSpace(sep) == "" {
 		sep = "\n"
 	}
 	if local.isPinned {
 		panic(todo(""))
 		p.w("%s// var %s %s at %s%s, %d\n", sep, local.name, p.typ(n, d.Type()), f.bpName, nonZeroUintptr(local.off), d.Type().Size())
 		return
 	}
 
 	p.w("%s%s = %sXrealloc(%s, %s, types.Size_t(", sep, local.name, p.task.crt, f.tlsName, local.name)
 	e := d.Type().LenExpr()
 	p.assignmentExpression(f, e, e.Operand.Type(), exprValue, 0)
 	if sz := d.Type().Elem().Size(); sz != 1 {
 		p.w("*%d", sz)
 	}
 	p.w("));")
 }
 
 func (p *project) initDeclaratorDecl(f *function, n *cc.InitDeclarator, sep string) {
 	d := n.Declarator
 	local := f.locals[d]
 	if strings.TrimSpace(sep) == "" {
 		sep = "\n"
 	}
 	if local.isPinned {
 		p.w("%s// var %s %s at %s%s, %d\n", sep, local.name, p.typ(n, d.Type()), f.bpName, nonZeroUintptr(local.off), d.Type().Size())
 		return
 	}
 
 	p.w("%svar %s %s;", sep, local.name, p.typ(n, d.Type()))
 }
 
 func (p *project) declarator(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprLValue:
 		p.declaratorLValue(n, f, d, t, mode, flags)
 	case exprFunc:
 		p.declaratorFunc(n, f, d, t, mode, flags)
 	case exprValue:
 		p.declaratorValue(n, f, d, t, mode, flags)
 	case exprAddrOf:
 		p.declaratorAddrOf(n, f, d, t, flags)
 	case exprSelect:
 		p.declaratorSelect(n, f, d)
 	case exprDecay:
 		p.declaratorDecay(n, f, d, t, mode, flags)
 	default:
 		panic(todo("", mode))
 	}
 }
 
 func (p *project) declaratorDecay(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	if d.Type().Kind() != cc.Array {
 		panic(todo("", n.Position(), p.pos(d)))
 	}
 
 	if f != nil {
 		if local := f.locals[d]; local != nil {
 			if d.Type().IsVLA() {
 				switch {
 				case local.isPinned:
 					panic(todo(""))
 				default:
 					p.w("%s", local.name)
 					return
 				}
 			}
 
 			if d.IsParameter {
 				p.w("%s", local.name)
 				return
 			}
 
 			if p.pass1 {
 				if !d.Type().IsVLA() {
 					f.pin(n, d)
 				}
 				return
 			}
 
 			if !local.isPinned {
 				p.err(n, "%v: %v: missed pinning", n.Position(), d.Position(), d.Name())
 			}
 			p.w("(%s%s)/* &%s[0] */", f.bpName, nonZeroUintptr(local.off), local.name)
 			return
 		}
 	}
 
 	if x := p.tlds[d]; x != nil && d.IsStatic() {
 		p.w("uintptr(unsafe.Pointer(&%s))", x.name)
 		return
 	}
 
 	switch x := p.symtab[d.Name().String()].(type) {
 	case *tld:
 		p.w("uintptr(unsafe.Pointer(&%s))", x.name)
 	case *imported:
 		x.used = true
 		p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
 	default:
 		panic(todo("%v: %v: %q %T", n.Position(), p.pos(d), d.Name(), x))
 	}
 }
 
 func (p *project) declaratorValue(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	switch k := p.declaratorKind(d); k {
 	case opNormal:
 		p.declaratorValueNormal(n, f, d, t, mode, flags)
 	case opArray:
 		p.declaratorValueArray(n, f, d, t, mode, flags)
 	case opFunction:
 		p.declarator(n, f, d, t, exprAddrOf, flags)
 	case opUnion:
 		p.declaratorValueUnion(n, f, d, t, mode, flags)
 	case opArrayParameter:
 		p.declaratorValueArrayParameter(n, f, d, t, mode, flags)
 	default:
 		panic(todo("", d.Position(), k))
 	}
 }
 
 func (p *project) declaratorValueArrayParameter(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	if d.Type().IsScalarType() {
 		defer p.w("%s", p.convertType(n, d.Type(), t, flags))
 	}
 	local := f.locals[d]
 	if local.isPinned {
 		p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(n, paramTypeDecay(d)), f.bpName, nonZeroUintptr(local.off), local.name)
 		return
 	}
 
 	p.w("%s", local.name)
 }
 
 func (p *project) declaratorValueUnion(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	if d.Type().IsScalarType() {
 		defer p.w("%s", p.convertType(n, d.Type(), t, flags))
 	}
 	if f != nil {
 		if local := f.locals[d]; local != nil {
 			if local.isPinned {
 				p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
 				return
 			}
 
 			p.w("%s", local.name)
 			return
 		}
 	}
 
 	p.declaratorDefault(n, d)
 }
 
 func (p *project) isVolatileOrAtomic(d *cc.Declarator) bool {
 	if d.Type().IsVolatile() || d.Type().IsAtomic() {
 		return true
 	}
 
 	_, ok := p.task.volatiles[d.Name()]
 	return ok
 }
 
 func (p *project) declaratorDefault(n cc.Node, d *cc.Declarator) {
 	if x := p.tlds[d]; x != nil && d.IsStatic() {
 		if p.isVolatileOrAtomic(d) {
 			p.atomicLoadNamedAddr(n, d.Type(), x.name)
 			return
 		}
 
 		p.w("%s", x.name)
 		return
 	}
 
 	switch x := p.symtab[d.Name().String()].(type) {
 	case *tld:
 		if p.isVolatileOrAtomic(d) {
 			p.atomicLoadNamedAddr(n, d.Type(), x.name)
 			return
 		}
 
 		p.w("%s", x.name)
 	case *imported:
 		x.used = true
 		if p.isVolatileOrAtomic(d) {
 			p.atomicLoadNamedAddr(n, d.Type(), fmt.Sprintf("%sX%s", x.qualifier, d.Name()))
 			return
 		}
 
 		p.w("%sX%s", x.qualifier, d.Name())
 	default:
 		if d.IsExtern() {
 			switch d.Name() {
 			case idEnviron:
 				if d.Type().String() == "pointer to pointer to char" {
 					p.w("%sEnviron()", p.task.crt)
 					return
 				}
 			}
 		}
 
 		if d.Linkage == cc.External && p.task.nostdlib {
 			p.w("X%s", d.Name())
 			return
 		}
 
 		id := fmt.Sprintf("__builtin_%s", d.Name())
 		switch x := p.symtab[id].(type) {
 		case *imported:
 			x.used = true
 			p.w("%sX%s", x.qualifier, d.Name())
 			return
 		}
 
 		if !d.IsImplicit() {
 			nm := d.Name()
 			name := nm.String()
 			switch d.Linkage {
 			case cc.External:
 				name = p.task.exportExterns + name
 				tld := &tld{name: name}
 				p.externs[nm] = tld
 				p.w("%s", name)
 				return
 			case cc.Internal:
 				if token.IsExported(name) {
 					name = "s" + name
 				}
 				tld := &tld{name: p.scope.take(cc.String(name))}
 				for _, v := range p.ast.Scope[nm] {
 					if d, ok := v.(*cc.Declarator); ok {
 						p.tlds[d] = tld
 					}
 				}
 				p.w("%s", name)
 				return
 			}
 		}
 
 		p.err(n, "back-end: undefined: %s", d.Name())
 	}
 }
 
 func (p *project) declaratorValueArray(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	if t.IsIntegerType() {
 		defer p.w("%s", p.convertType(n, nil, t, flags))
 	}
 	if f != nil {
 		if local := f.locals[d]; local != nil {
 			if local.isPinned {
 				p.w("(%s%s)/* %s */", f.bpName, nonZeroUintptr(local.off), local.name)
 				return
 			}
 
 			p.w("%s", local.name)
 			return
 		}
 	}
 
 	p.declaratorDefault(n, d)
 }
 
 func (p *project) declaratorValueNormal(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	if d.Type().IsScalarType() {
 		defer p.w("%s", p.convertType(n, d.Type(), t, flags))
 	}
 	if f != nil {
 		if local := f.locals[d]; local != nil {
 			if local.isPinned {
 				if p.isVolatileOrAtomic(d) && d.IsParameter && d.Write != 0 {
 					p.w("%sAtomicLoadP%s(%s%s/* %s */)", p.task.crt, p.helperType(n, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
 					return
 				}
 
 				p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
 				return
 			}
 
 			if p.isVolatileOrAtomic(d) && d.IsParameter && d.Write != 0 {
 				p.atomicLoadNamedAddr(n, d.Type(), local.name)
 				return
 			}
 
 			p.w("%s", local.name)
 			return
 		}
 	}
 
 	p.declaratorDefault(n, d)
 }
 
 func (p *project) declaratorFunc(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	switch k := p.declaratorKind(d); k {
 	case opFunction:
 		p.declaratorFuncFunc(n, f, d, t, exprValue, flags)
 	case opNormal:
 		p.declaratorFuncNormal(n, f, d, t, exprValue, flags)
 	default:
 		panic(todo("", d.Position(), k))
 	}
 }
 
 func (p *project) declaratorFuncNormal(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	u := d.Type()
 	if u.Kind() == cc.Ptr {
 		u = u.Elem()
 	}
 	switch u.Kind() {
 	case cc.Function:
 		if local := f.locals[d]; local != nil {
 			if local.isPinned {
 				p.w("(*(*")
 				p.functionSignature(n, f, u, "")
 				p.w(")(unsafe.Pointer(%s%s)))", f.bpName, nonZeroUintptr(local.off))
 				return
 			}
 
 			if d.IsParameter {
 				p.w("(*(*")
 				p.functionSignature(n, f, u, "")
 				p.w(")(unsafe.Pointer(&%s)))", local.name)
 				return
 			}
 
 			panic(todo("", p.pos(d)))
 		}
 
 		if x := p.tlds[d]; x != nil && d.IsStatic() {
 			p.w("(*(*")
 			p.functionSignature(n, f, u, "")
 			p.w(")(unsafe.Pointer(&%s)))", x.name)
 			return
 		}
 
 		switch x := p.symtab[d.Name().String()].(type) {
 		case *tld:
 			p.w("(*(*")
 			p.functionSignature(n, f, u, "")
 			p.w(")(unsafe.Pointer(&%s)))", x.name)
 		case *imported:
 			x.used = true
 			p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
 		default:
 			panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name()))
 		}
 	default:
 		panic(todo("", p.pos(d), u))
 	}
 }
 
 func (p *project) declaratorFuncFunc(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	switch d.Type().Kind() {
 	case cc.Function:
 		// ok
 	default:
 		panic(todo("", p.pos(d), d.Type(), d.Type().Kind()))
 	}
 
 	if f != nil {
 		if local := f.locals[d]; local != nil {
 			if local.isPinned {
 				panic(todo(""))
 			}
 
 			p.w(" %s", local.name)
 			return
 		}
 	}
 
 	p.declaratorDefault(n, d)
 }
 
 func (p *project) declaratorLValue(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	switch k := p.declaratorKind(d); k {
 	case opNormal, opArrayParameter, opUnion:
 		p.declaratorLValueNormal(n, f, d, t, mode, flags)
 	case opArray:
 		p.declaratorLValueArray(n, f, d, t, mode, flags)
 	default:
 		panic(todo("", d.Position(), k))
 	}
 }
 
 func (p *project) declaratorLValueArray(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	if f != nil {
 		if local := f.locals[d]; local != nil {
 			if local.isPinned {
 				p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
 				return
 			}
 
 			p.w("%s", local.name)
 			return
 		}
 	}
 
 	p.declaratorDefault(n, d)
 }
 
 func (p *project) declaratorLValueNormal(n cc.Node, f *function, d *cc.Declarator, t cc.Type, mode exprMode, flags flags) {
 	if p.isVolatileOrAtomic(d) {
 		panic(todo("", n.Position(), d.Position()))
 	}
 
 	if d.Type().IsScalarType() {
 		defer p.w("%s", p.convertType(n, d.Type(), t, flags))
 	}
 	if f != nil {
 		if local := f.locals[d]; local != nil {
 			if local.isPinned {
 				p.w("*(*%s)(unsafe.Pointer(%s%s/* %s */))", p.dtyp(d), f.bpName, nonZeroUintptr(local.off), local.name)
 				return
 			}
 
 			p.w("%s", local.name)
 			return
 		}
 	}
 
 	p.declaratorLValueDefault(n, d)
 }
 
 func (p *project) declaratorLValueDefault(n cc.Node, d *cc.Declarator) {
 	if x := p.tlds[d]; x != nil && d.IsStatic() {
 		p.w("%s", x.name)
 		return
 	}
 
 	switch x := p.symtab[d.Name().String()].(type) {
 	case *tld:
 		p.w("%s", x.name)
 	case *imported:
 		x.used = true
 		p.w("%sX%s", x.qualifier, d.Name())
 	default:
 		if d.IsExtern() {
 			switch d.Name() {
 			case idEnviron:
 				if d.Type().String() == "pointer to pointer to char" {
 					p.w("*(*uintptr)(unsafe.Pointer(%sEnvironP()))", p.task.crt)
 					return
 				}
 			}
 		}
 
 		panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name()))
 	}
 }
 
 func (p *project) declaratorKind(d *cc.Declarator) opKind {
 	switch {
 	case p.isArrayParameterDeclarator(d):
 		return opArrayParameter
 	case !p.pass1 && p.isArrayDeclarator(d):
 		return opArray
 	case d.Type().Kind() == cc.Function && !d.IsParameter:
 		return opFunction
 	case d.Type().Kind() == cc.Union:
 		return opUnion
 	default:
 		return opNormal
 	}
 }
 
 func (p *project) declaratorSelect(n cc.Node, f *function, d *cc.Declarator) {
 	switch k := p.declaratorKind(d); k {
 	case opNormal:
 		p.declaratorSelectNormal(n, f, d)
 	case opArray:
 		p.declaratorSelectArray(n, f, d)
 	default:
 		panic(todo("", d.Position(), k))
 	}
 }
 
 func (p *project) declaratorSelectArray(n cc.Node, f *function, d *cc.Declarator) {
 	if local := f.locals[d]; local != nil {
 		if local.isPinned {
 			panic(todo("", p.pos(n)))
 			//TODO type error
 			p.w("(*%s)(unsafe.Pointer(%s%s/* &%s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
 			return
 		}
 
 		p.w("%s", local.name)
 		return
 	}
 
 	p.declaratorDefault(n, d)
 }
 
 func (p *project) declaratorSelectNormal(n cc.Node, f *function, d *cc.Declarator) {
 	if local := f.locals[d]; local != nil {
 		if local.isPinned {
 			p.w("(*%s)(unsafe.Pointer(%s%s/* &%s */))", p.typ(d, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
 			return
 		}
 
 		p.w("%s", local.name)
 		return
 	}
 
 	p.declaratorDefault(n, d)
 }
 
 func (p *project) declaratorAddrOf(n cc.Node, f *function, d *cc.Declarator, t cc.Type, flags flags) {
 	switch k := p.declaratorKind(d); k {
 	case opArray:
 		p.declaratorAddrOfArray(n, f, d)
 	case opNormal:
 		p.declaratorAddrOfNormal(n, f, d, flags)
 	case opUnion:
 		p.declaratorAddrOfUnion(n, f, d)
 	case opFunction:
 		p.declaratorAddrOfFunction(n, f, d)
 	case opArrayParameter:
 		p.declaratorAddrOfArrayParameter(n, f, d)
 	default:
 		panic(todo("", d.Position(), k))
 	}
 }
 
 func (p *project) declaratorAddrOfArrayParameter(n cc.Node, f *function, d *cc.Declarator) {
 	if p.pass1 {
 		f.pin(n, d)
 		return
 	}
 
 	local := f.locals[d]
 	p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name)
 }
 
 func (p *project) declaratorAddrOfFunction(n cc.Node, f *function, d *cc.Declarator) {
 	if d.Type().Kind() != cc.Function {
 		panic(todo("", p.pos(n)))
 	}
 
 	if x := p.tlds[d]; x != nil && d.IsStatic() {
 		p.w("*(*uintptr)(unsafe.Pointer(&struct{f ")
 		p.functionSignature(n, f, d.Type(), "")
 		p.w("}{%s}))", x.name)
 		return
 	}
 
 	switch x := p.symtab[d.Name().String()].(type) {
 	case *tld:
 		p.w("*(*uintptr)(unsafe.Pointer(&struct{f ")
 		p.functionSignature(n, f, d.Type(), "")
 		p.w("}{%s}))", x.name)
 	case *imported:
 		x.used = true
 		p.w("*(*uintptr)(unsafe.Pointer(&struct{f ")
 		p.functionSignature(n, f, d.Type(), "")
 		p.w("}{%sX%s}))", x.qualifier, d.Name())
 	default:
 		p.err(d, "back-end: undefined: %s", d.Name())
 	}
 }
 
 func (p *project) declaratorAddrOfUnion(n cc.Node, f *function, d *cc.Declarator) {
 	if f != nil {
 		if local := f.locals[d]; local != nil {
 			if p.pass1 {
 				f.pin(n, d)
 				return
 			}
 
 			if local.isPinned {
 				p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name)
 				return
 			}
 
 			panic(todo("", p.pos(n)))
 		}
 	}
 
 	if x := p.tlds[d]; x != nil && d.IsStatic() {
 		p.w("uintptr(unsafe.Pointer(&%s))", x.name)
 		return
 	}
 
 	switch x := p.symtab[d.Name().String()].(type) {
 	case *tld:
 		p.w("uintptr(unsafe.Pointer(&%s))", x.name)
 	case *imported:
 		x.used = true
 		p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
 	default:
 		panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name()))
 	}
 }
 
 func (p *project) declaratorAddrOfNormal(n cc.Node, f *function, d *cc.Declarator, flags flags) {
 	if f != nil {
 		if local := f.locals[d]; local != nil {
 			if p.pass1 && flags&fAddrOfFuncPtrOk == 0 {
 				f.pin(n, d)
 				return
 			}
 
 			if local.isPinned {
 				p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name)
 				return
 			}
 
 			if flags&fAddrOfFuncPtrOk != 0 {
 				if dt := d.Type(); dt.Kind() == cc.Ptr {
 					if elem := dt.Elem(); elem.Kind() == cc.Function || elem.Kind() == cc.Ptr && elem.Elem().Kind() == cc.Function {
 						p.w("&%s", local.name)
 						return
 					}
 				}
 			}
 
 			panic(todo("", p.pos(n), p.pos(d), d.Name(), d.Type(), d.IsParameter, d.AddressTaken, flags&fAddrOfFuncPtrOk != 0))
 		}
 	}
 
 	if x := p.tlds[d]; x != nil && d.IsStatic() {
 		p.w("uintptr(unsafe.Pointer(&%s))", x.name)
 		return
 	}
 
 	switch x := p.symtab[d.Name().String()].(type) {
 	case *tld:
 		p.w("uintptr(unsafe.Pointer(&%s))", x.name)
 	case *imported:
 		x.used = true
 		p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
 	default:
 		p.err(n, "undefined: %s", d.Name())
 	}
 }
 
 func (p *project) declaratorAddrOfArray(n cc.Node, f *function, d *cc.Declarator) {
 	if f != nil {
 		if local := f.locals[d]; local != nil {
 			if p.pass1 {
 				f.pin(n, d)
 				return
 			}
 
 			if local.isPinned {
 				p.w("(%s%s)/* &%s */", f.bpName, nonZeroUintptr(local.off), local.name)
 				return
 			}
 
 			panic(todo("", p.pos(d), d.Name(), d.Type(), d.IsParameter))
 		}
 	}
 
 	if x := p.tlds[d]; x != nil && d.IsStatic() {
 		p.w("uintptr(unsafe.Pointer(&%s))", x.name)
 		return
 	}
 
 	switch x := p.symtab[d.Name().String()].(type) {
 	case *tld:
 		p.w("uintptr(unsafe.Pointer(&%s))", x.name)
 	case *imported:
 		x.used = true
 		p.w("uintptr(unsafe.Pointer(&%sX%s))", x.qualifier, d.Name())
 	default:
 		panic(todo("%v: %v: %q", n.Position(), p.pos(d), d.Name()))
 	}
 }
 
 func (p *project) convertType(n cc.Node, from, to cc.Type, flags flags) string {
 	// trc("%v: %v: %v -> %v %v", n.Position(), origin(1), from, to, flags) //TODO- DBG
 	if from != nil {
 		switch from.Kind() {
 		case cc.Int128:
 			return p.convertTypeFromInt128(n, to, flags)
 		case cc.UInt128:
 			return p.convertTypeFromUint128(n, to, flags)
 		}
 	}
 
 	switch to.Kind() {
 	case cc.Int128:
 		return p.convertTypeToInt128(n, from, flags)
 	case cc.UInt128:
 		return p.convertTypeToUint128(n, from, flags)
 	}
 
 	// trc("%v: %v -> %v\n%s", p.pos(n), from, to, debug.Stack()[:600]) //TODO-
 	force := flags&fForceConv != 0
 	if from == nil {
 		p.w("%s(", p.typ(n, to))
 		return ")"
 	}
 
 	if from.IsScalarType() {
 		switch {
 		case force:
 			p.w("%s(", p.helperType2(n, from, to))
 			return ")"
 		case from.Kind() == to.Kind():
 			return ""
 		default:
 			p.w("%s(", p.typ(n, to))
 			return ")"
 		}
 	}
 
 	switch from.Kind() {
 	case cc.Function, cc.Struct, cc.Union, cc.Ptr, cc.Array:
 		if from.Kind() == to.Kind() {
 			return ""
 		}
 
 		panic(todo("", n.Position(), from, to, from.Alias(), to.Alias()))
 	case cc.Double, cc.Float:
 		p.w("%s(", p.typ(n, to))
 		return ")"
 	}
 
 	panic(todo("", n.Position(), from, to, from.Alias(), to.Alias()))
 }
 
 func (p *project) convertTypeFromInt128(n cc.Node, to cc.Type, flags flags) string {
 	switch k := to.Kind(); {
 	case k == cc.Float, k == cc.Double:
 		p.w("(")
 		return fmt.Sprintf(").Float%d()", to.Size()*8)
 	case k == cc.Int128:
 		return ""
 	case k == cc.UInt128:
 		p.w("%sUint128FromInt128(", p.task.crt)
 		return ")"
 	case to.IsIntegerType() && to.IsSignedType():
 		p.w("int%d((", to.Size()*8)
 		return ").Lo)"
 	case to.IsIntegerType() && !to.IsSignedType():
 		p.w("uint%d((", to.Size()*8)
 		return ").Lo)"
 	default:
 		panic(todo("", n.Position(), to, to.Alias()))
 	}
 }
 
 func (p *project) convertTypeFromUint128(n cc.Node, to cc.Type, flags flags) string {
 	switch k := to.Kind(); {
 	case k == cc.Float, k == cc.Double:
 		p.w("(")
 		return fmt.Sprintf(").Float%d()", to.Size()*8)
 	case k == cc.Int128:
 		p.w("(")
 		return ").Int128()"
 	case k == cc.UInt128:
 		return ""
 	case to.IsIntegerType() && to.IsSignedType():
 		p.w("int%d((", to.Size()*8)
 		return ").Lo)"
 	case to.IsIntegerType() && !to.IsSignedType():
 		p.w("uint%d((", to.Size()*8)
 		return ").Lo)"
 	default:
 		panic(todo("", n.Position(), to, to.Alias()))
 	}
 }
 
 func (p *project) convertTypeToInt128(n cc.Node, from cc.Type, flags flags) string {
 	switch k := from.Kind(); {
 	case k == cc.Float, k == cc.Double:
 		p.w("%sInt128FromFloat%d(", p.task.crt, from.Size()*8)
 		return ")"
 	case k == cc.Int128:
 		return ""
 	case k == cc.UInt128:
 		p.w("%sInt128FromUint128(", p.task.crt)
 		return ")"
 	case from.IsIntegerType() && from.IsSignedType():
 		p.w("%sInt128FromInt%d(", p.task.crt, from.Size()*8)
 		return ")"
 	case from.IsIntegerType() && !from.IsSignedType():
 		p.w("%sInt128FromUint%d(", p.task.crt, from.Size()*8)
 		return ")"
 	default:
 		panic(todo("", n.Position(), from, from.Alias()))
 	}
 }
 
 func (p *project) convertTypeToUint128(n cc.Node, from cc.Type, flags flags) string {
 	switch k := from.Kind(); {
 	case k == cc.Float, k == cc.Double:
 		p.w("%sUint128FromFloat%d(", p.task.crt, from.Size()*8)
 		return ")"
 	case k == cc.Int128:
 		p.w("(")
 		return ").Uint128()"
 	case k == cc.UInt128:
 		return ""
 	case from.IsIntegerType() && from.IsSignedType():
 		p.w("%sUint128FromInt%d(", p.task.crt, from.Size()*8)
 		return ")"
 	case from.IsIntegerType() && !from.IsSignedType():
 		p.w("%sUint128FromUint%d(", p.task.crt, from.Size()*8)
 		return ")"
 	default:
 		panic(todo("", n.Position(), from, from.Alias()))
 	}
 }
 
 func (p *project) convertFromInt128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string {
 	switch k := to.Kind(); {
 	case k == cc.Float, k == cc.Double:
 		p.w("(")
 		return fmt.Sprintf(").Float%d()", to.Size()*8)
 	case k == cc.Int128:
 		return ""
 	case k == cc.UInt128:
 		p.w("(")
 		return ").Uint128()"
 	case to.IsIntegerType() && to.IsSignedType():
 		p.w("%sInt%d(", p.task.crt, to.Size()*8)
 		return ")"
 	case to.IsIntegerType() && !to.IsSignedType():
 		p.w("%sUint%d(", p.task.crt, to.Size()*8)
 		return ")"
 	default:
 		panic(todo("", n.Position(), to, to.Alias()))
 	}
 }
 
 func (p *project) convertFromUint128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string {
 	switch k := to.Kind(); {
 	case k == cc.Float, k == cc.Double:
 		p.w("%sUint128FromFloat%d(", p.task.crt, to.Size()*8)
 		return ")"
 	case k == cc.Int128:
 		p.w("(")
 		return ").Int128()"
 	case k == cc.UInt128:
 		return ""
 	case to.IsIntegerType() && to.IsSignedType():
 		p.w("%sInt%d(", p.task.crt, to.Size()*8)
 		return ")"
 	case to.IsIntegerType() && !to.IsSignedType():
 		p.w("%sUint%d(", p.task.crt, to.Size()*8)
 		return ")"
 	default:
 		panic(todo("", n.Position(), to, to.Alias()))
 	}
 }
 
 func (p *project) convertToInt128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string {
 	from := op.Type()
 	switch k := from.Kind(); {
 	case k == cc.Float, k == cc.Double:
 		p.w("%sInt128FromFloat%d(", p.task.crt, from.Size()*8)
 		return ")"
 	case k == cc.Int128:
 		return ""
 	case k == cc.UInt128:
 		p.w("(")
 		return ").Int128()"
 	case from.IsIntegerType() && from.IsSignedType():
 		p.w("%sInt128FromInt%d(", p.task.crt, from.Size()*8)
 		return ")"
 	case from.IsIntegerType() && !from.IsSignedType():
 		p.w("%sInt128FromUint%d(", p.task.crt, from.Size()*8)
 		return ")"
 	default:
 		panic(todo("", n.Position(), from, from.Alias()))
 	}
 }
 
 func (p *project) convertToUint128(n cc.Node, op cc.Operand, to cc.Type, flags flags) string {
 	from := op.Type()
 	switch k := from.Kind(); {
 	case k == cc.Float, k == cc.Double:
 		p.w("%sUint128FromFloat%d(", p.task.crt, from.Size()*8)
 		return ")"
 	case k == cc.Int128:
 		p.w("(")
 		return ").Uint128()"
 	case k == cc.UInt128:
 		return ""
 	case from.IsIntegerType() && from.IsSignedType():
 		p.w("%sUint128FromInt%d(", p.task.crt, from.Size()*8)
 		return ")"
 	case from.IsIntegerType() && !from.IsSignedType():
 		p.w("%sUint128FromUint%d(", p.task.crt, from.Size()*8)
 		return ")"
 	default:
 		panic(todo("", n.Position(), from, from.Alias()))
 	}
 }
 
 func (p *project) convertNil(n cc.Node, to cc.Type, flags flags) string {
 	switch to.Kind() {
 	case cc.Int128:
 		panic(todo("", p.pos(n)))
 	case cc.UInt128:
 		panic(todo("", p.pos(n)))
 	}
 
 	p.w("%s(", p.typ(n, to))
 	return ")"
 }
 
 func (p *project) convert(n cc.Node, op cc.Operand, to cc.Type, flags flags) string {
 	if op == nil {
 		panic(todo("internal error"))
 	}
 
 	from := op.Type()
 	switch from.Kind() {
 	case cc.Int128:
 		return p.convertFromInt128(n, op, to, flags)
 	case cc.UInt128:
 		return p.convertFromUint128(n, op, to, flags)
 	}
 	switch to.Kind() {
 	case cc.Int128:
 		return p.convertToInt128(n, op, to, flags)
 	case cc.UInt128:
 		return p.convertToUint128(n, op, to, flags)
 	}
 
 	if flags&fForceRuntimeConv != 0 {
 		flags |= fForceConv
 	}
 	force := flags&fForceConv != 0
 	if !force && from.IsScalarType() && from.Kind() == to.Kind() {
 		return ""
 	}
 
 	if from.IsIntegerType() {
 		return p.convertInt(n, op, to, flags)
 	}
 
 	if from == to {
 		return ""
 	}
 
 	switch from.Kind() {
 	case cc.Ptr:
 		if !force && from.Kind() == to.Kind() {
 			return ""
 		}
 
 		if to.IsIntegerType() {
 			p.w("%s(", p.typ(n, to))
 			return ")"
 		}
 
 		if to.Kind() == cc.Ptr {
 			return ""
 		}
 
 		panic(todo("%v: force %v, %q %v -> %q %v", p.pos(n), force, from, from.Kind(), to, to.Kind()))
 	case cc.Function, cc.Struct, cc.Union:
 		if !force && from.Kind() == to.Kind() {
 			return ""
 		}
 
 		trc("%p %p", from, to)
 		panic(todo("%q %v -> %q %v", from, from.Kind(), to, to.Kind()))
 	case cc.Double, cc.Float:
 		switch {
 		case to.IsIntegerType():
 			p.w("%s(", p.helperType2(n, from, to))
 			return ")"
 		default:
 			p.w("%s(", p.typ(n, to))
 			return ")"
 		}
 	case cc.Array:
 		if from.Kind() == to.Kind() {
 			return ""
 		}
 
 		switch to.Kind() {
 		case cc.Ptr:
 			return ""
 		}
 
 		panic(todo("%q, %v -> %q, %v", from, from.Kind(), to.Kind()))
 	}
 
 	panic(todo("%q -> %q", from, to))
 }
 
 func (p *project) convertInt(n cc.Node, op cc.Operand, to cc.Type, flags flags) string {
 	from := op.Type()
 	switch from.Kind() {
 	case cc.Int128:
 		panic(todo("", p.pos(n)))
 	case cc.UInt128:
 		panic(todo("", p.pos(n)))
 	}
 	switch to.Kind() {
 	case cc.Int128:
 		panic(todo("", p.pos(n)))
 	case cc.UInt128:
 		panic(todo("", p.pos(n)))
 	}
 
 	force := flags&fForceConv != 0
 	value := op.Value()
 	if value == nil || !to.IsIntegerType() {
 		if to.IsScalarType() {
 			p.w("%s(", p.typ(n, to))
 			return ")"
 		}
 
 		panic(todo("", op.Type(), to))
 	}
 
 	if flags&fForceRuntimeConv != 0 {
 		p.w("%s(", p.helperType2(n, op.Type(), to))
 		return ")"
 	}
 
 	switch {
 	case from.IsSignedType():
 		switch {
 		case to.IsSignedType():
 			switch x := value.(type) {
 			case cc.Int64Value:
 				switch to.Size() {
 				case 1:
 					if x >= math.MinInt8 && x <= math.MaxInt8 {
 						switch {
 						case !force && from.Size() == to.Size():
 							return ""
 						default:
 							p.w("int8(")
 							return ")"
 						}
 					}
 
 					p.w("%sInt8FromInt%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 2:
 					if x >= math.MinInt16 && x <= math.MaxInt16 {
 						switch {
 						case !force && from.Size() == to.Size():
 							return ""
 						default:
 							p.w("int16(")
 							return ")"
 						}
 					}
 
 					p.w("%sInt16FromInt%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 4:
 					if x >= math.MinInt32 && x <= math.MaxInt32 {
 						switch {
 						case !force && from.Size() == to.Size():
 							return ""
 						default:
 							p.w("int32(")
 							return ")"
 						}
 					}
 
 					p.w("%sInt32FromInt%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 8:
 					switch {
 					case !force && from.Size() == to.Size():
 						return ""
 					default:
 						p.w("int64(")
 						return ")"
 					}
 				default:
 					panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to))
 				}
 			default:
 				panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to))
 			}
 		default: // to is unsigned
 			switch x := value.(type) {
 			case cc.Int64Value:
 				switch to.Size() {
 				case 1:
 					if x >= 0 && x <= math.MaxUint8 {
 						p.w("%s(", p.typ(n, to))
 						return ")"
 					}
 
 					p.w("%sUint8FromInt%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 2:
 					if x >= 0 && x <= math.MaxUint16 {
 						p.w("%s(", p.typ(n, to))
 						return ")"
 					}
 
 					p.w("%sUint16FromInt%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 4:
 					if x >= 0 && x <= math.MaxUint32 {
 						p.w("%s(", p.typ(n, to))
 						return ")"
 					}
 
 					p.w("%sUint32FromInt%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 8:
 					if x >= 0 {
 						p.w("uint64(")
 						return ")"
 					}
 
 					p.w("%sUint64FromInt%d(", p.task.crt, from.Size()*8)
 					return ")"
 				default:
 					panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to))
 				}
 			case cc.Uint64Value:
 				switch to.Size() {
 				case 1:
 					if x <= math.MaxUint8 {
 						p.w("%s(", p.typ(n, to))
 						return ")"
 					}
 
 					p.w("%sUint8FromUint%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 2:
 					if x <= math.MaxUint16 {
 						p.w("%s(", p.typ(n, to))
 						return ")"
 					}
 
 					p.w("%sUint16FromUint%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 4:
 					if x <= math.MaxUint32 {
 						p.w("%s(", p.typ(n, to))
 						return ")"
 					}
 
 					p.w("%sUint32FromUint%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 8:
 					p.w("uint64(")
 					return ")"
 				default:
 					panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to))
 				}
 			default:
 				panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to))
 			}
 		}
 	default: // from is unsigned
 		switch {
 		case to.IsSignedType():
 			switch x := value.(type) {
 			case cc.Uint64Value:
 				switch to.Size() {
 				case 1:
 					if x <= math.MaxInt8 {
 						p.w("int8(")
 						return ")"
 					}
 
 					p.w("%sInt8FromUint%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 2:
 					if x <= math.MaxInt16 {
 						p.w("int16(")
 						return ")"
 					}
 
 					p.w("%sInt16FromUint%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 4:
 					if x <= math.MaxInt32 {
 						p.w("int32(")
 						return ")"
 					}
 
 					p.w("%sInt32FromUint%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 8:
 					if x <= math.MaxInt64 {
 						p.w("int64(")
 						return ")"
 					}
 
 					p.w("%sInt64FromUint%d(", p.task.crt, from.Size()*8)
 					return ")"
 				default:
 					panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to))
 				}
 			default:
 				panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to))
 			}
 		default: // to is unsigned
 			switch x := value.(type) {
 			case cc.Uint64Value:
 				switch to.Size() {
 				case 1:
 					if x <= math.MaxUint8 {
 						switch {
 						case !force && from.Size() == 1:
 							return ""
 						default:
 							p.w("uint8(")
 							return ")"
 						}
 					}
 
 					p.w("%sUint8FromUint%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 2:
 					if x <= math.MaxUint16 {
 						switch {
 						case !force && from.Size() == 2:
 							return ""
 						default:
 							p.w("uint16(")
 							return ")"
 						}
 					}
 
 					p.w("%sUint16FromUint%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 4:
 					if x <= math.MaxUint32 {
 						switch {
 						case !force && from.Size() == 4:
 							return ""
 						default:
 							p.w("uint32(")
 							return ")"
 						}
 					}
 
 					p.w("%sUint32FromUint%d(", p.task.crt, from.Size()*8)
 					return ")"
 				case 8:
 					switch {
 					case !force && from.Size() == 8:
 						return ""
 					default:
 						p.w("uint64(")
 						return ")"
 					}
 				default:
 					panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to))
 				}
 			default:
 				panic(todo("%T(%v) %v -> %v", x, op.Value(), from, to))
 			}
 		}
 	}
 }
 
 func nonZeroUintptr(n uintptr) string {
 	if n == 0 {
 		return ""
 	}
 
 	return fmt.Sprintf("%+d", n)
 }
 
 func alias(attr []*cc.AttributeSpecifier) (r cc.StringID) {
 	for _, v := range attr {
 		cc.Inspect(v, func(n cc.Node, entry bool) bool {
 			if !entry {
 				return true
 			}
 
 			if x, ok := n.(*cc.AttributeValue); ok && x.Token.Value == idAlias {
 				switch y := x.ExpressionList.AssignmentExpression.Operand.Value().(type) {
 				case cc.StringValue:
 					r = cc.StringID(y)
 					return false
 				}
 			}
 			return true
 		})
 		if r != 0 {
 			return r
 		}
 	}
 	return 0
 }
 
 func (p *project) tld(f *function, n *cc.InitDeclarator, sep string, staticLocal bool) {
 	d := n.Declarator
 	if d.IsExtern() && d.Linkage == cc.External && !d.IsTypedefName {
 		if alias := alias(attrs(d.Type())); alias != 0 {
 			p.capi = append(p.capi, d.Name().String())
 			p.w("\n\nvar %s%s = %s\t// %v:\n", p.task.exportExterns, d.Name(), p.externs[alias].name, p.pos(d))
 			return
 		}
 	}
 
 	if _, ok := p.wanted[d]; !ok && !staticLocal {
 		isFn := d.Type().Kind() == cc.Function
 		if isFn && p.task.header && p.task.funcSig {
 			if nm := d.Name().String(); !strings.HasPrefix(nm, "__") {
 				p.w("\n\n")
 				t := p.tlds[d]
 				if t == nil {
 					t = &tld{}
 					t.name = p.tldScope.take(d.Name())
 				}
 				p.functionSignature2(n, nil, d.Type(), t.name)
 			}
 		}
 		return
 	}
 
 	tld := p.tlds[d]
 	if tld == nil { // Dead declaration.
 		return
 	}
 
 	t := d.Type()
 	if d.IsTypedefName {
 		p.checkAttributes(t)
 		if _, ok := p.typedefsEmited[tld.name]; ok {
 			return
 		}
 
 		p.typedefsEmited[tld.name] = struct{}{}
 		if t.Kind() != cc.Void {
 			p.w("%stype %s = %s; /* %v */", sep, tld.name, p.typ(n, t), p.pos(d))
 		}
 		return
 	}
 
 	switch n.Case {
 	case cc.InitDeclaratorDecl: // Declarator AttributeSpecifierList
 		p.w("%svar %s %s\t/* %v: */", sep, tld.name, p.typ(n, t), p.pos(n))
 		switch t.Kind() {
 		case cc.Struct, cc.Union:
 			p.structs[t.Tag()].emit(p, nil)
 		}
 	case cc.InitDeclaratorInit: // Declarator AttributeSpecifierList '=' Initializer
 		if d.IsStatic() && d.Read == 0 && d.Write == 1 && n.Initializer.IsConst() { // Initialized with no side effects and unused.
 			break
 		}
 
 		p.w("%svar %s ", sep, tld.name)
 		if !isAggregateTypeOrUnion(d.Type()) {
 			p.w("%s ", p.typ(n, d.Type()))
 		}
 		p.w("= ")
 		p.initializer(f, n.Initializer, d.Type(), d.StorageClass, tld)
 		p.w("; /* %v */", p.pos(d))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) functionDefinition(n *cc.FunctionDefinition) {
 	// DeclarationSpecifiers Declarator DeclarationList CompoundStatement
 	if p.task.header && !p.task.funcSig {
 		return
 	}
 
 	if _, ok := p.sharedFns[n]; ok {
 		if _, ok := p.sharedFnsEmitted[n]; ok {
 			return
 		}
 
 		p.sharedFnsEmitted[n] = struct{}{}
 	}
 
 	d := n.Declarator
 	if d.IsExtern() && d.Type().Inline() {
 		// https://gcc.gnu.org/onlinedocs/gcc/Inline.html
 		//
 		// If you specify both inline and extern in the function definition, then the
 		// definition is used only for inlining. In no case is the function compiled on
 		// its own, not even if you refer to its address explicitly. Such an address
 		// becomes an external reference, as if you had only declared the function, and
 		// had not defined it.
 		//
 		// This combination of inline and extern has almost the effect of a macro. The
 		// way to use it is to put a function definition in a header file with these
 		// keywords, and put another copy of the definition (lacking inline and extern)
 		// in a library file. The definition in the header file causes most calls to
 		// the function to be inlined. If any uses of the function remain, they refer
 		// to the single copy in the library.
 		return
 	}
 
 	name := d.Name().String()
 	if _, ok := p.task.hide[name]; ok {
 		return
 	}
 
 	if p.isMain && d.Linkage == cc.External && d.Read == 0 && !d.AddressTaken && len(p.task.asts) == 1 {
 		return
 	}
 
 	if d.Linkage == cc.Internal && d.Read == 0 && !d.AddressTaken /*TODO- && strings.HasPrefix(name, "__") */ {
 		return
 	}
 
 	tld := p.tlds[d]
 	if tld == nil {
 		return
 	}
 
 	p.fn = name
 
 	defer func() { p.fn = "" }()
 
 	f := newFunction(p, n)
 	p.pass1 = true
 	p.compoundStatement(f, n.CompoundStatement, "", false, false, 0)
 	p.pass1 = false
 	p.w("\n\n")
 	p.functionDefinitionSignature(n, f, tld)
 	if p.task.header && p.task.funcSig {
 		return
 	}
 
 	p.w(" ")
 	comment := fmt.Sprintf("/* %v: */", p.pos(d))
 	if p.task.panicStubs {
 		p.w("%s{ panic(%q) }", comment, tld.name)
 		return
 	}
 
 	brace := "{"
 	if need := f.off; need != 0 {
 		scope := f.blocks[n.CompoundStatement].scope
 		f.bpName = scope.take(idBp)
 		p.w("{%s\n%s := %s.Alloc(%d)\n", comment, f.bpName, f.tlsName, need)
 		p.w("defer %s.Free(%d)\n", f.tlsName, need)
 		for _, v := range d.Type().Parameters() {
 			if local := f.locals[v.Declarator()]; local != nil && local.isPinned { // Pin it.
 				p.w("*(*%s)(unsafe.Pointer(%s%s)) = %s\n", p.typ(v.Declarator(), paramTypeDecay(v.Declarator())), f.bpName, nonZeroUintptr(local.off), local.name)
 			}
 		}
 		comment = ""
 		brace = ""
 	}
 	if len(f.vlas) != 0 {
 		p.w("%s%s\n", brace, comment)
 		var vlas []*cc.Declarator
 		for k := range f.vlas {
 			vlas = append(vlas, k)
 		}
 		sort.Slice(vlas, func(i, j int) bool {
 			return vlas[i].NameTok().Seq() < vlas[j].NameTok().Seq()
 		})
 		for _, v := range vlas {
 			local := f.locals[v]
 			switch {
 			case local.isPinned:
 				panic(todo("", v.Position()))
 			default:
 				p.w("var %s uintptr // %v: %v\n", local.name, p.pos(v), v.Type())
 			}
 		}
 		switch {
 		case len(vlas) == 1:
 			p.w("defer %sXfree(%s, %s)\n", p.task.crt, f.tlsName, f.locals[vlas[0]].name)
 		default:
 			p.w("defer func() {\n")
 			for _, v := range vlas {
 				p.w("%sXfree(%s, %s)\n", p.task.crt, f.tlsName, f.locals[v].name)
 			}
 			p.w("\n}()\n")
 		}
 	}
 	p.compoundStatement(f, n.CompoundStatement, comment, false, true, 0)
 	p.w(";")
 	p.flushLocalTaggesStructs()
 	p.flushStaticTLDs()
 }
 
 func (p *project) flushLocalTaggesStructs() {
 	for _, v := range p.localTaggedStructs {
 		v()
 	}
 	p.localTaggedStructs = nil
 }
 
 func (p *project) flushStaticTLDs() {
 	for _, v := range p.staticQueue {
 		p.tld(nil, v, "\n", true)
 	}
 	p.staticQueue = nil
 }
 
 func (p *project) compoundStatement(f *function, n *cc.CompoundStatement, scomment string, forceNoBraces, fnBody bool, mode exprMode) {
 	if p.task.panicStubs {
 		return
 	}
 
 	// '{' BlockItemList '}'
 	brace := (!n.IsJumpTarget() || n.Parent() == nil) && !forceNoBraces
 	if brace && len(f.vlas) == 0 && (n.Parent() != nil || f.off == 0) {
 		p.w("{%s", scomment)
 	}
 	if fnBody {
 		p.instrument(n)
 	}
 	sv := f.block
 	f.block = f.blocks[n]
 	if f.block.topDecl {
 		for _, v := range f.block.decls {
 			p.declaration(f, v, true)
 		}
 	}
 	var r *cc.JumpStatement
 	for list := n.BlockItemList; list != nil; list = list.BlockItemList {
 		m := mode
 		if list.BlockItemList != nil {
 			m = 0
 		}
 		r = p.blockItem(f, list.BlockItem, m)
 	}
 	if n.Parent() == nil && r == nil && f.rt.Kind() != cc.Void {
 		p.w("\nreturn ")
 		p.zeroValue(n, f.rt)
 	}
 	s := tidyComment("\n", &n.Token2)
 	p.w("%s", s)
 	if brace {
 		if !strings.HasSuffix(s, "\n") {
 			p.w("\n")
 		}
 		p.w("}")
 	}
 	f.block = sv
 }
 
 func (p *project) zeroValue(n cc.Node, t cc.Type) {
 	if t.IsScalarType() {
 		p.w("%s(0)", p.typ(n, t))
 		return
 	}
 
 	switch t.Kind() {
 	case cc.Struct, cc.Union:
 		p.w("%s{}", p.typ(n, t))
 	default:
 		panic(todo("", t, t.Kind()))
 	}
 }
 
 func (p *project) blockItem(f *function, n *cc.BlockItem, mode exprMode) (r *cc.JumpStatement) {
 	switch n.Case {
 	case cc.BlockItemDecl: // Declaration
 		p.declaration(f, n.Declaration, false)
 	case cc.BlockItemStmt: // Statement
 		r = p.statement(f, n.Statement, false, false, false, mode)
 		p.w(";")
 		if r == nil {
 			p.instrument(n)
 		}
 	case cc.BlockItemLabel: // LabelDeclaration
 		panic(todo("", p.pos(n)))
 		p.w(";")
 	case cc.BlockItemFuncDef: // DeclarationSpecifiers Declarator CompoundStatement
 		p.err(n, "nested functions not supported")
 		p.w(";")
 	case cc.BlockItemPragma: // PragmaSTDC
 		panic(todo("", p.pos(n)))
 		p.w(";")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 	return r
 }
 
 func (p *project) instrument(n cc.Node) {
 	if p.task.cover {
 		p.w("%sCover();", p.task.crt)
 	}
 	if p.task.coverC {
 		p.w("%sCoverC(%q);", p.task.crt, p.pos(n).String()+" "+p.fn)
 	}
 	if p.task.watch {
 		p.w("%sWatch();", p.task.crt)
 	}
 }
 
 var dummyJumpStatement = &cc.JumpStatement{}
 
 func (p *project) statement(f *function, n *cc.Statement, forceCompoundStmtBrace, forceNoBraces, switchBlock bool, mode exprMode) (r *cc.JumpStatement) {
 	if forceCompoundStmtBrace {
 		if f.switchCtx == inSwitchFirst && p.pauseCodegen {
 			p.pauseCodegen = false
 			p.w(" {")
 			p.pauseCodegen = true
 		}
 		p.w(" {")
 		if !switchBlock {
 			p.instrument(n)
 		}
 	}
 	switch n.Case {
 	case cc.StatementLabeled: // LabeledStatement
 		r = p.labeledStatement(f, n.LabeledStatement)
 	case cc.StatementCompound: // CompoundStatement
 		if !forceCompoundStmtBrace {
 			p.w("%s", n.CompoundStatement.Token.Sep)
 		}
 		if f.hasJumps {
 			forceNoBraces = true
 		}
 		p.compoundStatement(f, n.CompoundStatement, "", forceCompoundStmtBrace || forceNoBraces, false, 0)
 	case cc.StatementExpr: // ExpressionStatement
 		if mode != 0 {
 			p.w("return ")
 			e := n.ExpressionStatement.Expression
 			p.expression(f, e, e.Operand.Type(), exprValue, 0)
 			r = dummyJumpStatement
 			break
 		}
 
 		p.expressionStatement(f, n.ExpressionStatement)
 	case cc.StatementSelection: // SelectionStatement
 		p.selectionStatement(f, n.SelectionStatement)
 	case cc.StatementIteration: // IterationStatement
 		p.iterationStatement(f, n.IterationStatement)
 	case cc.StatementJump: // JumpStatement
 		r = p.jumpStatement(f, n.JumpStatement)
 	case cc.StatementAsm: // AsmStatement
 		// AsmStatement:
 		//         Asm AttributeSpecifierList ';'
 		// Asm:
 		//         "__asm__" AsmQualifierList '(' STRINGLITERAL AsmArgList ')'
 		if n.AsmStatement.Asm.Token3.Value == 0 && n.AsmStatement.Asm.AsmArgList == nil {
 			break
 		}
 
 		p.w("panic(`%s: assembler statements not supported`)", n.Position())
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 	if forceCompoundStmtBrace {
 		// We need to do this, to guarantee that we always close the brace is we opened it
 		if f.switchCtx == inSwitchFirst && p.pauseCodegen {
 			p.pauseCodegen = false
 			p.w("}")
 			p.pauseCodegen = true
 		}
 		p.w("}")
 	}
 	return r
 }
 
 func (p *project) jumpStatement(f *function, n *cc.JumpStatement) (r *cc.JumpStatement) {
 	p.w("%s", tidyComment("\n", n))
 	if _, ok := n.Context().(*cc.SelectionStatement); ok && f.ifCtx == nil {
 		switch f.switchCtx {
 		case inSwitchCase:
 			f.switchCtx = inSwitchSeenBreak
 		case inSwitchSeenBreak:
 			// nop but TODO
 		case inSwitchFlat:
 			// ok
 		default:
 			panic(todo("", n.Position(), f.switchCtx))
 		}
 	}
 
 	switch n.Case {
 	case cc.JumpStatementGoto: // "goto" IDENTIFIER ';'
 		p.w("goto %s", f.labelNames[n.Token2.Value])
 	case cc.JumpStatementGotoExpr: // "goto" '*' Expression ';'
 		panic(todo("", p.pos(n)))
 	case cc.JumpStatementContinue: // "continue" ';'
 		switch {
 		case f.continueCtx != 0:
 			p.w("goto __%d", f.continueCtx)
 		default:
 			p.w("continue")
 		}
 	case cc.JumpStatementBreak: // "break" ';'
 		switch {
 		case f.breakCtx != 0:
 			p.w("goto __%d", f.breakCtx)
 		default:
 			p.w("break")
 		}
 	case cc.JumpStatementReturn: // "return" Expression ';'
 		r = n
 		switch {
 		case f.rt != nil && f.rt.Kind() == cc.Void:
 			if n.Expression != nil {
 				p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, 0)
 				p.w(";")
 			}
 			p.w("return")
 		case f.rt != nil && f.rt.Kind() != cc.Void:
 			if n.Expression != nil {
 				p.expression(f, n.Expression, f.rt, exprCondReturn, 0)
 				break
 			}
 
 			p.w("return ")
 			p.zeroValue(n, f.rt)
 		default:
 			if n.Expression != nil {
 				p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, 0)
 				p.w(";")
 			}
 			p.w("return")
 		}
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 	return r
 }
 
 func (p *project) expression(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprVoid:
 		p.expressionVoid(f, n, t, mode, flags)
 	case exprValue, exprCondReturn, exprCondInit:
 		p.expressionValue(f, n, t, mode, flags)
 	case exprBool:
 		p.expressionBool(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.expressionAddrOf(f, n, t, mode, flags)
 	case exprPSelect:
 		p.expressionPSelect(f, n, t, mode, flags)
 	case exprLValue:
 		p.expressionLValue(f, n, t, mode, flags)
 	case exprFunc:
 		p.expressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.expressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.expressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) expressionDecay(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExpressionAssign: // AssignmentExpression
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 	case cc.ExpressionComma: // Expression ',' AssignmentExpression
 		p.w("func() uintptr {")
 		p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, flags)
 		p.w("; return ")
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 		p.w("}()")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) expressionSelect(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExpressionAssign: // AssignmentExpression
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 	case cc.ExpressionComma: // Expression ',' AssignmentExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) expressionFunc(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExpressionAssign: // AssignmentExpression
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 	case cc.ExpressionComma: // Expression ',' AssignmentExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) expressionLValue(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExpressionAssign: // AssignmentExpression
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 	case cc.ExpressionComma: // Expression ',' AssignmentExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) expressionPSelect(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExpressionAssign: // AssignmentExpression
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 	case cc.ExpressionComma: // Expression ',' AssignmentExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) expressionAddrOf(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExpressionAssign: // AssignmentExpression
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 	case cc.ExpressionComma: // Expression ',' AssignmentExpression
 		p.w(" func() uintptr {")
 		p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, flags)
 		p.w("; return ")
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 		p.w("}()")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) expressionBool(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExpressionAssign: // AssignmentExpression
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 	case cc.ExpressionComma: // Expression ',' AssignmentExpression
 		p.w("func() bool {")
 		p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, flags)
 		p.w("; return ")
 		p.assignmentExpression(f, n.AssignmentExpression, n.AssignmentExpression.Operand.Type(), mode, flags)
 		p.w("}()")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) expressionValue(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExpressionAssign: // AssignmentExpression
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 	case cc.ExpressionComma: // Expression ',' AssignmentExpression
 		if mode == exprCondReturn {
 			p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, flags)
 			p.w("; return ")
 			p.assignmentExpression(f, n.AssignmentExpression, n.AssignmentExpression.Operand.Type(), exprValue, flags)
 			return
 		}
 
 		switch {
 		case n.AssignmentExpression.Operand.Type().Kind() == cc.Array:
 			p.expressionDecay(f, n, t, exprDecay, flags)
 		default:
 			defer p.w("%s", p.convertType(n, n.Operand.Type(), t, flags))
 			p.w("func() %v {", p.typ(n, n.AssignmentExpression.Operand.Type()))
 			p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, flags)
 			p.w("; return ")
 			p.assignmentExpression(f, n.AssignmentExpression, n.AssignmentExpression.Operand.Type(), exprValue, flags)
 			p.w("}()")
 		}
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) expressionVoid(f *function, n *cc.Expression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExpressionAssign: // AssignmentExpression
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 	case cc.ExpressionComma: // Expression ',' AssignmentExpression
 		p.expression(f, n.Expression, t, mode, flags)
 		p.w(";")
 		p.assignmentExpression(f, n.AssignmentExpression, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) opKind(f *function, d declarator, t cc.Type) opKind {
 	switch {
 	case p.isArrayParameter(d, t):
 		return opArrayParameter
 	case !p.pass1 && p.isArray(f, d, t):
 		return opArray
 	case t.Kind() == cc.Union:
 		return opUnion
 	case t.Kind() == cc.Struct:
 		return opStruct
 	case t.IsBitFieldType():
 		return opBitfield
 	case t.Kind() == cc.Function:
 		return opFunction
 	default:
 		return opNormal
 	}
 }
 
 func (p *project) assignmentExpression(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprVoid:
 		p.assignmentExpressionVoid(f, n, t, mode, flags)
 	case exprValue, exprCondReturn, exprCondInit:
 		p.assignmentExpressionValue(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.assignmentExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.assignmentExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.assignmentExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.assignmentExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.assignmentExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.assignmentExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.assignmentExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) assignmentExpressionDecay(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AssignmentExpressionCond: // ConditionalExpression
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 	case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionLsh: // UnaryExpression "<<= AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) assignmentExpressionSelect(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AssignmentExpressionCond: // ConditionalExpression
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 	case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) assignmentExpressionFunc(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AssignmentExpressionCond: // ConditionalExpression
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 	case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionLsh: // UnaryExpremode, ssion "<<=
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) assignmentExpressionPSelect(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AssignmentExpressionCond: // ConditionalExpression
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 	case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.AssignmentExpression.Operand.Type().Elem()))
 		p.assignmentExpression(f, n, t, exprValue, flags)
 		p.w("))")
 	case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) assignmentExpressionLValue(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AssignmentExpressionCond: // ConditionalExpression
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 	case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) assignmentExpressionBool(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AssignmentExpressionCond: // ConditionalExpression
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 	default:
 		// case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
 		// case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
 		// case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
 		// case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
 		// case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
 		// case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
 		// case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression
 		// case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
 		// case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
 		// case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
 		// case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0 ")
 		p.assignmentExpression(f, n, t, exprValue, flags)
 	}
 }
 
 func (p *project) assignmentExpressionAddrOf(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AssignmentExpressionCond: // ConditionalExpression
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 	case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
 		p.assignmentExpressionValueAddrOf(f, n, t, mode, flags)
 	case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) assignmentExpressionValueAddrOf(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	// UnaryExpression '=' AssignmentExpression
 	if mode == exprCondReturn {
 		panic(todo("", p.pos(n)))
 	}
 
 	lhs := n.UnaryExpression
 	switch k := p.opKind(f, lhs, lhs.Operand.Type()); k {
 	case opStruct, opUnion:
 		p.assignmentExpressionValueAssignStructAddrof(f, n, n.Operand.Type(), mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) assignmentExpressionValueAssignStructAddrof(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	// UnaryExpression '=' AssignmentExpression
 	lhs := n.UnaryExpression.Operand.Type()
 	rhs := n.AssignmentExpression.Operand.Type()
 	if lhs.Kind() == cc.Array || rhs.Kind() == cc.Array {
 		panic(todo("", p.pos(n)))
 	}
 
 	if d := n.UnaryExpression.Declarator(); d != nil {
 		if local := f.locals[d]; local != nil {
 			if local.isPinned {
 				if !p.pass1 {
 					p.w("%sXmemmove(tls, ", p.task.crt)
 					p.unaryExpression(f, n.UnaryExpression, lhs, exprAddrOf, flags)
 					p.w(", ")
 					p.assignmentExpression(f, n.AssignmentExpression, rhs, exprAddrOf, flags)
 					p.w(", %d)", lhs.Size())
 					return
 				}
 			}
 
 			if !p.pass1 {
 				panic(todo("", p.pos(n)))
 			}
 		}
 	}
 
 	p.w("%sXmemmove(tls, ", p.task.crt)
 	p.unaryExpression(f, n.UnaryExpression, lhs, exprAddrOf, flags)
 	p.w(", ")
 	p.assignmentExpression(f, n.AssignmentExpression, rhs, exprAddrOf, flags)
 	p.w(", %d)", lhs.Size())
 }
 
 func (p *project) assignmentExpressionValue(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AssignmentExpressionCond: // ConditionalExpression
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 	case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
 		p.assignmentExpressionValueAssign(f, n, t, mode, flags)
 	case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "*", "Mul", flags)
 	case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "/", "Div", flags)
 	case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "%", "Rem", flags)
 	case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "+", "Add", flags)
 	case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "-", "Sub", flags)
 	case cc.AssignmentExpressionLsh: // UnaryExpremode, ssion "<<=
 		p.assignOp(f, n, t, mode, "<<", "Shl", flags)
 	case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
 		p.assignOp(f, n, t, mode, ">>", "Shr", flags)
 	case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "&", "And", flags)
 	case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "^", "Xor", flags)
 	case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "|", "Or", flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) assignmentExpressionValueAssign(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	// UnaryExpression '=' AssignmentExpression
 	if mode == exprCondReturn {
 		p.w("return ")
 	}
 	lhs := n.UnaryExpression
 	switch k := p.opKind(f, lhs, lhs.Operand.Type()); k {
 	case opNormal:
 		p.assignmentExpressionValueAssignNormal(f, n, t, mode, flags)
 	case opBitfield:
 		p.assignmentExpressionValueAssignBitfield(f, n, t, mode, flags)
 	case opStruct, opUnion:
 		p.assignmentExpressionValueAssignStruct(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) assignmentExpressionValueAssignStruct(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	// UnaryExpression '=' AssignmentExpression
 	lhs := n.UnaryExpression.Operand.Type()
 	rhs := n.AssignmentExpression.Operand.Type()
 	if lhs.Kind() == cc.Array || rhs.Kind() == cc.Array {
 		panic(todo("", p.pos(n)))
 	}
 
 	p.w(" func() %s { __v := ", p.typ(n, lhs))
 	p.assignmentExpression(f, n.AssignmentExpression, rhs, exprValue, flags)
 	p.w(";")
 	p.unaryExpression(f, n.UnaryExpression, lhs, exprLValue, flags)
 	p.w(" = __v; return __v}()")
 }
 
 func (p *project) assignmentExpressionValueAssignBitfield(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	if d := n.UnaryExpression.Declarator(); d != nil {
 		panic(todo("", p.pos(n)))
 	}
 
 	lhs := n.UnaryExpression
 	lt := lhs.Operand.Type()
 	bf := lt.BitField()
 	defer p.w("%s", p.convertType(n, lt, t, flags))
 	p.w("%sAssignBitFieldPtr%d%s(", p.task.crt, bf.BitFieldBlockWidth(), p.bfHelperType(lt))
 	p.unaryExpression(f, lhs, lt, exprAddrOf, flags)
 	p.w(", ")
 	p.assignmentExpression(f, n.AssignmentExpression, lt, exprValue, flags)
 	p.w(", %d, %d, %#x)", bf.BitFieldWidth(), bf.BitFieldOffset(), bf.Mask())
 }
 
 func (p *project) assignmentExpressionValueAssignNormal(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	if d := n.UnaryExpression.Declarator(); d != nil {
 		if !d.Type().IsScalarType() {
 			panic(todo("", p.pos(n)))
 		}
 
 		if local := f.locals[d]; local != nil {
 			if local.isPinned {
 				defer p.w(")%s", p.convertType(n, d.Type(), t, flags))
 				p.w("%sAssignPtr%s(", p.task.crt, p.helperType(d, d.Type()))
 				p.w("%s%s /* %s */", f.bpName, nonZeroUintptr(local.off), local.name)
 				p.w(", ")
 				p.assignmentExpression(f, n.AssignmentExpression, n.UnaryExpression.Operand.Type(), exprValue, flags)
 				return
 			}
 
 			defer p.w(")%s", p.convertType(n, d.Type(), t, flags))
 			p.w("%sAssign%s(&%s, ", p.task.crt, p.helperType(n, d.Type()), local.name)
 			p.assignmentExpression(f, n.AssignmentExpression, n.UnaryExpression.Operand.Type(), exprValue, flags)
 			return
 		}
 	}
 
 	defer p.w(")%s", p.convertType(n, n.UnaryExpression.Operand.Type(), t, flags))
 	p.w("%sAssignPtr%s(", p.task.crt, p.helperType(n, n.UnaryExpression.Operand.Type()))
 	p.unaryExpression(f, n.UnaryExpression, n.UnaryExpression.Operand.Type(), exprAddrOf, flags)
 	p.w(", ")
 	p.assignmentExpression(f, n.AssignmentExpression, n.UnaryExpression.Operand.Type(), exprValue, flags)
 }
 
 func (p *project) assignmentExpressionVoid(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AssignmentExpressionCond: // ConditionalExpression
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 	case cc.AssignmentExpressionAssign: // UnaryExpression '=' AssignmentExpression
 		d := n.UnaryExpression.Declarator()
 		lhs := n.UnaryExpression
 		lt := lhs.Operand.Type()
 		sv := f.condInitPrefix
 		switch k := p.opKind(f, lhs, lt); k {
 		case opArrayParameter:
 			lt = lt.Decay()
 			fallthrough
 		case opNormal, opStruct:
 			mode = exprValue
 			if p.isArrayOrPinnedArray(f, n.AssignmentExpression, n.AssignmentExpression.Operand.Type()) {
 				mode = exprDecay
 			}
 			switch {
 			case flags&fNoCondAssignment == 0 && mode == exprValue && n.UnaryExpression.Declarator() != nil && p.isConditionalAssignmentExpr(n.AssignmentExpression):
 				f.condInitPrefix = func() {
 					p.unaryExpression(f, lhs, lt, exprLValue, flags)
 					p.w(" = ")
 				}
 				p.assignmentExpression(f, n.AssignmentExpression, lt, exprCondInit, flags)
 				p.w(";")
 			default:
 				if d != nil && p.isVolatileOrAtomic(d) {
 					p.setVolatileDeclarator(d, f, n.AssignmentExpression, lt, mode, flags)
 					return
 				}
 
 				p.unaryExpression(f, lhs, lt, exprLValue, flags)
 				p.w(" = ")
 				p.assignmentExpression(f, n.AssignmentExpression, lt, mode, flags)
 			}
 		case opBitfield:
 			bf := lt.BitField()
 			p.w("%sSetBitFieldPtr%d%s(", p.task.crt, bf.BitFieldBlockWidth(), p.bfHelperType(lt))
 			p.unaryExpression(f, lhs, lt, exprAddrOf, flags)
 			p.w(", ")
 			p.assignmentExpression(f, n.AssignmentExpression, lt, exprValue, flags)
 			p.w(", %d, %#x)", bf.BitFieldOffset(), bf.Mask())
 		case opUnion:
 			p.unaryExpression(f, lhs, lt, exprLValue, flags)
 			p.w(" = ")
 			p.assignmentExpression(f, n.AssignmentExpression, lt, exprValue, flags)
 		default:
 			panic(todo("", n.Position(), k))
 		}
 		f.condInitPrefix = sv
 	case cc.AssignmentExpressionMul: // UnaryExpression "*=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "*", "Mul", flags)
 	case cc.AssignmentExpressionDiv: // UnaryExpression "/=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "/", "Div", flags)
 	case cc.AssignmentExpressionMod: // UnaryExpression "%=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "%", "Mod", flags)
 	case cc.AssignmentExpressionAdd: // UnaryExpression "+=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "+", "Add", flags)
 	case cc.AssignmentExpressionSub: // UnaryExpression "-=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "-", "Sub", flags)
 	case cc.AssignmentExpressionLsh: // UnaryExpression "<<=" AssignmentExpression
 		p.assignShiftOp(f, n, t, mode, "<<", "Shl", flags)
 	case cc.AssignmentExpressionRsh: // UnaryExpression ">>=" AssignmentExpression
 		p.assignShiftOp(f, n, t, mode, ">>", "Shr", flags)
 	case cc.AssignmentExpressionAnd: // UnaryExpression "&=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "&", "And", flags)
 	case cc.AssignmentExpressionXor: // UnaryExpression "^=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "^", "Xor", flags)
 	case cc.AssignmentExpressionOr: // UnaryExpression "|=" AssignmentExpression
 		p.assignOp(f, n, t, mode, "|", "Or", flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) setVolatileDeclarator(d *cc.Declarator, f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, flags flags) {
 	sz := d.Type().Size()
 	switch sz {
 	case 4, 8:
 		// ok
 	default:
 		p.err(d, "unsupported volatile declarator size: %v", sz)
 		return
 	}
 
 	if local := f.locals[d]; local != nil {
 		if local.isPinned {
 			p.w("%sAtomicStoreP%s(%s%s /* %s */, ", p.task.crt, p.helperType(n, d.Type()), f.bpName, nonZeroUintptr(local.off), local.name)
 			p.assignmentExpression(f, n, t, mode, flags)
 			p.w(")")
 			return
 		}
 
 		p.atomicStoreNamedAddr(n, d.Type(), local.name, n, f, mode, flags)
 		return
 	}
 
 	if tld := p.tlds[d]; tld != nil {
 		p.atomicStoreNamedAddr(n, d.Type(), tld.name, n, f, mode, flags)
 		return
 	}
 
 	if imp := p.imports[d.Name().String()]; imp != nil {
 		p.atomicStoreNamedAddr(n, d.Type(), fmt.Sprintf("%sX%s", imp.qualifier, d.Name()), n, f, mode, flags)
 		return
 	}
 
 	panic(todo("", n.Position(), d.Position(), d.Name()))
 }
 
 func (p *project) atomicStoreNamedAddr(n cc.Node, t cc.Type, nm string, expr *cc.AssignmentExpression, f *function, mode exprMode, flags flags) {
 	sz := t.Size()
 	switch sz {
 	case 4, 8:
 		// ok
 	default:
 		p.err(n, "unsupported volatile declarator size: %v", sz)
 		return
 	}
 
 	var ht string
 	switch {
 	case t.IsScalarType():
 		ht = p.helperType(n, t)
 	default:
 		p.err(n, "unsupported volatile declarator type: %v", t)
 		return
 	}
 
 	p.w("%sAtomicStore%s(&%s, %s(", p.task.crt, ht, nm, p.typ(n, t))
 	p.assignmentExpression(f, expr, t, mode, flags)
 	p.w("))")
 }
 
 func (p *project) atomicLoadNamedAddr(n cc.Node, t cc.Type, nm string) {
 	sz := t.Size()
 	switch sz {
 	case 4, 8:
 		// ok
 	default:
 		p.err(n, "unsupported volatile declarator size: %v", sz)
 		return
 	}
 
 	var ht string
 	switch {
 	case t.IsScalarType():
 		ht = p.helperType(n, t)
 	default:
 		p.err(n, "unsupported volatile declarator type: %v", t)
 		return
 	}
 
 	p.w("%sAtomicLoad%s(&%s)", p.task.crt, ht, nm)
 }
 
 func isRealType(op cc.Operand) bool {
 	switch op.Type().Kind() {
 	case cc.Float, cc.Double:
 		return true
 	default:
 		return false
 	}
 }
 
 func (p *project) bfHelperType(t cc.Type) string {
 	switch {
 	case t.IsSignedType():
 		return fmt.Sprintf("Int%d", t.Size()*8)
 	default:
 		return fmt.Sprintf("Uint%d", t.Size()*8)
 	}
 }
 
 func (p *project) helperType(n cc.Node, t cc.Type) string {
 	for t.IsAliasType() {
 		if t2 := t.Alias(); t2 != t { //TODO HDF5 H5O.c
 			t = t2
 			continue
 		}
 
 		break
 	}
 	switch t.Kind() {
 	case cc.Int128:
 		return "Int128"
 	case cc.UInt128:
 		return "Uint128"
 	}
 
 	s := p.typ(n, t)
 	return strings.ToUpper(s[:1]) + s[1:]
 }
 
 func (p *project) helperType2(n cc.Node, from, to cc.Type) string {
 	if from.Kind() == to.Kind() {
 		return fmt.Sprintf("%s%s", p.task.crt, p.helperType(n, from))
 	}
 
 	return fmt.Sprintf("%s%sFrom%s", p.task.crt, p.helperType(n, to), p.helperType(n, from))
 }
 
 func (p *project) conditionalExpression(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.conditionalExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.conditionalExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.conditionalExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.conditionalExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.conditionalExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.conditionalExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.conditionalExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.conditionalExpressionSelect(f, n, t, mode, flags)
 	case exprCondReturn:
 		p.conditionalExpressionReturn(f, n, t, mode, flags)
 	case exprCondInit:
 		p.conditionalExpressionInit(f, n, t, mode, flags)
 	case exprDecay:
 		p.conditionalExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) conditionalExpressionDecay(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		t = t.Decay()
 		p.w(" func() %s { if ", p.typ(n, t))
 		p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags)
 		p.w(" { return ")
 		switch n.Expression.Operand.Type().Kind() {
 		case cc.Array:
 			p.expression(f, n.Expression, t, exprDecay, flags)
 		case cc.Ptr:
 			panic(todo("", n.Expression.Position(), n.Expression.Operand.Type()))
 		default:
 			panic(todo("", n.Expression.Position(), n.Expression.Operand.Type()))
 		}
 		p.w("}; return ")
 		switch n.ConditionalExpression.Operand.Type().Kind() {
 		case cc.Array:
 			p.conditionalExpression(f, n.ConditionalExpression, t, exprDecay, flags)
 		default:
 			p.conditionalExpression(f, n.ConditionalExpression, t, exprValue, flags)
 		}
 		p.w("}()")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) conditionalExpressionInit(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		f.condInitPrefix()
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, exprValue, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		t = t.Decay()
 		p.w("if ")
 		p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags)
 		p.w(" {")
 		p.expression(f, n.Expression, t, mode, flags)
 		p.w("} else { ")
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 		p.w("}")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) conditionalExpressionReturn(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		p.w("return ")
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, exprValue, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		t = t.Decay()
 		p.w("if ")
 		p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags)
 		p.w(" {")
 		p.expression(f, n.Expression, t, mode, flags)
 		p.w("}; ")
 		p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) conditionalExpressionSelect(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) conditionalExpressionFunc(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		switch ot := n.Operand.Type(); ot.Kind() {
 		case cc.Function:
 			if t.Kind() != cc.Function {
 				panic(todo("", n.Position()))
 			}
 		default:
 			panic(todo("", ot.Kind()))
 		}
 
 		p.w(" func() ")
 		p.functionSignature(n, f, t, "")
 		p.w("{ if ")
 		p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags)
 		p.w(" { return ")
 		switch d := n.Expression.Declarator(); {
 		case d != nil:
 			p.declaratorDefault(n, d)
 		default:
 			panic(todo("", n.Position()))
 		}
 		p.w("}; return ")
 		switch d := n.ConditionalExpression.Declarator(); {
 		case d != nil:
 			p.declaratorDefault(n, d)
 		default:
 			panic(todo("", n.Position()))
 		}
 		p.w("}()")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) conditionalExpressionPSelect(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem()))
 		p.conditionalExpression(f, n, t, exprValue, flags)
 		p.w("))")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) conditionalExpressionLValue(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) conditionalExpressionBool(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0 ")
 		p.conditionalExpression(f, n, t, exprValue, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) conditionalExpressionAddrOf(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		t = t.Decay()
 		p.w(" func() %s { if ", p.typ(n, t))
 		p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags)
 		p.w(" { return ")
 		p.expression(f, n.Expression, t, exprValue, flags)
 		p.w("}; return ")
 		p.conditionalExpression(f, n.ConditionalExpression, t, exprValue, flags)
 		p.w("}()")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) conditionalExpressionVoid(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, mode, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		switch {
 		case n.Expression.IsSideEffectsFree:
 			p.w("if !(")
 			p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags)
 			p.w(") {")
 			p.conditionalExpression(f, n.ConditionalExpression, n.ConditionalExpression.Operand.Type(), mode, flags)
 			p.w("}")
 		default:
 			p.w("if ")
 			p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags)
 			p.w(" {")
 			p.expression(f, n.Expression, n.Expression.Operand.Type(), mode, flags)
 			p.w("} else {")
 			p.conditionalExpression(f, n.ConditionalExpression, n.ConditionalExpression.Operand.Type(), mode, flags)
 			p.w("}")
 		}
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) conditionalExpressionValue(f *function, n *cc.ConditionalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ConditionalExpressionLOr: // LogicalOrExpression
 		p.logicalOrExpression(f, n.LogicalOrExpression, t, exprValue, flags)
 	case cc.ConditionalExpressionCond: // LogicalOrExpression '?' Expression ':' ConditionalExpression
 		t = t.Decay()
 		p.w(" func() %s { if ", p.typ(n, t))
 		p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags)
 		p.w(" { return ")
 		p.expression(f, n.Expression, t, exprValue, flags)
 		p.w("}; return ")
 		p.conditionalExpression(f, n.ConditionalExpression, t, exprValue, flags)
 		p.w("}()")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalOrExpression(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.logicalOrExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.logicalOrExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.logicalOrExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.logicalOrExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.logicalOrExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.logicalOrExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.logicalOrExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.logicalOrExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.logicalOrExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) logicalOrExpressionDecay(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalOrExpressionLAnd: // LogicalAndExpression
 		p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags)
 	case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalOrExpressionSelect(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalOrExpressionLAnd: // LogicalAndExpression
 		p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags)
 	case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalOrExpressionFunc(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalOrExpressionLAnd: // LogicalAndExpression
 		p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags)
 	case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalOrExpressionPSelect(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalOrExpressionLAnd: // LogicalAndExpression
 		p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags)
 	case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalOrExpressionLValue(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalOrExpressionLAnd: // LogicalAndExpression
 		p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags)
 	case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalOrExpressionBool(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalOrExpressionLAnd: // LogicalAndExpression
 		p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags)
 	case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
 		p.binaryLogicalOrExpression(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalOrExpressionAddrOf(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalOrExpressionLAnd: // LogicalAndExpression
 		p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags)
 	case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalOrExpressionVoid(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalOrExpressionLAnd: // LogicalAndExpression
 		p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags)
 	case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
 		p.w("_ = ")
 		p.logicalOrExpression(f, n, n.Operand.Type(), exprValue, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalOrExpressionValue(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalOrExpressionLAnd: // LogicalAndExpression
 		p.logicalAndExpression(f, n.LogicalAndExpression, t, mode, flags)
 	case cc.LogicalOrExpressionLOr: // LogicalOrExpression "||" LogicalAndExpression
 		p.binaryLogicalOrExpression(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) binaryLogicalOrExpression(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.binaryLogicalOrExpressionValue(f, n, t, mode, flags)
 	case exprBool:
 		p.binaryLogicalOrExpressionBool(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) binaryLogicalOrExpressionBool(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, n.Operand.Type(), &mode, flags))
 	p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags)
 	p.w(" ||%s", tidyComment(" ", &n.Token))
 	p.logicalAndExpression(f, n.LogicalAndExpression, n.LogicalAndExpression.Operand.Type(), exprBool, flags)
 }
 
 func (p *project) binaryLogicalOrExpressionValue(f *function, n *cc.LogicalOrExpression, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.logicalOrExpression(f, n.LogicalOrExpression, n.LogicalOrExpression.Operand.Type(), exprBool, flags)
 	p.w(" ||%s", tidyComment(" ", &n.Token))
 	p.logicalAndExpression(f, n.LogicalAndExpression, n.LogicalAndExpression.Operand.Type(), exprBool, flags)
 }
 
 func (p *project) booleanBinaryExpression(n cc.Node, from cc.Operand, to cc.Type, mode *exprMode, flags flags) (r string) {
 	p.w("(")
 	r = ")"
 	switch *mode {
 	case exprBool:
 		*mode = exprValue
 	default:
 		r = p.convert(n, from, to, flags) + r
 		p.w("%sBool32(", p.task.crt)
 		r = ")" + r
 	}
 	return r
 }
 
 func (p *project) logicalAndExpression(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.logicalAndExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.logicalAndExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.logicalAndExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.logicalAndExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.logicalAndExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.logicalAndExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.logicalAndExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.logicalAndExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.logicalAndExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) logicalAndExpressionDecay(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalAndExpressionOr: // InclusiveOrExpression
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags)
 	case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalAndExpressionSelect(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalAndExpressionOr: // InclusiveOrExpression
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags)
 	case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalAndExpressionFunc(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalAndExpressionOr: // InclusiveOrExpression
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags)
 	case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalAndExpressionPSelect(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalAndExpressionOr: // InclusiveOrExpression
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags)
 	case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalAndExpressionLValue(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalAndExpressionOr: // InclusiveOrExpression
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags)
 	case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalAndExpressionBool(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalAndExpressionOr: // InclusiveOrExpression
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags)
 	case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
 		p.binaryLogicalAndExpression(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalAndExpressionAddrOf(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalAndExpressionOr: // InclusiveOrExpression
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags)
 	case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalAndExpressionVoid(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalAndExpressionOr: // InclusiveOrExpression
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags)
 	case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
 		p.binaryLogicalAndExpressionValue(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) logicalAndExpressionValue(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.LogicalAndExpressionOr: // InclusiveOrExpression
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, t, mode, flags)
 	case cc.LogicalAndExpressionLAnd: // LogicalAndExpression "&&" InclusiveOrExpression
 		p.binaryLogicalAndExpression(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) binaryLogicalAndExpression(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprBool:
 		p.binaryLogicalAndExpressionBool(f, n, t, mode, flags)
 	case exprValue:
 		p.binaryLogicalAndExpressionValue(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) binaryLogicalAndExpressionValue(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.logicalAndExpression(f, n.LogicalAndExpression, n.LogicalAndExpression.Operand.Type(), exprBool, flags)
 	p.w(" &&%s", tidyComment(" ", &n.Token))
 	p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.InclusiveOrExpression.Operand.Type(), exprBool, flags)
 }
 
 func (p *project) binaryLogicalAndExpressionBool(f *function, n *cc.LogicalAndExpression, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.logicalAndExpression(f, n.LogicalAndExpression, n.LogicalAndExpression.Operand.Type(), exprBool, flags)
 	p.w(" &&%s", tidyComment(" ", &n.Token))
 	p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.InclusiveOrExpression.Operand.Type(), exprBool, flags)
 }
 
 func (p *project) inclusiveOrExpression(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.inclusiveOrExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.inclusiveOrExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.inclusiveOrExpressionAddrof(f, n, t, mode, flags)
 	case exprBool:
 		p.inclusiveOrExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.inclusiveOrExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.inclusiveOrExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.inclusiveOrExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.inclusiveOrExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.inclusiveOrExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) inclusiveOrExpressionDecay(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags)
 	case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) inclusiveOrExpressionSelect(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags)
 	case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) inclusiveOrExpressionFunc(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags)
 	case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) inclusiveOrExpressionPSelect(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags)
 	case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) inclusiveOrExpressionLValue(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags)
 	case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) inclusiveOrExpressionBool(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags)
 	case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
 		p.binaryInclusiveOrExpression(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) inclusiveOrExpressionAddrof(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags)
 	case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) inclusiveOrExpressionVoid(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags)
 	case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
 		p.w("_ = ")
 		p.inclusiveOrExpression(f, n, n.Operand.Type(), exprValue, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) inclusiveOrExpressionValue(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.InclusiveOrExpressionXor: // ExclusiveOrExpression
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, t, mode, flags)
 	case cc.InclusiveOrExpressionOr: // InclusiveOrExpression '|' ExclusiveOrExpression
 		p.binaryInclusiveOrExpression(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) binaryInclusiveOrExpression(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	// InclusiveOrExpression '|' ExclusiveOrExpression
 	switch mode {
 	case exprBool:
 		p.binaryInclusiveOrExpressionBool(f, n, t, mode, flags)
 	case exprValue:
 		p.binaryInclusiveOrExpressionValue(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) binaryInclusiveOrExpressionValue(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	// InclusiveOrExpression '|' ExclusiveOrExpression
 
 	lt := n.InclusiveOrExpression.Operand.Type()
 	rt := n.ExclusiveOrExpression.Operand.Type()
 	switch lk, rk := lt.Kind(), rt.Kind(); {
 	case
 		lk == cc.UInt128 || rk == cc.UInt128,
 		lk == cc.Int128 || rk == cc.Int128:
 
 		p.binaryOrExpressionUint128(f, n, t, mode, flags)
 		return
 	}
 
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	switch {
 	case orOverflows(n.InclusiveOrExpression.Operand, n.ExclusiveOrExpression.Operand, n.Promote()):
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.Promote(), exprValue, flags)
 		p.w(" |%s", tidyComment(" ", &n.Token))
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags|fForceRuntimeConv)
 	default:
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.Promote(), exprValue, flags)
 		p.w(" |%s", tidyComment(" ", &n.Token))
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags)
 	}
 }
 
 func (p *project) binaryOrExpressionUint128(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	// InclusiveOrExpression '|' ExclusiveOrExpression
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.Promote(), exprValue, flags)
 	p.w(".Or(")
 	p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags)
 	p.w(")")
 }
 
 func (p *project) binaryInclusiveOrExpressionBool(f *function, n *cc.InclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	switch {
 	case orOverflows(n.InclusiveOrExpression.Operand, n.ExclusiveOrExpression.Operand, n.Promote()):
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.Promote(), exprValue, flags)
 		p.w(" |%s", tidyComment(" ", &n.Token))
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags|fForceRuntimeConv)
 	default:
 		p.inclusiveOrExpression(f, n.InclusiveOrExpression, n.Promote(), exprValue, flags)
 		p.w(" |%s", tidyComment(" ", &n.Token))
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags)
 	}
 }
 
 func orOverflows(lo, ro cc.Operand, promote cc.Type) bool {
 	a, b, ok := getIntOperands(lo, ro)
 	if !ok {
 		return false
 	}
 
 	return overflows(a.Or(a, b), promote)
 }
 
 func (p *project) artithmeticBinaryExpression(n cc.Node, from cc.Operand, to cc.Type, mode *exprMode, flags flags) (r string) {
 	p.w("(")
 	r = ")"
 	switch *mode {
 	case exprBool:
 		p.w("(")
 		r = ") != 0" + r
 		*mode = exprValue
 	default:
 		switch fk, tk := from.Type().Kind(), to.Kind(); {
 		case fk != tk && fk == cc.Int128:
 			return fmt.Sprintf(".%s()%s", p.helperType(n, to), r)
 		case fk != tk && fk == cc.UInt128:
 			return fmt.Sprintf(".%s()%s", p.helperType(n, to), r)
 		default:
 			r = p.convert(n, from, to, flags) + r
 		}
 	}
 	return r
 }
 
 func (p *project) exclusiveOrExpression(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.exclusiveOrExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.exclusiveOrExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.exclusiveOrExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.exclusiveOrExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.exclusiveOrExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.exclusiveOrExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.exclusiveOrExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.exclusiveOrExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.exclusiveOrExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) exclusiveOrExpressionDecay(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExclusiveOrExpressionAnd: // AndExpression
 		p.andExpression(f, n.AndExpression, t, mode, flags)
 	case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) exclusiveOrExpressionSelect(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExclusiveOrExpressionAnd: // AndExpression
 		p.andExpression(f, n.AndExpression, t, mode, flags)
 	case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) exclusiveOrExpressionFunc(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExclusiveOrExpressionAnd: // AndExpression
 		p.andExpression(f, n.AndExpression, t, mode, flags)
 	case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) exclusiveOrExpressionPSelect(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExclusiveOrExpressionAnd: // AndExpression
 		p.andExpression(f, n.AndExpression, t, mode, flags)
 	case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) exclusiveOrExpressionLValue(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExclusiveOrExpressionAnd: // AndExpression
 		p.andExpression(f, n.AndExpression, t, mode, flags)
 	case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) exclusiveOrExpressionBool(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExclusiveOrExpressionAnd: // AndExpression
 		p.andExpression(f, n.AndExpression, t, mode, flags)
 	case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
 		p.binaryExclusiveOrExpression(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) exclusiveOrExpressionAddrOf(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExclusiveOrExpressionAnd: // AndExpression
 		p.andExpression(f, n.AndExpression, t, mode, flags)
 	case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) exclusiveOrExpressionVoid(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExclusiveOrExpressionAnd: // AndExpression
 		p.andExpression(f, n.AndExpression, t, mode, flags)
 	case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
 		p.w("_ = ")
 		p.exclusiveOrExpression(f, n, n.Operand.Type(), exprValue, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) exclusiveOrExpressionValue(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ExclusiveOrExpressionAnd: // AndExpression
 		p.andExpression(f, n.AndExpression, t, mode, flags)
 	case cc.ExclusiveOrExpressionXor: // ExclusiveOrExpression '^' AndExpression
 		p.binaryExclusiveOrExpression(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) binaryExclusiveOrExpression(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	// ExclusiveOrExpression '^' AndExpression
 	switch mode {
 	case exprValue, exprBool:
 		p.binaryExclusiveOrExpressionValue(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) binaryExclusiveOrExpressionValue(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	// ExclusiveOrExpression '^' AndExpression
 
 	lt := n.ExclusiveOrExpression.Operand.Type()
 	rt := n.AndExpression.Operand.Type()
 	switch lk, rk := lt.Kind(), rt.Kind(); {
 	case
 		lk == cc.UInt128 || rk == cc.UInt128,
 		lk == cc.Int128 || rk == cc.Int128:
 
 		p.binaryExclusiveOrExpressionUint128(f, n, t, mode, flags)
 		return
 	}
 
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	switch {
 	case xorOverflows(n.ExclusiveOrExpression.Operand, n.AndExpression.Operand, n.Promote()):
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags)
 		p.w(" ^%s", tidyComment(" ", &n.Token))
 		p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags|fForceRuntimeConv)
 	default:
 		p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags)
 		p.w(" ^%s", tidyComment(" ", &n.Token))
 		p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags)
 	}
 }
 
 func (p *project) binaryExclusiveOrExpressionUint128(f *function, n *cc.ExclusiveOrExpression, t cc.Type, mode exprMode, flags flags) {
 	// ExclusiveOrExpression '^' AndExpression
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.exclusiveOrExpression(f, n.ExclusiveOrExpression, n.Promote(), exprValue, flags)
 	p.w(".Xor(")
 	p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags)
 	p.w(")")
 }
 
 func xorOverflows(lo, ro cc.Operand, promote cc.Type) bool {
 	a, b, ok := getIntOperands(lo, ro)
 	if !ok {
 		return false
 	}
 
 	return !lo.Type().IsSignedType() && a.Sign() == 0 ||
 		!ro.Type().IsSignedType() && b.Sign() == 0 ||
 		overflows(a.Xor(a, b), promote)
 }
 
 func (p *project) andExpression(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.andExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.andExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.andExpressionAddrof(f, n, t, mode, flags)
 	case exprBool:
 		p.andExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.andExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.andExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.andExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.andExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.andExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) andExpressionDecay(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AndExpressionEq: // EqualityExpression
 		p.equalityExpression(f, n.EqualityExpression, t, mode, flags)
 	case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) andExpressionSelect(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AndExpressionEq: // EqualityExpression
 		p.equalityExpression(f, n.EqualityExpression, t, mode, flags)
 	case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) andExpressionFunc(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AndExpressionEq: // EqualityExpression
 		p.equalityExpression(f, n.EqualityExpression, t, mode, flags)
 	case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) andExpressionPSelect(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AndExpressionEq: // EqualityExpression
 		p.equalityExpression(f, n.EqualityExpression, t, mode, flags)
 	case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) andExpressionLValue(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AndExpressionEq: // EqualityExpression
 		p.equalityExpression(f, n.EqualityExpression, t, mode, flags)
 	case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) andExpressionBool(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AndExpressionEq: // EqualityExpression
 		p.equalityExpression(f, n.EqualityExpression, t, mode, flags)
 	case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression
 		p.binaryAndExpression(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) andExpressionAddrof(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AndExpressionEq: // EqualityExpression
 		p.equalityExpression(f, n.EqualityExpression, t, mode, flags)
 	case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) andExpressionVoid(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AndExpressionEq: // EqualityExpression
 		p.equalityExpression(f, n.EqualityExpression, t, mode, flags)
 	case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression
 		p.w("_ = ")
 		p.andExpression(f, n, n.Operand.Type(), exprValue, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) andExpressionValue(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AndExpressionEq: // EqualityExpression
 		p.equalityExpression(f, n.EqualityExpression, t, mode, flags)
 	case cc.AndExpressionAnd: // AndExpression '&' EqualityExpression
 		p.binaryAndExpression(f, n, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) binaryAndExpression(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	// AndExpression '&' EqualityExpression
 	switch mode {
 	case exprValue:
 		p.binaryAndExpressionValue(f, n, t, mode, flags)
 	case exprBool:
 		p.binaryAndExpressionBool(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) binaryAndExpressionBool(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, n.Operand.Type(), &mode, flags))
 	switch {
 	case andOverflows(n.AndExpression.Operand, n.EqualityExpression.Operand, n.Promote()):
 		p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags)
 		p.w(" &%s", tidyComment(" ", &n.Token))
 		p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags|fForceRuntimeConv)
 	default:
 		p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags)
 		p.w(" &%s", tidyComment(" ", &n.Token))
 		p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags)
 	}
 }
 
 func (p *project) binaryAndExpressionValue(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	// AndExpression '&' EqualityExpression
 
 	lt := n.AndExpression.Operand.Type()
 	rt := n.EqualityExpression.Operand.Type()
 	switch lk, rk := lt.Kind(), rt.Kind(); {
 	case
 		lk == cc.UInt128 || rk == cc.UInt128,
 		lk == cc.Int128 || rk == cc.Int128:
 
 		p.binaryAndExpressionUint128(f, n, t, mode, flags)
 		return
 	}
 
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	switch {
 	case andOverflows(n.AndExpression.Operand, n.EqualityExpression.Operand, n.Promote()):
 		p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags)
 		p.w(" &%s", tidyComment(" ", &n.Token))
 		p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags|fForceRuntimeConv)
 	default:
 		p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags)
 		p.w(" &%s", tidyComment(" ", &n.Token))
 		p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags)
 	}
 }
 
 func (p *project) binaryAndExpressionUint128(f *function, n *cc.AndExpression, t cc.Type, mode exprMode, flags flags) {
 	// AndExpression '&' EqualityExpression
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.andExpression(f, n.AndExpression, n.Promote(), exprValue, flags)
 	p.w(".And(")
 	p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags)
 	p.w(")")
 }
 
 func andOverflows(lo, ro cc.Operand, promote cc.Type) bool {
 	a, b, ok := getIntOperands(lo, ro)
 	if !ok {
 		return false
 	}
 
 	return overflows(a.And(a, b), promote)
 }
 
 func (p *project) equalityExpression(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.equalityExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.equalityExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.equalityExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.equalityExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.equalityExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.equalityExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.equalityExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.equalityExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.equalityExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) equalityExpressionDecay(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.EqualityExpressionRel: // RelationalExpression
 		p.relationalExpression(f, n.RelationalExpression, t, mode, flags)
 	case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
 		panic(todo("", p.pos(n)))
 	case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) equalityExpressionSelect(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.EqualityExpressionRel: // RelationalExpression
 		p.relationalExpression(f, n.RelationalExpression, t, mode, flags)
 	case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
 		panic(todo("", p.pos(n)))
 	case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) equalityExpressionFunc(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.EqualityExpressionRel: // RelationalExpression
 		p.relationalExpression(f, n.RelationalExpression, t, mode, flags)
 	case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
 		panic(todo("", p.pos(n)))
 	case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) equalityExpressionPSelect(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.EqualityExpressionRel: // RelationalExpression
 		p.relationalExpression(f, n.RelationalExpression, t, mode, flags)
 	case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
 		panic(todo("", p.pos(n)))
 	case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) equalityExpressionLValue(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.EqualityExpressionRel: // RelationalExpression
 		p.relationalExpression(f, n.RelationalExpression, t, mode, flags)
 	case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
 		panic(todo("", p.pos(n)))
 	case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) equalityExpressionBool(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.EqualityExpressionRel: // RelationalExpression
 		p.relationalExpression(f, n.RelationalExpression, t, mode, flags)
 	case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
 		p.binaryEqualityExpression(f, n, " == ", t, mode, flags)
 	case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
 		p.binaryEqualityExpression(f, n, " != ", t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) equalityExpressionAddrOf(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.EqualityExpressionRel: // RelationalExpression
 		p.relationalExpression(f, n.RelationalExpression, t, mode, flags)
 	case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
 		panic(todo("", p.pos(n)))
 	case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) equalityExpressionVoid(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.EqualityExpressionRel: // RelationalExpression
 		p.relationalExpression(f, n.RelationalExpression, t, mode, flags)
 	default:
 		// case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
 		// case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
 		p.w("_ = ")
 		p.equalityExpression(f, n, n.Operand.Type(), exprValue, flags)
 	}
 }
 
 func (p *project) equalityExpressionValue(f *function, n *cc.EqualityExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.EqualityExpressionRel: // RelationalExpression
 		p.relationalExpression(f, n.RelationalExpression, t, mode, flags)
 	case cc.EqualityExpressionEq: // EqualityExpression "==" RelationalExpression
 		p.binaryEqualityExpression(f, n, " == ", t, mode, flags)
 	case cc.EqualityExpressionNeq: // EqualityExpression "!=" RelationalExpression
 		p.binaryEqualityExpression(f, n, " != ", t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) binaryEqualityExpression(f *function, n *cc.EqualityExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.binaryEqualityExpressionValue(f, n, oper, t, mode, flags)
 	case exprBool:
 		p.binaryEqualityExpressionBool(f, n, oper, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) binaryEqualityExpressionBool(f *function, n *cc.EqualityExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags)
 	p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 	p.relationalExpression(f, n.RelationalExpression, n.Promote(), exprValue, flags)
 }
 
 func (p *project) binaryEqualityExpressionValue(f *function, n *cc.EqualityExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.equalityExpression(f, n.EqualityExpression, n.Promote(), exprValue, flags)
 	p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 	p.relationalExpression(f, n.RelationalExpression, n.Promote(), exprValue, flags)
 }
 
 func (p *project) relationalExpression(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.relationalExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.relationalExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.relationalExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.relationalExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.relationalExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.relationalExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.relationalExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.relationalExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.relationalExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) relationalExpressionDecay(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.RelationalExpressionShift: // ShiftExpression
 		p.shiftExpression(f, n.ShiftExpression, t, mode, flags)
 	case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) relationalExpressionSelect(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.RelationalExpressionShift: // ShiftExpression
 		p.shiftExpression(f, n.ShiftExpression, t, mode, flags)
 	case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) relationalExpressionFunc(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.RelationalExpressionShift: // ShiftExpression
 		p.shiftExpression(f, n.ShiftExpression, t, mode, flags)
 	case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) relationalExpressionPSelect(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.RelationalExpressionShift: // ShiftExpression
 		p.shiftExpression(f, n.ShiftExpression, t, mode, flags)
 	case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) relationalExpressionLValue(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.RelationalExpressionShift: // ShiftExpression
 		p.shiftExpression(f, n.ShiftExpression, t, mode, flags)
 	case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) relationalExpressionBool(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.RelationalExpressionShift: // ShiftExpression
 		p.shiftExpression(f, n.ShiftExpression, t, mode, flags)
 	case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
 		p.binaryRelationalExpression(f, n, " < ", t, mode, flags)
 	case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
 		p.binaryRelationalExpression(f, n, " > ", t, mode, flags)
 	case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
 		p.binaryRelationalExpression(f, n, " <= ", t, mode, flags)
 	case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
 		p.binaryRelationalExpression(f, n, " >= ", t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) relationalExpressionAddrOf(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.RelationalExpressionShift: // ShiftExpression
 		p.shiftExpression(f, n.ShiftExpression, t, mode, flags)
 	case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) relationalExpressionVoid(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.RelationalExpressionShift: // ShiftExpression
 		p.shiftExpression(f, n.ShiftExpression, t, mode, flags)
 	default:
 		// case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
 		// case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
 		// case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
 		// case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
 		p.w("_ = ")
 		p.relationalExpression(f, n, n.Operand.Type(), exprValue, flags)
 	}
 }
 
 func (p *project) relationalExpressionValue(f *function, n *cc.RelationalExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.RelationalExpressionShift: // ShiftExpression
 		p.shiftExpression(f, n.ShiftExpression, t, mode, flags)
 	case cc.RelationalExpressionLt: // RelationalExpression '<' ShiftExpression
 		p.binaryRelationalExpression(f, n, " < ", t, mode, flags)
 	case cc.RelationalExpressionGt: // RelationalExpression '>' ShiftExpression
 		p.binaryRelationalExpression(f, n, " > ", t, mode, flags)
 	case cc.RelationalExpressionLeq: // RelationalExpression "<=" ShiftExpression
 		p.binaryRelationalExpression(f, n, " <= ", t, mode, flags)
 	case cc.RelationalExpressionGeq: // RelationalExpression ">=" ShiftExpression
 		p.binaryRelationalExpression(f, n, " >= ", t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) binaryRelationalExpression(f *function, n *cc.RelationalExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// RelationalExpression "<=" ShiftExpression
 	lt := n.RelationalExpression.Operand.Type()
 	rt := n.ShiftExpression.Operand.Type()
 	switch lk, rk := lt.Kind(), rt.Kind(); {
 	case
 		lk == cc.UInt128 || rk == cc.UInt128,
 		lk == cc.Int128 || rk == cc.Int128:
 
 		p.binaryRelationalExpressionInt128(f, n, oper, t, mode, flags)
 		return
 	}
 
 	defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.relationalExpression(f, n.RelationalExpression, n.Promote(), exprValue, flags)
 	p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 	p.shiftExpression(f, n.ShiftExpression, n.Promote(), exprValue, flags)
 }
 
 func (p *project) binaryRelationalExpressionInt128(f *function, n *cc.RelationalExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// RelationalExpression "<=" ShiftExpression
 	defer p.w("%s", p.booleanBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.relationalExpression(f, n.RelationalExpression, n.Promote(), exprValue, flags)
 	p.w(".Cmp(")
 	p.shiftExpression(f, n.ShiftExpression, n.Promote(), exprValue, flags)
 	p.w(") %s 0", oper)
 }
 
 func (p *project) shiftExpression(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.shiftExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.shiftExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.shiftExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.shiftExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.shiftExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.shiftExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.shiftExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.shiftExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.shiftExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) shiftExpressionDecay(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ShiftExpressionAdd: // AdditiveExpression
 		p.additiveExpression(f, n.AdditiveExpression, t, mode, flags)
 	case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) shiftExpressionSelect(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ShiftExpressionAdd: // AdditiveExpression
 		p.additiveExpression(f, n.AdditiveExpression, t, mode, flags)
 	case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) shiftExpressionFunc(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ShiftExpressionAdd: // AdditiveExpression
 		p.additiveExpression(f, n.AdditiveExpression, t, mode, flags)
 	case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) shiftExpressionPSelect(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ShiftExpressionAdd: // AdditiveExpression
 		p.additiveExpression(f, n.AdditiveExpression, t, mode, flags)
 	case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) shiftExpressionLValue(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ShiftExpressionAdd: // AdditiveExpression
 		p.additiveExpression(f, n.AdditiveExpression, t, mode, flags)
 	case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) shiftExpressionBool(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ShiftExpressionAdd: // AdditiveExpression
 		p.additiveExpression(f, n.AdditiveExpression, t, mode, flags)
 	case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
 		p.binaryShiftExpression(f, n, "<<", t, mode, flags)
 	case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
 		p.binaryShiftExpression(f, n, ">>", t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) shiftExpressionAddrOf(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ShiftExpressionAdd: // AdditiveExpression
 		p.additiveExpression(f, n.AdditiveExpression, t, mode, flags)
 	case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) shiftExpressionVoid(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ShiftExpressionAdd: // AdditiveExpression
 		p.additiveExpression(f, n.AdditiveExpression, t, mode, flags)
 	case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) shiftExpressionValue(f *function, n *cc.ShiftExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.ShiftExpressionAdd: // AdditiveExpression
 		p.additiveExpression(f, n.AdditiveExpression, t, mode, flags)
 	case cc.ShiftExpressionLsh: // ShiftExpression "<<" AdditiveExpression
 		p.binaryShiftExpression(f, n, "<<", t, mode, flags)
 	case cc.ShiftExpressionRsh: // ShiftExpression ">>" AdditiveExpression
 		p.binaryShiftExpression(f, n, ">>", t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) binaryShiftExpression(f *function, n *cc.ShiftExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// ShiftExpression "<<" AdditiveExpression
 	switch mode {
 	case exprValue:
 		p.binaryShiftExpressionValue(f, n, oper, t, mode, flags)
 	case exprBool:
 		p.binaryShiftExpressionBool(f, n, oper, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) todo(n cc.Node, t cc.Type) {
 	p.w("func() %s { panic(`%v: TODO (%v)`)}()", p.typ(n, t), n.Position(), origin(2))
 }
 
 func (p *project) binaryShiftExpressionBool(f *function, n *cc.ShiftExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, n.Operand.Type(), &mode, flags))
 	switch {
 	case n.ShiftExpression.Operand.Type().IsBitFieldType():
 		p.w("(")
 		p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags)
 		p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 		p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 		p.w(")&%#x", bfValueMask(n.ShiftExpression.Operand.Type().BitField()))
 	case shiftOverflows(n, n.ShiftExpression.Operand, n.AdditiveExpression.Operand, oper, n.Operand.Type()):
 		p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags|fForceRuntimeConv)
 		p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 		p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 	case isConstInteger(n.ShiftExpression.Operand):
 		s := p.convertNil(n, n.Operand.Type(), 0)
 		p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags)
 		p.w("%s %s%s", s, oper, tidyComment(" ", &n.Token))
 		p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 	default:
 		p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags)
 		p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 		p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 	}
 }
 
 func shiftOp(s string) string {
 	switch s {
 	case "<<":
 		return "Shl"
 	case ">>":
 		return "Shr"
 	default:
 		panic(todo("%q", s))
 	}
 }
 
 func bfValueMask(bf cc.Field) uint64 {
 	return uint64(1)<<bf.BitFieldWidth() - 1
 }
 
 func (p *project) binaryShiftExpressionValue(f *function, n *cc.ShiftExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// ShiftExpression "<<" AdditiveExpression
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	switch k := n.ShiftExpression.Operand.Type().Kind(); {
 	case k == cc.Int128, k == cc.UInt128:
 		p.w("(")
 		p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags)
 		p.w(").%s(", shiftOp(oper))
 		p.additiveExpression(f, n.AdditiveExpression, p.intType, exprValue, flags)
 		p.w(")")
 	case n.ShiftExpression.Operand.Type().IsBitFieldType():
 		p.w("(")
 		p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags)
 		p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 		p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 		p.w(")&%#x", bfValueMask(n.ShiftExpression.Operand.Type().BitField()))
 	case shiftOverflows(n, n.ShiftExpression.Operand, n.AdditiveExpression.Operand, oper, n.Operand.Type()):
 		p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags|fForceRuntimeConv)
 		p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 		p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 	case isConstInteger(n.ShiftExpression.Operand):
 		s := p.convertNil(n, n.Operand.Type(), 0)
 		p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags)
 		p.w("%s %s%s", s, oper, tidyComment(" ", &n.Token))
 		p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 	default:
 		p.shiftExpression(f, n.ShiftExpression, n.Operand.Type(), exprValue, flags)
 		p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 		p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 	}
 }
 
 func shiftOverflows(n cc.Node, lo, ro cc.Operand, oper string, result cc.Type) bool {
 	a, b, ok := getIntOperands(lo, ro)
 	if !ok {
 		return false
 	}
 
 	if !b.IsUint64() {
 		return true
 	}
 
 	bits := b.Uint64()
 	if bits > mathutil.MaxUint {
 		return true
 	}
 
 	switch oper {
 	case "<<":
 		return overflows(a.Lsh(a, uint(bits)), result)
 	case ">>":
 		return overflows(a.Rsh(a, uint(bits)), result)
 	default:
 		panic(todo("", pos(n)))
 	}
 }
 
 func (p *project) additiveExpression(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.additiveExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.additiveExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.additiveExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.additiveExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.additiveExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.additiveExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.additiveExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.additiveExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.additiveExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) additiveExpressionDecay(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AdditiveExpressionMul: // MultiplicativeExpression
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags)
 	case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
 		panic(todo("", p.pos(n)))
 	case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) additiveExpressionSelect(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AdditiveExpressionMul: // MultiplicativeExpression
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags)
 	case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
 		panic(todo("", p.pos(n)))
 	case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) additiveExpressionFunc(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AdditiveExpressionMul: // MultiplicativeExpression
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags)
 	case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
 		panic(todo("", p.pos(n)))
 	case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) additiveExpressionPSelect(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AdditiveExpressionMul: // MultiplicativeExpression
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags)
 	case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, t.Elem()))
 		p.additiveExpression(f, n, t, exprValue, flags)
 		p.w("))")
 	case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, t.Elem()))
 		p.additiveExpression(f, n, t, exprValue, flags)
 
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) additiveExpressionLValue(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AdditiveExpressionMul: // MultiplicativeExpression
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags)
 	case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
 		panic(todo("", p.pos(n)))
 	case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) additiveExpressionBool(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AdditiveExpressionMul: // MultiplicativeExpression
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags)
 	case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
 		p.binaryAdditiveExpression(f, n, "+", t, mode, flags)
 	case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
 		p.binaryAdditiveExpression(f, n, "-", t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) additiveExpressionAddrOf(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AdditiveExpressionMul: // MultiplicativeExpression
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags)
 	case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
 		panic(todo("", p.pos(n)))
 	case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) additiveExpressionVoid(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AdditiveExpressionMul: // MultiplicativeExpression
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags)
 	case
 		cc.AdditiveExpressionAdd, // AdditiveExpression '+' MultiplicativeExpression
 		cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
 
 		p.w("_ = ")
 		p.additiveExpression(f, n, n.Operand.Type(), exprValue, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) additiveExpressionValue(f *function, n *cc.AdditiveExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.AdditiveExpressionMul: // MultiplicativeExpression
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, t, mode, flags)
 	case cc.AdditiveExpressionAdd: // AdditiveExpression '+' MultiplicativeExpression
 		p.binaryAdditiveExpression(f, n, "+", t, mode, flags)
 	case cc.AdditiveExpressionSub: // AdditiveExpression '-' MultiplicativeExpression
 		p.binaryAdditiveExpression(f, n, "-", t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) binaryAdditiveExpression(f *function, n *cc.AdditiveExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// AdditiveExpression '+' MultiplicativeExpression
 	switch mode {
 	case exprValue:
 		p.binaryAdditiveExpressionValue(f, n, oper, t, mode, flags)
 	case exprBool:
 		p.binaryAdditiveExpressionBool(f, n, oper, t, mode, flags)
 	default:
 		panic(todo("", mode))
 	}
 }
 
 func (p *project) binaryAdditiveExpressionBool(f *function, n *cc.AdditiveExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// AdditiveExpression '+' MultiplicativeExpression
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, n.Operand.Type(), &mode, flags))
 	lo := n.AdditiveExpression.Operand
 	ro := n.MultiplicativeExpression.Operand
 	lt := lo.Type()
 	rt := ro.Type()
 	switch {
 	case lt.Kind() == cc.Ptr && rt.Kind() == cc.Ptr && oper == "-":
 		p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 		p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags)
 	case lt.IsArithmeticType() && rt.IsArithmeticType(): // x +- y
 		defer p.w("%s", p.bitFieldPatch2(n, lo, ro, n.Promote())) //TODO bit field big endian
 		switch {
 		case intAddOverflows(n, lo, ro, oper, n.Promote()): // i +- j
 			p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 			p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 			p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags|fForceRuntimeConv)
 		default:
 			var s string
 			if isRealType(n.Operand) && n.Operand.Value() != nil {
 				s = p.convertNil(n, n.Promote(), flags)
 			}
 			p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 			p.w("%s %s%s", s, oper, tidyComment(" ", &n.Token))
 			p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags)
 		}
 	default:
 		panic(todo("", n.Position(), lt, rt, oper))
 	}
 }
 
 func (p *project) binaryAdditiveExpressionValue(f *function, n *cc.AdditiveExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// AdditiveExpression '+' MultiplicativeExpression
 
 	lt := n.AdditiveExpression.Operand.Type()
 	rt := n.MultiplicativeExpression.Operand.Type()
 	switch lk, rk := lt.Kind(), rt.Kind(); {
 	case
 		lk == cc.UInt128 || rk == cc.UInt128,
 		lk == cc.Int128 || rk == cc.Int128:
 
 		p.binaryAdditiveExpressionUint128(f, n, oper, t, mode, flags)
 		return
 	}
 
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	lo := n.AdditiveExpression.Operand
 	ro := n.MultiplicativeExpression.Operand
 	switch {
 	case lt.IsArithmeticType() && rt.IsArithmeticType(): // x +- y
 		defer p.w("%s", p.bitFieldPatch2(n, lo, ro, n.Promote())) //TODO bit field big endian
 		switch {
 		case intAddOverflows(n, lo, ro, oper, n.Promote()): // i +- j
 			p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 			p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 			p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags|fForceRuntimeConv)
 		default:
 			var s string
 			if isRealType(n.Operand) && n.Operand.Value() != nil {
 				s = p.convertNil(n, n.Promote(), flags)
 			}
 			p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 			p.w("%s %s%s", s, oper, tidyComment(" ", &n.Token))
 			p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags)
 		}
 	case lt.Kind() == cc.Ptr && rt.IsIntegerType(): // p +- i
 		p.additiveExpression(f, n.AdditiveExpression, lt, exprValue, flags)
 		p.w(" %s%s uintptr(", oper, tidyComment(" ", &n.Token))
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, rt, exprValue, flags)
 		p.w(")")
 		if sz := lt.Elem().Size(); sz != 1 {
 			p.w("*%d", sz)
 		}
 	case lt.Kind() == cc.Array && rt.IsIntegerType(): // p +- i
 		p.additiveExpression(f, n.AdditiveExpression, lt, exprDecay, flags)
 		p.w(" %s%s uintptr(", oper, tidyComment(" ", &n.Token))
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, rt, exprValue, flags)
 		p.w(")")
 		if sz := lt.Elem().Size(); sz != 1 {
 			p.w("*%d", sz)
 		}
 	case lt.IsIntegerType() && rt.Kind() == cc.Ptr: // i +- p
 		p.w("uintptr(")
 		p.additiveExpression(f, n.AdditiveExpression, lt, exprValue, flags)
 		p.w(")")
 		if sz := rt.Elem().Size(); sz != 1 {
 			p.w("*%d", sz)
 		}
 		p.w(" %s%s ", oper, tidyComment(" ", &n.Token))
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, rt, exprValue, flags)
 	case lt.IsIntegerType() && rt.Kind() == cc.Array: // i +- p
 		panic(todo("", p.pos(n)))
 	case lt.Kind() == cc.Ptr && rt.Kind() == cc.Ptr && oper == "-": // p - q
 		p.w("(")
 		p.additiveExpression(f, n.AdditiveExpression, n.Operand.Type(), exprValue, flags)
 		p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Operand.Type(), exprValue, flags)
 		p.w(")/%d", lt.Elem().Size())
 	case lt.Kind() == cc.Ptr && rt.Kind() == cc.Array && oper == "-": // p - q
 		defer p.w("%s", p.convertType(n, nil, n.Operand.Type(), 0))
 		p.w("(")
 		p.additiveExpression(f, n.AdditiveExpression, lt, exprValue, flags)
 		p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, rt.Decay(), exprDecay, flags)
 		p.w(")/%d", lt.Elem().Size())
 	case lt.Kind() == cc.Array && rt.Kind() == cc.Ptr && oper == "-": // p - q
 		panic(todo("", p.pos(n)))
 	case lt.Kind() == cc.Array && rt.Kind() == cc.Array && oper == "-": // p - q
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("", n.Position(), lt, rt, oper))
 	}
 }
 
 func (p *project) binaryAdditiveExpressionUint128(f *function, n *cc.AdditiveExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// AdditiveExpression '+' MultiplicativeExpression
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.additiveExpression(f, n.AdditiveExpression, n.Promote(), exprValue, flags)
 	switch oper {
 	case "+":
 		p.w(".Add(")
 	case "-":
 		p.w(".Sub(")
 	default:
 		panic(todo("%q", oper))
 	}
 	p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags)
 	p.w(")")
 }
 
 func (p *project) bitFieldPatch2(n cc.Node, a, b cc.Operand, promote cc.Type) string {
 	//TODO bit field big endian
 	var m uint64
 	var w int
 	switch {
 	case a.Type().IsBitFieldType():
 		bf := a.Type().BitField()
 		w = bf.BitFieldWidth()
 		m = bf.Mask() >> bf.BitFieldOffset()
 		if b.Type().IsBitFieldType() {
 			bf = b.Type().BitField()
 			w2 := bf.BitFieldWidth()
 			if w2 != w {
 				panic(todo("", p.pos(n)))
 			}
 		}
 	case b.Type().IsBitFieldType():
 		bf := b.Type().BitField()
 		w = bf.BitFieldWidth()
 		m = bf.Mask() >> bf.BitFieldOffset()
 	default:
 		return ""
 	}
 
 	p.w("((")
 	switch {
 	case promote.IsSignedType():
 		n := int(promote.Size())*8 - w
 		var s string
 		switch promote.Size() {
 		case 4:
 			s = fmt.Sprintf(")&%#x", int32(m))
 		default:
 			s = fmt.Sprintf(")&%#x", m)
 		}
 		if n != 0 {
 			s += fmt.Sprintf("<<%d>>%[1]d", n)
 		}
 		return ")" + s
 	default:
 		return fmt.Sprintf(")&%#x)", m)
 	}
 }
 
 func intAddOverflows(n cc.Node, lo, ro cc.Operand, oper string, promote cc.Type) bool {
 	a, b, ok := getIntOperands(lo, ro)
 	if !ok {
 		return false
 	}
 
 	switch oper {
 	case "+":
 		return overflows(a.Add(a, b), promote)
 	case "-":
 		return overflows(a.Sub(a, b), promote)
 	default:
 		panic(todo("", pos(n)))
 	}
 }
 
 func getIntOperands(a, b cc.Operand) (x, y *big.Int, ok bool) {
 	switch n := a.Value().(type) {
 	case cc.Int64Value:
 		x = big.NewInt(int64(n))
 	case cc.Uint64Value:
 		x = big.NewInt(0).SetUint64(uint64(n))
 	default:
 		return nil, nil, false
 	}
 
 	switch n := b.Value().(type) {
 	case cc.Int64Value:
 		return x, big.NewInt(int64(n)), true
 	case cc.Uint64Value:
 		return x, big.NewInt(0).SetUint64(uint64(n)), true
 	default:
 		return nil, nil, false
 	}
 }
 
 func overflows(n *big.Int, promote cc.Type) bool {
 	switch k := promote.Kind(); {
 	case k == cc.Int128, k == cc.UInt128:
 		return false
 	case isSigned(promote):
 		switch promote.Size() {
 		case 4:
 			return n.Cmp(minInt32) < 0 || n.Cmp(maxInt32) > 0
 		case 8:
 			return n.Cmp(minInt64) < 0 || n.Cmp(maxInt64) > 0
 		}
 	default:
 		switch promote.Size() {
 		case 4:
 			return n.Sign() < 0 || n.Cmp(maxUint32) > 0
 		case 8:
 			return n.Sign() < 0 || n.Cmp(maxUint64) > 0
 		}
 	}
 	panic(todo("", promote.Size(), promote))
 }
 
 func (p *project) multiplicativeExpression(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprValue:
 		p.multiplicativeExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.multiplicativeExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.multiplicativeExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.multiplicativeExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.multiplicativeExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.multiplicativeExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.multiplicativeExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.multiplicativeExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.multiplicativeExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) multiplicativeExpressionDecay(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.MultiplicativeExpressionCast: // CastExpression
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) multiplicativeExpressionSelect(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.MultiplicativeExpressionCast: // CastExpression
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) multiplicativeExpressionFunc(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.MultiplicativeExpressionCast: // CastExpression
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) multiplicativeExpressionPSelect(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.MultiplicativeExpressionCast: // CastExpression
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) multiplicativeExpressionLValue(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.MultiplicativeExpressionCast: // CastExpression
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) multiplicativeExpressionBool(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.MultiplicativeExpressionCast: // CastExpression
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	case
 		cc.MultiplicativeExpressionMul, // MultiplicativeExpression '*' CastExpression
 		cc.MultiplicativeExpressionDiv, // MultiplicativeExpression '/' CastExpression
 		cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
 
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0 ")
 		p.multiplicativeExpression(f, n, t, exprValue, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) multiplicativeExpressionAddrOf(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.MultiplicativeExpressionCast: // CastExpression
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) multiplicativeExpressionVoid(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.MultiplicativeExpressionCast: // CastExpression
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) multiplicativeExpressionValue(f *function, n *cc.MultiplicativeExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.MultiplicativeExpressionCast: // CastExpression
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	case cc.MultiplicativeExpressionMul: // MultiplicativeExpression '*' CastExpression
 		p.binaryMultiplicativeExpression(f, n, "*", t, mode, flags)
 	case cc.MultiplicativeExpressionDiv: // MultiplicativeExpression '/' CastExpression
 		p.binaryMultiplicativeExpression(f, n, "/", t, mode, flags)
 	case cc.MultiplicativeExpressionMod: // MultiplicativeExpression '%' CastExpression
 		p.binaryMultiplicativeExpression(f, n, "%", t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) binaryMultiplicativeExpression(f *function, n *cc.MultiplicativeExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// MultiplicativeExpression '*' CastExpression
 	switch mode {
 	case exprValue:
 		p.binaryMultiplicativeExpressionValue(f, n, oper, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) binaryMultiplicativeExpressionValue(f *function, n *cc.MultiplicativeExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// MultiplicativeExpression '*' CastExpression
 
 	lt := n.MultiplicativeExpression.Operand.Type()
 	rt := n.CastExpression.Operand.Type()
 	switch lk, rk := lt.Kind(), rt.Kind(); {
 	case
 		lk == cc.UInt128 || rk == cc.UInt128,
 		lk == cc.Int128 || rk == cc.Int128:
 
 		p.binaryMultiplicativeExpressionUint128(f, n, oper, t, mode, flags)
 		return
 	}
 
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	switch {
 	case intMulOverflows(n, n.Operand, n.MultiplicativeExpression.Operand, n.CastExpression.Operand, oper, n.Promote()):
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags|fForceRuntimeConv)
 		p.w(" %s%s", oper, tidyComment(" ", &n.Token))
 		p.castExpression(f, n.CastExpression, n.Promote(), exprValue, flags|fForceRuntimeConv)
 	default:
 		defer p.w("%s", p.bitFieldPatch2(n, n.MultiplicativeExpression.Operand, n.CastExpression.Operand, n.Promote())) //TODO bit field big endian
 		var s string
 		if isRealType(n.Operand) && n.Operand.Value() != nil {
 			s = p.convertNil(n, n.Promote(), flags)
 		}
 		p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags)
 		p.w("%s %s%s", s, oper, tidyComment(" ", &n.Token))
 		if (oper == "/" || oper == "%") && (isZeroReal(n.MultiplicativeExpression.Operand) || isZeroReal(n.CastExpression.Operand)) {
 			p.w("%s%sFrom%[2]s(", p.task.crt, p.helperType(n, n.Promote()))
 			defer p.w(")")
 		}
 		p.castExpression(f, n.CastExpression, n.Promote(), exprValue, flags)
 	}
 }
 
 func (p *project) binaryMultiplicativeExpressionUint128(f *function, n *cc.MultiplicativeExpression, oper string, t cc.Type, mode exprMode, flags flags) {
 	// MultiplicativeExpression '*' CastExpression
 	defer p.w("%s", p.artithmeticBinaryExpression(n, n.Operand, t, &mode, flags))
 	p.multiplicativeExpression(f, n.MultiplicativeExpression, n.Promote(), exprValue, flags)
 	switch oper {
 	case "*":
 		p.w(".Mul(")
 	case "/":
 		p.w(".Div(")
 	case "%":
 		p.w(".Mod(")
 	default:
 		panic(todo("%q", oper))
 	}
 	p.castExpression(f, n.CastExpression, n.Promote(), exprValue, flags)
 	p.w(")")
 }
 
 func isZeroReal(op cc.Operand) bool {
 	switch x := op.Value().(type) {
 	case cc.Float32Value:
 		return x == 0
 	case cc.Float64Value:
 		return x == 0
 	default:
 		return false
 	}
 }
 
 func intMulOverflows(n cc.Node, r, lo, ro cc.Operand, oper string, promote cc.Type) bool {
 	if (isReal(lo) && !isInf(lo) || isReal(ro) && !isInf(ro)) && isInf(r) {
 		return true
 	}
 
 	a, b, ok := getIntOperands(lo, ro)
 	if !ok {
 		return false
 	}
 
 	switch oper {
 	case "*":
 		return overflows(a.Mul(a, b), promote)
 	case "/":
 		if b.Sign() == 0 {
 			return true
 		}
 
 		return overflows(a.Div(a, b), promote)
 	case "%":
 		if b.Sign() == 0 {
 			return true
 		}
 
 		return overflows(a.Mod(a, b), promote)
 	default:
 		panic(todo("", pos(n)))
 	}
 }
 
 func isReal(op cc.Operand) bool {
 	switch op.Value().(type) {
 	case cc.Float32Value, cc.Float64Value:
 		return true
 	default:
 		return false
 	}
 }
 
 func isInf(op cc.Operand) bool {
 	switch x := op.Value().(type) {
 	case cc.Float32Value:
 		return math.IsInf(float64(x), 0)
 	case cc.Float64Value:
 		return math.IsInf(float64(x), 0)
 	default:
 		return false
 	}
 }
 
 func (p *project) castExpression(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	if n.Case == cc.CastExpressionCast {
 		if f != nil && n.CastExpression.Operand.Type().Kind() == cc.Ptr { // void *__ccgo_va_arg(__builtin_va_list ap);
 			sv := f.vaType
 			f.vaType = n.TypeName.Type()
 			defer func() { f.vaType = sv }()
 		}
 	}
 	switch mode {
 	case exprValue:
 		p.castExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.castExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.castExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.castExpressionBool(f, n, t, mode, flags)
 	case exprLValue:
 		p.castExpressionLValue(f, n, t, mode, flags)
 	case exprPSelect:
 		p.castExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.castExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.castExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.castExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) castExpressionDecay(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.CastExpressionUnary: // UnaryExpression
 		p.unaryExpression(f, n.UnaryExpression, t, mode, flags)
 	case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) castExpressionSelect(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.CastExpressionUnary: // UnaryExpression
 		p.unaryExpression(f, n.UnaryExpression, t, mode, flags)
 	case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 		p.castExpression(f, n.CastExpression, n.TypeName.Type(), mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) castExpressionFunc(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.CastExpressionUnary: // UnaryExpression
 		p.unaryExpression(f, n.UnaryExpression, t, mode, flags)
 	case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 		ot := n.CastExpression.Operand.Type()
 		tn := n.TypeName.Type()
 		var ft cc.Type
 		switch tn.Kind() {
 		case cc.Ptr:
 			switch et := ot.Elem(); et.Kind() {
 			case cc.Function, cc.Void:
 				// ok
 			default:
 				panic(todo("", p.pos(n), et, et.Kind()))
 			}
 		default:
 			panic(todo("%v: %v, %v -> %v, %v -> %v, %v", p.pos(n), ot, ot.Kind(), tn, tn.Kind(), t, t.Kind()))
 		}
 		switch t.Kind() {
 		case cc.Ptr:
 			switch et := t.Elem(); et.Kind() {
 			case cc.Function:
 				ft = et
 			default:
 				panic(todo("", p.pos(n), et, et.Kind()))
 			}
 		default:
 			panic(todo("%v: %v, %v -> %v, %v -> %v, %v", p.pos(n), ot, ot.Kind(), tn, tn.Kind(), t, t.Kind()))
 		}
 		switch ot.Kind() {
 		case cc.Ptr:
 			switch et := ot.Elem(); et.Kind() {
 			case cc.Function, cc.Void:
 				p.w("(*(*")
 				p.functionSignature(n, f, ft, "")
 				p.w(")(unsafe.Pointer(")
 				p.castExpression(f, n.CastExpression, ot, exprAddrOf, flags)
 				p.w(")))")
 			default:
 				panic(todo("", p.pos(n), et, et.Kind()))
 			}
 		default:
 			panic(todo("%v: %v, %v -> %v, %v -> %v, %v", p.pos(n), ot, ot.Kind(), tn, tn.Kind(), t, t.Kind()))
 		}
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) castExpressionPSelect(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.CastExpressionUnary: // UnaryExpression
 		p.unaryExpression(f, n.UnaryExpression, t, mode, flags)
 	case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 		p.castExpression(f, n.CastExpression, n.TypeName.Type(), mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) castExpressionLValue(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.CastExpressionUnary: // UnaryExpression
 		p.unaryExpression(f, n.UnaryExpression, t, mode, flags)
 	case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) castExpressionBool(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.CastExpressionUnary: // UnaryExpression
 		p.unaryExpression(f, n.UnaryExpression, t, mode, flags)
 	case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0 ")
 		p.castExpression(f, n, n.Operand.Type(), exprValue, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) castExpressionAddrOf(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.CastExpressionUnary: // UnaryExpression
 		p.unaryExpression(f, n.UnaryExpression, t, mode, flags)
 	case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 		p.castExpressionAddrOf(f, n.CastExpression, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) castExpressionVoid(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.CastExpressionUnary: // UnaryExpression
 		p.unaryExpression(f, n.UnaryExpression, t, mode, flags)
 	case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) castExpressionValue(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.CastExpressionUnary: // UnaryExpression
 		p.unaryExpression(f, n.UnaryExpression, t, mode, flags)
 	case cc.CastExpressionCast: // '(' TypeName ')' CastExpression
 		if f != nil && p.pass1 && n.TypeName.Type().IsIntegerType() && n.CastExpression.Operand.Type().Kind() == cc.Array {
 			if d := n.CastExpression.Declarator(); d != nil {
 				f.pin(n, d)
 			}
 		}
 		switch k := p.opKind(f, n.CastExpression, n.CastExpression.Operand.Type()); k {
 		case opNormal, opBitfield:
 			p.castExpressionValueNormal(f, n, t, mode, flags)
 		case opArray:
 			p.castExpressionValueArray(f, n, t, mode, flags)
 		case opFunction:
 			p.castExpressionValueFunction(f, n, t, mode, flags)
 		case opArrayParameter:
 			p.castExpressionValueNormal(f, n, t, mode, flags)
 		default:
 			panic(todo("", n.Position(), k))
 		}
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) castExpressionValueArrayParameter(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	// '(' TypeName ')' CastExpression
 	tn := n.TypeName.Type()
 	defer p.w("%s", p.convertType(n, tn, t, flags))
 	p.castExpression(f, n.CastExpression, tn, mode, flags)
 }
 
 func (p *project) castExpressionValueFunction(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	// '(' TypeName ')' CastExpression
 	op := n.CastExpression.Operand
 	tn := n.TypeName.Type()
 	switch {
 	case op.Type().Kind() == cc.Function:
 		switch {
 		case tn.Kind() == cc.Ptr && t.Kind() == cc.Ptr:
 			p.castExpression(f, n.CastExpression, op.Type(), exprValue, flags)
 		case tn.IsIntegerType():
 			p.w("%s(", p.typ(n, tn))
 			p.castExpression(f, n.CastExpression, op.Type(), exprValue, flags)
 			p.w(")")
 		default:
 			panic(todo("%v: tn %v expr %v", n.Position(), tn, op.Type()))
 		}
 	default:
 		panic(todo("%v: %v -> %v -> %v", p.pos(n), op.Type(), tn, t))
 	}
 }
 
 func (p *project) castExpressionValueArray(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	// '(' TypeName ')' CastExpression
 	tn := n.TypeName.Type()
 	switch {
 	case tn.IsScalarType():
 		defer p.w("%s", p.convertType(n, nil, t, flags))
 		p.castExpression(f, n.CastExpression, tn, exprDecay, flags)
 	default:
 		panic(todo("", p.pos(n)))
 	}
 }
 
 func (p *project) castExpressionValueNormal(f *function, n *cc.CastExpression, t cc.Type, mode exprMode, flags flags) {
 	// '(' TypeName ')' CastExpression
 	op := n.CastExpression.Operand
 	tn := n.TypeName.Type()
 	switch {
 	case op.Type().Kind() == cc.Ptr && tn.IsArithmeticType():
 		defer p.w("%s", p.convertType(n, nil, t, flags|fForceConv))
 		p.castExpression(f, n.CastExpression, op.Type(), mode, flags)
 	case tn.IsArithmeticType():
 		switch {
 		case (tn.Kind() == cc.Float || tn.Kind() == cc.Double) && op.Type().IsIntegerType() && op.Value() != nil && t.IsIntegerType():
 			panic(todo("", p.pos(n)))
 		case isNegativeInt(op) && isUnsigned(t):
 			defer p.w("%s", p.convertType(n, tn, t, flags|fForceConv))
 			p.castExpression(f, n.CastExpression, tn, exprValue, flags)
 		default:
 			defer p.w("%s", p.convertType(n, tn, t, flags))
 			p.castExpression(f, n.CastExpression, tn, exprValue, flags)
 		}
 	default:
 		switch tn.Kind() {
 		case cc.Ptr:
 			switch {
 			case t.Kind() == cc.Ptr && isNegativeInt(op):
 				p.w("%s(", p.helperType2(n, op.Type(), tn))
 				defer p.w(")")
 				p.castExpression(f, n.CastExpression, op.Type(), mode, flags)
 			default:
 				defer p.w("%s", p.convertType(n, tn, t, flags))
 				p.castExpression(f, n.CastExpression, tn, mode, flags)
 			}
 		case cc.Void:
 			p.castExpression(f, n.CastExpression, tn, exprVoid, flags)
 		default:
 			panic(todo("%s: %s %s -> %s %s -> %s %s", n.Position(), op.Type(), op.Type().Kind(), tn, tn.Kind(), t, t.Kind()))
 		}
 	}
 }
 
 func (p *project) unaryExpression(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprLValue:
 		p.unaryExpressionLValue(f, n, t, mode, flags)
 	case exprValue:
 		p.unaryExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.unaryExpressionVoid(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.unaryExpressionAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.unaryExpressionBool(f, n, t, mode, flags)
 	case exprPSelect:
 		p.unaryExpressionPSelect(f, n, t, mode, flags)
 	case exprFunc:
 		p.unaryExpressionFunc(f, n, t, mode, flags)
 	case exprSelect:
 		p.unaryExpressionSelect(f, n, t, mode, flags)
 	case exprDecay:
 		p.unaryExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) unaryExpressionDecay(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		p.postfixExpression(f, n.PostfixExpression, t, mode, flags)
 	case cc.UnaryExpressionInc: // "++" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionDec: // "--" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAddrof: // '&' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionDeref: // '*' CastExpression
 		p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 	case cc.UnaryExpressionPlus: // '+' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionMinus: // '-' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionCpl: // '~' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionNot: // '!' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionImag: // "__imag__" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionReal: // "__real__" UnaryExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) unaryExpressionSelect(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		p.postfixExpression(f, n.PostfixExpression, t, mode, flags)
 	case cc.UnaryExpressionInc: // "++" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionDec: // "--" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionAddrof: // '&' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionDeref: // '*' CastExpression
 		ot := n.CastExpression.Operand.Type()
 		switch ot.Kind() {
 		case cc.Ptr:
 			switch et := ot.Elem(); et.Kind() {
 			case
 				cc.Struct,
 				cc.Union:
 
 				p.w("(*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 				p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 				p.w(")))")
 			default:
 				panic(todo("", p.pos(n), et, et.Kind()))
 			}
 		case cc.Array:
 			p.w("(*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 			p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprAddrOf, flags)
 			p.w(")))")
 		default:
 			panic(todo("", p.pos(n), ot, ot.Kind()))
 		}
 	case cc.UnaryExpressionPlus: // '+' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionMinus: // '-' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionCpl: // '~' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionNot: // '!' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionImag: // "__imag__" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionReal: // "__real__" UnaryExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) unaryExpressionFunc(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		p.postfixExpression(f, n.PostfixExpression, t, mode, flags)
 	case cc.UnaryExpressionInc: // "++" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionDec: // "--" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAddrof: // '&' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionDeref: // '*' CastExpression
 		ot := n.CastExpression.Operand.Type()
 		switch ot.Kind() {
 		case cc.Ptr:
 			switch et := ot.Elem(); et.Kind() {
 			case cc.Function:
 				p.castExpression(f, n.CastExpression, ot, mode, flags|fAddrOfFuncPtrOk)
 			case cc.Ptr:
 				switch et2 := et.Elem(); et2.Kind() {
 				case cc.Function:
 					// C: (**)()
 					p.fnVal(n, f, func() { p.castExpression(f, n.CastExpression, p.ptrType, exprValue, flags|fAddrOfFuncPtrOk) }, n.CastExpression.Declarator(), n.CastExpression.Operand.Type(), 1, mode, flags)
 				default:
 					panic(todo("", p.pos(n), et2, et2.Kind()))
 				}
 			default:
 				panic(todo("", p.pos(n), et, et.Kind()))
 			}
 		case cc.Function:
 			p.castExpression(f, n.CastExpression, ot, mode, flags|fAddrOfFuncPtrOk)
 		default:
 			panic(todo("", p.pos(n), ot, ot.Kind(), mode))
 		}
 	case cc.UnaryExpressionPlus: // '+' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionMinus: // '-' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionCpl: // '~' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionNot: // '!' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionImag: // "__imag__" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionReal: // "__real__" UnaryExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) unaryExpressionPSelect(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		p.postfixExpression(f, n.PostfixExpression, t, mode, flags)
 	case cc.UnaryExpressionInc: // "++" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionDec: // "--" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionAddrof: // '&' CastExpression
 		panic(todo("", n.Position()))
 		//TODO- p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem()))
 		//TODO- p.unaryExpression(f, n, t, exprValue, flags)
 		//TODO- p.w("))")
 	case cc.UnaryExpressionDeref: // '*' CastExpression
 		panic(todo("", n.Position()))
 		//TODO- ot := n.CastExpression.Operand.Type()
 		//TODO- switch ot.Kind() {
 		//TODO- case cc.Ptr:
 		//TODO- 	switch et := ot.Elem(); {
 		//TODO- 	case et.Kind() == cc.Ptr:
 		//TODO- 		switch et2 := et.Elem(); et2.Kind() {
 		//TODO- 		case cc.Struct:
 		//TODO- 			if et2.IsIncomplete() {
 		//TODO- 				p.w("(*(**uintptr)(unsafe.Pointer(")
 		//TODO- 				p.castExpression(f, n.CastExpression, t, exprValue, flags)
 		//TODO- 				p.w(")))")
 		//TODO- 				break
 		//TODO- 			}
 
 		//TODO- 			p.w("(*(**%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem()))
 		//TODO- 			p.castExpression(f, n.CastExpression, t, exprValue, flags)
 		//TODO- 			p.w(")))")
 		//TODO- 		default:
 		//TODO- 			panic(todo("", p.pos(n), et2, et2.Kind()))
 		//TODO- 		}
 		//TODO- 	default:
 		//TODO- 		panic(todo("", p.pos(n), et, et.Kind()))
 		//TODO- 	}
 		//TODO- default:
 		//TODO- 	panic(todo("", p.pos(n), ot, ot.Kind()))
 		//TODO- }
 	case cc.UnaryExpressionPlus: // '+' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionMinus: // '-' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionCpl: // '~' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionNot: // '!' CastExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionImag: // "__imag__" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionReal: // "__real__" UnaryExpression
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) unaryExpressionBool(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		p.postfixExpression(f, n.PostfixExpression, t, mode, flags)
 	case cc.UnaryExpressionNot: // '!' CastExpression
 		p.w("!(")
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 		p.w(")")
 	default:
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0 ")
 		p.unaryExpression(f, n, t, exprValue, flags)
 	}
 }
 
 func (p *project) unaryExpressionAddrOf(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		p.postfixExpression(f, n.PostfixExpression, t, mode, flags)
 	case cc.UnaryExpressionInc: // "++" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionDec: // "--" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionAddrof: // '&' CastExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionDeref: // '*' CastExpression
 		ot := n.CastExpression.Operand.Type()
 		switch ot.Kind() {
 		case cc.Ptr:
 			switch et := ot.Elem(); {
 			case
 				et.IsScalarType(),
 				et.Kind() == cc.Struct,
 				et.Kind() == cc.Union,
 				et.Kind() == cc.Array:
 
 				p.unaryExpressionDeref(f, n, t, mode, flags)
 			default:
 				panic(todo("", p.pos(n), et, et.Kind()))
 			}
 		default:
 			panic(todo("", p.pos(n), ot, ot.Kind()))
 		}
 	case cc.UnaryExpressionPlus: // '+' CastExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionMinus: // '-' CastExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionCpl: // '~' CastExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionNot: // '!' CastExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')'
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')'
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionImag: // "__imag__" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionReal: // "__real__" UnaryExpression
 		panic(todo("", n.Position()))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) unaryExpressionVoid(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		p.postfixExpression(f, n.PostfixExpression, t, mode, flags)
 	case cc.UnaryExpressionInc: // "++" UnaryExpression
 		p.unaryExpressionPreIncDec(f, n, "++", "+=", t, mode, flags)
 	case cc.UnaryExpressionDec: // "--" UnaryExpression
 		p.unaryExpressionPreIncDec(f, n, "--", "-=", t, mode, flags)
 	case cc.UnaryExpressionAddrof: // '&' CastExpression
 		p.w("_ = ")
 		switch {
 		case n.CastExpression.Operand.Type().Kind() == cc.Array:
 			panic(todo("", p.pos(n)))
 		default:
 			p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprAddrOf, flags)
 		}
 	case cc.UnaryExpressionDeref: // '*' CastExpression
 		p.w("_ = *(*byte)(unsafe.Pointer(")
 		p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 		p.w("))")
 	case
 		cc.UnaryExpressionPlus,  // '+' CastExpression
 		cc.UnaryExpressionMinus, // '-' CastExpression
 		cc.UnaryExpressionNot,   // '!' CastExpression
 		cc.UnaryExpressionCpl:   // '~' CastExpression
 
 		p.w("_ = ")
 		defer p.w("%s", p.convert(n, n.CastExpression.Operand, p.intType, flags))
 		p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 	case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression
 		// nop
 	case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')'
 		// nop
 	case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')'
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionImag: // "__imag__" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionReal: // "__real__" UnaryExpression
 		panic(todo("", n.Position()))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) unaryExpressionValue(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		p.postfixExpression(f, n.PostfixExpression, t, mode, flags)
 	case cc.UnaryExpressionInc: // "++" UnaryExpression
 		p.unaryExpressionPreIncDec(f, n, "++", "+=", t, mode, flags)
 	case cc.UnaryExpressionDec: // "--" UnaryExpression
 		p.unaryExpressionPreIncDec(f, n, "--", "-=", t, mode, flags)
 	case cc.UnaryExpressionAddrof: // '&' CastExpression
 		if t.Kind() != cc.Ptr {
 			defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		}
 		switch {
 		case n.CastExpression.Operand.Type().Kind() == cc.Array:
 			panic(todo("", p.pos(n)))
 		default:
 			p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprAddrOf, flags)
 		}
 	case cc.UnaryExpressionDeref: // '*' CastExpression
 		ot := n.CastExpression.Operand.Type()
 		switch ot.Kind() {
 		case cc.Ptr, cc.Array:
 			switch et := ot.Elem(); {
 			case
 				et.IsScalarType(),
 				et.Kind() == cc.Array,
 				et.Kind() == cc.Struct,
 				et.Kind() == cc.Union:
 
 				p.unaryExpressionDeref(f, n, t, mode, flags)
 			case et.Kind() == cc.Function:
 				p.castExpression(f, n.CastExpression, t, mode, flags)
 			default:
 				panic(todo("", p.pos(n), et, et.Kind()))
 			}
 		default:
 			panic(todo("", p.pos(n), ot, ot.Kind()))
 		}
 	case cc.UnaryExpressionPlus: // '+' CastExpression
 		p.w(" +")
 		p.castExpression(f, n.CastExpression, t, mode, flags)
 	case cc.UnaryExpressionMinus: // '-' CastExpression
 		switch {
 		case isNonNegativeInt(n.CastExpression.Operand) && t.Kind() == cc.Ptr:
 			p.w(" -%sUintptr(", p.task.crt)
 			p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 			p.w(")")
 		case isZeroReal(n.CastExpression.Operand):
 			p.w(" -")
 			defer p.w("%s", p.convert(n, n.CastExpression.Operand, t, flags))
 			p.w("%s%sFrom%[2]s(", p.task.crt, p.helperType(n, n.CastExpression.Operand.Type()))
 			p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 			p.w(")")
 		case isNonNegativeInt(n.CastExpression.Operand) && isUnsigned(n.Operand.Type()):
 			defer p.w("%s", p.convert(n, n.CastExpression.Operand, t, flags))
 			p.w("%sNeg%s(", p.task.crt, p.helperType(n, n.CastExpression.Operand.Type()))
 			p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 			p.w(")")
 		default:
 			defer p.w("%s", p.convert(n, n.Operand, t, flags))
 			p.w(" -")
 			p.castExpression(f, n.CastExpression, n.Operand.Type(), exprValue, flags)
 		}
 	case cc.UnaryExpressionCpl: // '~' CastExpression
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		switch {
 		case n.CastExpression.Operand.Value() != nil:
 			switch {
 			case !t.IsIntegerType():
 				p.w(" ^")
 				p.castExpression(f, n.CastExpression, n.Operand.Type(), exprValue, flags|fForceRuntimeConv)
 			default:
 				p.w("%sCpl%s(", p.task.crt, p.helperType(n, n.Operand.Type()))
 				p.castExpression(f, n.CastExpression, n.Operand.Type(), exprValue, flags)
 				p.w(")")
 			}
 		default:
 			p.w(" ^")
 			p.castExpression(f, n.CastExpression, n.Operand.Type(), exprValue, flags)
 		}
 	case cc.UnaryExpressionNot: // '!' CastExpression
 		p.w("%sBool%s(!(", p.task.crt, p.helperType(n, t))
 		p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprBool, flags)
 		p.w("))")
 	case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression
 		p.checkSizeof(n.UnaryExpression, n.UnaryExpression.Operand.Type())
 		defer p.w("%s", p.convertNil(n, t, flags))
 		if d := n.UnaryExpression.Declarator(); d != nil {
 			var isLocal bool
 			if f != nil {
 				if local := f.locals[d]; local != nil {
 					isLocal = true
 					if !local.isPinned {
 						p.w("unsafe.Sizeof(%s)", local.name)
 						return
 					}
 				}
 			}
 
 			if !isLocal {
 				if tld := p.tlds[d]; tld != nil {
 					p.w("unsafe.Sizeof(%s)", tld.name)
 					break
 				}
 
 				nm := d.Name().String()
 				if imp := p.imports[nm]; imp != nil {
 					imp.used = true
 					p.w("unsafe.Sizeof(%sX%s)", imp.qualifier, nm)
 					break
 				}
 			}
 		}
 
 		t := n.UnaryExpression.Operand.Type()
 		if p.isArray(f, n.UnaryExpression, t) {
 			p.w("%d", t.Len()*t.Elem().Size())
 			break
 		}
 
 		s := "(0)"
 		if !t.IsArithmeticType() {
 			switch t.Kind() {
 			case cc.Ptr:
 				// ok
 			case cc.Struct, cc.Union, cc.Array:
 				s = "{}"
 			default:
 				panic(todo("", t.Kind()))
 			}
 		}
 		switch t.Kind() {
 		case cc.Int128, cc.UInt128:
 			s = "{}"
 		}
 		p.w("unsafe.Sizeof(%s%s)", p.typ(n, t), s)
 	case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')'
 		defer p.w("%s", p.convertNil(n, t, flags))
 		t := n.TypeName.Type()
 		p.checkSizeof(n.TypeName, t)
 		if t.Kind() == cc.Array {
 			p.w("%d", t.Len()*t.Elem().Size())
 			break
 		}
 
 		s := "(0)"
 		if !t.IsArithmeticType() {
 			switch t.Kind() {
 			case cc.Ptr:
 				// ok
 			case cc.Struct, cc.Union:
 				s = "{}"
 			default:
 				panic(todo("", t.Kind()))
 			}
 		}
 		switch t.Kind() {
 		case cc.Int128, cc.UInt128:
 			s = "{}"
 		}
 		p.w("unsafe.Sizeof(%s%s)", p.typ(n, t), s)
 	case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression
 		if n.TypeName.Type().Kind() == cc.Void {
 			p.intConst(n, "", n.Operand, t, flags)
 			break
 		}
 
 		defer p.w("%s", p.convertNil(n, t, flags))
 		t := n.UnaryExpression.Operand.Type()
 		if p.isArray(f, n.UnaryExpression, t) {
 			p.w("%d", t.Len()*t.Elem().Size())
 			break
 		}
 
 		s := "(0)"
 		if !t.IsArithmeticType() {
 			switch t.Kind() {
 			case cc.Ptr:
 				// ok
 			case cc.Struct, cc.Union:
 				s = "{}"
 			default:
 				panic(todo("", t.Kind()))
 			}
 		}
 		p.w("unsafe.Alignof(%s%s)", p.typ(n, t), s)
 	case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')'
 		if n.TypeName.Type().Kind() == cc.Void {
 			p.intConst(n, "", n.Operand, t, flags)
 			break
 		}
 
 		defer p.w("%s", p.convertNil(n, t, flags))
 		t := n.TypeName.Type()
 		if t.Kind() == cc.Array {
 			p.w("%d", t.Len()*t.Elem().Size())
 			break
 		}
 
 		s := "(0)"
 		if !t.IsArithmeticType() {
 			switch t.Kind() {
 			case cc.Ptr:
 				// ok
 			case cc.Struct, cc.Union:
 				s = "{}"
 			default:
 				panic(todo("", t.Kind()))
 			}
 		}
 		p.w("unsafe.Alignof(%s%s)", p.typ(n, t), s)
 	case cc.UnaryExpressionImag: // "__imag__" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionReal: // "__real__" UnaryExpression
 		panic(todo("", n.Position()))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) checkSizeof(n cc.Node, t cc.Type) {
 	if !p.checkSizeof0(n, t) {
 		p.err(n, "sizeof type %s: not supported", t.Alias())
 	}
 }
 
 func (p *project) checkSizeof0(n cc.Node, t cc.Type) (ok bool) {
 	switch t.Kind() {
 	case cc.Array:
 		return !t.IsVLA()
 	case cc.Struct, cc.Union:
 		nf := t.NumField()
 		for i := []int{0}; i[0] < nf; i[0]++ {
 			if !p.checkSizeof0(n, t.FieldByIndex(i).Type()) {
 				return false
 			}
 		}
 	}
 	return true
 }
 
 func (p *project) unaryExpressionLValue(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		p.postfixExpression(f, n.PostfixExpression, t, mode, flags)
 	case cc.UnaryExpressionInc: // "++" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionDec: // "--" UnaryExpression
 		panic(todo("", p.pos(n)))
 	case cc.UnaryExpressionAddrof: // '&' CastExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionDeref: // '*' CastExpression
 		ot := n.CastExpression.Operand.Type()
 		switch ot.Kind() {
 		case cc.Ptr, cc.Array:
 			switch et := ot.Elem(); {
 			case
 				et.IsScalarType(),
 				et.Kind() == cc.Struct,
 				et.Kind() == cc.Union:
 
 				p.unaryExpressionDeref(f, n, t, mode, flags)
 			default:
 				panic(todo("", p.pos(n), et, et.Kind()))
 			}
 		default:
 			panic(todo("", p.pos(n), ot, ot.Kind()))
 		}
 	case cc.UnaryExpressionPlus: // '+' CastExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionMinus: // '-' CastExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionCpl: // '~' CastExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionNot: // '!' CastExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionSizeofExpr: // "sizeof" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionSizeofType: // "sizeof" '(' TypeName ')'
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionLabelAddr: // "&&" IDENTIFIER
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionAlignofExpr: // "_Alignof" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionAlignofType: // "_Alignof" '(' TypeName ')'
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionImag: // "__imag__" UnaryExpression
 		panic(todo("", n.Position()))
 	case cc.UnaryExpressionReal: // "__real__" UnaryExpression
 		panic(todo("", n.Position()))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func isSigned(t cc.Type) bool   { return t.IsIntegerType() && t.IsSignedType() }
 func isUnsigned(t cc.Type) bool { return t.IsIntegerType() && !t.IsSignedType() }
 
 func isConstInteger(op cc.Operand) bool {
 	switch op.Value().(type) {
 	case cc.Int64Value, cc.Uint64Value:
 		return true
 	default:
 		return false
 	}
 }
 
 func isNegativeInt(op cc.Operand) bool {
 	switch x := op.Value().(type) {
 	case cc.Int64Value:
 		return x < 0
 	default:
 		return false
 	}
 }
 
 func isNonNegativeInt(op cc.Operand) bool {
 	switch x := op.Value().(type) {
 	case cc.Int64Value:
 		return x >= 0
 	case cc.Uint64Value:
 		return true
 	default:
 		return false
 	}
 }
 
 func (p *project) unaryExpressionPreIncDec(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	// "++" UnaryExpression etc.
 	switch mode {
 	case exprValue:
 		p.unaryExpressionPreIncDecValue(f, n, oper, oper2, t, mode, flags)
 	case exprVoid:
 		p.unaryExpressionPreIncDecVoid(f, n, oper, oper2, t, mode, flags)
 	default:
 		panic(todo("", p.pos(n), mode))
 	}
 }
 
 func (p *project) unaryExpressionPreIncDecVoid(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	// "++" UnaryExpression etc.
 	switch n.UnaryExpression.Operand.Type().Kind() {
 	case cc.Int128, cc.UInt128:
 		p.unaryExpressionLValue(f, n.UnaryExpression, n.UnaryExpression.Operand.Type(), exprLValue, 0)
 		switch oper {
 		case "++":
 			p.w(".LValueInc()")
 		case "--":
 			p.w(".LValueDec()")
 		default:
 			panic(todo("internal error: %q", oper))
 		}
 		return
 	}
 
 	// "++" UnaryExpression etc.
 	switch k := p.opKind(f, n.UnaryExpression, n.UnaryExpression.Operand.Type()); k {
 	case opNormal:
 		p.unaryExpressionPreIncDecVoidNormal(f, n, oper, oper2, t, mode, flags)
 	case opArrayParameter:
 		p.unaryExpressionPreIncDecVoidArrayParameter(f, n, oper, oper2, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) unaryExpressionPreIncDecVoidArrayParameter(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	// "++" UnaryExpression etc.
 	ut := n.UnaryExpression.Operand.Type()
 	p.unaryExpression(f, n.UnaryExpression, n.UnaryExpression.Operand.Type(), exprLValue, flags)
 	switch d := p.incDelta(n, ut); d {
 	case 1:
 		p.w("%s", oper)
 	default:
 		p.w("%s %d", oper2, d)
 	}
 }
 
 func (p *project) unaryExpressionPreIncDecVoidNormal(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	// "++" UnaryExpression etc.
 	ut := n.UnaryExpression.Operand.Type()
 	if d := n.UnaryExpression.Declarator(); d != nil && p.isVolatileOrAtomic(d) {
 		x := "Dec"
 		if oper == "++" {
 			x = "Inc"
 		}
 		p.w("%sPre%sAtomic%s(&", p.task.crt, x, p.helperType(n, d.Type()))
 		switch local, tld := f.locals[d], p.tlds[d]; {
 		case local != nil:
 			p.w("%s", local.name)
 		case tld != nil:
 			p.w("%s", tld.name)
 		default:
 			panic(todo(""))
 		}
 		p.w(", %d)", p.incDelta(n.PostfixExpression, ut))
 		return
 	}
 
 	p.unaryExpression(f, n.UnaryExpression, n.UnaryExpression.Operand.Type(), exprLValue, flags)
 	if ut.IsIntegerType() || ut.Kind() == cc.Ptr && p.incDelta(n, ut) == 1 {
 		p.w("%s", oper)
 		return
 	}
 
 	switch ut.Kind() {
 	case cc.Ptr, cc.Double, cc.Float:
 		p.w("%s %d", oper2, p.incDelta(n, ut))
 		return
 	}
 
 	panic(todo("", p.pos(n)))
 }
 
 func (p *project) unaryExpressionPreIncDecValue(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	// "++" UnaryExpression etc.
 	switch k := p.opKind(f, n.UnaryExpression, n.UnaryExpression.Operand.Type()); k {
 	case opNormal:
 		p.unaryExpressionPreIncDecValueNormal(f, n, oper, oper2, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) unaryExpressionPreIncDecValueNormal(f *function, n *cc.UnaryExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	// "++" UnaryExpression etc.
 	defer p.w("%s", p.convert(n, n.UnaryExpression.Operand, t, flags))
 	x := "Dec"
 	if oper == "++" {
 		x = "Inc"
 	}
 	ut := n.UnaryExpression.Operand.Type()
 	p.w("%sPre%s%s(&", p.task.crt, x, p.helperType(n, ut))
 	p.unaryExpression(f, n.UnaryExpression, ut, exprLValue, flags)
 	p.w(", %d)", p.incDelta(n.PostfixExpression, ut))
 }
 
 func (p *project) unaryExpressionDeref(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	// '*' CastExpression
 	switch mode {
 	case exprValue:
 		p.unaryExpressionDerefValue(f, n, t, mode, flags)
 	case exprLValue:
 		p.unaryExpressionDerefLValue(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.unaryExpressionDerefAddrOf(f, n, t, mode, flags)
 	case exprBool:
 		p.unaryExpressionDerefBool(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) unaryExpressionDerefBool(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	// '*' CastExpression
 	p.w("(")
 	defer p.w(")")
 	p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 	p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 	p.w(")) != 0")
 }
 
 func (p *project) unaryExpressionDerefAddrOf(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	// '*' CastExpression
 	p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 }
 
 func (p *project) unaryExpressionDerefLValue(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	// '*' CastExpression
 	switch k := p.opKind(f, n.CastExpression, n.CastExpression.Operand.Type()); k {
 	case opNormal:
 		p.unaryExpressionDerefLValueNormal(f, n, t, mode, flags)
 	case opArray:
 		panic(todo("", p.pos(n)))
 		p.unaryExpressionDerefLValueArray(f, n, t, mode, flags)
 	case opArrayParameter:
 		p.unaryExpressionDerefLValueNormal(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) unaryExpressionDerefLValueArray(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("))%s", p.convertType(n, n.CastExpression.Operand.Type().Elem(), t, flags))
 	p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 	p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 }
 
 func (p *project) unaryExpressionDerefLValueNormal(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("))%s", p.convertType(n, n.CastExpression.Operand.Type().Elem(), t, flags))
 	p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 	p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 }
 
 func (p *project) unaryExpressionDerefValue(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	// '*' CastExpression
 	switch k := p.opKind(f, n.CastExpression, n.CastExpression.Operand.Type()); k {
 	case opNormal, opArrayParameter:
 		p.unaryExpressionDerefValueNormal(f, n, t, mode, flags)
 	case opArray:
 		p.unaryExpressionDerefValueArray(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) unaryExpressionDerefValueArray(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.convertType(n, n.CastExpression.Operand.Type().Elem(), t, flags))
 	p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), exprValue, flags)
 	p.w("[0]")
 }
 
 func (p *project) unaryExpressionDerefValueNormal(f *function, n *cc.UnaryExpression, t cc.Type, mode exprMode, flags flags) {
 	// '*' CastExpression
 	switch op := n.Operand.Type(); {
 	case op.Kind() == cc.Array:
 		p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), mode, flags)
 	default:
 		defer p.w("))%s", p.convertType(n, n.CastExpression.Operand.Type().Elem(), t, flags))
 		p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 		p.castExpression(f, n.CastExpression, n.CastExpression.Operand.Type(), mode, flags)
 	}
 }
 
 func (p *project) postfixExpression(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprLValue:
 		p.postfixExpressionLValue(f, n, t, mode, flags)
 	case exprValue:
 		p.postfixExpressionValue(f, n, t, mode, flags)
 	case exprVoid:
 		p.postfixExpressionVoid(f, n, t, mode, flags)
 	case exprFunc:
 		p.postfixExpressionFunc(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.postfixExpressionAddrOf(f, n, t, mode, flags)
 	case exprSelect:
 		p.postfixExpressionSelect(f, n, t, mode, flags)
 	case exprPSelect:
 		p.postfixExpressionPSelect(f, n, t, mode, flags)
 	case exprBool:
 		p.postfixExpressionBool(f, n, t, mode, flags)
 	case exprDecay:
 		p.postfixExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) postfixExpressionDecay(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PostfixExpressionPrimary: // PrimaryExpression
 		p.primaryExpression(f, n.PrimaryExpression, t, mode, flags)
 	case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		pe := n.PostfixExpression.Operand.Type()
 		p.w("(")
 		switch {
 		case pe.Kind() == cc.Array:
 			p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags)
 		case pe.Kind() == cc.Ptr:
 			p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		default:
 			panic(todo("", p.pos(n)))
 		}
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 		p.w(")")
 	case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 		p.postfixExpression(f, n, t, exprAddrOf, flags)
 	case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 		p.postfixExpression(f, n, t, exprAddrOf, flags)
 	case cc.PostfixExpressionInc: // PostfixExpression "++"
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionDec: // PostfixExpression "--"
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionChooseExpr:
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) postfixExpressionBool(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PostfixExpressionPrimary: // PrimaryExpression
 		p.primaryExpression(f, n.PrimaryExpression, t, mode, flags)
 	case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0")
 		p.postfixExpression(f, n, t, exprValue, flags)
 	case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
 		p.postfixExpressionCall(f, n, t, mode, flags)
 	case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0")
 		p.postfixExpression(f, n, t, exprValue, flags)
 	case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0")
 		p.postfixExpression(f, n, t, exprValue, flags)
 	case cc.PostfixExpressionInc: // PostfixExpression "++"
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0")
 		p.postfixExpression(f, n, t, exprValue, flags)
 	case cc.PostfixExpressionDec: // PostfixExpression "--"
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0")
 		p.postfixExpression(f, n, t, exprValue, flags)
 	case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionChooseExpr:
 		p.w("(")
 		defer p.w(")")
 		defer p.w(" != 0")
 		p.postfixExpression(f, n, t, exprValue, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) postfixExpressionPSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	switch n.Case {
 	case cc.PostfixExpressionPrimary: // PrimaryExpression
 		p.primaryExpression(f, n.PrimaryExpression, t, mode, flags)
 	case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
 		p.postfixExpressionPSelectIndex(f, n, t, mode, flags)
 	case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
 		p.postfixExpressionPSelectCall(f, n, t, mode, flags)
 	case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 		p.postfixExpressionPSelectSelect(f, n, t, mode, flags)
 	case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 		p.postfixExpressionPSelectPSelect(f, n, t, mode, flags)
 	case cc.PostfixExpressionInc: // PostfixExpression "++"
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionDec: // PostfixExpression "--"
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionChooseExpr:
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) postfixExpressionPSelectSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k {
 	case opStruct:
 		p.postfixExpressionPSelectSelectStruct(f, n, t, mode, flags)
 	case opUnion:
 		p.postfixExpressionPSelectSelectUnion(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionPSelectSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	fld := n.Field
 	if fld.Offset() != 0 {
 		p.err(&n.Token2, "internal error, union field with non-zero offset: %s %v", n.Token2.Value, fld.Offset())
 	}
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		pe := n.PostfixExpression.Operand.Type()
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("(*(**%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 		p.w("/* .%s */", p.fieldName(n, n.Token2.Value))
 		p.w(")))")
 	}
 }
 
 func (p *project) postfixExpressionPSelectSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	fld := n.Field
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		pe := n.PostfixExpression.Operand.Type()
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, t.Elem()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprSelect, flags)
 		p.w(".%s", p.fieldName(n, n.Token2.Value))
 		p.w("))")
 
 	}
 }
 
 func (p *project) postfixExpressionPSelectCall(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem()))
 	p.postfixExpressionCall(f, n, t, exprValue, flags)
 	p.w("))")
 }
 
 func (p *project) postfixExpressionPSelectIndex(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k {
 	// case opArray:
 	// 	p.postfixExpressionSelectIndexArray(f, n, t, mode, flags)
 	case opNormal:
 		p.postfixExpressionPSelectIndexNormal(f, n, t, mode, flags)
 	case opArrayParameter:
 		p.postfixExpressionSelectIndexArrayParamater(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionPSelectIndexNormal(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	pe := n.PostfixExpression.Operand.Type()
 	// PostfixExpression '[' Expression ']'
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	case n.Operand.Type().Kind() == cc.Array:
 		panic(todo("", p.pos(n)))
 	case pe.Kind() == cc.Array:
 		p.w("(")
 		defer p.w(")")
 		p.w("(*(**%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Decay().Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 		p.w(")))")
 	default:
 		p.w("(")
 		defer p.w(")")
 		p.w("(*(**%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type().Elem()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Decay().Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 		p.w(")))")
 	}
 }
 
 func (p *project) postfixExpressionSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	switch n.Case {
 	case cc.PostfixExpressionPrimary: // PrimaryExpression
 		p.primaryExpression(f, n.PrimaryExpression, t, mode, flags)
 	case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
 		p.postfixExpressionSelectIndex(f, n, t, mode, flags)
 	case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
 		p.postfixExpression(f, n, t, exprValue, flags)
 	case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 		p.postfixExpressionSelectSelect(f, n, t, mode, flags)
 	case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 		p.postfixExpressionSelectPSelect(f, n, t, mode, flags)
 	case cc.PostfixExpressionInc: // PostfixExpression "++"
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionDec: // PostfixExpression "--"
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionChooseExpr:
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) postfixExpressionPSelectPSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type().Elem()); k {
 	case opStruct:
 		p.postfixExpressionPSelectPSelectStruct(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionPSelectPSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	fld := n.Field
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		pe := n.PostfixExpression.Operand.Type()
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, t.Elem()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprPSelect, flags)
 		p.w(".%s", p.fieldName(n, n.Token2.Value))
 		p.w("))")
 	}
 }
 
 func (p *project) postfixExpressionSelectPSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type().Elem()); k {
 	case opStruct:
 		p.postfixExpressionSelectPSelectStruct(f, n, t, mode, flags)
 	case opUnion:
 		p.postfixExpressionSelectPSelectUnion(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionSelectPSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	fld := n.Field
 	if fld.Offset() != 0 {
 		p.err(&n.Token2, "internal error, union field with non-zero offset: %s %v", n.Token2.Value, fld.Offset())
 	}
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	case n.Operand.Type().Kind() == cc.Array:
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		pe := n.PostfixExpression.Operand.Type()
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		p.w("))")
 	}
 }
 
 func (p *project) postfixExpressionSelectPSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	fld := n.Field
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		pe := n.PostfixExpression.Operand.Type()
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		et := n.PostfixExpression.Operand.Type().Elem()
 		fld, path, ok := et.FieldByName2(n.Token2.Value)
 		switch {
 		case !ok:
 			panic(todo("", n.Token.Position()))
 		case fld.InUnion():
 			p.w("(*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 			p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 			p.w("%s)))", nonZeroUintptr(pathOff(et, path)))
 		case len(path) != 1:
 			panic(todo("", n.Token.Position()))
 		default:
 			p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 			switch {
 			case pe.Kind() == cc.Array:
 				p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 			default:
 				p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 			}
 			p.w(")).%s", p.fieldName(n, n.Token2.Value))
 		}
 	}
 }
 
 func (p *project) postfixExpressionSelectSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	switch k := p.structOrUnion(n); k {
 	case opUnion:
 		p.postfixExpressionSelectSelectUnion(f, n, t, mode, flags)
 	case opStruct:
 		p.postfixExpressionSelectSelectStruct(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) structOrUnion(n *cc.PostfixExpression) opKind {
 	t := n.PostfixExpression.Operand.Type()
 	switch n.Case {
 	case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 		// ok
 	case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 		if t.Kind() == cc.Ptr {
 			t = t.Elem()
 			break
 		}
 
 		p.err(n, "expected pointer type: %s", t)
 		return opStruct
 	}
 	f, path, ok := t.FieldByName2(n.Token2.Src)
 	if !ok {
 		p.err(&n.Token, "unknown field: %s", n.Token2)
 		return opStruct
 	}
 
 	for len(path) > 1 {
 		f = t.FieldByIndex(path[:1])
 		path = path[1:]
 		t = f.Type()
 	}
 	if t.Kind() == cc.Union {
 		// trc("%v: %q %v", n.Token2.Position(), n.Token2.Src, opUnion)
 		return opUnion
 	}
 
 	// trc("%v: %q %v", n.Token2.Position(), n.Token2.Src, opStruct)
 	return opStruct
 }
 
 func (p *project) postfixExpressionSelectSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	fld := n.Field
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	case n.Operand.Type().Kind() == cc.Array:
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		pe := n.PostfixExpression.Operand.Type()
 		p.postfixExpression(f, n.PostfixExpression, pe, exprSelect, flags)
 		p.w(".%s", p.fieldName(n, n.Token2.Value))
 	}
 }
 
 func (p *project) postfixExpressionSelectSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	fld := n.Field
 	if fld.Offset() != 0 {
 		p.err(&n.Token2, "internal error, union field with non-zero offset: %s %v", n.Token2.Value, fld.Offset())
 	}
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	case n.Operand.Type().Kind() == cc.Array:
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		pe := n.PostfixExpression.Operand.Type()
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 		p.w("))")
 	}
 }
 
 func (p *project) postfixExpressionSelectIndex(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k {
 	case opArray:
 		p.postfixExpressionSelectIndexArray(f, n, t, mode, flags)
 	case opNormal:
 		p.postfixExpressionSelectIndexNormal(f, n, t, mode, flags)
 	case opArrayParameter:
 		p.postfixExpressionSelectIndexArrayParamater(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionSelectIndexArrayParamater(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	pe := n.PostfixExpression.Operand.Type()
 	// PostfixExpression '[' Expression ']'
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	case n.Operand.Type().Kind() == cc.Array:
 		panic(todo("", p.pos(n)))
 	default:
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Decay().Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 		p.w("))")
 	}
 }
 
 func (p *project) postfixExpressionSelectIndexNormal(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	pe := n.PostfixExpression.Operand.Type()
 	// PostfixExpression '[' Expression ']'
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	case n.Operand.Type().Kind() == cc.Array:
 		panic(todo("", p.pos(n)))
 	case pe.Kind() != cc.Ptr:
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Decay().Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 		p.w("))")
 	default:
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Decay().Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 		p.w("))")
 	}
 }
 
 func (p *project) postfixExpressionSelectIndexArray(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	case n.Operand.Type().Kind() == cc.Array:
 		panic(todo("", p.pos(n)))
 	default:
 		pe := n.PostfixExpression.Operand.Type()
 		p.postfixExpression(f, n.PostfixExpression, pe, mode, flags)
 		p.w("[")
 		p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags)
 		p.w("]")
 	}
 }
 
 func (p *project) postfixExpressionAddrOf(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PostfixExpressionPrimary: // PrimaryExpression
 		p.primaryExpression(f, n.PrimaryExpression, t, mode, flags)
 	case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
 		p.postfixExpressionAddrOfIndex(f, n, t, mode, flags)
 	case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
 		ot := n.Operand.Type()
 		switch ot.Kind() {
 		case cc.Struct, cc.Union:
 			// ok
 		default:
 			p.err(n, "cannot take address of value of type %v", n.Operand.Type())
 			return
 		}
 
 		if p.pass1 {
 			off := roundup(f.off, uintptr(ot.Align()))
 			f.complits[n] = off
 			f.off += ot.Size()
 			return
 		}
 
 		off := f.complits[n]
 		p.w("func() uintptr { *(*%s)(unsafe.Pointer(%s%s)) = ", p.typ(n, ot), f.bpName, nonZeroUintptr(off))
 		p.postfixExpressionValue(f, n, ot, exprValue, flags)
 		p.w("; return %s%s }()", f.bpName, nonZeroUintptr(off))
 	case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 		p.postfixExpressionAddrOfSelect(f, n, t, mode, flags)
 	case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 		p.postfixExpressionAddrOfPSelect(f, n, t, mode, flags)
 	case cc.PostfixExpressionInc: // PostfixExpression "++"
 		p.postfixExpressionIncDec(f, n, "++", "+=", t, exprLValue, flags)
 	case cc.PostfixExpressionDec: // PostfixExpression "--"
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
 		tn := n.TypeName.Type()
 		switch tn.Decay().Kind() {
 		case cc.Ptr:
 			switch tn.Kind() {
 			case cc.Array:
 				switch {
 				case p.pass1:
 					off := roundup(f.off, uintptr(tn.Elem().Align()))
 					f.complits[n] = off
 					f.off += tn.Size()
 				default:
 					off := f.complits[n]
 					p.w(" func() uintptr { *(*%s)(unsafe.Pointer(%s%s)) = ", p.typ(n, tn), f.bpName, nonZeroUintptr(off))
 					p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil)
 					p.w("; return %s%s }()", f.bpName, nonZeroUintptr(off))
 				}
 			default:
 				panic(todo("%v: %v", n.Position(), tn))
 			}
 		default:
 			switch {
 			case p.pass1:
 				off := roundup(f.off, uintptr(tn.Align()))
 				f.complits[n] = off
 				f.off += tn.Size()
 			default:
 				off := f.complits[n]
 				p.w(" func() uintptr { *(*%s)(unsafe.Pointer(%s%s)) = ", p.typ(n, tn), f.bpName, nonZeroUintptr(off))
 				p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil)
 				p.w("; return %s%s }()", f.bpName, nonZeroUintptr(off))
 			}
 		}
 	case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionChooseExpr:
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) postfixExpressionAddrOfPSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	p.w("(")
 	defer p.w(")")
 	pe := n.PostfixExpression.Operand.Type()
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		p.bitFldOff(pe.Elem(), n.Token2)
 	case pe.Kind() == cc.Array:
 		p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags)
 		p.fldOff(pe.Elem(), n.Token2)
 	default:
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		p.fldOff(pe.Elem(), n.Token2)
 	}
 }
 
 func (p *project) postfixExpressionAddrOfIndex(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	p.w("(")
 	defer p.w(")")
 	switch {
 	case n.Operand.Type().Kind() == cc.Array:
 		fallthrough
 	default:
 		pe := n.PostfixExpression.Operand.Type()
 		d := n.PostfixExpression.Declarator()
 		switch {
 		case pe.Kind() == cc.Ptr:
 			p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		case pe.Kind() == cc.Array && d != nil && d.IsParameter:
 			p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		default:
 			p.postfixExpression(f, n.PostfixExpression, pe, mode, flags)
 		}
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Decay().Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 	}
 }
 
 func (p *project) postfixExpressionAddrOfSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	p.w("(")
 	defer p.w(")")
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		pe := n.PostfixExpression.Operand.Type()
 		p.postfixExpression(f, n.PostfixExpression, nil, mode, flags)
 		p.bitFldOff(pe, n.Token2)
 	case n.Operand.Type().Kind() == cc.Array:
 		fallthrough
 	default:
 		pe := n.PostfixExpression.Operand.Type()
 		p.postfixExpression(f, n.PostfixExpression, nil, mode, flags)
 		p.fldOff(pe, n.Token2)
 	}
 }
 
 func (p *project) postfixExpressionFunc(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PostfixExpressionPrimary: // PrimaryExpression
 		p.primaryExpression(f, n.PrimaryExpression, t, mode, flags)
 	case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
 		switch n.Operand.Type().Kind() {
 		case cc.Ptr:
 			switch et := n.Operand.Type().Elem(); et.Kind() {
 			case cc.Function:
 				p.fnVal(n, f, func() {
 					p.postfixExpression(f, n, n.Operand.Type(), exprValue, flags)
 				}, nil, n.Operand.Type(), 0, mode, flags)
 			default:
 				panic(todo("", p.pos(n), et, et.Kind()))
 			}
 		default:
 			panic(todo("", n.Position(), n.Operand.Type()))
 		}
 	case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
 		switch n.Operand.Type().Kind() {
 		case cc.Ptr:
 			switch et := n.Operand.Type().Elem(); et.Kind() {
 			case cc.Function:
 				p.fnVal(n, f, func() {
 					p.postfixExpressionCall(f, n, t, exprValue, flags)
 				}, nil, n.Operand.Type(), 0, mode, flags)
 			default:
 				panic(todo("", p.pos(n), et, et.Kind()))
 			}
 		default:
 			panic(todo("", n.Position(), n.Operand.Type()))
 		}
 	case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 		switch n.Operand.Type().Kind() {
 		case cc.Ptr:
 			switch n.Operand.Type().Kind() {
 			case cc.Ptr:
 				switch et := n.Operand.Type().Elem(); et.Kind() {
 				case cc.Function:
 					p.fnVal(n, f, func() { p.postfixExpression(f, n, p.ptrType, exprValue, flags) }, nil, n.Operand.Type(), 0, mode, flags)
 				default:
 					panic(todo("", p.pos(n), et, et.Kind()))
 				}
 			default:
 				panic(todo("", p.pos(n), n.Operand.Type(), n.Operand.Type().Kind()))
 			}
 		default:
 			panic(todo("", n.Position(), n.Operand.Type()))
 		}
 	case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 		p.fnVal(n, f, func() { p.postfixExpression(f, n, p.ptrType, exprValue, flags) }, nil, n.Operand.Type(), 0, mode, flags)
 	case cc.PostfixExpressionInc: // PostfixExpression "++"
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionDec: // PostfixExpression "--"
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionChooseExpr:
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) postfixExpressionVoid(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PostfixExpressionPrimary: // PrimaryExpression
 		p.primaryExpression(f, n.PrimaryExpression, t, mode, flags)
 	case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
 		p.w("_ = ")
 		p.postfixExpression(f, n, n.Operand.Type(), exprValue, flags)
 	case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
 		p.postfixExpressionCall(f, n, n.Operand.Type(), mode, flags)
 	case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 		p.w("_ = ")
 		p.postfixExpression(f, n, n.Operand.Type(), exprValue, flags)
 	case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 		p.w("_ = ")
 		p.postfixExpression(f, n, n.Operand.Type(), exprValue, flags)
 	case cc.PostfixExpressionInc: // PostfixExpression "++"
 		p.postfixExpressionIncDec(f, n, "++", "+=", t, mode, flags)
 	case cc.PostfixExpressionDec: // PostfixExpression "--"
 		p.postfixExpressionIncDec(f, n, "--", "-=", t, mode, flags)
 	case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
 		tn := n.TypeName.Type()
 		switch tn.Decay().Kind() {
 		case cc.Ptr:
 			switch tn.Kind() {
 			case cc.Array:
 				switch {
 				case p.pass1:
 					off := roundup(f.off, uintptr(tn.Elem().Align()))
 					f.complits[n] = off
 					f.off += tn.Size()
 				default:
 					off := f.complits[n]
 					p.w("*(*%s)(unsafe.Pointer(%s%s)) = ", p.typ(n, tn), f.bpName, nonZeroUintptr(off))
 					p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil)
 				}
 				return
 			default:
 				panic(todo("%v: %v", n.Position(), tn))
 			}
 		}
 
 		defer p.w("%s", p.convertType(n, tn, t, flags))
 		p.w("_ = ")
 		p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil)
 	case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionChooseExpr:
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) postfixExpressionValue(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PostfixExpressionPrimary: // PrimaryExpression
 		if p.isArray(f, n.PrimaryExpression, n.Operand.Type()) && t.Kind() == cc.Ptr {
 			mode = exprDecay
 		}
 		p.primaryExpression(f, n.PrimaryExpression, t, mode, flags)
 	case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
 		p.postfixExpressionValueIndex(f, n, t, mode, flags)
 	case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
 		p.postfixExpressionCall(f, n, t, mode, flags)
 	case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 		p.postfixExpressionValueSelect(f, n, t, mode, flags)
 	case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 		p.postfixExpressionValuePSelect(f, n, t, mode, flags)
 	case cc.PostfixExpressionInc: // PostfixExpression "++"
 		p.postfixExpressionIncDec(f, n, "++", "+=", t, mode, flags)
 	case cc.PostfixExpressionDec: // PostfixExpression "--"
 		p.postfixExpressionIncDec(f, n, "--", "-=", t, mode, flags)
 	case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
 		tn := n.TypeName.Type()
 		switch tn.Decay().Kind() {
 		case cc.Ptr:
 			switch tn.Kind() {
 			case cc.Array:
 				switch {
 				case p.pass1:
 					off := roundup(f.off, uintptr(tn.Elem().Align()))
 					f.complits[n] = off
 					f.off += tn.Size()
 				default:
 					off := f.complits[n]
 					p.w(" func() uintptr { *(*%s)(unsafe.Pointer(%s%s)) = ", p.typ(n, tn), f.bpName, nonZeroUintptr(off))
 					p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil)
 					p.w("; return %s%s }()", f.bpName, nonZeroUintptr(off))
 				}
 				return
 			default:
 				panic(todo("%v: %v", n.Position(), tn))
 			}
 		}
 
 		defer p.w("%s", p.convertType(n, tn, t, flags))
 		p.initializer(f, &cc.Initializer{Case: cc.InitializerInitList, InitializerList: n.InitializerList}, tn, cc.Automatic, nil)
 	case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
 		// Built-in Function: int __builtin_types_compatible_p (type1, type2) You can
 		// use the built-in function __builtin_types_compatible_p to determine whether
 		// two types are the same.
 		//
 		// This built-in function returns 1 if the unqualified versions of the types
 		// type1 and type2 (which are types, not expressions) are compatible, 0
 		// otherwise. The result of this built-in function can be used in integer
 		// constant expressions.
 		//
 		// This built-in function ignores top level qualifiers (e.g., const, volatile).
 		// For example, int is equivalent to const int.
 		//
 		// The type int[] and int[5] are compatible. On the other hand, int and char *
 		// are not compatible, even if the size of their types, on the particular
 		// architecture are the same. Also, the amount of pointer indirection is taken
 		// into account when determining similarity. Consequently, short * is not
 		// similar to short **. Furthermore, two types that are typedefed are
 		// considered compatible if their underlying types are compatible.
 		//
 		// An enum type is not considered to be compatible with another enum type even
 		// if both are compatible with the same integer type; this is what the C
 		// standard specifies. For example, enum {foo, bar} is not similar to enum
 		// {hot, dog}.
 		//
 		// You typically use this function in code whose execution varies depending on
 		// the arguments’ types. For example:
 		//
 		//	#define foo(x)                                                  \
 		//	  ({                                                           \
 		//	    typeof (x) tmp = (x);                                       \
 		//	    if (__builtin_types_compatible_p (typeof (x), long double)) \
 		//	      tmp = foo_long_double (tmp);                              \
 		//	    else if (__builtin_types_compatible_p (typeof (x), double)) \
 		//	      tmp = foo_double (tmp);                                   \
 		//	    else if (__builtin_types_compatible_p (typeof (x), float))  \
 		//	      tmp = foo_float (tmp);                                    \
 		//	    else                                                        \
 		//	      abort ();                                                 \
 		//	    tmp;                                                        \
 		//	  })
 		//
 		// Note: This construct is only available for C.
 		p.w(" %d ", n.Operand.Value())
 	case cc.PostfixExpressionChooseExpr: // "__builtin_choose_expr" '(' AssignmentExpression ',' AssignmentExpression ',' AssignmentExpression ')'
 		// You can use the built-in function __builtin_choose_expr to evaluate code
 		// depending on the value of a constant expression. This built-in function
 		// returns exp1 if const_exp, which is an integer constant expression, is
 		// nonzero. Otherwise it returns exp2.
 		//
 		// This built-in function is analogous to the ‘? :’ operator in C, except that
 		// the expression returned has its type unaltered by promotion rules. Also, the
 		// built-in function does not evaluate the expression that is not chosen. For
 		// example, if const_exp evaluates to true, exp2 is not evaluated even if it
 		// has side effects.
 		//
 		// This built-in function can return an lvalue if the chosen argument is an
 		// lvalue.
 		//
 		// If exp1 is returned, the return type is the same as exp1’s type. Similarly,
 		// if exp2 is returned, its return type is the same as exp2.
 		//
 		// Example:
 		//
 		// 	#define foo(x)                                                \
 		// 	  __builtin_choose_expr (                                     \
 		// 	    __builtin_types_compatible_p (typeof (x), double),        \
 		// 	    foo_double (x),                                           \
 		// 	    __builtin_choose_expr (                                   \
 		// 	      __builtin_types_compatible_p (typeof (x), float),       \
 		// 	      foo_float (x),                                          \
 		// 	      /* The void expression results in a compile-time error  \
 		// 	         when assigning the result to something.  */          \
 		// 	      (void)0))
 		//
 		// Note: This construct is only available for C. Furthermore, the unused
 		// expression (exp1 or exp2 depending on the value of const_exp) may still
 		// generate syntax errors. This may change in future revisions.
 		switch op := n.AssignmentExpression.Operand; {
 		case op.IsNonZero():
 			p.assignmentExpression(f, n.AssignmentExpression2, t, mode, flags)
 		case op.IsZero():
 			p.assignmentExpression(f, n.AssignmentExpression3, t, mode, flags)
 		default:
 			panic(todo(""))
 		}
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) postfixExpressionValuePSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type().Elem()); k {
 	case opStruct:
 		p.postfixExpressionValuePSelectStruct(f, n, t, mode, flags)
 	case opUnion:
 		p.postfixExpressionValuePSelectUnion(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionValuePSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	fld := n.Field
 	if fld.Offset() != 0 {
 		p.err(&n.Token2, "internal error, union field with non-zero offset: %s %v", n.Token2.Value, fld.Offset())
 	}
 	pe := n.PostfixExpression.Operand.Type()
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	case n.Operand.Type().Kind() == cc.Array:
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		p.w("/* .%s */", p.fieldName(n, n.Token2.Value))
 		p.w("))")
 	}
 }
 
 func (p *project) postfixExpressionValuePSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	fld := n.Field
 	pe := n.PostfixExpression.Operand.Type()
 	k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type())
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		p.w("(")
 		defer p.w(")")
 		fld := n.Field
 		defer p.w("%s", p.convertType(n, fld.Promote(), t, flags))
 		switch pe.Kind() {
 		case cc.Array:
 			x := p.convertType(n, nil, fld.Promote(), flags)
 			p.w("*(*uint%d)(unsafe.Pointer(", fld.BitFieldBlockWidth())
 			p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags)
 			p.bitFldOff(pe.Elem(), n.Token2)
 			p.w("))")
 			p.w("&%#x>>%d%s", fld.Mask(), fld.BitFieldOffset(), x)
 			if fld.Type().IsSignedType() {
 				panic(todo(""))
 				p.w("<<%d>>%[1]d", int(fld.Promote().Size()*8)-fld.BitFieldWidth())
 			}
 		default:
 			x := p.convertType(n, nil, fld.Promote(), flags)
 			p.w("*(*uint%d)(unsafe.Pointer(", fld.BitFieldBlockWidth())
 			p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 			p.bitFldOff(pe.Elem(), n.Token2)
 			p.w("))&%#x>>%d%s", fld.Mask(), fld.BitFieldOffset(), x)
 			if fld.Type().IsSignedType() {
 				p.w("<<%d>>%[1]d", int(fld.Promote().Size()*8)-fld.BitFieldWidth())
 			}
 		}
 	case n.Operand.Type().Kind() == cc.Array:
 		defer p.w("%s", p.convertType(n, n.Operand.Type().Decay(), t.Decay(), flags))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		p.fldOff(n.PostfixExpression.Operand.Type().Elem(), n.Token2)
 	case k == opArray:
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		p.w("[0].%s", p.fieldName(n, n.Token2.Value))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		et := pe.Elem()
 		fld, path, ok := et.FieldByName2(n.Token2.Value)
 		switch {
 		case !ok:
 			panic(todo(""))
 		case fld.InUnion():
 			p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 			p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 			p.w("%s))", nonZeroUintptr(pathOff(et, path)))
 		case len(path) != 1:
 			panic(todo(""))
 		default:
 			p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 			p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 			p.w(")).%s", p.fieldName(n, n.Token2.Value))
 		}
 	}
 }
 
 func pathOff(t cc.Type, path []int) (r uintptr) {
 	for len(path) != 0 {
 		f := t.FieldByIndex(path[:1])
 		r += f.Offset()
 		path = path[1:]
 		t = f.Type()
 	}
 	return r
 }
 
 func (p *project) postfixExpressionValueIndex(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k {
 	case opArray:
 		p.postfixExpressionValueIndexArray(f, n, t, mode, flags)
 	case opNormal:
 		p.postfixExpressionValueIndexNormal(f, n, t, mode, flags)
 	case opArrayParameter:
 		p.postfixExpressionValueIndexArrayParameter(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 func (p *project) postfixExpressionValueIndexArrayParameter(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	pe := n.PostfixExpression.Operand.Type()
 	switch {
 	case n.Operand.Type().Kind() == cc.Array:
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("(")
 		defer p.w(")")
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 	default:
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 		p.w("))")
 	}
 }
 
 func (p *project) postfixExpressionValueIndexNormal(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	switch {
 	case n.Operand.Type().Kind() == cc.Array:
 		p.w("(")
 		defer p.w(")")
 		pe := n.PostfixExpression.Operand.Type()
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 	default:
 		switch pe := n.PostfixExpression.Operand.Type(); pe.Kind() {
 		case cc.Ptr:
 			defer p.w("%s", p.convert(n, n.Operand, t, flags))
 			p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 			p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 			if !n.Expression.Operand.IsZero() {
 				p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 				if sz := pe.Elem().Size(); sz != 1 {
 					p.w("*%d", sz)
 				}
 			}
 			p.w("))")
 		case cc.Array:
 			defer p.w("%s", p.convert(n, n.Operand, t, flags))
 			p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 			p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags)
 			if !n.Expression.Operand.IsZero() {
 				p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 				if sz := pe.Elem().Size(); sz != 1 {
 					p.w("*%d", sz)
 				}
 			}
 			p.w("))")
 		default:
 			panic(todo("", p.pos(n), pe, pe.Kind()))
 		}
 	}
 }
 
 func (p *project) postfixExpressionValueIndexArray(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	pe := n.PostfixExpression.Operand.Type()
 	switch n.Operand.Type().Kind() {
 	case cc.Array:
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("(")
 		defer p.w(")")
 		p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags)
 		if !n.Expression.Operand.IsZero() {
 			p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 			if sz := pe.Elem().Size(); sz != 1 {
 				p.w("*%d", sz)
 			}
 		}
 	default:
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.postfixExpression(f, n.PostfixExpression, pe, mode, flags)
 		p.w("[")
 		p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags)
 		p.w("]")
 	}
 }
 
 func (p *project) postfixExpressionValueSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k {
 	case opStruct:
 		p.postfixExpressionValueSelectStruct(f, n, t, mode, flags)
 	case opUnion:
 		p.postfixExpressionValueSelectUnion(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionValueSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	pe := n.PostfixExpression.Operand.Type()
 	fld := n.Field
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		p.w("(")
 		defer p.w("%s)", p.convertType(n, fld.Promote(), t, flags))
 		x := p.convertType(n, nil, fld.Promote(), flags)
 		p.w("*(*uint%d)(unsafe.Pointer(", fld.BitFieldBlockWidth())
 		p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 		p.bitFldOff(pe, n.Token2)
 		p.w("))&%#x>>%d%s", fld.Mask(), fld.BitFieldOffset(), x)
 		if fld.Type().IsSignedType() {
 			p.w("<<%d>>%[1]d", int(fld.Promote().Size()*8)-fld.BitFieldWidth())
 		}
 	case n.Operand.Type().Kind() == cc.Array:
 		p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 		p.w("))")
 	}
 }
 
 func (p *project) postfixExpressionValueSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	pe := n.PostfixExpression.Operand.Type()
 	fld := n.Field
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		p.w("(")
 		defer p.w("%s)", p.convertType(n, fld.Promote(), t, flags))
 		x := p.convertType(n, nil, fld.Promote(), flags)
 		p.w("*(*uint%d)(unsafe.Pointer(", fld.BitFieldBlockWidth())
 		p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 		p.bitFldOff(pe, n.Token2)
 		p.w("))&%#x>>%d%s", fld.Mask(), fld.BitFieldOffset(), x)
 		if fld.Type().IsSignedType() {
 			p.w("<<%d>>%[1]d", int(fld.Promote().Size()*8)-fld.BitFieldWidth())
 		}
 	case n.Operand.Type().Kind() == cc.Array:
 		p.postfixExpression(f, n, t, exprDecay, flags)
 	case fld.InUnion():
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("*(*%s)(unsafe.Pointer(", p.typ(n, fld.Type()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 		p.fldOff(pe, n.Token2)
 		p.w("))")
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprSelect, flags)
 		p.w(".%s", p.fieldName(n, n.Token2.Value))
 	}
 }
 
 func (p *project) postfixExpressionLValue(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PostfixExpressionPrimary: // PrimaryExpression
 		p.primaryExpression(f, n.PrimaryExpression, t, mode, flags)
 	case cc.PostfixExpressionIndex: // PostfixExpression '[' Expression ']'
 		p.postfixExpressionLValueIndex(f, n, t, mode, flags)
 	case cc.PostfixExpressionCall: // PostfixExpression '(' ArgumentExpressionList ')'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 		p.postfixExpressionLValueSelect(f, n, t, mode, flags)
 	case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 		p.postfixExpressionLValuePSelect(f, n, t, mode, flags)
 	case cc.PostfixExpressionInc: // PostfixExpression "++"
 		p.postfixExpressionIncDec(f, n, "++", "+=", t, mode, flags)
 	case cc.PostfixExpressionDec: // PostfixExpression "--"
 		p.postfixExpressionIncDec(f, n, "--", "-=", t, mode, flags)
 	case cc.PostfixExpressionComplit: // '(' TypeName ')' '{' InitializerList ',' '}'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionTypeCmp: // "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'
 		panic(todo("", p.pos(n)))
 	case cc.PostfixExpressionChooseExpr:
 		panic(todo("", p.pos(n)))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) postfixExpressionLValuePSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	pe := n.PostfixExpression
 	switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type().Elem()); k {
 	case opStruct:
 		if !p.inUnion(n, pe.Operand.Type().Elem(), n.Token2.Value) {
 			p.postfixExpressionLValuePSelectStruct(f, n, t, mode, flags)
 			break
 		}
 
 		p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 		p.postfixExpression(f, pe, pe.Operand.Type(), exprValue, flags)
 		p.fldOff(pe.Operand.Type().Elem(), n.Token2)
 		p.w("))")
 	case opUnion:
 		p.postfixExpressionLValuePSelectUnion(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionLValuePSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	fld := n.Field
 	if fld.Offset() != 0 {
 		p.err(&n.Token2, "internal error, union field with non-zero offset: %s %v", n.Token2.Value, fld.Offset())
 	}
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		pe := n.PostfixExpression.Operand.Type()
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("(*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		p.w("/* .%s */", p.fieldName(n, n.Token2.Value))
 		p.w(")))")
 	}
 }
 
 func (p *project) postfixExpressionLValuePSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "->" IDENTIFIER
 	fld := n.Field
 	pe := n.PostfixExpression.Operand.Type()
 	k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type())
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	case k == opArray:
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		p.w("[0].%s", p.fieldName(n, n.Token2.Value))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		defer p.w("%s", p.convert(n, n.Operand, t, flags))
 		p.w("(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 		p.w(")).%s", p.fieldName(n, n.Token2.Value))
 	}
 }
 
 func (p *project) postfixExpressionLValueIndex(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	switch k := p.opKind(f, n.PostfixExpression, n.PostfixExpression.Operand.Type()); k {
 	case opArray:
 		p.postfixExpressionLValueIndexArray(f, n, t, mode, flags)
 	case opNormal:
 		p.postfixExpressionLValueIndexNormal(f, n, t, mode, flags)
 	case opArrayParameter:
 		p.postfixExpressionLValueIndexArrayParameter(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionLValueIndexArrayParameter(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	defer p.w("%s", p.convert(n, n.Operand, t, flags))
 	pe := n.PostfixExpression.Operand.Type()
 	p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 	p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 	if !n.Expression.Operand.IsZero() {
 		p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 		if sz := pe.Elem().Size(); sz != 1 {
 			p.w("*%d", sz)
 		}
 	}
 	p.w("))")
 }
 
 func (p *project) postfixExpressionLValueIndexNormal(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	switch {
 	case n.Operand.Type().Kind() == cc.Array:
 		panic(todo("", p.pos(n)))
 	default:
 		switch pe := n.PostfixExpression.Operand.Type(); pe.Kind() {
 		case cc.Ptr:
 			defer p.w("%s", p.convert(n, n.Operand, t, flags))
 			p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 			p.postfixExpression(f, n.PostfixExpression, pe, exprValue, flags)
 			if !n.Expression.Operand.IsZero() {
 				p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 				if sz := pe.Elem().Size(); sz != 1 {
 					p.w("*%d", sz)
 				}
 			}
 			p.w("))")
 		case cc.Array:
 			defer p.w("%s", p.convert(n, n.Operand, t, flags))
 			p.w("*(*%s)(unsafe.Pointer(", p.typ(n, pe.Elem()))
 			p.postfixExpression(f, n.PostfixExpression, pe, exprDecay, flags)
 			if !n.Expression.Operand.IsZero() {
 				p.nzUintptr(n, func() { p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags) }, n.Expression.Operand)
 				if sz := pe.Elem().Size(); sz != 1 {
 					p.w("*%d", sz)
 				}
 			}
 			p.w("))")
 		default:
 			panic(todo("", p.pos(n), pe))
 		}
 	}
 }
 
 func (p *project) postfixExpressionLValueIndexArray(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '[' Expression ']'
 	pe := n.PostfixExpression.Operand.Type()
 	p.postfixExpression(f, n.PostfixExpression, pe, mode, flags)
 	p.w("[")
 	p.expression(f, n.Expression, n.Expression.Operand.Type(), exprValue, flags)
 	p.w("]")
 }
 
 func (p *project) postfixExpressionLValueSelect(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	pe := n.PostfixExpression
 	switch k := p.opKind(f, pe, pe.Operand.Type()); k {
 	case opStruct:
 		if !p.inUnion(n, pe.Operand.Type(), n.Token2.Value) {
 			p.postfixExpressionLValueSelectStruct(f, n, t, mode, flags)
 			break
 		}
 
 		p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 		p.postfixExpression(f, pe, pe.Operand.Type(), exprAddrOf, flags)
 		p.fldOff(pe.Operand.Type(), n.Token2)
 		p.w("))")
 	case opUnion:
 		p.postfixExpressionLValueSelectUnion(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) inUnion(n cc.Node, t cc.Type, fname cc.StringID) bool {
 	f, ok := t.FieldByName(fname)
 	if !ok {
 		p.err(n, "unknown field: %s", fname)
 		return false
 	}
 
 	return f.InUnion()
 }
 
 func (p *project) postfixExpressionLValueSelectUnion(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	fld := n.Field
 	pe := n.PostfixExpression.Operand.Type()
 	switch {
 	case pe.Kind() == cc.Array:
 		panic(todo("", p.pos(n)))
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		p.w("*(*%s)(unsafe.Pointer(", p.typ(n, n.Operand.Type()))
 		p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 		nonZeroUintptr(fld.Offset())
 		p.w("))")
 	}
 }
 
 func (p *project) postfixExpressionLValueSelectStruct(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '.' IDENTIFIER
 	fld := n.Field
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	default:
 		if fld.IsBitField() {
 			p.err(&n.Token2, "internal error, wrong function for accessing a bit field: %s", n.Token2.Value)
 		}
 		pe := n.PostfixExpression.Operand.Type()
 		p.postfixExpression(f, n.PostfixExpression, pe, exprSelect, flags)
 		p.w(".%s", p.fieldName(n, n.Token2.Value))
 	}
 }
 
 func (p *project) postfixExpressionIncDec(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprVoid:
 		p.postfixExpressionIncDecVoid(f, n, oper, oper2, t, mode, flags)
 	case exprLValue:
 		p.postfixExpressionIncDecLValue(f, n, oper, oper2, t, mode, flags)
 	case exprValue:
 		p.postfixExpressionIncDecValue(f, n, oper, oper2, t, mode, flags)
 	default:
 		panic(todo("", mode))
 	}
 }
 
 func (p *project) postfixExpressionIncDecValue(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "++"
 	pe := n.PostfixExpression.Operand.Type()
 	switch k := p.opKind(f, n.PostfixExpression, pe); k {
 	case opNormal:
 		p.postfixExpressionIncDecValueNormal(f, n, oper, oper2, t, mode, flags)
 	case opBitfield:
 		p.postfixExpressionIncDecValueBitfield(f, n, oper, oper2, t, mode, flags)
 	case opArrayParameter:
 		p.postfixExpressionIncDecValueArrayParameter(f, n, oper, oper2, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), pe, pe.Kind(), k))
 	}
 }
 
 func (p *project) postfixExpressionIncDecValueArrayParameter(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "++"
 	pe := n.PostfixExpression.Operand.Type()
 	defer p.w("%s", p.convert(n, n.PostfixExpression.Operand, t, flags))
 	x := "Dec"
 	if oper == "++" {
 		x = "Inc"
 	}
 	p.w("%sPost%s%s(&", p.task.crt, x, p.helperType(n, pe.Decay()))
 	p.postfixExpression(f, n.PostfixExpression, pe, exprLValue, flags)
 	p.w(", %d)", p.incDelta(n.PostfixExpression, pe))
 }
 
 func (p *project) postfixExpressionIncDecValueBitfield(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "++"
 	pe := n.PostfixExpression.Operand.Type()
 	defer p.w("%s", p.convert(n, n.PostfixExpression.Operand, t, flags))
 	x := "Dec"
 	if oper == "++" {
 		x = "Inc"
 	}
 	bf := pe.BitField()
 	p.w("%sPost%sBitFieldPtr%d%s(", p.task.crt, x, bf.BitFieldBlockWidth(), p.bfHelperType(pe))
 	p.postfixExpression(f, n.PostfixExpression, pe, exprAddrOf, flags)
 	p.w(", %d, %d, %d, %#x)", p.incDelta(n.PostfixExpression, pe), bf.BitFieldBlockWidth(), bf.BitFieldOffset(), bf.Mask())
 }
 
 func (p *project) postfixExpressionIncDecValueNormal(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression "++"
 	pe := n.PostfixExpression.Operand.Type()
 	defer p.w("%s", p.convert(n, n.PostfixExpression.Operand, t, flags))
 	x := "Dec"
 	if oper == "++" {
 		x = "Inc"
 	}
 	if d := n.PostfixExpression.Declarator(); d != nil && p.isVolatileOrAtomic(d) {
 		p.w("%sPost%sAtomic%s(&", p.task.crt, x, p.helperType(n, pe))
 		var local *local
 		var tld *tld
 		if f != nil {
 			local = f.locals[d]
 		}
 		if local == nil {
 			tld = p.tlds[d]
 		}
 		switch {
 		case local != nil:
 			p.w("%s", local.name)
 		case tld != nil:
 			p.w("%s", tld.name)
 		default:
 			panic(todo(""))
 		}
 		p.w(", %d)", p.incDelta(n.PostfixExpression, pe))
 		return
 	}
 
 	p.w("%sPost%s%s(&", p.task.crt, x, p.helperType(n, pe))
 	p.postfixExpression(f, n.PostfixExpression, pe, exprLValue, flags)
 	p.w(", %d)", p.incDelta(n.PostfixExpression, pe))
 }
 
 func (p *project) postfixExpressionIncDecLValue(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	switch k := p.opKind(f, n, n.Operand.Type()); k {
 	case opNormal:
 		p.postfixExpressionIncDecLValueNormal(f, n, oper, oper2, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionIncDecLValueNormal(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	pe := n.PostfixExpression.Operand.Type()
 	defer p.w("%s", p.convert(n, n.PostfixExpression.Operand, t, flags))
 	x := "Dec"
 	if oper == "++" {
 		x = "Inc"
 	}
 	p.w("%sPost%s%s(&", p.task.crt, x, p.helperType(n, pe))
 	p.postfixExpression(f, n.PostfixExpression, pe, exprLValue, flags)
 	p.w(", %d)", p.incDelta(n.PostfixExpression, pe))
 }
 
 func (p *project) postfixExpressionIncDecVoid(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	switch k := p.opKind(f, n, n.Operand.Type()); k {
 	case opNormal:
 		p.postfixExpressionIncDecVoidNormal(f, n, oper, oper2, t, mode, flags)
 	case opBitfield:
 		p.postfixExpressionIncDec(f, n, oper, oper2, t, exprValue, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) postfixExpressionIncDecVoidNormal(f *function, n *cc.PostfixExpression, oper, oper2 string, t cc.Type, mode exprMode, flags flags) {
 	if d := n.PostfixExpression.Declarator(); d != nil && p.isVolatileOrAtomic(d) {
 		switch d.Type().Size() {
 		case 4, 8:
 			if !d.Type().IsIntegerType() {
 				p.err(n, "unsupported volatile declarator type: %v", d.Type())
 				return
 			}
 
 			if f != nil {
 				if local := f.locals[d]; local != nil {
 					if local.isPinned {
 						panic(todo(""))
 					}
 
 					p.w("atomic.Add%s(&%s, ", p.helperType(n, d.Type()), local.name)
 					switch oper {
 					case "++":
 						// ok
 					case "--":
 						p.w("-")
 					default:
 						p.err(n, "unsupported volatile declarator operation: %v", oper)
 					}
 					p.w("%d)", p.incDelta(n, d.Type()))
 					return
 				}
 			}
 
 			if tld := p.tlds[d]; tld != nil {
 				p.w("atomic.Add%s(&%s, ", p.helperType(n, d.Type()), tld.name)
 				switch oper {
 				case "++":
 					// ok
 				case "--":
 					p.w("-")
 				default:
 					p.err(n, "unsupported volatile declarator operation: %v", oper)
 				}
 				p.w("%d)", p.incDelta(n, d.Type()))
 				return
 			}
 
 			panic(todo("", n.Position(), d.Position()))
 		default:
 			p.err(n, "unsupported volatile declarator size: %v", d.Type().Size())
 			return
 		}
 	}
 
 	pe := n.PostfixExpression.Operand.Type().Decay()
 	p.postfixExpression(f, n.PostfixExpression, pe, exprLValue, flags)
 	if pe.IsIntegerType() || pe.Kind() == cc.Ptr && p.incDelta(n, pe) == 1 {
 		p.w("%s", oper)
 		return
 	}
 
 	switch pe.Kind() {
 	case cc.Ptr, cc.Float, cc.Double:
 		p.w("%s %d", oper2, p.incDelta(n, pe))
 		return
 	}
 
 	panic(todo("", n.Position(), pe, pe.Kind()))
 }
 
 func (p *project) incDelta(n cc.Node, t cc.Type) uintptr {
 	if t.IsArithmeticType() {
 		return 1
 	}
 
 	if t.Kind() == cc.Ptr || t.Kind() == cc.Array {
 		return t.Elem().Size()
 	}
 
 	panic(todo("", n.Position(), t.Kind()))
 }
 
 func (p *project) bitFldOff(t cc.Type, tok cc.Token) {
 	var off uintptr
 	fld, ok := t.FieldByName(tok.Value)
 	switch {
 	case ok && !fld.IsBitField():
 		panic(todo("%v: internal error: bitFdlOff must not be used with non bit fields", origin(2)))
 	case !ok:
 		p.err(&tok, "uknown field: %s", tok.Value)
 	default:
 		off = fld.BitFieldBlockFirst().Offset()
 	}
 	if off != 0 {
 		p.w("+%d", off)
 	}
 	p.w("/* &.%s */", tok.Value)
 }
 
 func (p *project) fldOff(t cc.Type, tok cc.Token) {
 	if t.Kind() == cc.Ptr {
 		t = t.Elem()
 	}
 	var off uintptr
 	fld, ok := t.FieldByName(tok.Value)
 	switch {
 	case ok && fld.IsBitField():
 		panic(todo("%v: internal error: fdlOff must not be used with bit fields", origin(2)))
 	case !ok:
 		p.err(&tok, "uknown field: %s", tok.Value)
 	default:
 		off = fld.Offset()
 	}
 	if off != 0 {
 		p.w("+%d", off)
 	}
 	p.w("/* &.%s */", tok.Value)
 }
 
 func (p *project) postfixExpressionCall(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '(' ArgumentExpressionList ')'
 	switch mode {
 	case exprVoid:
 		p.postfixExpressionCallVoid(f, n, t, mode, flags)
 	case exprValue:
 		p.postfixExpressionCallValue(f, n, t, mode, flags)
 	case exprBool:
 		p.postfixExpressionCallBool(f, n, t, mode, flags)
 	default:
 		panic(todo("", mode))
 	}
 }
 
 func (p *project) postfixExpressionCallBool(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '(' ArgumentExpressionList ')'
 	p.w("(")
 	defer p.w(")")
 	defer p.w(" != 0")
 	if d := n.PostfixExpression.Declarator(); d != nil {
 		switch d.Name() {
 		case idVaArg:
 			if !f.vaType.IsScalarType() {
 				panic(todo("", f.vaType))
 			}
 
 			lhs := n.ArgumentExpressionList.AssignmentExpression
 			p.w("%sVa%s(&", p.task.crt, p.helperType(n, f.vaType))
 			p.assignmentExpression(f, lhs, lhs.Operand.Type(), exprLValue, flags)
 			p.w(")")
 			return
 		case idAtomicLoadN:
 			p.atomicLoadN(f, n, t, mode, flags)
 			return
 		case idBuiltinConstantPImpl:
 			p.w("%v", n.Operand.Value())
 			return
 		}
 	}
 
 	var va uintptr
 	if f != nil {
 		va = f.vaLists[n]
 	}
 	p.postfixExpression(f, n.PostfixExpression, n.PostfixExpression.Operand.Type(), exprFunc, flags)
 	p.argumentExpressionList(f, n.PostfixExpression, n.ArgumentExpressionList, va)
 }
 
 func (p *project) postfixExpressionCallValue(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '(' ArgumentExpressionList ')'
 	defer p.w("%s", p.convert(n, n.Operand, t, flags))
 	if d := n.PostfixExpression.Declarator(); d != nil {
 		switch d.Name() {
 		case idVaEnd:
 			p.w("_ = ")
 			arg := n.ArgumentExpressionList.AssignmentExpression
 			p.assignmentExpression(f, arg, arg.Operand.Type(), exprValue, flags)
 			return
 		case idVaStart:
 			lhs := n.ArgumentExpressionList.AssignmentExpression
 			p.assignmentExpression(f, lhs, lhs.Operand.Type(), exprLValue, flags)
 			p.w(" = %s", f.vaName)
 			return
 		case idVaArg:
 			if !f.vaType.IsScalarType() {
 				panic(todo("", f.vaType))
 			}
 
 			lhs := n.ArgumentExpressionList.AssignmentExpression
 			p.w("%sVa%s(&", p.task.crt, p.helperType(n, f.vaType))
 			p.assignmentExpression(f, lhs, lhs.Operand.Type(), exprLValue, flags)
 			p.w(")")
 			return
 		case idAtomicLoadN:
 			p.atomicLoadN(f, n, t, mode, flags)
 			return
 		case idAddOverflow:
 			p.addOverflow(f, n, t, mode, flags)
 			return
 		case idSubOverflow:
 			p.subOverflow(f, n, t, mode, flags)
 			return
 		case idMulOverflow:
 			p.mulOverflow(f, n, t, mode, flags)
 			return
 		case idBuiltinConstantPImpl:
 			p.w("%v", n.Operand.Value())
 			return
 		}
 	}
 	var va uintptr
 	if f != nil {
 		va = f.vaLists[n]
 	}
 	p.postfixExpression(f, n.PostfixExpression, n.PostfixExpression.Operand.Type(), exprFunc, flags)
 	p.argumentExpressionList(f, n.PostfixExpression, n.ArgumentExpressionList, va)
 }
 
 // bool __builtin_mul_overflow (type1 a, type2 b, type3 *res)
 func (p *project) mulOverflow(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	args := p.argList(n.ArgumentExpressionList)
 	if len(args) != 3 {
 		p.err(n, "expected 3 arguments in call to __builtin_mul_overflow")
 		return
 	}
 
 	pt := args[2].Operand.Type()
 	if pt.Kind() != cc.Ptr {
 		p.err(n, "invalid argument of __builtin_mul_overflow (expected pointer): %s", pt)
 		return
 	}
 
 	vt := pt.Elem()
 	switch {
 	case vt.IsIntegerType():
 		switch vt.Size() {
 		case 1, 2, 4, 8, 16:
 			p.w("%sX__builtin_mul_overflow%s", p.task.crt, p.helperType(n, vt))
 		default:
 			p.err(n, "invalid argument of __builtin_mul_overflow: %v, elem kind %v", pt, vt.Kind())
 			return
 		}
 		p.w("(%s", f.tlsName)
 		types := []cc.Type{vt, vt, pt}
 		for i, v := range args[:3] {
 			p.w(", ")
 			p.assignmentExpression(f, v, types[i], exprValue, flags)
 		}
 		p.w(")")
 		return
 	}
 
 	p.err(n, "invalid arguments of __builtin_mul_overflow: (%v, %v, %v)", args[0].Operand.Type(), args[1].Operand.Type(), args[2].Operand.Type())
 }
 
 // bool __builtin_sub_overflow (type1 a, type2 b, type3 *res)
 func (p *project) subOverflow(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	args := p.argList(n.ArgumentExpressionList)
 	if len(args) != 3 {
 		p.err(n, "expected 3 arguments in call to __builtin_sub_overflow")
 		return
 	}
 
 	pt := args[2].Operand.Type()
 	if pt.Kind() != cc.Ptr {
 		p.err(n, "invalid argument of __builtin_sub_overflow (expected pointer): %s", pt)
 		return
 	}
 
 	vt := pt.Elem()
 	switch {
 	case vt.IsIntegerType():
 		switch vt.Size() {
 		case 1, 2, 4, 8:
 			p.w("%sX__builtin_sub_overflow%s", p.task.crt, p.helperType(n, vt))
 		default:
 			p.err(n, "invalid argument of __builtin_sub_overflow: %v, elem kind %v", pt, vt.Kind())
 			return
 		}
 		p.w("(%s", f.tlsName)
 		types := []cc.Type{vt, vt, pt}
 		for i, v := range args[:3] {
 			p.w(", ")
 			p.assignmentExpression(f, v, types[i], exprValue, flags)
 		}
 		p.w(")")
 		return
 	}
 
 	p.err(n, "invalid arguments of __builtin_sub_overflow: (%v, %v, %v)", args[0].Operand.Type(), args[1].Operand.Type(), args[2].Operand.Type())
 }
 
 // bool __builtin_add_overflow (type1 a, type2 b, type3 *res)
 func (p *project) addOverflow(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	args := p.argList(n.ArgumentExpressionList)
 	if len(args) != 3 {
 		p.err(n, "expected 3 arguments in call to __builtin_add_overflow")
 		return
 	}
 
 	pt := args[2].Operand.Type()
 	if pt.Kind() != cc.Ptr {
 		p.err(n, "invalid argument of __builtin_add_overflow (expected pointer): %s", pt)
 		return
 	}
 
 	vt := pt.Elem()
 	switch {
 	case vt.IsIntegerType():
 		switch vt.Size() {
 		case 1, 2, 4, 8:
 			p.w("%sX__builtin_add_overflow%s", p.task.crt, p.helperType(n, vt))
 		default:
 			p.err(n, "invalid argument of __builtin_add_overflow: %v, elem kind %v", pt, vt.Kind())
 			return
 		}
 		p.w("(%s", f.tlsName)
 		types := []cc.Type{vt, vt, pt}
 		for i, v := range args[:3] {
 			p.w(", ")
 			p.assignmentExpression(f, v, types[i], exprValue, flags)
 		}
 		p.w(")")
 		return
 	}
 
 	p.err(n, "invalid arguments of __builtin_add_overflow: (%v, %v, %v)", args[0].Operand.Type(), args[1].Operand.Type(), args[2].Operand.Type())
 }
 
 // type __atomic_load_n (type *ptr, int memorder)
 func (p *project) atomicLoadN(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	args := p.argList(n.ArgumentExpressionList)
 	if len(args) != 2 {
 		p.err(n, "expected 2 arguments in call to __atomic_load_n")
 		return
 	}
 
 	pt := args[0].Operand.Type()
 	if pt.Kind() != cc.Ptr {
 		p.err(n, "invalid argument of __atomic_load_n (expected pointer): %s", pt)
 		return
 	}
 
 	vt := pt.Elem()
 	switch {
 	case vt.IsIntegerType():
 		var s string
 		switch {
 		case vt.IsSignedType():
 			s = "Int"
 		default:
 			s = "Uint"
 		}
 		switch vt.Size() {
 		case 2, 4, 8:
 			p.w("%sAtomicLoadN%s%d", p.task.crt, s, 8*vt.Size())
 		default:
 			p.err(n, "invalid argument of __atomic_load_n: %v, elem kind %v", pt, vt.Kind())
 			return
 		}
 		types := []cc.Type{pt, p.intType}
 		p.w("(")
 		for i, v := range args[:2] {
 			if i != 0 {
 				p.w(", ")
 			}
 			p.assignmentExpression(f, v, types[i], exprValue, flags)
 		}
 		p.w(")")
 		return
 	case vt.Kind() == cc.Ptr:
 		panic(todo("", pt, vt))
 	}
 
 	p.err(n, "invalid first argument of __atomic_load_n: %v, elem kind %v", pt, vt.Kind())
 }
 
 func (p *project) postfixExpressionCallVoid(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	// PostfixExpression '(' ArgumentExpressionList ')'
 	if d := n.PostfixExpression.Declarator(); d != nil {
 		switch d.Name() {
 		case idVaEnd:
 			p.w("_ = ")
 			arg := n.ArgumentExpressionList.AssignmentExpression
 			p.assignmentExpression(f, arg, arg.Operand.Type(), exprValue, flags)
 			return
 		case idVaStart:
 			lhs := n.ArgumentExpressionList.AssignmentExpression
 			p.assignmentExpression(f, lhs, lhs.Operand.Type(), exprLValue, flags)
 			p.w(" = %s", f.vaName)
 			return
 		case idVaArg:
 			if !f.vaType.IsScalarType() {
 				panic(todo("", f.vaType))
 			}
 
 			lhs := n.ArgumentExpressionList.AssignmentExpression
 			p.w("%sVa%s(&", p.task.crt, p.helperType(n, f.vaType))
 			p.assignmentExpression(f, lhs, lhs.Operand.Type(), exprLValue, flags)
 			p.w(")")
 			return
 		case idAtomicStoreN:
 			p.atomicStoreN(f, n, t, mode, flags)
 			return
 		case idMulOverflow:
 			p.mulOverflow(f, n, t, mode, flags)
 			return
 		}
 	}
 	var va uintptr
 	if f != nil {
 		va = f.vaLists[n]
 	}
 	p.postfixExpression(f, n.PostfixExpression, n.PostfixExpression.Operand.Type(), exprFunc, flags)
 	p.argumentExpressionList(f, n.PostfixExpression, n.ArgumentExpressionList, va)
 }
 
 // void __atomic_store_n (type *ptr, type val, int memorder)
 func (p *project) atomicStoreN(f *function, n *cc.PostfixExpression, t cc.Type, mode exprMode, flags flags) {
 	args := p.argList(n.ArgumentExpressionList)
 	if len(args) != 3 {
 		p.err(n, "expected 3 arguments in call to __atomic_store_n")
 		return
 	}
 
 	pt := args[0].Operand.Type()
 	if pt.Kind() != cc.Ptr {
 		p.err(n, "invalid first argument of __atomic_store_n (expected pointer): %s", pt)
 		return
 	}
 
 	vt := args[1].Operand.Type()
 	switch {
 	case vt.IsIntegerType():
 		var s string
 		switch {
 		case vt.IsSignedType():
 			s = "Int"
 		default:
 			s = "Uint"
 		}
 		switch vt.Size() {
 		case 2, 4, 8:
 			p.w("%sAtomicStoreN%s%d", p.task.crt, s, 8*vt.Size())
 		default:
 			p.err(n, "invalid arguments of __atomic_store_n: (%v, %v), element kind %v", pt, vt, vt.Kind())
 			return
 		}
 		p.w("(")
 		types := []cc.Type{pt, vt, p.intType}
 		for i, v := range args[:3] {
 			if i != 0 {
 				p.w(", ")
 			}
 			if i == 1 {
 				p.w("%s(", strings.ToLower(p.helperType(n, vt)))
 			}
 			p.assignmentExpression(f, v, types[i], exprValue, flags)
 			if i == 1 {
 				p.w(")")
 			}
 		}
 		p.w(")")
 		return
 	case vt.Kind() == cc.Ptr:
 		panic(todo("", pt, vt))
 	}
 
 	p.err(n, "invalid arguments of __atomic_store_n: (%v, %v), element kind %v", pt, vt, vt.Kind())
 }
 
 func (p *project) argList(n *cc.ArgumentExpressionList) (r []*cc.AssignmentExpression) {
 	for ; n != nil; n = n.ArgumentExpressionList {
 		r = append(r, n.AssignmentExpression)
 	}
 	return r
 }
 
 func (p *project) argumentExpressionList(f *function, pe *cc.PostfixExpression, n *cc.ArgumentExpressionList, bpOff uintptr) {
 	switch {
 	case f == nil:
 		p.w("(nil")
 	default:
 		p.w("(%s", f.tlsName)
 	}
 	ft := funcType(pe.Operand.Type())
 	isVariadic := ft.IsVariadic()
 	params := ft.Parameters()
 	if len(params) == 1 && params[0].Type().Kind() == cc.Void {
 		params = nil
 	}
 	var args []*cc.AssignmentExpression
 	for ; n != nil; n = n.ArgumentExpressionList {
 		args = append(args, n.AssignmentExpression)
 	}
 	if len(args) < len(params) {
 		panic(todo("", p.pos(n)))
 	}
 
 	va := true
 	if len(args) > len(params) && !isVariadic {
 		var a []string
 		for _, v := range args {
 			a = append(a, v.Operand.Type().String())
 		}
 		sargs := strings.Join(a, ",")
 		switch d := pe.Declarator(); {
 		case d == nil:
 			p.err(pe, "too many arguments (%s) in call to %s", sargs, ft)
 		default:
 			p.err(pe, "too many arguments (%s) in call to %s of type %s", sargs, d.Name(), ft)
 		}
 		va = false
 	}
 
 	paren := ""
 	for i, arg := range args {
 		p.w(",%s", tidyComment(" ", arg))
 		mode := exprValue
 		if at := arg.Operand.Type(); at.Kind() == cc.Array {
 			mode = exprDecay
 		}
 		switch {
 		case i < len(params):
 			switch pt := params[i].Type(); {
 			case isTransparentUnion(params[i].Type()):
 				p.callArgTransparentUnion(f, arg, pt)
 			default:
 				p.assignmentExpression(f, arg, arg.Promote(), mode, 0)
 			}
 		case va && i == len(params):
 			p.w("%sVaList(%s%s, ", p.task.crt, f.bpName, nonZeroUintptr(bpOff))
 			paren = ")"
 			fallthrough
 		default:
 			var flags flags
 			if arg.Promote().IsIntegerType() {
 				switch x := arg.Operand.Value().(type) {
 				case cc.Int64Value:
 					if x < mathutil.MinInt || x > mathutil.MaxInt {
 						flags |= fForceConv
 					}
 				case cc.Uint64Value:
 					if x > mathutil.MaxInt {
 						flags |= fForceConv
 					}
 				}
 			}
 			p.assignmentExpression(f, arg, arg.Promote(), mode, flags)
 		}
 	}
 	if isVariadic && len(args) == len(params) {
 		p.w(", 0")
 	}
 	p.w("%s)", paren)
 }
 
 // https://gcc.gnu.org/onlinedocs/gcc-3.3/gcc/Type-Attributes.html
 //
 // transparent_union
 //
 // This attribute, attached to a union type definition, indicates that any
 // function parameter having that union type causes calls to that function to
 // be treated in a special way.
 //
 // First, the argument corresponding to a transparent union type can be of any
 // type in the union; no cast is required. Also, if the union contains a
 // pointer type, the corresponding argument can be a null pointer constant or a
 // void pointer expression; and if the union contains a void pointer type, the
 // corresponding argument can be any pointer expression. If the union member
 // type is a pointer, qualifiers like const on the referenced type must be
 // respected, just as with normal pointer conversions.
 //
 // Second, the argument is passed to the function using the calling conventions
 // of first member of the transparent union, not the calling conventions of the
 // union itself. All members of the union must have the same machine
 // representation; this is necessary for this argument passing to work
 // properly.
 //
 // Transparent unions are designed for library functions that have multiple
 // interfaces for compatibility reasons. For example, suppose the wait function
 // must accept either a value of type int * to comply with Posix, or a value of
 // type union wait * to comply with the 4.1BSD interface. If wait's parameter
 // were void *, wait would accept both kinds of arguments, but it would also
 // accept any other pointer type and this would make argument type checking
 // less useful. Instead, <sys/wait.h> might define the interface as follows:
 //
 //	typedef union
 //		{
 //			int *__ip;
 //			union wait *__up;
 //		} wait_status_ptr_t __attribute__ ((__transparent_union__));
 //
 //	pid_t wait (wait_status_ptr_t);
 //
 // This interface allows either int * or union wait * arguments to be passed,
 // using the int * calling convention. The program can call wait with arguments
 // of either type:
 //
 //	int w1 () { int w; return wait (&w); }
 //	int w2 () { union wait w; return wait (&w); }
 //
 // With this interface, wait's implementation might look like this:
 //
 //	pid_t wait (wait_status_ptr_t p)
 //	{
 //		return waitpid (-1, p.__ip, 0);
 //	}
 func (p *project) callArgTransparentUnion(f *function, n *cc.AssignmentExpression, pt cc.Type) {
 	if pt.Kind() != cc.Union {
 		panic(todo("internal error"))
 	}
 
 	ot := n.Operand.Type()
 	switch k := pt.UnionCommon(); k {
 	case cc.Ptr:
 		if ot.Kind() != k {
 			panic(todo("", n.Position(), k, pt))
 		}
 
 		p.assignmentExpression(f, n, ot, exprValue, 0)
 	default:
 		panic(todo("", n.Position(), k, pt))
 	}
 }
 
 func isTransparentUnion(t cc.Type) (r bool) {
 	for _, v := range attrs(t) {
 		cc.Inspect(v, func(n cc.Node, _ bool) bool {
 			if x, ok := n.(*cc.AttributeValue); ok && x.Token.Value == idTransparentUnion {
 				r = true
 				return false
 			}
 
 			return true
 		})
 	}
 	return r
 }
 
 func attrs(t cc.Type) []*cc.AttributeSpecifier {
 	if a := t.Attributes(); len(a) != 0 {
 		return a
 	}
 
 	if t.IsAliasType() {
 		if a := t.Alias().Attributes(); len(a) != 0 {
 			return a
 		}
 
 		return t.AliasDeclarator().Type().Attributes()
 	}
 
 	return nil
 }
 
 func (p *project) nzUintptr(n cc.Node, f func(), op cc.Operand) {
 	if op.Type().IsIntegerType() {
 		switch {
 		case op.IsZero():
 			return
 		case op.Value() != nil:
 			switch x := op.Value().(type) {
 			case cc.Int64Value:
 				if x > 0 && uint64(x) <= 1<<(8*p.ptrSize)-1 {
 					p.w("+%d", x)
 					return
 				}
 			case cc.Uint64Value:
 				if uint64(x) <= 1<<(8*p.ptrSize)-1 {
 					p.w("+%d", x)
 					return
 				}
 			}
 
 			p.w(" +%sUintptrFrom%s(", p.task.crt, p.helperType(n, op.Type()))
 		default:
 			p.w(" +uintptr(")
 		}
 
 		f()
 		p.w(")")
 		return
 	}
 
 	panic(todo("", p.pos(n)))
 }
 
 func (p *project) primaryExpression(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch mode {
 	case exprLValue:
 		p.primaryExpressionLValue(f, n, t, mode, flags)
 	case exprValue:
 		p.primaryExpressionValue(f, n, t, mode, flags)
 	case exprFunc:
 		p.primaryExpressionFunc(f, n, t, mode, flags)
 	case exprAddrOf:
 		p.primaryExpressionAddrOf(f, n, t, mode, flags)
 	case exprSelect:
 		p.primaryExpressionSelect(f, n, t, mode, flags)
 	case exprPSelect:
 		p.primaryExpressionPSelect(f, n, t, mode, flags)
 	case exprBool:
 		p.primaryExpressionBool(f, n, t, mode, flags)
 	case exprVoid:
 		p.primaryExpressionVoid(f, n, t, mode, flags)
 	case exprDecay:
 		p.primaryExpressionDecay(f, n, t, mode, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) primaryExpressionDecay(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PrimaryExpressionIdent: // IDENTIFIER
 		switch d := n.Declarator(); {
 		case d != nil:
 			p.declarator(n, f, d, t, mode, flags)
 		default:
 			panic(todo("", p.pos(n)))
 		}
 	case cc.PrimaryExpressionInt: // INTCONST
 		p.intConst(n, n.Token.Src.String(), n.Operand, t, flags)
 	case cc.PrimaryExpressionFloat: // FLOATCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionEnum: // ENUMCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionChar: // CHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLChar: // LONGCHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionString: // STRINGLITERAL
 		p.w("%s", p.stringLiteral(n.Operand.Value()))
 	case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL
 		p.w("%s", p.wideStringLiteral(n.Operand.Value(), 0))
 	case cc.PrimaryExpressionExpr: // '(' Expression ')'
 		p.expression(f, n.Expression, t, mode, flags)
 	case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')'
 		p.err(n, "statement expressions not supported")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) primaryExpressionVoid(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) {
 
 	switch n.Case {
 	case cc.PrimaryExpressionIdent: // IDENTIFIER
 		p.w("_ = ")
 		p.primaryExpression(f, n, n.Operand.Type(), exprValue, flags)
 	case cc.PrimaryExpressionInt, // INTCONST
 		cc.PrimaryExpressionFloat,   // FLOATCONST
 		cc.PrimaryExpressionEnum,    // ENUMCONST
 		cc.PrimaryExpressionChar,    // CHARCONST
 		cc.PrimaryExpressionLChar,   // LONGCHARCONST
 		cc.PrimaryExpressionString,  // STRINGLITERAL
 		cc.PrimaryExpressionLString: // LONGSTRINGLITERAL
 
 		// nop
 	case cc.PrimaryExpressionExpr: // '(' Expression ')'
 		p.expression(f, n.Expression, n.Expression.Operand.Type(), mode, flags)
 	case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')'
 		p.compoundStatement(f, n.CompoundStatement, "", true, false, 0)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) primaryExpressionBool(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) {
 	if n.Case != cc.PrimaryExpressionExpr {
 		p.w("(")
 		defer p.w(")")
 	}
 
 	if n.Case != cc.PrimaryExpressionExpr {
 		defer p.w(" != 0")
 	}
 	switch n.Case {
 	case cc.PrimaryExpressionIdent: // IDENTIFIER
 		switch d := n.Declarator(); {
 		case d != nil:
 			p.declarator(n, f, d, d.Type(), exprValue, flags)
 		default:
 			panic(todo("", p.pos(n)))
 		}
 	case cc.PrimaryExpressionInt: // INTCONST
 		p.intConst(n, n.Token.Src.String(), n.Operand, n.Operand.Type(), flags)
 	case cc.PrimaryExpressionFloat: // FLOATCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionEnum: // ENUMCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionChar: // CHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLChar: // LONGCHARCONST
 		p.charConst(n, n.Token.Src.String(), n.Operand, t, flags)
 	case cc.PrimaryExpressionString: // STRINGLITERAL
 		p.w(" 1 ")
 	case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionExpr: // '(' Expression ')'
 		p.w("(")
 		defer p.w(")")
 		p.expression(f, n.Expression, t, mode, flags)
 	case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')'
 		p.w("func() %v {", p.typ(n, n.CompoundStatement.Operand.Type()))
 		p.compoundStatement(f, n.CompoundStatement, "", true, false, exprValue)
 		p.w("}()")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) primaryExpressionPSelect(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PrimaryExpressionIdent: // IDENTIFIER
 		switch d := n.Declarator(); {
 		case d != nil:
 			switch k := p.declaratorKind(d); k {
 			case opArray:
 				panic(todo("", p.pos(n)))
 				p.primaryExpression(f, n, t, exprDecay, flags)
 			default:
 				p.declarator(n, f, d, t, mode, flags)
 			}
 		default:
 			panic(todo("", p.pos(n)))
 		}
 	case cc.PrimaryExpressionInt: // INTCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionFloat: // FLOATCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionEnum: // ENUMCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionChar: // CHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLChar: // LONGCHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionString: // STRINGLITERAL
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionExpr: // '(' Expression ')'
 		p.expression(f, n.Expression, t, mode, flags)
 	case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')'
 		p.err(n, "statement expressions not supported")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) primaryExpressionSelect(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PrimaryExpressionIdent: // IDENTIFIER
 		switch d := n.Declarator(); {
 		case d != nil:
 			p.declarator(n, f, d, t, mode, flags)
 		default:
 			panic(todo("", p.pos(n)))
 		}
 	case cc.PrimaryExpressionInt: // INTCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionFloat: // FLOATCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionEnum: // ENUMCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionChar: // CHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLChar: // LONGCHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionString: // STRINGLITERAL
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionExpr: // '(' Expression ')'
 		p.expression(f, n.Expression, t, mode, flags)
 	case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')'
 		p.err(n, "statement expressions not supported")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) primaryExpressionAddrOf(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PrimaryExpressionIdent: // IDENTIFIER
 		switch d := n.Declarator(); {
 		case d != nil:
 			p.declarator(n, f, d, t, mode, flags)
 		default:
 			panic(todo("", p.pos(n)))
 		}
 	case cc.PrimaryExpressionInt: // INTCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionFloat: // FLOATCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionEnum: // ENUMCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionChar: // CHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLChar: // LONGCHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionString: // STRINGLITERAL
 		p.w("%s", p.stringLiteral(n.Operand.Value()))
 	case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL
 		p.w("%s", p.wideStringLiteral(n.Operand.Value(), 0))
 	case cc.PrimaryExpressionExpr: // '(' Expression ')'
 		p.expression(f, n.Expression, t, mode, flags)
 	case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')'
 		p.err(n, "statement expressions not supported")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) primaryExpressionFunc(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PrimaryExpressionIdent: // IDENTIFIER
 		p.fnVal(n, f, func() { p.primaryExpression(f, n, n.Operand.Type(), exprValue, flags) }, n.Declarator(), n.Operand.Type(), 0, mode, flags)
 	case cc.PrimaryExpressionInt: // INTCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionFloat: // FLOATCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionEnum: // ENUMCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionChar: // CHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLChar: // LONGCHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionString: // STRINGLITERAL
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionExpr: // '(' Expression ')'
 		p.expression(f, n.Expression, t, mode, flags)
 	case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')'
 		p.err(n, "statement expressions not supported")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func cmpNormalizeValue(v cc.Value) cc.Value {
 	switch x := v.(type) {
 	case cc.Int64Value:
 		if x >= 0 {
 			return cc.Uint64Value(x)
 		}
 	}
 	return v
 }
 
 func (p *project) primaryExpressionValue(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PrimaryExpressionIdent: // IDENTIFIER
 		switch d := n.Declarator(); {
 		case d != nil:
 			p.declarator(n, f, d, t, mode, flags)
 		default:
 			panic(todo("", p.pos(n)))
 		}
 	case cc.PrimaryExpressionInt: // INTCONST
 		if m := n.Token.Macro(); m != 0 {
 			if d := p.defines[m]; d.name != "" {
 				if cmpNormalizeValue(n.Operand.Value()) == cmpNormalizeValue(d.value) {
 					defer p.w("%s", p.convert(n, n.Operand, t, flags))
 					p.w(" %s ", d.name)
 					break
 				}
 
 				p.w("/* %s */", m)
 			}
 		}
 
 		p.intConst(n, n.Token.Src.String(), n.Operand, t, flags)
 	case cc.PrimaryExpressionFloat: // FLOATCONST
 		//TODO use #define
 		p.floatConst(n, n.Token.Src.String(), n.Operand, t, flags)
 	case cc.PrimaryExpressionEnum: // ENUMCONST
 		en := n.ResolvedTo().(*cc.Enumerator)
 		if n.ResolvedIn().Parent() == nil {
 			if nm := p.enumConsts[en.Token.Value]; nm != "" {
 				p.w(" %s ", nm)
 				break
 			}
 		}
 
 		p.intConst(n, "", n.Operand, t, flags)
 		p.w("/* %s */", en.Token.Value)
 	case cc.PrimaryExpressionChar: // CHARCONST
 		p.charConst(n, n.Token.Src.String(), n.Operand, t, flags)
 	case cc.PrimaryExpressionLChar: // LONGCHARCONST
 		p.charConst(n, n.Token.Src.String(), n.Operand, t, flags)
 	case cc.PrimaryExpressionString: // STRINGLITERAL
 		p.w("%s", p.stringLiteral(n.Operand.Value()))
 	case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL
 		p.w("%s", p.wideStringLiteral(n.Operand.Value(), 0))
 	case cc.PrimaryExpressionExpr: // '(' Expression ')'
 		p.w("(")
 		defer p.w(")")
 		p.expression(f, n.Expression, t, mode, flags)
 	case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')'
 		p.statementExpression(f, n.CompoundStatement, t, mode, flags)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) statementExpression(f *function, n *cc.CompoundStatement, t cc.Type, mode exprMode, flags flags) {
 	defer p.w("%s", p.convert(n, n.Operand, t, flags))
 	p.w(" func() %v {", p.typ(n, n.Operand.Type()))
 	p.compoundStatement(f, n, "", true, false, mode)
 	p.w("}()")
 }
 
 func (p *project) primaryExpressionLValue(f *function, n *cc.PrimaryExpression, t cc.Type, mode exprMode, flags flags) {
 	switch n.Case {
 	case cc.PrimaryExpressionIdent: // IDENTIFIER
 		switch d := n.Declarator(); {
 		case d != nil:
 			p.declarator(n, f, d, t, mode, flags)
 		default:
 			panic(todo("", p.pos(n)))
 		}
 	case cc.PrimaryExpressionInt: // INTCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionFloat: // FLOATCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionEnum: // ENUMCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionChar: // CHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLChar: // LONGCHARCONST
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionString: // STRINGLITERAL
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionLString: // LONGSTRINGLITERAL
 		panic(todo("", p.pos(n)))
 	case cc.PrimaryExpressionExpr: // '(' Expression ')'
 		p.w("(")
 		defer p.w(")")
 		p.expression(f, n.Expression, t, mode, flags)
 	case cc.PrimaryExpressionStmt: // '(' CompoundStatement ')'
 		p.err(n, "statement expressions not supported")
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) stringLiteralString(s string) string {
 	if p.pass1 {
 		return ""
 	}
 
 	id := cc.String(s)
 	off, ok := p.tsOffs[id]
 	if !ok {
 		off = uintptr(p.ts.Len())
 		p.ts.WriteString(s)
 		p.ts.WriteByte(0)
 		p.tsOffs[id] = off
 	}
 	return fmt.Sprintf("(%s%s)%s", p.tsNameP, nonZeroUintptr(off), p.stringSnippet(s))
 }
 
 func (p *project) stringLiteral(v cc.Value) string {
 	if p.pass1 {
 		return ""
 	}
 
 	switch x := v.(type) {
 	case cc.StringValue:
 		id := cc.StringID(x)
 		off, ok := p.tsOffs[id]
 		s := id.String()
 		if !ok {
 			off = uintptr(p.ts.Len())
 			p.ts.WriteString(s)
 			p.ts.WriteByte(0)
 			p.tsOffs[id] = off
 		}
 		return fmt.Sprintf("(%s%s)%s", p.tsNameP, nonZeroUintptr(off), p.stringSnippet(s))
 	default:
 		panic(todo("%T", x))
 	}
 }
 
 func (p *project) stringSnippet(s string) string {
 	s = strings.ReplaceAll(s, "*/", "*\\/")
 	const max = 16
 	switch {
 	case len(s) <= max:
 		return fmt.Sprintf("/* %q */", s)
 	default:
 		return fmt.Sprintf("/* %q */", s[:16]+"...")
 	}
 }
 
 func (p *project) wideStringLiteral(v cc.Value, pad int) string {
 	if p.pass1 {
 		return ""
 	}
 
 	switch x := v.(type) {
 	case cc.WideStringValue:
 		id := cc.StringID(x)
 		off, ok := p.tsWOffs[id]
 		if !ok {
 			off = p.wcharSize * uintptr(len(p.tsW))
 			s := []rune(id.String())
 			if pad != 0 {
 				s = append(s, make([]rune, pad)...)
 			}
 			p.tsW = append(p.tsW, s...)
 			p.tsW = append(p.tsW, 0)
 			p.tsWOffs[id] = off
 		}
 		return fmt.Sprintf("(%s%s)", p.tsWNameP, nonZeroUintptr(off))
 	default:
 		panic(todo("%T", x))
 	}
 }
 
 func (p *project) charConst(n cc.Node, src string, op cc.Operand, to cc.Type, flags flags) {
 	switch {
 	case to.IsArithmeticType():
 		defer p.w("%s", p.convert(n, op, to, flags))
 	case to.Kind() == cc.Ptr && op.IsZero():
 		p.w(" 0 ")
 		return
 	default:
 		panic(todo("%v: t %v, to %v, to.Alias() %v", n.Position(), op.Type(), to, to.Alias()))
 	}
 
 	r, mb, _, err := strconv.UnquoteChar(src[1:len(src)-1], '\'')
 	rValid := !mb && err == nil
 	var on uint64
 	switch x := op.Value().(type) {
 	case cc.Int64Value:
 		on = uint64(x)
 	case cc.Uint64Value:
 		on = uint64(x)
 	default:
 		panic(todo("%T(%v)", x, x))
 	}
 	var mask uint64
 	switch {
 	case !to.IsIntegerType():
 		// ok
 		if rValid { // Prefer original form
 			p.w("%s", src)
 			return
 		}
 
 		p.w("%d", on)
 		return
 	case to.IsSignedType():
 		var in int64
 		var ok bool
 		switch to.Size() {
 		case 1:
 			in = int64(int8(on))
 			ok = int8(on) >= 0
 		case 2:
 			in = int64(int16(on))
 			ok = int16(on) >= 0
 		case 4:
 			in = int64(int32(on))
 			ok = int32(on) >= 0
 		case 8:
 			in = int64(int64(on))
 			ok = in >= 0
 		default:
 			panic(todo("", op.Type().Size()))
 		}
 		if ok && rValid && uint64(in) == on { // Prefer original form
 			p.w("%s", src)
 			return
 		}
 
 		p.w("%d", in)
 	default:
 		switch to.Size() {
 		case 1:
 			mask = 0xff
 		case 2:
 			mask = 0xffff
 		case 4:
 			mask = 0xffffffff
 		case 8:
 			mask = 0xffffffffffffffff
 		default:
 			panic(todo("", op.Type().Size()))
 		}
 		if rValid && uint64(r)&mask == on { // Prefer original form
 			p.w("%s", src)
 			return
 		}
 
 		p.w("%d", on&mask)
 	}
 }
 
 func (p *project) floatConst(n cc.Node, src string, op cc.Operand, to cc.Type, flags flags) {
 	if flags&fForceRuntimeConv != 0 {
 		p.w("%s(", p.helperType2(n, op.Type(), to))
 		defer p.w(")")
 	}
 
 	bits := 64
 	switch to.Kind() {
 	case cc.Float:
 		bits = 32
 	}
 	src = strings.TrimRight(src, "flFL")
 	sn, err := strconv.ParseFloat(src, bits)
 	snValid := err == nil
 	switch x := op.Value().(type) {
 	case cc.Float64Value:
 		switch to.Kind() {
 		case cc.Double:
 			if snValid && sn == float64(x) { // Prefer original form.
 				p.w("%s", src)
 				return
 			}
 
 			p.w("math.Float64frombits(%#x)", math.Float64bits(float64(x)))
 		case cc.Float:
 			if snValid && float32(sn) == float32(x) { // Prefer original form.
 				p.w("%s", src)
 				return
 			}
 
 			p.w("math.Float32frombits(%#x)", math.Float32bits(float32(x)))
 		default:
 			defer p.w("%s", p.convert(n, op, to, 0))
 			if snValid && sn == float64(x) { // Prefer original form.
 				p.w("%s", src)
 				return
 			}
 
 			p.w("math.Float64frombits(%#x)", math.Float64bits(float64(x)))
 		}
 	case cc.Float32Value:
 		switch to.Kind() {
 		case cc.Double:
 			if snValid && float32(sn) == float32(x) { // Prefer original form.
 				p.w("%s", src)
 				return
 			}
 
 			p.w("math.Float64frombits(%#x)", math.Float64bits(float64(x)))
 		case cc.Float:
 			if snValid && float32(sn) == float32(x) { // Prefer original form.
 				p.w("%s", src)
 				return
 			}
 
 			p.w("math.Float32frombits(%#x)", math.Float32bits(float32(x)))
 		default:
 			if to.IsIntegerType() {
 				if s := p.float2Int(n, x, to); s != "" {
 					defer p.w("%s%s", s, p.convertType(n, op.Type(), to, 0))
 					break
 				}
 			}
 
 			defer p.w("%s", p.convert(n, op, to, 0))
 			if snValid && float32(sn) == float32(x) { // Prefer original form.
 				p.w("%s", src)
 				return
 			}
 
 			p.w("math.Float32frombits(%#x)", math.Float32bits(float32(x)))
 		}
 	default:
 		panic(todo("%T(%v)", x, x))
 	}
 }
 
 func (p *project) float2Int(n cc.Node, x cc.Float32Value, to cc.Type) string {
 	switch {
 	case to.IsSignedType():
 		limits := &signedSaturationLimits[to.Size()]
 		v := float64(x)
 		switch {
 		case math.IsNaN(v):
 			panic(todo("", p.pos(n)))
 		case math.IsInf(v, -1):
 			panic(todo("", p.pos(n)))
 		case math.IsInf(v, 1):
 			panic(todo("", p.pos(n)))
 		case v < limits.fmin:
 			return fmt.Sprint(limits.min)
 		case v > limits.fmax:
 			return fmt.Sprint(limits.max)
 		}
 	default:
 		limits := &unsignedSaturationLimits[to.Size()]
 		v := float64(x)
 		switch {
 		case math.IsNaN(v):
 			panic(todo("", p.pos(n)))
 		case math.IsInf(v, -1):
 			panic(todo("", p.pos(n)))
 		case math.IsInf(v, 1):
 			panic(todo("", p.pos(n)))
 		case v < 0:
 			return "0"
 		case v > limits.fmax:
 			return fmt.Sprint(limits.max)
 		}
 	}
 	return ""
 }
 
 type signedSaturationLimit struct {
 	fmin, fmax float64
 	min, max   int64
 }
 
 type unsignedSaturationLimit struct {
 	fmax float64
 	max  uint64
 }
 
 var (
 	signedSaturationLimits = [...]signedSaturationLimit{
 		1: {math.Nextafter(math.MinInt32, 0), math.Nextafter(math.MaxInt32, 0), math.MinInt32, math.MaxInt32},
 		2: {math.Nextafter(math.MinInt32, 0), math.Nextafter(math.MaxInt32, 0), math.MinInt32, math.MaxInt32},
 		4: {math.Nextafter(math.MinInt32, 0), math.Nextafter(math.MaxInt32, 0), math.MinInt32, math.MaxInt32},
 		8: {math.Nextafter(math.MinInt64, 0), math.Nextafter(math.MaxInt64, 0), math.MinInt64, math.MaxInt64},
 	}
 
 	unsignedSaturationLimits = [...]unsignedSaturationLimit{
 		1: {math.Nextafter(math.MaxUint32, 0), math.MaxUint32},
 		2: {math.Nextafter(math.MaxUint32, 0), math.MaxUint32},
 		4: {math.Nextafter(math.MaxUint32, 0), math.MaxUint32},
 		8: {math.Nextafter(math.MaxUint64, 0), math.MaxUint64},
 	}
 )
 
 func (p *project) intConst(n cc.Node, src string, op cc.Operand, to cc.Type, flags flags) {
 	ptr := to.Kind() == cc.Ptr
 	switch {
 	case to.IsArithmeticType():
 		// p.w("/*10568 %T(%#[1]x) %v -> %v */", op.Value(), op.Type(), to) //TODO-
 		if flags&fForceNoConv != 0 {
 			break
 		}
 
 		if !op.Type().IsSignedType() && op.Type().Size() == 8 && op.Value().(cc.Uint64Value) > math.MaxInt64 {
 			flags |= fForceRuntimeConv
 		}
 		defer p.w("%s", p.convert(n, op, to, flags))
 	case ptr:
 		p.w(" uintptr(")
 		defer p.w(")")
 		// ok
 	default:
 		panic(todo("%v: %v -> %v", p.pos(n), op.Type(), to))
 	}
 
 	src = strings.TrimRight(src, "luLU")
 	sn, err := strconv.ParseUint(src, 0, 64)
 	snValid := err == nil
 	var on uint64
 	switch x := op.Value().(type) {
 	case cc.Int64Value:
 		if x < 0 {
 			sn, err := strconv.ParseInt(src, 0, 64)
 			snValid := err == nil
 			if snValid && sn == int64(x) { // Prefer original form
 				p.w("%s", src)
 				return
 			}
 
 			p.w("%d", x)
 			return
 		}
 
 		on = uint64(x)
 	case cc.Uint64Value:
 		on = uint64(x)
 	default:
 		panic(todo("%T(%v)", x, x))
 	}
 
 	if snValid && sn == on { // Prefer original form
 		p.w("%s", src)
 		return
 	}
 
 	p.w("%d", on)
 }
 
 func (p *project) assignShiftOp(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) {
 	// UnaryExpression "<<=" AssignmentExpression etc.
 	switch mode {
 	case exprVoid:
 		p.assignShiftOpVoid(f, n, t, mode, oper, oper2, flags)
 	default:
 		panic(todo("", mode))
 	}
 }
 
 func (p *project) assignShiftOpVoid(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) {
 	// UnaryExpression "<<=" AssignmentExpression etc.
 	switch k := p.opKind(f, n.UnaryExpression, n.UnaryExpression.Operand.Type()); k {
 	case opNormal:
 		p.assignShiftOpVoidNormal(f, n, t, mode, oper, oper2, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) assignShiftOpVoidNormal(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) {
 	switch {
 	case n.Operand.Type().IsBitFieldType():
 		panic(todo("", p.pos(n)))
 	default:
 		if d := n.UnaryExpression.Declarator(); d != nil {
 			switch d.Type().Kind() {
 			case cc.Int128, cc.UInt128:
 				p.declarator(n, f, d, d.Type(), exprLValue, flags)
 				p.w(".LValue%s(", oper2)
 				p.assignmentExpression(f, n.AssignmentExpression, p.intType, exprValue, flags)
 				p.w(")")
 				return
 			default:
 				p.declarator(n, f, d, d.Type(), exprLValue, flags)
 				p.w(" %s= ", oper)
 				p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 				return
 			}
 		}
 
 		lhs := n.UnaryExpression
 		switch {
 		case lhs.Operand.Type().IsArithmeticType():
 			p.w("%sAssign%sPtr%s(", p.task.crt, oper2, p.helperType(n, lhs.Operand.Type()))
 			p.unaryExpression(f, lhs, lhs.Operand.Type(), exprAddrOf, flags)
 			p.w(", int(")
 			p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 			p.w("))")
 		default:
 			panic(todo("", p.pos(n), lhs.Operand.Type()))
 		}
 	}
 }
 
 func (p *project) assignOp(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) {
 	// UnaryExpression "*=" AssignmentExpression etc.
 	switch mode {
 	case exprVoid:
 		p.assignOpVoid(f, n, t, mode, oper, oper2, flags)
 	case exprValue, exprCondReturn:
 		p.assignOpValue(f, n, t, mode, oper, oper2, flags)
 	default:
 		panic(todo("", n.Position(), mode))
 	}
 }
 
 func (p *project) assignOpValue(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) {
 	// UnaryExpression "*=" AssignmentExpression etc.
 	switch k := p.opKind(f, n.UnaryExpression, n.UnaryExpression.Operand.Type()); k {
 	case opNormal:
 		p.assignOpValueNormal(f, n, t, oper, oper2, mode, flags)
 	case opBitfield:
 		p.assignOpValueBitfield(f, n, t, oper, oper2, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) assignOpValueBitfield(f *function, n *cc.AssignmentExpression, t cc.Type, oper, oper2 string, mode exprMode, flags flags) {
 	// UnaryExpression "*=" AssignmentExpression etc.
 
 	asInt := oper2 == "Shl" || oper2 == "Shr"
 	if asInt {
 		panic(todo(""))
 	}
 
 	ot := n.Operand.Type()
 	lhs := n.UnaryExpression
 	bf := lhs.Operand.Type().BitField()
 	defer p.w("%s", p.convertType(n, ot, t, flags))
 	p.w(" func() %v {", p.typ(n, ot))
 	switch lhs.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		pe := n.UnaryExpression.PostfixExpression
 		switch pe.Case {
 		case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 			p.w("__p := ")
 			p.postfixExpression(f, pe, pe.Operand.Type(), exprAddrOf, flags)
 			p.w("; __v := ")
 			p.readBitfield(lhs, "__p", bf, ot)
 			p.w(" %s (", oper)
 			p.assignmentExpression(f, n.AssignmentExpression, ot, exprValue, flags)
 			p.w("); return %sAssignBitFieldPtr%d%s(__p, __v, %d, %d, %#x)", p.task.crt, bf.BitFieldBlockWidth(), p.bfHelperType(ot), bf.BitFieldWidth(), bf.BitFieldOffset(), bf.Mask())
 		case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 			panic(todo("", p.pos(n)))
 		default:
 			panic(todo("", n.Position(), pe.Case))
 		}
 	default:
 		panic(todo("", n.Position(), lhs.Case))
 	}
 	p.w("}()")
 }
 
 func (p *project) readBitfield(n cc.Node, ptr string, bf cc.Field, promote cc.Type) {
 	bw := bf.BitFieldBlockWidth()
 	m := bf.Mask()
 	o := bf.BitFieldOffset()
 	w := bf.BitFieldWidth()
 	p.w("(%s(*(*uint%d)(unsafe.Pointer(%s))&%#x)", p.typ(n, promote), bw, ptr, m)
 	switch {
 	case bf.Type().IsSignedType():
 		bits := int(promote.Size()) * 8
 		p.w("<<%d>>%d)", bits-w-o, bits-w)
 	default:
 		p.w(">>%d)", o)
 	}
 }
 
 func (p *project) assignOpValueNormal(f *function, n *cc.AssignmentExpression, t cc.Type, oper, oper2 string, mode exprMode, flags flags) {
 	if mode == exprCondReturn {
 		p.w("return ")
 	}
 	asInt := oper2 == "Shl" || oper2 == "Shr"
 	lhs := n.UnaryExpression
 	// UnaryExpression "*=" AssignmentExpression etc.
 	if d := lhs.Declarator(); d != nil {
 		if local := f.locals[d]; local != nil && local.isPinned {
 			switch {
 			case lhs.Operand.Type().IsArithmeticType():
 				defer p.w("%s", p.convertType(n, lhs.Operand.Type(), t, flags))
 				p.w("%sAssign%sPtr%s(", p.task.crt, oper2, p.helperType(n, lhs.Operand.Type()))
 				p.unaryExpression(f, lhs, lhs.Operand.Type(), exprAddrOf, flags)
 				p.w(", ")
 				if asInt {
 					p.w("int(")
 				}
 				p.assignmentExpression(f, n.AssignmentExpression, lhs.Operand.Type(), exprValue, flags)
 				if asInt {
 					p.w(")")
 				}
 				p.w(")")
 			default:
 				panic(todo("", lhs.Operand.Type()))
 			}
 			return
 		}
 
 		switch {
 		case d.Type().Kind() == cc.Ptr:
 			defer p.w("%s", p.convertType(n, d.Type(), t, flags))
 			p.w("%sAssign%s%s(&", p.task.crt, oper2, p.helperType(n, d.Type()))
 			p.declarator(n, f, d, d.Type(), exprLValue, flags)
 			p.w(", ")
 			if dd := p.incDelta(d, d.Type()); dd != 1 {
 				p.w("%d*(", dd)
 				defer p.w(")")
 			}
 			p.assignmentExpression(f, n.AssignmentExpression, d.Type(), exprValue, flags)
 			p.w(")")
 		case d.Type().IsArithmeticType():
 			defer p.w("%s", p.convertType(n, d.Type(), t, flags))
 			p.w("%sAssign%s%s(&", p.task.crt, oper2, p.helperType(n, d.Type()))
 			p.declarator(n, f, d, d.Type(), exprLValue, flags)
 			p.w(", ")
 			if asInt {
 				p.w("int(")
 			}
 			p.assignmentExpression(f, n.AssignmentExpression, d.Type(), exprValue, flags)
 			p.w(")")
 			if asInt {
 				p.w(")")
 			}
 		default:
 			panic(todo("", p.pos(n), p.pos(d), d.Name()))
 		}
 		return
 	}
 
 	switch {
 	case lhs.Operand.Type().IsArithmeticType():
 		defer p.w("%s", p.convertType(n, lhs.Operand.Type(), t, flags))
 		p.w("%sAssign%sPtr%s(", p.task.crt, oper2, p.helperType(n, lhs.Operand.Type()))
 		p.unaryExpression(f, lhs, lhs.Operand.Type(), exprAddrOf, flags)
 		p.w(", ")
 		if asInt {
 			p.w("int(")
 		}
 		p.assignmentExpression(f, n.AssignmentExpression, lhs.Operand.Type(), exprValue, flags)
 		if asInt {
 			p.w(")")
 		}
 		p.w(")")
 	default:
 		panic(todo("", lhs.Operand.Type()))
 	}
 }
 
 func (p *project) assignOpVoid(f *function, n *cc.AssignmentExpression, t cc.Type, mode exprMode, oper, oper2 string, flags flags) {
 	// UnaryExpression "*=" AssignmentExpression etc.
 	switch k := p.opKind(f, n.UnaryExpression, n.UnaryExpression.Operand.Type()); k {
 	case opNormal:
 		p.assignOpVoidNormal(f, n, t, oper, oper2, mode, flags)
 	case opBitfield:
 		p.assignOpVoidBitfield(f, n, t, oper, oper2, mode, flags)
 	case opArrayParameter:
 		p.assignOpVoidArrayParameter(f, n, t, oper, oper2, mode, flags)
 	default:
 		panic(todo("", n.Position(), k))
 	}
 }
 
 func (p *project) assignOpVoidArrayParameter(f *function, n *cc.AssignmentExpression, t cc.Type, oper, oper2 string, mode exprMode, flags flags) {
 	// UnaryExpression "*=" AssignmentExpression etc.
 	if oper != "+" && oper != "-" {
 		panic(todo("", p.pos(n)))
 	}
 
 	d := n.UnaryExpression.Declarator()
 	switch local := f.locals[d]; {
 	case local != nil && local.isPinned:
 		p.w("*(*uintptr)(unsafe.Pointer(%s%s))", f.bpName, nonZeroUintptr(local.off))
 	default:
 		p.declarator(n, f, d, d.Type(), exprLValue, flags)
 	}
 
 	p.w(" %s= ", oper)
 	if dd := p.incDelta(d, d.Type()); dd != 1 {
 		p.w("%d*", dd)
 	}
 	p.w("uintptr(")
 	p.assignmentExpression(f, n.AssignmentExpression, n.AssignmentExpression.Operand.Type(), exprValue, flags)
 	p.w(")")
 }
 
 func (p *project) assignOpVoidBitfield(f *function, n *cc.AssignmentExpression, t cc.Type, oper, oper2 string, mode exprMode, flags flags) {
 	// UnaryExpression "*=" AssignmentExpression etc.
 	lhs := n.UnaryExpression
 	lt := lhs.Operand.Type()
 	switch lhs.Case {
 	case cc.UnaryExpressionPostfix: // PostfixExpression
 		pe := n.UnaryExpression.PostfixExpression
 		switch pe.Case {
 		case cc.PostfixExpressionSelect: // PostfixExpression '.' IDENTIFIER
 			bf := lt.BitField()
 			p.w("%sSetBitFieldPtr%d%s(", p.task.crt, bf.BitFieldBlockWidth(), p.bfHelperType(n.Promote()))
 			p.unaryExpression(f, lhs, lt, exprAddrOf, flags)
 			p.w(", (")
 			s := p.convertType(n, lt, n.Promote(), flags)
 			p.unaryExpression(f, lhs, lt, exprValue, flags)
 			p.w(")%s %s ", s, oper)
 			s = p.convertType(n, lt, n.Promote(), flags)
 			p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 			p.w("%s", s)
 			p.w(", %d, %#x)", bf.BitFieldOffset(), bf.Mask())
 		case cc.PostfixExpressionPSelect: // PostfixExpression "->" IDENTIFIER
 			switch d := pe.PostfixExpression.Declarator(); {
 			case d != nil:
 				panic(todo("", p.pos(n)))
 			default:
 				panic(todo("", p.pos(n)))
 			}
 		default:
 			panic(todo("", n.Position(), pe.Case))
 		}
 	default:
 		panic(todo("", n.Position(), lhs.Case))
 	}
 }
 
 func (p *project) assignOpVoidNormal(f *function, n *cc.AssignmentExpression, t cc.Type, oper, oper2 string, mode exprMode, flags flags) {
 	// UnaryExpression "*=" AssignmentExpression etc.
 	rop := n.AssignmentExpression.Operand
 	if d := n.UnaryExpression.Declarator(); d != nil {
 		if local := f.locals[d]; local != nil && local.isPinned {
 			if p.isVolatileOrAtomic(d) {
 				panic(todo(""))
 			}
 
 			p.declarator(n, f, d, d.Type(), exprLValue, flags)
 			switch {
 			case d.Type().Kind() == cc.Ptr:
 				p.w(" %s= ", oper)
 				if dd := p.incDelta(d, d.Type()); dd != 1 {
 					p.w("%d*(", dd)
 					defer p.w(")")
 				}
 				defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), d.Type(), flags))
 				p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 			case d.Type().IsArithmeticType():
 				p.w(" %s= ", oper)
 				defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), d.Type(), flags))
 				p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 			default:
 				panic(todo("", n.Position(), d.Type().Kind()))
 			}
 			return
 		}
 
 		if p.isVolatileOrAtomic(d) {
 			var local *local
 			var tld *tld
 			var nm string
 			if f != nil {
 				if local = f.locals[d]; local != nil {
 					nm = local.name
 				}
 			}
 
 			if local == nil {
 				if tld = p.tlds[d]; tld == nil {
 					p.err(n, "%v: internal error (%v: %v)", n.Position(), d.Position(), d.Name())
 					return
 				}
 
 				nm = tld.name
 			}
 			var sign string
 			switch oper {
 			case "-":
 				sign = oper
 				fallthrough
 			case "+":
 				sz := d.Type().Size()
 				var ht string
 				switch sz {
 				case 4, 8:
 					if !d.Type().IsScalarType() {
 						p.err(n, "unsupported volatile declarator type: %v", d.Type())
 						break
 					}
 
 					ht = p.helperType(n, d.Type())
 				default:
 					p.err(n, "unsupported volatile declarator size: %v", sz)
 					return
 				}
 
 				if local != nil {
 					if local.isPinned {
 						panic(todo(""))
 					}
 				}
 
 				p.w("%sAtomicAdd%s(&%s, %s%s(", p.task.crt, ht, nm, sign, p.typ(n, d.Type()))
 				p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 				p.w("))")
 				return
 			default:
 				p.warn(n, "unsupported volatile declarator operation: %v", oper)
 				p.w("%s = ", nm)
 				defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), d.Type(), flags))
 				p.declarator(n, f, d, n.Promote(), exprValue, flags)
 				p.w(" %s (", oper)
 				p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 				p.w(")")
 				return
 			}
 		}
 
 		p.declarator(n, f, d, d.Type(), exprLValue, flags)
 		switch d.Type().Kind() {
 		case cc.Ptr:
 			if oper != "+" && oper != "-" {
 				panic(todo("", p.pos(n)))
 			}
 
 			p.w(" %s= ", oper)
 			if dd := p.incDelta(d, d.Type()); dd != 1 {
 				p.w("%d*(", dd)
 				defer p.w(")")
 			}
 			defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), d.Type(), flags))
 			p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 		case cc.Int128, cc.UInt128:
 			p.w(" = ")
 			p.declarator(n, f, d, n.Promote(), exprValue, flags)
 			p.w(".%s(", oper2)
 			p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 			p.w(")")
 		default:
 			p.w(" = ")
 			defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), d.Type(), flags))
 			p.declarator(n, f, d, n.Promote(), exprValue, flags)
 			p.w(" %s (", oper)
 			p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 			p.w(")")
 		}
 		return
 	}
 
 	lhs := n.UnaryExpression
 	switch {
 	case lhs.Operand.Type().IsArithmeticType():
 		p.w("*(*%s)(unsafe.Pointer(", p.typ(n, lhs.Operand.Type()))
 		p.unaryExpression(f, lhs, lhs.Operand.Type(), exprAddrOf, flags)
 		p.w(")) %s= ", oper)
 		defer p.w("%s", p.convert(n, rop.ConvertTo(n.Promote()), lhs.Operand.Type(), flags))
 		p.w("(")
 		p.assignmentExpression(f, n.AssignmentExpression, n.Promote(), exprValue, flags)
 		p.w(")")
 	case lhs.Operand.Type().Kind() == cc.Ptr:
 		p.w("*(*%s)(unsafe.Pointer(", p.typ(n, lhs.Operand.Type()))
 		p.unaryExpression(f, lhs, lhs.Operand.Type(), exprAddrOf, flags)
 		p.w(")) %s= (", oper)
 		p.assignmentExpression(f, n.AssignmentExpression, lhs.Operand.Type(), exprValue, flags)
 		p.w(")")
 		if dd := p.incDelta(n, lhs.Operand.Type()); dd != 1 {
 			p.w("*%d", dd)
 		}
 	default:
 		panic(todo("", lhs.Operand.Type()))
 	}
 }
 
 func (p *project) warn(n cc.Node, s string, args ...interface{}) {
 	s = fmt.Sprintf(s, args...)
 	s = strings.TrimRight(s, "\t\n\r")
 	fmt.Fprintf(os.Stderr, "%v: warning: %s\n", n.Position(), s)
 }
 
 func (p *project) iterationStatement(f *function, n *cc.IterationStatement) {
 	sv := f.switchCtx
 	sv2 := f.continueCtx
 	sv3 := f.breakCtx
 	f.switchCtx = 0
 	f.continueCtx = 0
 	f.breakCtx = 0
 	defer func() {
 		f.breakCtx = sv3
 		f.continueCtx = sv2
 		f.switchCtx = sv
 	}()
 	p.w("%s", tidyComment("\n", n))
 	switch n.Case {
 	case cc.IterationStatementWhile: // "while" '(' Expression ')' Statement
 		if f.hasJumps {
 			// a:	if !expr goto b
 			//	stmt
 			//	goto a
 			// b:
 			a := f.flatLabel()
 			b := f.flatLabel()
 			f.continueCtx = a
 			f.breakCtx = b
 			p.w("__%d: if !(", a)
 			p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0)
 			p.w(") { goto __%d };", b)
 			p.statement(f, n.Statement, false, false, false, 0)
 			p.w("; goto __%d; __%d:", a, b)
 			break
 		}
 
 		p.w("for ")
 		p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0)
 		p.statement(f, n.Statement, true, false, false, 0)
 	case cc.IterationStatementDo: // "do" Statement "while" '(' Expression ')' ';'
 		if f.hasJumps {
 			// a:	stmt
 			// b:	if expr goto a // b is the continue label
 			// c:
 			a := f.flatLabel()
 			b := f.flatLabel()
 			c := f.flatLabel()
 			f.continueCtx = b
 			f.breakCtx = c
 			p.w("__%d:", a)
 			p.statement(f, n.Statement, false, false, false, 0)
 			p.w(";goto __%d; __%[1]d: if ", b)
 			p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0)
 			p.w("{goto __%d};goto __%d;__%[2]d:", a, c)
 			break
 		}
 
 		v := "__ccgo"
 		if !p.pass1 {
 			v = f.scope.take(cc.String(v))
 		}
 		p.w("for %v := true; %[1]v; %[1]v = ", v)
 		p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0)
 		p.statement(f, n.Statement, true, false, false, 0)
 	case cc.IterationStatementFor: // "for" '(' Expression ';' Expression ';' Expression ')' Statement
 		if f.hasJumps || n.Expression3 != nil && n.Expression3.Case == cc.ExpressionComma {
 			//	expr
 			// a:	if !expr2 goto c
 			//	stmt
 			// b: 	expr3 // label for continue
 			//	goto a
 			// c:
 			a := f.flatLabel()
 			b := f.flatLabel()
 			f.continueCtx = b
 			c := f.flatLabel()
 			f.breakCtx = c
 			if n.Expression != nil {
 				p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, fNoCondAssignment)
 			}
 			semi := ""
 			if n.Expression != nil || n.Expression2 != nil || n.Expression3 != nil {
 				semi = ";"
 			}
 			p.w("%s__%d:", semi, a)
 			if n.Expression2 != nil {
 				p.w("if !(")
 				p.expression(f, n.Expression2, n.Expression2.Operand.Type(), exprBool, 0)
 				p.w(") { goto __%d }", c)
 			}
 			p.w("%s", semi)
 			p.statement(f, n.Statement, false, false, false, 0)
 			p.w(";goto __%d; __%[1]d:", b)
 			if n.Expression3 != nil {
 				p.expression(f, n.Expression3, n.Expression3.Operand.Type(), exprVoid, fNoCondAssignment)
 			}
 			p.w("%sgoto __%d; goto __%d;__%[3]d:", semi, a, c)
 			break
 		}
 
 		expr := true
 		if n.Expression != nil && n.Expression.Case == cc.ExpressionComma {
 			p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, 0)
 			p.w(";")
 			expr = false
 		}
 		p.w("for ")
 		if expr && n.Expression != nil {
 			p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, fNoCondAssignment)
 		}
 		p.w("; ")
 		if n.Expression2 != nil {
 			p.expression(f, n.Expression2, n.Expression2.Operand.Type(), exprBool, 0)
 		}
 		p.w("; ")
 		if n.Expression3 != nil {
 			p.expression(f, n.Expression3, n.Expression3.Operand.Type(), exprVoid, fNoCondAssignment)
 		}
 		p.statement(f, n.Statement, true, false, false, 0)
 	case cc.IterationStatementForDecl: // "for" '(' Declaration Expression ';' Expression ')' Statement
 		if !(f.hasJumps || n.Expression2 != nil && n.Expression2.Case == cc.ExpressionComma) {
 			p.w("{")
 			p.declaration(f, n.Declaration, false)
 			p.w("for ;")
 			if n.Expression != nil {
 				p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0)
 			}
 			p.w(";")
 			if n.Expression2 != nil {
 				p.expression(f, n.Expression2, n.Expression2.Operand.Type(), exprVoid, fNoCondAssignment)
 			}
 			p.w("{")
 			p.statement(f, n.Statement, false, true, false, 0)
 			p.w("}};")
 			break
 		}
 
 		var ids []*cc.InitDeclarator
 		for list := n.Declaration.InitDeclaratorList; list != nil; list = list.InitDeclaratorList {
 			ids = append(ids, list.InitDeclarator)
 		}
 
 		//	declaration
 		// a:	if !expr goto c
 		//	stmt
 		// b: 	expr2 // label for continue
 		//	goto a
 		// c:
 		a := f.flatLabel()
 		b := f.flatLabel()
 		f.continueCtx = b
 		c := f.flatLabel()
 		f.breakCtx = c
 		p.w("{")
 		p.declaration(f, n.Declaration, false)
 		p.w(";")
 		p.w("__%d:", a)
 		if n.Expression != nil {
 			p.w("if !(")
 			p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0)
 			p.w(") { goto __%d }", c)
 		}
 		p.w(";")
 		p.statement(f, n.Statement, false, false, false, 0)
 		p.w(";goto __%d; __%[1]d:", b)
 		if n.Expression2 != nil {
 			p.expression(f, n.Expression2, n.Expression2.Operand.Type(), exprVoid, fNoCondAssignment)
 		}
 		p.w("; goto __%d; goto __%d;__%[2]d:\n}", a, c)
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) selectionStatement(f *function, n *cc.SelectionStatement) {
 	p.w("%s", tidyComment("\n", n))
 	switch n.Case {
 	case cc.SelectionStatementIf: // "if" '(' Expression ')' Statement
 		sv := f.ifCtx
 		f.ifCtx = n
 		defer func() { f.ifCtx = sv }()
 		if f.hasJumps {
 			// if !expr goto a
 			// stmt
 			// a:
 			f.ifCtx = n
 			a := f.flatLabel()
 			p.w("if !(")
 			p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0)
 			p.w(") { goto __%d };", a)
 			p.statement(f, n.Statement, false, false, false, 0)
 			p.w(";__%d: ", a)
 			break
 		}
 
 		p.w("if ")
 		p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0)
 		p.statement(f, n.Statement, true, false, false, 0)
 	case cc.SelectionStatementIfElse: // "if" '(' Expression ')' Statement "else" Statement
 		sv := f.ifCtx
 		f.ifCtx = n
 		defer func() { f.ifCtx = sv }()
 		if f.hasJumps {
 			// if !expr goto a
 			// stmt
 			// goto b
 			// a:
 			// stmt2
 			// b:
 			a := f.flatLabel()
 			b := f.flatLabel()
 			p.w("if !(")
 			p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0)
 			p.w(") { goto __%d };", a)
 			p.statement(f, n.Statement, false, false, false, 0)
 			p.w(";goto __%d; __%d:", b, a)
 			p.statement(f, n.Statement2, false, false, false, 0)
 			p.w(";__%d:", b)
 			break
 		}
 
 		p.w("if ")
 		p.expression(f, n.Expression, n.Expression.Operand.Type(), exprBool, 0)
 		p.statement(f, n.Statement, true, false, false, 0)
 		p.w(" else ")
 		switch {
 		case p.isIfStmt(n.Statement2):
 			p.statement(f, n.Statement2, false, true, false, 0)
 		default:
 			p.statement(f, n.Statement2, true, false, false, 0)
 		}
 	case cc.SelectionStatementSwitch: // "switch" '(' Expression ')' Statement
 		// just dont generate in this case
 		if f.switchCtx == inSwitchFirst {
 			break
 		}
 		sv := f.switchCtx
 		sb := f.block
 		sc := p.pauseCodegen
 		svBreakCtx := f.breakCtx
 		f.breakCtx = 0
 		f.block = f.blocks[n.Statement.CompoundStatement]
 
 		defer func() {
 			f.block = sb
 			f.switchCtx = sv
 			f.breakCtx = svBreakCtx
 			p.pauseCodegen = sc
 		}()
 		if f.hasJumps {
 			f.switchCtx = inSwitchFlat
 			p.flatSwitch(f, n)
 			break
 		}
 
 		f.switchCtx = inSwitchFirst
 		// fmt.Println(f.block.decls)
 		if len(f.block.decls) != 0 {
 			f.block.topDecl = true
 			// fmt.Printf("%p:%tf\n", f.block, f.block.topDecl)
 			p.w("{")
 			for _, v := range f.block.decls {
 				// fmt.Printf("%p:%tf\n", f.block, f.block.topDecl)
 				p.declaration(f, v, true)
 				// fmt.Println("done!")
 			}
 		}
 
 		p.w("switch ")
 		p.expression(f, n.Expression, n.Promote(), exprValue, 0)
 		p.pauseCodegen = true
 		p.statement(f, n.Statement, true, false, true, 0)
 		p.pauseCodegen = false
 		if len(f.block.decls) != 0 {
 			p.w("}")
 		}
 
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 }
 
 func (p *project) isIfStmt(n *cc.Statement) bool {
 	if n.Case != cc.StatementSelection {
 		return false
 	}
 
 	switch n.SelectionStatement.Case {
 	case cc.SelectionStatementIf, cc.SelectionStatementIfElse:
 		return true
 	}
 
 	return false
 }
 
 func (p *project) flatSwitch(f *function, n *cc.SelectionStatement) {
 	if n.Statement.Case != cc.StatementCompound {
 		panic(todo("", p.pos(n)))
 	}
 
 	sv := f.block
 	f.block = f.blocks[n.Statement.CompoundStatement]
 	defer func() { f.block = sv }()
 	// "switch" '(' Expression ')' Statement
 	cases := n.Cases()
 	labels := map[*cc.LabeledStatement]int{}
 	svBreakCtx := f.breakCtx
 	f.breakCtx = f.flatLabel()
 	p.w("switch ")
 	p.expression(f, n.Expression, n.Promote(), exprValue, 0)
 	p.w("{")
 	for _, ls := range cases {
 		switch ls.Case {
 		case cc.LabeledStatementLabel: // IDENTIFIER ':' AttributeSpecifierList Statement
 			continue
 		case cc.LabeledStatementCaseLabel: // "case" ConstantExpression ':' Statement
 			p.w("%scase ", tidyComment("\n", ls))
 			p.constantExpression(f, ls.ConstantExpression, ls.ConstantExpression.Operand.Type(), exprValue, 0)
 			p.w(":")
 		case cc.LabeledStatementDefault: // "default" ':' Statement
 			p.w("%sdefault:", tidyComment("\n", ls))
 		case cc.LabeledStatementRange: // "case" ConstantExpression "..." ConstantExpression ':' Statement
 			panic(todo("", p.pos(n)))
 		default:
 			panic(todo("%v: internal error: %v", n.Position(), n.Case))
 		}
 		label := f.flatLabel()
 		labels[ls] = label
 		p.w("goto __%d;", label)
 	}
 	p.w("}; goto __%d;", f.breakCtx)
 	svLabels := f.flatSwitchLabels
 	f.flatSwitchLabels = labels
 	p.statement(f, n.Statement, false, true, false, 0)
 	f.flatSwitchLabels = svLabels
 	p.w("__%d:", f.breakCtx)
 	f.breakCtx = svBreakCtx
 }
 
 func (p *project) expressionStatement(f *function, n *cc.ExpressionStatement) {
 	p.w("%s", tidyComment("\n", n))
 	// Expression AttributeSpecifierList ';'
 	if n.Expression == nil {
 		return
 	}
 
 	p.expression(f, n.Expression, n.Expression.Operand.Type(), exprVoid, 0)
 }
 
 func (p *project) labeledStatement(f *function, n *cc.LabeledStatement) (r *cc.JumpStatement) {
 	if f.hasJumps { //TODO merge with ...Flat below
 		return p.labeledStatementFlat(f, n)
 	}
 
 	switch n.Case {
 	case cc.LabeledStatementLabel: // IDENTIFIER ':' AttributeSpecifierList Statement
 		if _, ok := f.unusedLabels[n.Token.Value]; ok {
 			p.w("goto %s;", f.labelNames[n.Token.Value])
 		}
 		p.w("%s%s:", comment("\n", n), f.labelNames[n.Token.Value])
 		r = p.statement(f, n.Statement, false, false, false, 0)
 	case
 		cc.LabeledStatementCaseLabel, // "case" ConstantExpression ':' Statement
 		cc.LabeledStatementDefault:   // "default" ':' Statement
 
 		p.labeledStatementCase(f, n)
 	case cc.LabeledStatementRange: // "case" ConstantExpression "..." ConstantExpression ':' Statement
 		panic(todo("", n.Position(), n.Case))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 	return r
 }
 
 func (p *project) labeledStatementFlat(f *function, n *cc.LabeledStatement) (r *cc.JumpStatement) {
 	switch n.Case {
 	case cc.LabeledStatementLabel: // IDENTIFIER ':' AttributeSpecifierList Statement
 		if _, ok := f.unusedLabels[n.Token.Value]; ok {
 			p.w("goto %s;", f.labelNames[n.Token.Value])
 		}
 		p.w("%s%s:", tidyComment("\n", n), f.labelNames[n.Token.Value])
 		r = p.statement(f, n.Statement, false, false, false, 0)
 	case
 		cc.LabeledStatementCaseLabel, // "case" ConstantExpression ':' Statement
 		cc.LabeledStatementDefault:   // "default" ':' Statement
 
 		p.labeledStatementCase(f, n)
 	case cc.LabeledStatementRange: // "case" ConstantExpression "..." ConstantExpression ':' Statement
 		panic(todo("", n.Position(), n.Case))
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 	return r
 }
 
 func (p *project) labeledStatementCase(f *function, n *cc.LabeledStatement) {
 	switch f.switchCtx {
 	case inSwitchFirst:
 		f.switchCtx = inSwitchCase
 		p.pauseCodegen = false
 	case inSwitchCase:
 		p.w("\nfallthrough;")
 	case inSwitchSeenBreak:
 		f.switchCtx = inSwitchCase
 	case inSwitchFlat:
 		// ok
 	default:
 		panic(todo("", n.Position(), f.switchCtx))
 	}
 	switch n.Case {
 	case cc.LabeledStatementCaseLabel: // "case" ConstantExpression ':' Statement
 		switch {
 		case f.switchCtx == inSwitchFlat:
 			p.w("%s__%d:", tidyComment("\n", n), f.flatSwitchLabels[n])
 		default:
 			p.w("%scase ", tidyComment("\n", n))
 			p.constantExpression(f, n.ConstantExpression, n.ConstantExpression.Operand.Type(), exprValue, 0)
 			p.w(":")
 		}
 	case cc.LabeledStatementDefault: // "default" ':' Statement
 		switch {
 		case f.switchCtx == inSwitchFlat:
 			p.w("%s__%d:", tidyComment("\n", n), f.flatSwitchLabels[n])
 		default:
 			p.w("%sdefault:", tidyComment("\n", n))
 		}
 	default:
 		panic(todo("%v: internal error: %v", n.Position(), n.Case))
 	}
 	p.statement(f, n.Statement, false, false, false, 0)
 }
 
 func (p *project) constantExpression(f *function, n *cc.ConstantExpression, t cc.Type, mode exprMode, flags flags) {
 	// ConditionalExpression
 	p.conditionalExpression(f, n.ConditionalExpression, t, mode, flags)
 }
 
 func (p *project) functionDefinitionSignature(n cc.Node, f *function, tld *tld) {
 	switch {
 	case f.mainSignatureForced:
 		p.w("%sfunc %s(%s *%sTLS, _ int32, _ uintptr) int32", tidyComment("\n", f.fndef), tld.name, f.tlsName, p.task.crt)
 	default:
 		p.w("%s", tidyComment("\n", f.fndef))
 		p.functionSignature(n, f, f.fndef.Declarator.Type(), tld.name)
 	}
 }
 
 func (p *project) functionSignature2(n cc.Node, f *function, t cc.Type, nm string) {
 	p.w("func %s", nm)
 	p.w("(_ *%sTLS", p.task.crt)
 	suffix := 1
 	for _, v := range t.Parameters() {
 		if v.Type().Kind() == cc.Void {
 			break
 		}
 
 		pn := "_"
 		if d := v.Declarator(); d != nil {
 			pn = d.Name().String()
 			if _, ok := reservedNames[pn]; ok {
 				pn += strconv.Itoa(suffix)
 				suffix++
 			}
 		}
 		p.w(", %s %s", pn, p.paramTyp(v.Declarator(), v.Type()))
 	}
 	if t.IsVariadic() {
 		p.w(", _ /* va_list */ uintptr")
 	}
 	p.w(")")
 	if rt := t.Result(); rt != nil && rt.Kind() != cc.Void {
 		p.w(" %s", p.typ(n, rt))
 	}
 }
 
 func (p *project) functionSignature(n cc.Node, f *function, t cc.Type, nm string) {
 	p.w("func")
 	if nm != "" {
 		p.w(" %s", nm)
 	}
 	switch {
 	case f == nil || nm == "":
 		p.w("(*%sTLS", p.task.crt)
 	default:
 		p.w("(%s *%sTLS", f.tlsName, p.task.crt)
 	}
 	for _, v := range t.Parameters() {
 		if v.Type().Kind() == cc.Void {
 			break
 		}
 
 		var pn string
 		if f != nil && nm != "" {
 			pn = "_"
 			if d := v.Declarator(); d != nil {
 				if local := f.locals[d]; local != nil {
 					pn = local.name
 				}
 			}
 		}
 		p.w(", %s %s", pn, p.paramTyp(v.Declarator(), v.Type()))
 	}
 	if t.IsVariadic() {
 		switch {
 		case f == nil || nm == "":
 			p.w(", uintptr")
 		default:
 			p.w(", %s uintptr", f.vaName)
 		}
 	}
 	p.w(")")
 	if rt := t.Result(); rt != nil && rt.Kind() != cc.Void {
 		p.w(" %s", p.typ(n, rt))
 	}
 }
 
 func (p *project) paramTyp(n cc.Node, t cc.Type) string {
 	if t.Kind() == cc.Array {
 		return "uintptr"
 	}
 
 	if isTransparentUnion(t) {
 		switch k := t.UnionCommon(); k {
 		case cc.Ptr:
 			return "uintptr"
 		default:
 			panic(todo("%v: %v %k", n, t, k))
 		}
 	}
 
 	return p.typ(n, t)
 }
 
 func (p *project) dbg(a ...interface{}) {
 	p.w("/*DBG.%v %v */", a, origin(2))
 }
 
 func (p *project) fnVal(n cc.Node, f *function, expr func(), exprDecl *cc.Declarator, exprType cc.Type, deref int, mode exprMode, flags flags) {
 	//  C type		Go type
 	//  fn			N/A: produce name from exprDecl
 	//  (*)()		func()
 	//  (**)()		*func()
 
 	if deref < 0 || deref > 1 {
 		panic(todo(""))
 	}
 
 	switch exprType.Kind() {
 	case cc.Function:
 		// C: fn
 		switch deref {
 		case 0:
 			p.declarator(n, f, exprDecl, exprType, mode, flags)
 		default:
 			panic(todo("", n.Position()))
 		}
 	case cc.Ptr:
 		switch et := exprType.Elem(); et.Kind() {
 		case cc.Function:
 			// C: (*)()
 			switch deref {
 			case 0:
 				// (*struct{ f func()})(unsafe.Pointer(&struct{uintptr}{fprintfptr})).f()
 				p.w("(*struct{ f ")
 				p.functionSignature(n, f, et, "")
 				p.w("})(unsafe.Pointer(&struct{uintptr}{")
 				expr()
 				p.w("})).f")
 			default:
 				p.declarator(n, f, exprDecl, et, mode, flags)
 			}
 		case cc.Ptr:
 			switch et2 := et.Elem(); et2.Kind() {
 			case cc.Function:
 				// C: (**)()
 				switch deref {
 				case 0:
 					panic(todo("", n.Position()))
 				default:
 					// (*struct{ f func()})(unsafe.Pointer(&struct{uintptr}{fprintfptr})).f()
 					p.w("(*(**struct{ f ")
 					p.functionSignature(n, f, et2, "")
 					p.w("})(unsafe.Pointer(&struct{uintptr}{")
 					expr()
 					p.w("}))).f")
 				}
 			default:
 				panic(todo("", n.Position(), et2.Kind(), deref))
 			}
 		default:
 			panic(todo("", n.Position(), et.Kind(), deref))
 		}
 	default:
 		panic(todo("", n.Position(), exprType.Kind(), deref))
 	}
 }