Function1<?, ?> action,
        @KotlinDefaultMask int mask,
        @CallerClassName String consumer
    ) throws Throwable {
        Instrumented.fileOpened(self, consumer);
        if (mask == 0) {
            FilesKt.forEachLine(self, charset, Cast.uncheckedNonnullCast(action));
        } else {
            invokeKotlinStaticDefault(FOR_EACH_LINE_DEFAULT, mask, self, charset, action);
        }
    }

    @InterceptCalls

  static int getHashPrefix(int value, int mask) {
    return value & ~mask;
  }

  /** Returns the index, or 0 if the entry is "null". */
  static int getNext(int entry, int mask) {
    return entry & mask;
  }

  /** Returns a new value combining the prefix and suffix using the given mask. */
  static int maskCombine(int prefix, int suffix, int mask) {
    return (prefix & ~mask) | (suffix & mask);
  }

  static int remove(

// <endcallsites>
// <endfuncpreamble>
func T_feeds_if_via_call(x int) {
	feedsif(x)
}

// acrosscall.go T_feeds_if_via_call_conditional 69 0 1
// ParamFlags
//   0 ParamMayFeedIfOrSwitch
// <endpropsdump>
// {"Flags":0,"ParamFlags":[64],"ResultFlags":null}
// callsite: acrosscall.go:71:10|0 flagstr "" flagval 0 score 8 mask 0 maskstr ""
// <endcallsites>

		// may be larger than we expect.
		return
	}
	t.Errorf("bad GC program for %v:\nwant %+v\ngot  %+v", name, mask0, mask)
}

func trimDead(mask []byte) []byte {
	for len(mask) > 0 && mask[len(mask)-1] == typeScalar {
		mask = mask[:len(mask)-1]
	}
	return mask
}

var infoPtr = []byte{typePointer}

type Ptr struct {
	*byte
}

	}

	for i, v := range tests {
		result := encodePPC64RotateMask(v.rotate, int64(v.mask), v.nbits)
		if result != v.encoded {
			t.Errorf("encodePPC64RotateMask(%d,0x%x,%d) = 0x%x, expected 0x%x", v.rotate, v.mask, v.nbits, result, v.encoded)
		}
		rotate, mb, me, mask := DecodePPC64RotateMask(result)
		if rotate != v.rotate || mb != v.mb || me != v.me || mask != v.mask {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package ir

type bitset8 uint8

func (f *bitset8) set(mask uint8, b bool) {
	if b {
		*(*uint8)(f) |= mask
	} else {
		*(*uint8)(f) &^= mask
	}
}

func (f bitset8) get2(shift uint8) uint8 {
	return uint8(f>>shift) & 3
}

// set2 sets two bits in f using the bottom two bits of b.

//go:nosplit
//go:nowritebarrierrec
func sigaddset(mask *sigset, i int) {
	if i > 64 {
		throw("unexpected signal greater than 64")
	}
	*mask |= 1 << (uint(i) - 1)
}

func sigdelset(mask *sigset, i int) {
	if i > 64 {
		throw("unexpected signal greater than 64")
	}
	*mask &^= 1 << (uint(i) - 1)
}

//go:nosplit
func sigfillset(mask *uint64) {
	*mask = ^uint64(0)

// license that can be found in the LICENSE file.

package types

const BADWIDTH = -1000000000

type bitset8 uint8

func (f *bitset8) set(mask uint8, b bool) {
	if b {
		*(*uint8)(f) |= mask
	} else {
		*(*uint8)(f) &^= mask
	}

// Signal handler for SIGSEGV on a C thread.
static void segvHandler(int signo, siginfo_t* info, void* ctxt) {
	sigset_t mask;
	int i;

	if (sigemptyset(&mask) < 0) {
		die("sigemptyset");
	}
	if (sigaddset(&mask, SIGSEGV) < 0) {
		die("sigaddset");
	}
	i = sigprocmask(SIG_UNBLOCK, &mask, NULL);
	if (i != 0) {
		fprintf(stderr, "sigprocmask: %s\n", strerror(i));
		exit(EXIT_FAILURE);
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package s390x

import (
	"fmt"
)

// CCMask represents a 4-bit condition code mask. Bits that
// are not part of the mask should be 0.
//
// Condition code masks represent the 4 possible values of
// the 2-bit condition code as individual bits. Since IBM Z
// is a big-endian platform bits are numbered from left to