Get the current first responder without using a private API

Question

I submitted my app a little over a week ago and got the dreaded rejection email today. It tells me that my app cannot be accepted because I'm using a non-public API; specifically, it says,

The non-public API that is included in your application is firstResponder.

Now, the offending API call is actually a solution I found here on SO:

UIWindow *keyWindow = [[UIApplication sharedApplication] keyWindow];
UIView   *firstResponder = [keyWindow performSelector:@selector(firstResponder)];

How do I get the current first responder on the screen? I'm looking for a way that won't get my app rejected.

Scop

Rather than iterating over views, you can use this truly brilliant bit of magic: https://mcmap.net/q/76927/-is-there-any-way-of-asking-an-ios-view-which-of-its-children-has-first-responder-status-duplicate – Rosenberg

Answer 1

In one of my applications I often want the first responder to resign if the user taps on the background. For this purpose I wrote a category on UIView, which I call on the UIWindow.

The following is based on that and should return the first responder.

@implementation UIView (FindFirstResponder)
- (id)findFirstResponder
{
    if (self.isFirstResponder) {
        return self;        
    }
    for (UIView *subView in self.subviews) {
        id responder = [subView findFirstResponder];
        if (responder) return responder;
    }
    return nil;
}
@end

iOS 7+

- (id)findFirstResponder
{
    if (self.isFirstResponder) {
        return self;
    }
    for (UIView *subView in self.view.subviews) {
        if ([subView isFirstResponder]) {
            return subView;
        }
    }
    return nil;
}

Swift:

extension UIView {
    var firstResponder: UIView? {
        guard !isFirstResponder else { return self }

        for subview in subviews {
            if let firstResponder = subview.firstResponder {
                return firstResponder
            }
        }

        return nil
    }
}

Usage example in Swift:

if let firstResponder = view.window?.firstResponder {
    // do something with `firstResponder`
}

Ctn

Why is this a better solution than simply calling [self.view endEditing:YES]? – Matronize

@Tim I didn't you could do that. It's obviously a much simpler way to resign the first responder. It doesn't help with the original questions, though, which was to identify the first responder. – Bollen

"if(firstResponder != nil)" is the same thing as writing "BOOL b = ...; if (b != NO)" instead of "BOOL b = ...; if (b)" – Torquemada

@TimSullivan for one thing, calling [self.view endEditing:YES] does not animate the keyboard. – Greeting

@Tim: Because question is not about dismissing - question is about finding the first responser in the first place. – Faxan

@Lukasz: My comment was a response to the original wording of the answer, in case people (like me, for example) saw this and thought it was the correct way to dismiss the keyboard. Thomas noted, 3 years ago, the point of the original question, and I responded to him then. – Matronize

Also, this is a better answer because you might want to do something else with the first responder than resigning it... – Stendhal

It should be noted that this only finds UIViews, not other UIResponders that could also be the first responder (e.g. UIViewController or UIApplication). – Anatolia

Why the difference for iOS 7? wouldn't you also want to recurse in that case? – Hebdomadary

I don't know why Cripto edited the answer for iOS7. Looks like he was trying to use this in a view controller ('self.view')? – Bollen

This code is technically correct but should not be used again and agan. Correct way to resign first responder is https://mcmap.net/q/76644/-get-the-current-first-responder-without-using-a-private-api – Defend

In iOS8 have some bugs where the selector of first responder calls parent view controller methods unexpectedly. This answer is "perfect" for this kind of issue. – Conlen

Just throwing my hat into the ring. Check out my answer below. It works with any UIResponder, not just views, and doesn't require any recursion, but like here, you still get back the actual first responder in case you wanted to do something with it. – Sukiyaki

This should be recursive. What if the subview has subviews of its own. – Ali

A more efficient way would be to just track the first responder in textFieldShouldBeginEditing and other relevant delegate calls, and then reference the stored variable as needed. – Plea

Answer 2

If your ultimate aim is just to resign the first responder, this should work: [self.view endEditing:YES]

Ulcerous

Wow, I've always done crazy hacks for this and it's been there since 2.0! (according to the docs). Vote this one up more! – Inefficiency

For all of you saying that this is the answer to the "question", can you take a look at the actual question? The question asks how to get the current first responder. Not how to resign the first responder. – Scop

and where should we call this self.view endEditing? – Deon

True enough that this is not exactly answering the question, but clearly it is a very useful answer. Thanks! – Spermatophore

+1 even if it's not an answer to the question. Why? Because many come here with a question in mind that this answer answers :) At least 267 (at the moment) of them... – Vostok

This is not answering the question. – Magistrate

If you try to resign a view outside of "view" (you cant see it), you will get an EXC_BAD_ACCESS Exception... – Broiler

Great. So, how do you use it and from where do you call it? – Declaratory

@AlexZavatone - If you don't know where to put it, search for questions related to your goal - under what circumstances are you wanting to resign first responder? If you can't find the correct situation, then ask a new question. – Thoth

Answer 3

A common way of manipulating the first responder is to use nil targeted actions. This is a way of sending an arbitrary message to the responder chain (starting with the first responder), and continuing down the chain until someone responds to the message (has implemented a method matching the selector).

For the case of dismissing the keyboard, this is the most effective way that will work no matter which window or view is first responder:

[[UIApplication sharedApplication] sendAction:@selector(resignFirstResponder) to:nil from:nil forEvent:nil];

This should be more effective than even [self.view.window endEditing:YES].

(Thanks to BigZaphod for reminding me of the concept)

Keelson

this is BY FAR the best solution, thanks a million ! this is way better than the solution above this one, because it works even of the active textfield is part of the accessory view of the keyboard (in that case it is not part of our view hierarchy) – Chiropractic

Awesome, this is exactly what I needed (I want to send custom actions through the responder chain). The above solutions fail when the first responder is a view, but this is perfect. – Anatolia

This solution is the best-practice solution. The system already knows who the first responder is, there's no need to find it. – Worl

This doesn't even answer the question asked. How can it be the best solution? See Jakob Egger's answer for the real solution. – Cambell

devios1: Jakob's answer is exactly what the question asks for, but it's a hack on top of the responder system, rather than using the responder system the way it was designed to. This is cleaner and accomplishes what most people come to this question for, and in a one-liner too. (You can of course send any target-action style message, and not just resignFirstResponder). – Keelson

Warning: This doesn't work if you start adding multiple windows. I unfortunately can't point to a cause beyond that yet. – Tanguay

Answer 4

Here's a category that allows you to quickly find the first responder by calling [UIResponder currentFirstResponder]. Just add the following two files to your project:

UIResponder+FirstResponder.h:

#import <Cocoa/Cocoa.h>
@interface UIResponder (FirstResponder)
    +(id)currentFirstResponder;
@end

UIResponder+FirstResponder.m:

#import "UIResponder+FirstResponder.h"
static __weak id currentFirstResponder;
@implementation UIResponder (FirstResponder)
    +(id)currentFirstResponder {
         currentFirstResponder = nil;
         [[UIApplication sharedApplication] sendAction:@selector(findFirstResponder:) to:nil from:nil forEvent:nil];
         return currentFirstResponder;
    }
    -(void)findFirstResponder:(id)sender {
        currentFirstResponder = self;
    }
@end

The trick here is that sending an action to nil sends it to the first responder.

(I originally published this answer here: https://mcmap.net/q/76927/-is-there-any-way-of-asking-an-ios-view-which-of-its-children-has-first-responder-status-duplicate)

Euphemie

Very nice. Should work really well for then being able to ask the first responder who (if anyone) in the chain will handle a particular action method were it to be sent. You can use this to enable or disable controls based on whether they're able to be handled. I'll answer my own question on this and reference your answer. – Hayse

In Swift: #1823817 – Koerner

Warning: This doesn't work if you start adding multiple windows. I unfortunately can't point to a cause beyond that yet. – Tanguay

This is an actual answer, unlike the several super upvoted answers that don't actually answer the question. And the accepted answer which is super inefficient. – Currency

Apple blocked using the method name findFirstResponder in a selector passed to -[UIApplication sendAction:to:from:forEvent:] in iOS 14. It seems they noticed this answer. But you can just use a different method name instead. – Figurative

Answer 5

Here is a Extension implemented in Swift based on Jakob Egger's most excellent answer:

import UIKit

extension UIResponder {
    // Swift 1.2 finally supports static vars!. If you use 1.1 see: 
    // https://mcmap.net/q/76929/-class-variables-not-yet-supported
    private weak static var _currentFirstResponder: UIResponder? = nil
    
    public class func currentFirstResponder() -> UIResponder? {
        UIResponder._currentFirstResponder = nil
        UIApplication.sharedApplication().sendAction("findFirstResponder:", to: nil, from: nil, forEvent: nil)
        return UIResponder._currentFirstResponder
    }
    
    internal func findFirstResponder(sender: AnyObject) {
        UIResponder._currentFirstResponder = self
    }
}

---

Swift 4

import UIKit    

extension UIResponder {
    private weak static var _currentFirstResponder: UIResponder? = nil
    
    public static var current: UIResponder? {
        UIResponder._currentFirstResponder = nil
        UIApplication.shared.sendAction(#selector(findFirstResponder(sender:)), to: nil, from: nil, for: nil)
        return UIResponder._currentFirstResponder
    }
    
    @objc internal func findFirstResponder(sender: AnyObject) {
        UIResponder._currentFirstResponder = self
    }
}

Doctrine

Modified answer to for swift1.2 where static var are supported. – Harville

Hi, when I print out the result of this on a brand new single-view application in viewDidAppear() I get nil. Shouldn't the view be the first responder? – Haemal

@LinusGeffarth Doesn't it make more sense to call the static method current instead of first ? – Doctrine

Guess so, edited it. I seem to have dropped the important part when abbreviating the variable name. – Longitude

Don't work on swift 5.4, I've tried with a textfield and a textview childs of the same view, the current value is always nil. – Smythe

Answer 6

It's not pretty, but the way I resign the firstResponder when I don't know what that the responder is:

Create an UITextField, either in IB or programmatically. Make it Hidden. Link it up to your code if you made it in IB.

Then, when you want to dismiss the keyboard, you switch the responder to the invisible text field, and immediately resign it:

    [self.invisibleField becomeFirstResponder];
    [self.invisibleField resignFirstResponder];

Vitrify

This is both horrible and genius at the same time. Nice. – Albata

I find that a bit dangerous - Apple may decide one day that making a hidden control become the first responder is not intended behavior and "fix" iOS not to do this any more, and then your trick may stop working. – Sudden

Or you can assign the firstResponder to a UITextField that is currently visible and then call resignFirstResponder on that particular textField. This removes the need to create a hidden view. All the same, +1. – Paulino

I rather think it is only horrible... it may change the keyboard layout (or input view) before hiding it – Ferrari

Answer 7

For a Swift 3 & 4 version of nevyn's answer:

UIApplication.shared.sendAction(#selector(UIView.resignFirstResponder), to: nil, from: nil, for: nil)

Postimpressionism

Answer 8

Here's a solution which reports the correct first responder (many other solutions won't report a UIViewController as the first responder, for example), doesn't require looping over the view hierarchy, and doesn't use private APIs.

It leverages Apple's method sendAction:to:from:forEvent:, which already knows how to access the first responder.

We just need to tweak it in 2 ways:

• Extend UIResponder so it can execute our own code on the first responder.
• Subclass UIEvent in order to return the first responder.

Here is the code:

@interface ABCFirstResponderEvent : UIEvent
@property (nonatomic, strong) UIResponder *firstResponder;
@end

@implementation ABCFirstResponderEvent
@end

@implementation UIResponder (ABCFirstResponder)
- (void)abc_findFirstResponder:(id)sender event:(ABCFirstResponderEvent *)event {
    event.firstResponder = self;
}
@end

@implementation ViewController

+ (UIResponder *)firstResponder {
    ABCFirstResponderEvent *event = [ABCFirstResponderEvent new];
    [[UIApplication sharedApplication] sendAction:@selector(abc_findFirstResponder:event:) to:nil from:nil forEvent:event];
    return event.firstResponder;
}

@end

Statius

Answer 9

Using Swift and with a specific UIView object this might help:

func findFirstResponder(inView view: UIView) -> UIView? {
    for subView in view.subviews as! [UIView] {
        if subView.isFirstResponder() {
            return subView
        }
        
        if let recursiveSubView = self.findFirstResponder(inView: subView) {
            return recursiveSubView
        }
    }
    
    return nil
}

Just place it in your UIViewController and use it like this:

let firstResponder = self.findFirstResponder(inView: self.view)

Take note that the result is an Optional value so it will be nil in case no firstResponder was found in the given views subview hierarchy.

Icterus

Answer 10

The first responder can be any instance of the class UIResponder, so there are other classes that might be the first responder despite the UIViews. For example UIViewController might also be the first responder.

In this gist you will find a recursive way to get the first responder by looping through the hierarchy of controllers starting from the rootViewController of the application's windows.

You can retrieve then the first responder by doing

- (void)foo
{
    // Get the first responder
    id firstResponder = [UIResponder firstResponder];

    // Do whatever you want
    [firstResponder resignFirstResponder];      
}

However, if the first responder is not a subclass of UIView or UIViewController, this approach will fail.

To fix this problem we can do a different approach by creating a category on UIResponder and perform some magic swizzeling to be able to build an array of all living instances of this class. Then, to get the first responder we can simple iterate and ask each object if -isFirstResponder.

This approach can be found implemented in this other gist.

Hope it helps.

Manometer

Answer 11

Iterate over the views that could be the first responder and use - (BOOL)isFirstResponder to determine if they currently are.

Trantham

Answer 12

Rather than iterate through the collection of views looking for the one that has isFirstResponder set, I too send a message to nil, but I store the receiver of the message so I can return it and do whatever I wish with it.

Additionally, I zero out the optional that holds the found responder in a defer statement from within the call itself. This ensures no references remain--even weak ones--at the end of the call.

import UIKit

private var _foundFirstResponder: UIResponder? = nil

extension UIResponder {

    static var first:UIResponder? {

        // Sending an action to 'nil' implicitly sends it to the first responder
        // where we simply capture it and place it in the _foundFirstResponder variable.
        // As such, the variable will contain the current first responder (if any) immediately after this line executes
        UIApplication.shared.sendAction(#selector(UIResponder.storeFirstResponder(_:)), to: nil, from: nil, for: nil)

        // The following 'defer' statement runs *after* this getter returns,
        // thus releasing any strong reference held by the variable immediately thereafter
        defer {
            _foundFirstResponder = nil
        }

        // Return the found first-responder (if any) back to the caller
        return _foundFirstResponder
    }

    // Make sure to mark this with '@objc' since it has to be reachable as a selector for `sendAction`
    @objc func storeFirstResponder(_ sender: AnyObject) {

        // Capture the recipient of this message (self), which is the first responder
        _foundFirstResponder = self
    }
}

With the above, I can resign the first responder by simply doing this...

UIResponder.first?.resignFirstResponder()

But since my API actually hands back whatever the first responder is, I can do whatever I want with it.

Here's an example that checks if the current first responder is a UITextField with a helpMessage property set, and if so, shows it in a help bubble right next to the control. We call this from a 'Quick Help' button on our screen.

func showQuickHelp(){

    if let textField = UIResponder?.first as? UITextField,
       let helpMessage = textField.helpMessage {
    
        textField.showHelpBubble(with:helpMessage)
    }
}

The support for the above is defined in an extension on UITextField like so...

extension UITextField {
    var helpMessage:String? { ... }
    func showHelpBubble(with message:String) { ... }
}

Now to support this feature, all we have to do is decide which text fields have help messages and the UI takes care of the rest for us.

Sukiyaki

Answer 13

Peter Steinberger just tweeted about the private notification UIWindowFirstResponderDidChangeNotification, which you can observe if you want to watch the firstResponder change.

Tanguay

He get rejected because using a private api, maybe using a private notification also could be a bad idea... – Anorak

Answer 14

If you just need to kill the keyboard when the user taps on a background area why not add a gesture recognizer and use it to send the [[self view] endEditing:YES] message?

you can add the Tap gesture recogniser in the xib or storyboard file and connect it to an action,

looks something like this then finished

- (IBAction)displayGestureForTapRecognizer:(UITapGestureRecognizer *)recognizer{
     [[self view] endEditing:YES];
}

Bosch

This worked great for me. I chose one connection to a view on the Xib, and I can add additional views for this to invoke in Referencing Outlet Collections – Skelly

Answer 15

Just it case here is Swift version of awesome Jakob Egger's approach:

import UIKit

private weak var currentFirstResponder: UIResponder?

extension UIResponder {

    static func firstResponder() -> UIResponder? {
        currentFirstResponder = nil
        UIApplication.sharedApplication().sendAction(#selector(self.findFirstResponder(_:)), to: nil, from: nil, forEvent: nil)
        return currentFirstResponder
    }

    func findFirstResponder(sender: AnyObject) {
        currentFirstResponder = self
    }

}

Koerner

Answer 16

This is what I did to find what UITextField is the firstResponder when the user clicks Save/Cancel in a ModalViewController:

    NSArray *subviews = [self.tableView subviews];

for (id cell in subviews ) 
{
    if ([cell isKindOfClass:[UITableViewCell class]]) 
    {
        UITableViewCell *aCell = cell;
        NSArray *cellContentViews = [[aCell contentView] subviews];
        for (id textField in cellContentViews) 
        {
            if ([textField isKindOfClass:[UITextField class]]) 
            {
                UITextField *theTextField = textField;
                if ([theTextField isFirstResponder]) {
                    [theTextField resignFirstResponder];
                }

            }
        }

    }

}

Grotesquery

Answer 17

This is what I have in my UIViewController Category. Useful for many things, including getting first responder. Blocks are great!

- (UIView*) enumerateAllSubviewsOf: (UIView*) aView UsingBlock: (BOOL (^)( UIView* aView )) aBlock {

 for ( UIView* aSubView in aView.subviews ) {
  if( aBlock( aSubView )) {
   return aSubView;
  } else if( ! [ aSubView isKindOfClass: [ UIControl class ]] ){
   UIView* result = [ self enumerateAllSubviewsOf: aSubView UsingBlock: aBlock ];

   if( result != nil ) {
    return result;
   }
  }
 }    

 return nil;
}

- (UIView*) enumerateAllSubviewsUsingBlock: (BOOL (^)( UIView* aView )) aBlock {
 return [ self enumerateAllSubviewsOf: self.view UsingBlock: aBlock ];
}

- (UIView*) findFirstResponder {
 return [ self enumerateAllSubviewsUsingBlock:^BOOL(UIView *aView) {
  if( [ aView isFirstResponder ] ) {
   return YES;
  }

  return NO;
 }];
}

Contradistinguish

Answer 18

You can try also like this:

- (void) touchesBegan: (NSSet *) touches withEvent: (UIEvent *) event { 

    for (id textField in self.view.subviews) {

        if ([textField isKindOfClass:[UITextField class]] && [textField isFirstResponder]) {
            [textField resignFirstResponder];
        }
    }
} 

I didn't try it but it seems a good solution

Fichu

Answer 19

This is good candidate for recursion! No need to add a category to UIView.

Usage (from your view controller):

UIView *firstResponder = [self findFirstResponder:[self view]];

Code:

// This is a recursive function
- (UIView *)findFirstResponder:(UIView *)view {

    if ([view isFirstResponder]) return view; // Base case

    for (UIView *subView in [view subviews]) {
        if ([self findFirstResponder:subView]) return subView; // Recursion
    }
    return nil;
}

Mont

This works correctly only if the first responder is a direct descendant of the view findFirstResponder is called onto. Otherwise it will return the ancestor that is a direct descendant of the target view. – Miscue

Answer 20

Swift version of @thomas-müller's response

extension UIView {

    func firstResponder() -> UIView? {
        if self.isFirstResponder() {
            return self
        }

        for subview in self.subviews {
            if let firstResponder = subview.firstResponder() {
                return firstResponder
            }
        }

        return nil
    }

}

Demisemiquaver

Answer 21

Update: I was wrong. You can indeed use UIApplication.shared.sendAction(_:to:from:for:) to call the first responder demonstrated in this link: https://mcmap.net/q/76927/-is-there-any-way-of-asking-an-ios-view-which-of-its-children-has-first-responder-status-duplicate.

---

Most of the answers here can't really find the current first responder if it is not in the view hierarchy. For example, AppDelegate or UIViewController subclasses.

There is a way to guarantee you to find it even if the first responder object is not a UIView.

First lets implement a reversed version of it, using the next property of UIResponder:

extension UIResponder {
    var nextFirstResponder: UIResponder? {
        return isFirstResponder ? self : next?.nextFirstResponder
    }
}

With this computed property, we can find the current first responder from bottom to top even if it's not UIView. For example, from a view to the UIViewController who's managing it, if the view controller is the first responder.

However, we still need a top-down resolution, a single var to get the current first responder.

First with the view hierarchy:

extension UIView {
    var previousFirstResponder: UIResponder? {
        return nextFirstResponder ?? subviews.compactMap { $0.previousFirstResponder }.first
    }
}

This will search for the first responder backwards, and if it couldn't find it, it would tell its subviews to do the same thing (because its subview's next is not necessarily itself). With this we can find it from any view, including UIWindow.

And finally, we can build this:

extension UIResponder {
    static var first: UIResponder? {
        return UIApplication.shared.windows.compactMap({ $0.previousFirstResponder }).first
    }
}

So when you want to retrieve the first responder, you can call:

let firstResponder = UIResponder.first

Wharf

Answer 22

You can choose the following UIView extension to get it (credit by Daniel):

extension UIView {
    var firstResponder: UIView? {
        guard !isFirstResponder else { return self }
        return subviews.first(where: {$0.firstResponder != nil })
    }
}

Zared

This works correctly only if the first responder is a direct descendant of the view findFirstResponder is called onto. Otherwise it will return the ancestor that is a direct descendant of the target view. – Miscue

Answer 23

The solution from romeo https://mcmap.net/q/76644/-get-the-current-first-responder-without-using-a-private-api is cool, but I noticed that the code needs one more loop. I was working with tableViewController. I edited the script and then I checked. Everything worked perfect.

I recommed to try this:

- (void)findFirstResponder
{
    NSArray *subviews = [self.tableView subviews];
    for (id subv in subviews )
    {
        for (id cell in [subv subviews] ) {
            if ([cell isKindOfClass:[UITableViewCell class]])
            {
                UITableViewCell *aCell = cell;
                NSArray *cellContentViews = [[aCell contentView] subviews];
                for (id textField in cellContentViews)
                {
                    if ([textField isKindOfClass:[UITextField class]])
                    {
                        UITextField *theTextField = textField;
                        if ([theTextField isFirstResponder]) {
                            NSLog(@"current textField: %@", theTextField);
                            NSLog(@"current textFields's superview: %@", [theTextField superview]);
                        }
                    }
                }
            }
        }
    }
}

Nephology

Thanks! You are correct, the most answers presented here are not a solution when working with uitableview. You could simplify your code a lot, even take out the if if ([textField isKindOfClass:[UITextField class]]) , allowing the use for uitextview, and could return the firstresponder. – Fichu

Answer 24

you can call privite api like this ,apple ignore:

UIWindow *keyWindow = [[UIApplication sharedApplication] keyWindow];
SEL sel = NSSelectorFromString(@"firstResponder");
UIView   *firstResponder = [keyWindow performSelector:sel];

Sleuth

but... please use 'respondsToSelector' to check – Sleuth

I do check 'respondsToSelector' now but I still get a warning, this might be unsafe. Can I get rid of the warning somehow? – Nihhi

Totally incorrect, Apple will reject your application if you use private API. It's even part of the question, the asker explicitly said that using the private firstResponder got them an rejection. – Miscue

Answer 25

I would like to shared with you my implementation for find first responder in anywhere of UIView. I hope it helps and sorry for my english. Thanks

+ (UIView *) findFirstResponder:(UIView *) _view {

    UIView *retorno;

    for (id subView in _view.subviews) {

        if ([subView isFirstResponder])
        return subView;

        if ([subView isKindOfClass:[UIView class]]) {
            UIView *v = subView;

            if ([v.subviews count] > 0) {
                retorno = [self findFirstResponder:v];
                if ([retorno isFirstResponder]) {
                    return retorno;
                }
            }
        }
    }

    return retorno;
}

Baleful

Answer 26

Code below work.

- (id)ht_findFirstResponder
{
    //ignore hit test fail view
    if (self.userInteractionEnabled == NO || self.alpha <= 0.01 || self.hidden == YES) {
        return nil;
    }
    if ([self isKindOfClass:[UIControl class]] && [(UIControl *)self isEnabled] == NO) {
        return nil;
    }

    //ignore bound out screen
    if (CGRectIntersectsRect(self.frame, [UIApplication sharedApplication].keyWindow.bounds) == NO) {
        return nil;
    }

    if ([self isFirstResponder]) {
        return self;
    }

    for (UIView *subView in self.subviews) {
        id result = [subView ht_findFirstResponder];
        if (result) {
            return result;
        }
    }
    return nil;
}   

Superfuse