* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.data;

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.PomReader.PomDependencyData;

import java.util.List;
import java.util.Map;

public interface PomProfile {
    String getId();
    Map<String, String> getProperties();

TensorFlow and LLVM:
  * Flags before the first '--' are parsed by tensorflow::InitMain while those
    post are parsed by LLVM's command line parser.
  * If there is no separator, then no flags are parsed by InitMain and only
    LLVM command line parser used.e
The above help options reported are for LLVM's parser, run with `--help --` for
TensorFlow's help.
)");

namespace tensorflow {

InitMlir::InitMlir(int *argc, char ***argv) {

func main() {
	fmt.Println(hello) // line comment 3
}
`

	// Create the AST by parsing src.
	fset := token.NewFileSet() // positions are relative to fset
	f, err := parser.ParseFile(fset, "src.go", src, parser.ParseComments)
	if err != nil {
		panic(err)
	}

	// Create an ast.CommentMap from the ast.File's comments.
	// This helps keeping the association between comments
	// and AST nodes.

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.data.MavenDependencyKey
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.data.PomDependencyMgt
import org.gradle.api.internal.file.TestFiles
import org.gradle.internal.resource.local.LocalFileStandInExternalResource

		// If k-1 is L-type, queue k for processing later in this loop.
		// If k-1 is S-type (text[k-1] < text[k]), queue -k to save for the caller.
		// If k is zero, k-1 doesn't exist, so we only need to leave it
		// for the caller. The caller can't tell the difference between
		// an empty slot and a non-empty zero, but there's no need
		// to distinguish them anyway: the final suffix array will end up

	
	for _, i := range *x {  // THIS IS LINE 17
		println(i)
	}
}

func g() {
}

func main() {
	defer func() {
		for i := 0;; i++ {
			pc, file, line, ok := runtime.Caller(i)
			if !ok {
				print("BUG: bug348: cannot find caller\n")
				return
			}
			if !strings.Contains(file, "bug348.go") || runtime.FuncForPC(pc).Name() != "main.f" {
				// walk past runtime frames
				continue
			}
			if line != 17 {

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

// To avoid a cyclic dependency with go/parser, this file is in a separate package.

package ast_test

import (
	"go/ast"
	"go/format"
	"go/parser"
	"go/token"
	"strings"
	"testing"
)

const input = `package p

type t1 struct{}
type t2 struct{}

func f1() {}
func f1() {}

 */

package org.gradle.api.internal.artifacts.ivyservice;

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.DescriptorParseContext;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.MetaDataParseException;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.MetaDataParser;
import org.gradle.internal.component.external.model.MutableModuleComponentResolveMetadata;

            }
            return [(treeDef.name): result]
        }
        packer.pack(entity(treeDefs), snapshots, output, writeOrigin)
    }

    def unpack(InputStream input, OriginReader readOrigin = this.readOrigin, TreeDefinition... treeDefs) {
        packer.unpack(entity(treeDefs), input, readOrigin)
    }

    def entity(TreeDefinition... treeDefs) {
        Stub(CacheableEntity) {

	case <-t.c:  // THIS IS LINE 22
		break
	case <-c:
		break
	}
}

func main() {
	defer func() {
		recover()
		for i := 0;; i++ {
			pc, file, line, ok := runtime.Caller(i)
			if !ok {
				print("BUG: bug347: cannot find caller\n")
				return
			}
			if !strings.Contains(file, "bug347.go") || runtime.FuncForPC(pc).Name() != "main.f" {
				// walk past runtime frames
				continue
			}
			if line != 22 {