def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) own tests
     if len(context.application.cache.nodes) == 0: return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) validating
     if not isinstance(context.application.cache.node, ConscanResults): return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) validating
     if len(context.application.cache.children) == 0: return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     if len(context.application.cache.nodes) == 0: return False
     if context.application.cache.some_nodes_without_children_fixed: return False
     # C) passed all tests:
     return True

    def analyze_selection():
        # A) calling ancestor
        if not Immediate.analyze_selection(): return False
        # B) validating

        # C) passed all tests:
        return True

 def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) validating
     if context.application.main is None: return False
     # C) passed all tests:
     return True

 def analyze_selection():
     if not Immediate.analyze_selection(): return False
     cache = context.application.cache
     if len(cache.nodes) < 2: return False
     Frame = context.application.plugins.get_node("Frame")
     for cls in cache.classes:
         if not issubclass(cls, Frame): return False
     return True

 def analyze_selection(parameters=None):
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) validating
     universe = context.application.model.universe
     if sum(universe.cell.active) == 0: return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestors
     if not Immediate.analyze_selection(): return False
     # B) validating
     cache = context.application.cache
     if cache.some_nodes_fixed: return False
     if len(cache.transformed_nodes) == 0: return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) validating
     cache = context.application.cache
     if len(cache.nodes) != 2: return False
     if len(cache.translations) != 2: return False
     if cache.common_parent is None: return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) validating
     cache = context.application.cache
     for cls in cache.classes:
         if not issubclass(cls, Spring):
             return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestors
     if not Immediate.analyze_selection(): return False
     # B) validating
     node = context.application.cache.node
     Universe = context.application.plugins.get_node("Universe")
     if not isinstance(node, Universe): return False
     if node.cell_active.sum() == 0: return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) validating
     cache = context.application.cache
     if len(cache.nodes) == 0: return False
     for cls in cache.classes:
         if issubclass(cls, Reference): return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) validating & initializing
     node = context.application.cache.node
     Frame = context.application.plugins.get_node("Frame")
     if not Frame.check_add(node.__class__): return False
     if node.get_fixed(): return False
     if not isinstance(node, GLTransformationMixin): return False
     if not node.parent.check_add(Frame): return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) validating and initialising
     cache = context.application.cache
     if len(cache.nodes) == 0: return False
     if len(cache.translations) == 0: return False
     parent = cache.common_parent
     if parent == None: return False
     while not parent.check_add(Point):
         parent = parent.parent
         if parent == None: return False
     # C) passed all tests:
     return True

 def analyze_selection():
     # A) calling ancestor
     if not Immediate.analyze_selection(): return False
     # B) validating
     cache = context.application.cache
     if cache.node is None: return False
     contains_atoms = False
     for cls in cache.child_classes:
         if issubclass(cls, Atom):
             contains_atoms = True
             break
     if not contains_atoms: return False
     # C) passed all tests
     return True