def merge(constraints):
    operators = defaultdict(set)
    for constraint in constraints:
        operators[constraint.operator].add(constraint.version)
    if gt in operators:
        gt_ver = sorted(operators[gt])[-1]
    else:
        gt_ver = None
    if ge in operators:
        ge_ver = sorted(operators[ge])[-1]
    else:
        ge_ver = None
    if lt in operators:
        lt_ver = sorted(operators[lt])[0]
    else:
        lt_ver = None
    if le in operators:
        le_ver = sorted(operators[le])[0]
    else:
        le_ver = None
    l_constraint = None
    if le_ver:
        if lt_ver:
            le_constraint = Constraint(le, le_ver)
            lt_constraint = Constraint(lt, lt_ver)
            if le_ver < lt_ver:
                l_constraint = le_constraint
                l_less_restrictive_c = lt_constraint
            else:
                l_constraint = lt_constraint
                l_less_restrictive_c = le_constraint
            LOGGER.debug('Removed constraint %s because it is less '
                         'restrictive than %s', l_less_restrictive_c,
                         l_constraint)
        else:
            l_constraint = Constraint(le, le_ver)
    elif lt_ver:
        l_constraint = Constraint(lt, lt_ver)
    g_constraint = None
    if ge_ver:
        if gt_ver:
            gt_constraint = Constraint(gt, gt_ver)
            ge_constraint = Constraint(ge, ge_ver)
            if ge_ver <= gt_ver:
                g_constraint = gt_constraint
                g_less_restrictive_c = ge_constraint
            else:
                g_constraint = ge_constraint
                g_less_restrictive_c = gt_constraint
            LOGGER.debug('Removed constraint %s because it is less '
                         'restrictive than %s', g_less_restrictive_c,
                         g_constraint)
        else:
            g_constraint = Constraint(ge, ge_ver)
    elif gt_ver:
        g_constraint = Constraint(gt, gt_ver)
    if g_constraint and l_constraint:
        if g_constraint.version == l_constraint.version:
            if g_constraint.operator == ge and l_constraint.operator == le:
                operators[eq].add(g_constraint.version)
                LOGGER.debug('Merged constraints: %s and %s into ==%s',
                             l_constraint, g_constraint, g_constraint.version)
                l_constraint, g_constraint = None, None
            else:
                raise ExclusiveConstraints(g_constraint, [l_constraint])
        elif g_constraint.version > l_constraint.version:
            raise ExclusiveConstraints(g_constraint, [l_constraint])
    ne_constraints = [Constraint(ne, v) for v in operators[ne]]
    eq_constraints = [Constraint(eq, v) for v in operators[eq]]
    if eq_constraints:
        eq_constraint = eq_constraints.pop()
        if g_constraint or l_constraint or ne_constraints or eq_constraints:
            conflict_list = [c for c in (g_constraint, l_constraint) if c]
            conflict_list.extend(ne_constraints)
            conflict_list.extend(eq_constraints)
            raise ExclusiveConstraints(eq_constraint, conflict_list)
        return [eq_constraint]
    else:
        constraints = ne_constraints + [g_constraint, l_constraint]
        return [c for c in constraints if c]