})
	if err == syscall.ENOENT || (err == nil && !found) {
		return nil, UnknownUserIdError(uid)
	}
	if err != nil {
		return nil, fmt.Errorf("user: lookup userid %d: %v", uid, err)
	}
	return buildUser(&pwd), nil
}

func buildUser(pwd *_C_struct_passwd) *User {
	u := &User{
		Uid:      strconv.FormatUint(uint64(_C_pw_uid(pwd)), 10),
		Gid:      strconv.FormatUint(uint64(_C_pw_gid(pwd)), 10),
		Username: _C_GoString(_C_pw_name(pwd)),

type Builder interface {
	// With adds a new Echo configuration to the Builder. Once built, the instance
	// pointer will be updated to point at the new Instance.
	With(i *echo.Instance, cfg echo.Config) Builder

	// WithConfig mimics the behavior of With, but does not allow passing a reference
	// and returns an echoboot builder rather than a generic echo builder.

John Howard <******@****.***> 1717711954 -0700

                }
        }
    }

    return annotationContainer.resolvedAnnotationsWithClassIds(firSymbol)
        .mapIndexedToAnnotationApplication(builder.rootSession, classId) { index, annotation ->
            annotation.toKaAnnotation(builder, index) {
                computeAnnotationArguments(firSymbol, annotationContainer, classId, index, builder)
            }
        }
}

 * this util collects all `.kt` and `.java` files under source roots.
 */
internal fun getSourceFilePaths(
    compilerConfig: CompilerConfiguration,
    includeDirectoryRoot: Boolean = false,
): Set<Path> {
    return buildSet {
        compilerConfig.javaSourceRoots.forEach { srcRoot ->
            val path = Paths.get(srcRoot)
            if (Files.isDirectory(path)) {
                // E.g., project/app/src

    }
}

internal fun FirElement.buildSymbol(builder: KaSymbolByFirBuilder) =
    (this as? FirDeclaration)?.symbol?.let(builder::buildSymbol)

internal fun FirDeclaration.buildSymbol(builder: KaSymbolByFirBuilder): KaSymbol =
    builder.buildSymbol(symbol)

internal fun FirBasedSymbol<*>.buildSymbol(builder: KaSymbolByFirBuilder): KaSymbol =
    builder.buildSymbol(this)

                                    mlir::Builder builder) {
  return builder.getStringAttr(str);
}

static mlir::Attribute BuildF32Attr(float value, mlir::Builder builder) {
  return builder.getF32FloatAttr(value);
}

static mlir::Attribute BuildI32Attr(int32_t value, mlir::Builder builder) {
  return builder.getI32IntegerAttr(value);
}

			func(builder *IptablesRuleBuilder) {
				builder.AppendRuleV6(iptableslog.UndefinedCommand, "chain", "table", "-f", "foo", "-b", "bar")
				builder.AppendRuleV6(iptableslog.UndefinedCommand, "chain", "table", "-f", "fu", "-b", "bar")
				builder.AppendRuleV6(iptableslog.UndefinedCommand, "chain", "table", "-f", "foo", "-b", "baz")
			},
			true,
		},
		{
			"insert-multi-v4",
			true,
			false,

      /*strides=*/Create1DConstValue<int32_t>(builder, loc, {1}),
      /*begin_mask=*/builder.getIntegerAttr(attribute_type, 0),
      /*end_mask=*/builder.getIntegerAttr(attribute_type, 0),
      /*ellipsis_mask=*/builder.getIntegerAttr(attribute_type, 0),
      /*new_axis_mask=*/builder.getIntegerAttr(attribute_type, 0),
      /*shrink_axis_mask=*/builder.getIntegerAttr(attribute_type, 1));
}

        spec.sourceCompatibility = "1.7"

        when:
        builder.includeMainOptions(true)

        then:
        builder.build() == ["-source", "1.7"] + defaultOptions

        when:
        builder.includeMainOptions(false)

        then:
        builder.build() == ["-classpath", ""]
    }

    def "includes main options by default"() {