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

protocol b {
enum A : CollectionType where h)
a()
}
}
protocol a {
func ^()
println("
protocol b where T> String {
return "a: c(true {
}
func g<T where A() -> T where Optional<S {
return nil
}
struct c in 0.R
S()))?
public var b(.E
let h = A() {
}
return "cd"""ab""))
self.d == b
}
get {
}
var d {
func a: k) {
}
func compose<B {
protocol c : b {
var e([Int
func e!.b {
func g<T, e, T : d
func b
typealias h
return {
}
return [(object1: Array) {
return true
case b {
}
func c<T, y)
typealias d<Y> {
class func a: start: b[1])
}
}
public subscript (a<T : b(T) {
}
}
typealias d = c) {
}
}
f, end: Array<T>(self)
for (s: U : c<T>Bool) + seq
enum S() { x }
enum A : B
}
}
class b() in return NSData()
}
protocol A {
func f()"foo""a<T> T> == T> T -> A : Array<T>() -> : l) -> {
self.C(()
}
}() {
println(x(Any) {
protocol c where g(2, B, (() {
var f.advance(T>()
println() {
}
typealias C {
let f = ")
self.advance(T, e() -> Int = e> {
}
}
class A {
typealias e = 1)) {
}
class d(self, "))
return z: C {
func f.advance() -> == F>? = c))
struct Q<Int
typealias B(f("
class C(B>(h.A> {
func g<T -> {
}
func ^(Any) -> : (x) -> ([1)
}
return z: 1)
class A {
func a: String) in 0] {
})
let v: b(B(self[0) -> {
}
}
typealias f = g<T, i: b = A, range.a
enum A {
let d
return [unowned self.Type
}
func f)"a()
class A : a {
}
func a: A? {
println(t: A, e = a: Int
A.d.substringWithRange(1)
let h = b: a {
}
}
var d>(2, U, e {
}
return "
typealias R
}
}
func e(b: Int = 
