var bs []byte = []byte{104, 97, 108, 108, 111}

func main() {
    x := string(bs) == "hello"
    println(x)
}

func slicebytetostringtmp(b []byte) string {
    // Return a "string" referring to the actual []byte bytes.
    // This is only for use by internal compiler optimizations
    // that know that the string form will be discarded before
    // the calling goroutine could possibly modify the original
    // slice or synchronize with another goroutine.
    // First such case is a m[string(k)] lookup where
    // m is a string-keyed map and k is a []byte.
    // Second such case is "<"+string(b)+">" concatenation where b is []byte.
    // Third such case is string(b)=="foo" comparison where b is []byte.

    if raceenabled && len(b) > 0 {
        racereadrangepc(unsafe.Pointer(&b[0]),
            uintptr(len(b)),
            getcallerpc(unsafe.Pointer(&b)),
            funcPC(slicebytetostringtmp))
    }
    if msanenabled && len(b) > 0 {
        msanread(unsafe.Pointer(&b[0]), uintptr(len(b)))
    }
    return *(*string)(unsafe.Pointer(&b))
}

var res bool

func BenchmarkStrCast(b *testing.B) {
    s1 := strings.Repeat("a", 1000)
    b2 := []byte(strings.Repeat("a", 999) + "b")
    for n := 0; n < b.N; n++ {
        res = string(b2) == s1
    }
}

func BenchmarkBytesCmp(b *testing.B) {
    b1 := []byte(strings.Repeat("a", 1000))
    b2 := []byte(strings.Repeat("a", 999) + "b")
    for n := 0; n < b.N; n++ {
        res = bytes.Equal(b1, b2)
    }
}

BenchmarkStrCast-4  50000000            28.5 ns/op         0 B/op          0 allocs/op
BenchmarkBytesCmp-4 50000000            27.1 ns/op         0 B/op          0 allocs/op