                     case .Rejected:
                         bind(nil, self_.errorInfo!)
                     default:
-                        self_.machine.addEventHandler(.Progress) { context in
-                            if let (_, progressValue) = context.userInfo as? Task<Progress2, Value2, Error>.ProgressTuple {
-                                progress(progressValue)
-                            }
-                        }
+                        // comment-out: only innerTask's progress should be sent to newTask
+//                        self_.machine.addEventHandler(.Progress) { context in
+//                            if let (_, progressValue) = context.userInfo as? Task<Progress2, Value2, Error>.ProgressTuple {
+//                                progress(progressValue)
+//                            }
+//                        }
                         self_.machine.addEventHandler(.Fulfill) { context in
                             if let value = context.userInfo as? Value {
                                 bind(value, nil)

                        let errorInfo = self_.errorInfo!
                        bind(errorInfo)
                    default:
                        self_.machine.addEventHandler(.Progress) { context in
                            if let (_, progressValue) = context.userInfo as? Task.ProgressTuple {
                                progress(progressValue)
                            }
                        }
                        self_.machine.addEventHandler(.Fulfill) { context in
                            if let value = context.userInfo as? Value {
                                fulfill(value)

        
        if initClosure == nil { return self }
        
        let newTask = Task { [weak self] machine, progress, fulfill, _reject, configure in
        
            var nextTask: Task = self!
        
            for i in 1...maxTryCount-1 {
                nextTask = nextTask.progress { _, progressValue in
                    progress(progressValue)
                }.failure { _ -> Task in
                    return Task(weakified: weakified, _initClosure: initClosure!)   // create a clone-task when rejected
                }
            }
            
            nextTask.progress { _, progressValue in
                progress(progressValue)
            }.success { value -> Void in
                fulfill(value)
            }.failure { errorInfo -> Void in
                _reject(errorInfo)
            }
            
            configure.pause = { nextTask.pause(); return }
            configure.resume = { nextTask.resume(); return }
            configure.cancel = { nextTask.cancel(); return }
            
        }
        
        return newTask
    }
    
    ///
