You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: bench_literals.go
    path of file: ./repos/garble/scripts
    
    the code of the file until where you have to start completion: // This script generate benchmarks for performance analysis of individual obfuscator literals.
// Note that only the speed of obfuscated methods is measured, initialization cost or build speed are not measured.

//go:build ignore

package main

import (
	_ "embed"
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"reflect"
	"runtime"
	"strconv"
	"strings"

	"mvdan.cc/garble/internal/literals"
)

const (
	minDataLen      = 8
	maxDataLen      = 64
	stepDataLen     = 4
	dataCountPerLen = 10
	moduleName      = "test/literals"
	garbleSeed      = "o9WDTZ4CN4w"

	// For benchmarking individual obfuscators, we use package=obfuscator mapping
	// and add a prefix to package name to make sure there are no collisions with system packages.
	packagePrefix = "literals_bench_"
)

func generateRunSrc() string {
	var sb strings.Builder

	sb.WriteString(`
var alwaysFalseFlag = false

func noop(i interface{}) {
	if alwaysFalseFlag {
		println(i)
	}	
}

func Run() {
`)

	dataStr := strings.Repeat("X", maxDataLen)
	dataBytes := make([]string, maxDataLen)
	for i := 0; i < len(dataBytes); i++ {
		dataBytes[i] = strconv.Itoa(i)
	}

	for dataLen := minDa
    
func main() {
	tdir, err := os.MkdirTemp("", "literals-bench*")
	if err != nil {
		log.Fatalf("create temp directory failed: %v", err)
	}
	defer os.RemoveAll(tdir)

	if err := os.WriteFile(filepath.Join(tdir, "go.mod"), []byte("module "+moduleName), 0o777); err != nil {
		log.Fatalf("write go.mod failed: %v", err)
	}

	runSrc := generateRunSrc()
	writeTest := func(name string) {
		writeDateFile(tdir, name, runSrc)
		writeTestFile(tdir, name)
	}

	var packageToObfuscatorIndex []string
	for i, obf := range literals.Obfuscators {
		obfName := reflect.TypeOf(obf).Name()
		writeTest(obfName)
		packageToObfuscatorIndex = append(packageToObfuscatorIndex, fmt.Sprintf(packagePrefix+"%s=%d", obfName, i))
	}
	writeTest("all")

	garbleBin := buildTestGarble(tdir)
	args := append([]string{"-seed", garbleSeed, "-literals", "test", "-bench"}, os.Args[1:]...)
	cmd := exec.Command(garbleBin, args...)
	cmd.Env = append(cmd.Environ(),
		// Explicitly specify package for obfuscation to avoid affecting testing package.
		"GOGARBLE="+moduleName,
		"GARBLE_TEST_LITERALS_OBFUSCATOR_MAP="+strings.Join(packageToObfuscatorIndex, ","),
	)
	cmd.Dir = tdir
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	if err := cmd.Run(); err != nil {
		if exitErr, ok := err.(*exec.ExitError); ok {
			os.Exit(exitErr.ExitCode())
		}
		log.Fatalf("run garble test failed: %v", err)
	}
}