// RUN: not %target-swift-frontend %s -parse

// Distributed under the terms of the MIT license
// Test case submitted to project by https://github.com/practicalswift (practicalswift)
// Test case found by fuzzing

] == 1)
func a<A? {
func a(object1, V, (T] {
init(() -> Any] == 1]()
assert(T> Any, U>(.<c<f = compose<T.c where Optional<D>Bool)] as String):
A"
func a)
let n1: CollectionType where f: b: l.endIndex - range..b(b(i> {
protocol a {
}
}
struct c, U, let start = {
let foo as a: T: [0
func b> String
func compose<T>(self, x in a {
}
})?
()
extension String = Swift.B
}
}
(c
}
var b> T : (b: T) {
func f)
enum B == Int>: () -> e() -> T : A<T where H.startIndex)
return p: String)!.startIndex)
}
}
class a: Int {
class A) -> String {
print()
}
f: a {
d
}
}
func c(c: ())
init()()
import Foundation
typealias F>](.c : b(b[c
return p
return [Any) {
i()
protocol a {
typealias e {
class d() -> {
var b: A, A : d : d = {
typealias f = { self.h : T, () { c
struct A.dynamicType)
import Foundation
class func i(T>(a)
let end = B
}
private class A, B
protocol b {
func e: (""")) -> String = b<T
class b: d = [Int>? = T>] {
}
struct A {
protocol b {
f)
}
print(T>
func f.h : d = true {
}
}
}
}
func a: String
func f<c]
struct c, i : b() -> Any) -> {
map("foo"foobar"
self[1)
}
typealias f == g<U) {
struct B, d>()
convenience init() -> U, k : a {
typealias C {
}
protocol A {
var a""
return { _, g = Int
}(c) -> : T>(f() -> (z: BooleanType>(m(v: Int>()] = { c
}
typealias e : NSObject {
let n1: 1], let g == Swift.join(h, Bool) -> (g.endIndex - range.startIndex))
func f())
class A? {
}
typealias F>(g..substringWithRange(")
}
func i<Q<T, e: S() -> String {
}
var f = b.init(t: H
