func (c *sigctxt) sigaddr() uint64 { return c.info.si_addr }

func (c *sigctxt) set_pc(x uint64)  { c.regs().pc = x }
func (c *sigctxt) set_sp(x uint64)  { c.regs().sp = x }
func (c *sigctxt) set_lr(x uint64)  { c.regs().regs[30] = x }
func (c *sigctxt) set_r28(x uint64) { c.regs().regs[28] = x }

func (c *sigctxt) set_sigaddr(x uint64) {
	*(*uintptr)(add(unsafe.Pointer(c.info), 2*goarch.PtrSize)) = uintptr(x)

		})
	}
}

func verifyExecTestOutput(t *testing.T, cmd *cobra.Command, c execTestCase) {
	t.Helper()

	var out bytes.Buffer
	cmd.SetArgs(c.args)
	cmd.SilenceUsage = true
	cmd.SetOut(&out)
	cmd.SetErr(&out)

	fErr := cmd.Execute()
	output := out.String()

	if c.expectedOutput != "" && c.expectedOutput != output {

	return nil
}

func (f *FakeCmd) CombinedOutput() ([]byte, error) {
	return f.out, f.err
}

func (f *FakeCmd) Output() ([]byte, error) {
	return f.stdout, f.err
}

func (f *FakeCmd) SetDir(dir string) {}

func (f *FakeCmd) SetStdin(in io.Reader) {}

func (f *FakeCmd) SetStdout(out io.Writer) {
	f.writer = out
}

func (f *FakeCmd) SetStderr(out io.Writer) {
	f.writer = out
}

        analyseForTest(context) { declaration ->
            val propertySymbol = (declaration as KtProperty).getVariableSymbol() as KaPropertySymbol
            val setterSymbol = propertySymbol.setter!!
            val setterParameterSymbol = setterSymbol.valueParameters.single()
            testServices.assertions.assertEquals(propertySymbol, setterSymbol.getContainingSymbol())

func (c *context) lr() uintptr { return uintptr(c.x[30]) }

func (c *context) set_ip(x uintptr) { c.pc = uint64(x) }
func (c *context) set_sp(x uintptr) { c.xsp = uint64(x) }
func (c *context) set_lr(x uintptr) { c.x[30] = uint64(x) }
func (c *context) set_fp(x uintptr) { c.x[29] = uint64(x) }

func prepareContextForSigResume(c *context) {
	c.x[0] = c.xsp
	c.x[1] = c.pc
}

func dumpregs(r *context) {

func (c *sigctxt) sigaddr() uint64 { return c.info.si_addr }

func (c *sigctxt) set_pc(x uint64)  { c.regs().mc_gpregs.gp_elr = x }
func (c *sigctxt) set_sp(x uint64)  { c.regs().mc_gpregs.gp_sp = x }
func (c *sigctxt) set_lr(x uint64)  { c.regs().mc_gpregs.gp_lr = x }
func (c *sigctxt) set_r28(x uint64) { c.regs().mc_gpregs.gp_x[28] = x }

func (c *sigctxt) set_sigcode(x uint64) { c.info.si_code = int32(x) }

func (c *sigctxt) pc() uint64 { return uint64(c.regs().sc_elr) }

func (c *sigctxt) set_pc(x uint64)  { c.regs().sc_elr = uintptr(x) }
func (c *sigctxt) set_sp(x uint64)  { c.regs().sc_sp = uintptr(x) }
func (c *sigctxt) set_lr(x uint64)  { c.regs().sc_lr = uintptr(x) }
func (c *sigctxt) set_r28(x uint64) { c.regs().sc_x[28] = uintptr(x) }

func (c *sigctxt) set_sigcode(x uint64) { c.info.si_code = int32(x) }
func (c *sigctxt) set_sigaddr(x uint64) {

func (c *sigctxt) sigaddr() uint64 { return uint64(c.info._reason) }

func (c *sigctxt) set_pc(x uint64)  { c.regs().__gregs[_REG_ELR] = x }
func (c *sigctxt) set_sp(x uint64)  { c.regs().__gregs[_REG_X31] = x }
func (c *sigctxt) set_lr(x uint64)  { c.regs().__gregs[_REG_X30] = x }
func (c *sigctxt) set_r28(x uint64) { c.regs().__gregs[_REG_X28] = x }

func (c *sigctxt) set_sigcode(x uint64) { c.info._code = int32(x) }
func (c *sigctxt) set_sigaddr(x uint64) {

                // See https://stackoverflow.com/q/1206970.
                entry.setSize(contents.length);
                entry.setCompressedSize(contents.length);
                entry.setCrc(computeCrc32Of(contents));
            }
        }

        private static boolean shouldCompress(CompressionMethod compressionMethod) {

    }

    override suspend fun ReadContext.decode(): ConfigurableFileTree {
        val dir = readFile()
        val patterns = read() as PatternSet
        val tree = fileCollectionFactory.fileTree()
        tree.setDir(dir)
        // TODO - read patterns directly into tree
        tree.patterns.copyFrom(patterns)
        return tree
    }