def bodyCells(self, row, yParentStructuralNode, xStructuralNodes, zAspectStructuralNodes, yChildrenFirst):
        if yParentStructuralNode is not None:
            dimDefaults = self.modelXbrl.qnameDimensionDefaults
            for yStructuralNode in yParentStructuralNode.childStructuralNodes:
                if yChildrenFirst:
                    row = self.bodyCells(row, yStructuralNode, xStructuralNodes, zAspectStructuralNodes, yChildrenFirst)
                if not (yStructuralNode.isAbstract or 
                        (yStructuralNode.childStructuralNodes and
                         not isinstance(yStructuralNode.definitionNode, (ModelClosedDefinitionNode, ModelEuAxisCoord)))) and yStructuralNode.isLabeled:
                    isYEntryPrototype = yStructuralNode.isEntryPrototype(default=False) # row to enter open aspects
                    yAspectStructuralNodes = defaultdict(set)
                    for aspect in aspectModels[self.aspectModel]:
                        if yStructuralNode.hasAspect(aspect):
                            if aspect == Aspect.DIMENSIONS:
                                for dim in (yStructuralNode.aspectValue(Aspect.DIMENSIONS) or emptyList):
                                    yAspectStructuralNodes[dim].add(yStructuralNode)
                            else:
                                yAspectStructuralNodes[aspect].add(yStructuralNode)
                    yTagSelectors = yStructuralNode.tagSelectors
                    # data for columns of row
                    #print ("row " + str(row) + "yNode " + yStructuralNode.definitionNode.objectId() )
                    ignoreDimValidity = self.ignoreDimValidity.get()
                    for i, xStructuralNode in enumerate(xStructuralNodes):
                        isEntryPrototype = isYEntryPrototype or xStructuralNode.isEntryPrototype(default=False)
                        xAspectStructuralNodes = defaultdict(set)
                        for aspect in aspectModels[self.aspectModel]:
                            if xStructuralNode.hasAspect(aspect):
                                if aspect == Aspect.DIMENSIONS:
                                    for dim in (xStructuralNode.aspectValue(Aspect.DIMENSIONS) or emptyList):
                                        xAspectStructuralNodes[dim].add(xStructuralNode)
                                else:
                                    xAspectStructuralNodes[aspect].add(xStructuralNode)
                        cellTagSelectors = yTagSelectors | xStructuralNode.tagSelectors
                        cellAspectValues = {}
                        matchableAspects = set()
                        for aspect in _DICT_SET(xAspectStructuralNodes.keys()) | _DICT_SET(yAspectStructuralNodes.keys()) | _DICT_SET(zAspectStructuralNodes.keys()):
                            aspectValue = xStructuralNode.inheritedAspectValue(yStructuralNode,
                                               self, aspect, cellTagSelectors, 
                                               xAspectStructuralNodes, yAspectStructuralNodes, zAspectStructuralNodes)
                            # value is None for a dimension whose value is to be not reported in this slice
                            if (isinstance(aspect, _INT) or  # not a dimension
                                dimDefaults.get(aspect) != aspectValue or # explicit dim defaulted will equal the value
                                aspectValue is not None): # typed dim absent will be none
                                cellAspectValues[aspect] = aspectValue
                            matchableAspects.add(aspectModelAspect.get(aspect,aspect)) #filterable aspect from rule aspect
                        cellDefaultedDims = _DICT_SET(dimDefaults) - _DICT_SET(cellAspectValues.keys())
                        priItemQname = cellAspectValues.get(Aspect.CONCEPT)
                            
                        concept = self.modelXbrl.qnameConcepts.get(priItemQname)
                        conceptNotAbstract = concept is None or not concept.isAbstract
                        value = None
                        objectId = None
                        justify = None
                        fp = FactPrototype(self, cellAspectValues)
                        if conceptNotAbstract:
                            # reduce set of matchable facts to those with pri item qname and have dimension aspects
                            facts = self.modelXbrl.factsByQname[priItemQname] if priItemQname else self.modelXbrl.factsInInstance
                            if self.hasTableFilters:
                                facts = self.modelTable.filterFacts(self.rendrCntx, facts)
                            for aspect in matchableAspects:  # trim down facts with explicit dimensions match or just present
                                if isinstance(aspect, QName):
                                    aspectValue = cellAspectValues.get(aspect, None)
                                    if isinstance(aspectValue, ModelDimensionValue):
                                        if aspectValue.isExplicit:
                                            dimMemQname = aspectValue.memberQname # match facts with this explicit value
                                        else:
                                            dimMemQname = None  # match facts that report this dimension
                                    elif isinstance(aspectValue, QName): 
                                        dimMemQname = aspectValue  # match facts that have this explicit value
                                    elif aspectValue is None: # match typed dims that don't report this value
                                        dimMemQname = ModelXbrl.DEFAULT
                                    else:
                                        dimMemQname = None # match facts that report this dimension
                                    facts = facts & self.modelXbrl.factsByDimMemQname(aspect, dimMemQname)
                                    if len(facts)==0:
                                        break;
                            for fact in facts:
                                if (all(aspectMatches(self.rendrCntx, fact, fp, aspect) 
                                        for aspect in matchableAspects) and
                                    all(fact.context.dimMemberQname(dim,includeDefaults=True) in (dimDefaults[dim], None)
                                        for dim in cellDefaultedDims) and
                                    len(fp.context.qnameDims) == len(fact.context.qnameDims)):
                                    if yStructuralNode.hasValueExpression(xStructuralNode):
                                        value = yStructuralNode.evalValueExpression(fact, xStructuralNode)
                                    else:
                                        value = fact.effectiveValue
                                    objectId = fact.objectId()
                                    justify = XbrlTable.TG_RIGHT_JUSTIFIED if fact.isNumeric else XbrlTable.TG_LEFT_JUSTIFIED
                                    break
                        if (conceptNotAbstract and
                            (value is not None or ignoreDimValidity or isFactDimensionallyValid(self, fp) or
                             isEntryPrototype)):
                            if objectId is None:
                                objectId = "f{0}".format(len(self.factPrototypes))
                                self.factPrototypes.append(fp)  # for property views
                                for aspect, aspectValue in cellAspectValues.items():
                                    if isinstance(aspectValue, str) and aspectValue.startswith(OPEN_ASPECT_ENTRY_SURROGATE):
                                        self.factPrototypeAspectEntryObjectIds[objectId].add(aspectValue)
                            modelConcept = fp.concept
                            if (justify is None) and modelConcept is not None:
                                justify = XbrlTable.TG_RIGHT_JUSTIFIED if modelConcept.isNumeric else XbrlTable.TG_LEFT_JUSTIFIED
                            if modelConcept is not None and modelConcept.isEnumeration:
                                myValidationObject = ValidateXbrl(self.modelXbrl)
                                myValidationObject.modelXbrl = self.modelXbrl
                                enumerationSet = ValidateXbrlDimensions.usableEnumerationMembers(myValidationObject, modelConcept)
                                enumerationDict = dict()
                                for enumerationItem in enumerationSet:
                                    # we need to specify the concept linkrole to sort out between possibly many different labels
                                    enumerationDict[enumerationItem.label(linkrole=modelConcept.enumLinkrole)] = enumerationItem.qname
                                enumerationValues = sorted(list(enumerationDict.keys()))
                                enumerationQNameStrings = [""]+list(str(enumerationDict[enumerationItem]) for enumerationItem in enumerationValues)
                                enumerationValues = [""]+enumerationValues
                                try:
                                    selectedIdx = enumerationQNameStrings.index(value)
                                    effectiveValue = enumerationValues[selectedIdx]
                                except ValueError:
                                    effectiveValue = enumerationValues[0]
                                    selectedIdx = 0
                                xValue = self.dataFirstCol + i-1
                                yValue = row-1
                                self.table.initCellCombobox(effectiveValue,
                                                            enumerationValues,
                                                            xValue,
                                                            yValue,
                                                            objectId=objectId,
                                                            selectindex=selectedIdx,
                                                            codes=enumerationDict)
                            elif modelConcept is not None and modelConcept.type.qname == XbrlConst.qnXbrliQNameItemType:
                                if eurofilingModelPrefix in concept.nsmap and concept.nsmap.get(eurofilingModelPrefix) == eurofilingModelNamespace:
                                    hierarchy = concept.get("{" + eurofilingModelNamespace + "}" + "hierarchy", None)
                                    domainQNameAsString = concept.get("{" + eurofilingModelNamespace + "}" + "domain", None)
                                    if hierarchy is not None and domainQNameAsString is not None:
                                        newAspectValues = [""]
                                        newAspectQNames = dict()
                                        newAspectQNames[""] = None
                                        domPrefix, _, domLocalName = domainQNameAsString.strip().rpartition(":")
                                        domNamespace = concept.nsmap.get(domPrefix)
                                        relationships = concept_relationships(self.rendrCntx, 
                                             None, 
                                             (QName(domPrefix, domNamespace, domLocalName),
                                              hierarchy, # linkrole,
                                              "XBRL-dimensions",
                                              'descendant'),
                                             False) # return flat list
                                        for rel in relationships:
                                            if (rel.arcrole in (XbrlConst.dimensionDomain, XbrlConst.domainMember)
                                                and rel.isUsable):
                                                header = rel.toModelObject.label(lang=self.lang)
                                                newAspectValues.append(header)
                                                currentQName = rel.toModelObject.qname
                                                if str(currentQName) == value:
                                                    value = header
                                                newAspectQNames[header] = currentQName
                                    else:
                                        newAspectValues = None
                                else:
                                    newAspectValues = None
                                if newAspectValues is None:
                                    xValue = self.dataFirstCol + 1-i
                                    yValue = row-1
                                    self.table.initCellValue(value,
                                                             xValue,
                                                             yValue,
                                                             justification=justify,
                                                             objectId=objectId,
                                                             backgroundColourTag=self.getbackgroundColor(fp))
                                else:
                                    qNameValues = newAspectValues
                                    try:
                                        selectedIdx = qNameValues.index(value)
                                        effectiveValue = value
                                    except ValueError:
                                        effectiveValue = qNameValues[0]
                                        selectedIdx = 0
                                    xValue = self.dataFirstCol + i-1
                                    yValue = row-1
                                    self.table.initCellCombobox(effectiveValue,
                                                                qNameValues,
                                                                xValue,
                                                                yValue,
                                                                objectId=objectId,
                                                                selectindex=selectedIdx,
                                                                codes=newAspectQNames)
                            elif modelConcept is not None and modelConcept.type.qname == XbrlConst.qnXbrliBooleanItemType:
                                booleanValues = ["",
                                                 XbrlConst.booleanValueTrue,
                                                 XbrlConst.booleanValueFalse]
                                try:
                                    selectedIdx = booleanValues.index(value)
                                    effectiveValue = value
                                except ValueError:
                                    effectiveValue = booleanValues[0]
                                    selectedIdx = 0
                                xValue = self.dataFirstCol + i-1
                                yValue = row-1
                                self.table.initCellCombobox(effectiveValue,
                                                            booleanValues,
                                                            xValue,
                                                            yValue,
                                                            objectId=objectId,
                                                            selectindex=selectedIdx)
                            else:
                                xValue = self.dataFirstCol + i-1
                                yValue = row-1
                                self.table.initCellValue(value,
                                                         xValue,
                                                         yValue,
                                                         justification=justify,
                                                         objectId=objectId,
                                                         backgroundColourTag=self.getbackgroundColor(fp))
                        else:
                            fp.clear()  # dereference
                    row += 1
                if not yChildrenFirst:
                    row = self.bodyCells(row, yStructuralNode, xStructuralNodes, zAspectStructuralNodes, yChildrenFirst)
            return row
dataset/ETHPy150Open Arelle/Arelle/arelle/ViewWinRenderedGrid.py/ViewRenderedGrid.bodyCells/swapped operands of `-`