--- a/cargo2rpm/semver.py	2023-03-06 05:26:17.000000000 -0800
+++ b/cargo2rpm/semver.py	2023-04-23 18:00:11.731932963 -0700
@@ -255,89 +255,89 @@
 
         comparators = []
 
-        match self.op:
-            case Op.EXACT:
-                match (self.minor, self.patch):
-                    case (None, None):
+#        match self.op:
+        if self.op == Op.EXACT:
+#            match (self.minor, self.patch):
+            if self.minor==None and self.patch==None:
                         comparators.append(Comparator(Op.GREATER_EQ, self.major, 0, 0, None))
                         comparators.append(Comparator(Op.LESS, self.major + 1, 0, 0, None))
-                    case (minor, None):
+            if self.minor=="minor" and self.patch==None:
                         comparators.append(Comparator(Op.GREATER_EQ, self.major, minor, 0, None))
                         comparators.append(Comparator(Op.LESS, self.major, minor + 1, 0, None))
-                    case (minor, patch):
+            if self.minor=="minor" and self.patch=="patch" :
                         comparators.append(Comparator(Op.EXACT, self.major, minor, patch, self.pre))
 
-            case Op.GREATER:
-                match (self.minor, self.patch):
-                    case (None, None):
+        elif self.op == Op.GREATER:
+#            match (self.minor, self.patch): 
+                if self.minor==None and self.patch==None:
                         comparators.append(Comparator(Op.GREATER_EQ, self.major + 1, 0, 0, None))
-                    case (minor, None):
+                if self.minor=="minor" and self.patch==None :
                         comparators.append(Comparator(Op.GREATER_EQ, self.major, minor + 1, 0, None))
-                    case (minor, patch):
+                if self.minor=="minor" and self.patch=="patch":
                         comparators.append(Comparator(Op.GREATER, self.major, minor, patch, self.pre))
 
-            case Op.GREATER_EQ:
-                match (self.minor, self.patch):
-                    case (None, None):
+        elif self.op == Op.GREATER_EQ:
+#            match (self.minor, self.patch):
+                if self.minor==None and self.patch==None:
                         comparators.append(Comparator(Op.GREATER_EQ, self.major, 0, 0, None))
-                    case (minor, None):
+                if self.minor=="minor" and self.patch==None :
                         comparators.append(Comparator(Op.GREATER_EQ, self.major, minor, 0, None))
-                    case (minor, patch):
+                if self.minor=="minor" and self.patch=="patch":
                         comparators.append(Comparator(Op.GREATER_EQ, self.major, minor, patch, self.pre))
 
-            case Op.LESS:
-                match (self.minor, self.patch):
-                    case (None, None):
+        elif self.op == Op.LESS:
+#            match (self.minor, self.patch):
+                if self.minor==None and self.patch==None:
                         comparators.append(Comparator(Op.LESS, self.major, 0, 0, None))
-                    case (minor, None):
+                if self.minor=="minor" and self.patch==None:
                         comparators.append(Comparator(Op.LESS, self.major, minor, 0, None))
-                    case (minor, patch):
+                if self.minor=="minor" and self.patch=="patch":
                         comparators.append(Comparator(Op.LESS, self.major, minor, patch, self.pre))
 
-            case Op.LESS_EQ:
-                match (self.minor, self.patch):
-                    case (None, None):
+        elif self.op == Op.LESS_EQ:
+#            match (self.minor, self.patch):
+                if self.minor==None and self.patch==None:
                         comparators.append(Comparator(Op.LESS, self.major + 1, 0, 0, None))
-                    case (minor, None):
+                if self.minor=="minor" and self.patch==None:
                         comparators.append(Comparator(Op.LESS, self.major, minor + 1, 0, None))
-                    case (minor, patch):
+                if self.minor=="minor" and self.patch=="patch":
                         comparators.append(Comparator(Op.LESS_EQ, self.major, minor, patch, self.pre))
 
-            case Op.TILDE:
-                match (self.minor, self.patch):
-                    case (None, None):
+        elif self.op == Op.TILDE:
+#            match (self.minor, self.patch):
+                if self.minor==None and self.patch==None:
                         comparators.extend(Comparator(Op.EXACT, self.major, None, None, None).normalize())
-                    case (minor, None):
+                if self.minor=="minor" and self.patch==None:
                         comparators.extend(Comparator(Op.EXACT, self.major, minor, None, None).normalize())
-                    case (minor, patch):
+                if self.minor=="minor" and self.patch=="patch":
                         comparators.append(Comparator(Op.GREATER_EQ, self.major, minor, patch, self.pre))
                         comparators.append(Comparator(Op.LESS, self.major, minor + 1, 0, None))
 
-            case Op.CARET:
-                match (self.major, self.minor, self.patch):
-                    case (major, None, None):
+        elif self.op == Op.CARET:
+#            match (self.major, self.minor, self.patch): case (major, None, None)
+                if self.major=="major" and self.minor==None and self.patch==None:
                         comparators.extend(Comparator(Op.EXACT, major, None, None, None).normalize())
-                    case (0, 0, None):
+                if self.major==0 and self.minor==0 and self.patch==None:
                         comparators.extend(Comparator(Op.EXACT, 0, 0, None, None).normalize())
-                    case (major, minor, None):
+                if self.major=="major" and self.minor=="minor" and self.patch==None:
                         comparators.extend(Comparator(Op.CARET, major, minor, 0, None).normalize())
-                    case (0, 0, patch):
+                if self.major==0 and self.minor==0 and self.patch=="patch":
                         comparators.extend(Comparator(Op.EXACT, 0, 0, patch, self.pre).normalize())
-                    case (0, minor, patch):
+                if self.major==0 and self.minor=="minor" and self.patch=="patch":
                         comparators.append(Comparator(Op.GREATER_EQ, 0, minor, patch, self.pre))
                         comparators.append(Comparator(Op.LESS, 0, minor + 1, 0, None))
-                    case (major, minor, patch):
+                if self.major=="major" and self.minor=="minor" and self.patch=="patch":
                         comparators.append(Comparator(Op.GREATER_EQ, major, minor, patch, self.pre))
                         comparators.append(Comparator(Op.LESS, major + 1, 0, 0, None))
 
-            case Op.WILDCARD:
-                match (self.minor, self.patch):
-                    case (None, None):
+        elif self.op == Op.WILDCARD:
+#            match (self.minor, self.patch):
+            if self.minor==None and self.patch==None:
                         comparators.extend(Comparator(Op.EXACT, self.major, None, None, None).normalize())
-                    case (minor, None):
+            if self.minor=="minor" and self.patch==None:
                         comparators.extend(Comparator(Op.EXACT, self.major, minor, None, None).normalize())
 
-            case _:  # pragma nocover
+        else:  # pragma nocover
                 raise ValueError(f"Unknown operator: {self.op} (this should never happen)")
 
         return comparators
@@ -368,18 +368,18 @@
             pre_str = f"~{pre}"
             pre_str_less = f"~{pre}"
 
-        match self.op:
-            case Op.EXACT:
+#        match self.op:
+        if self.op == Op.EXACT:
                 return f"crate({crate}{feature_str}) = {version_str}{pre_str}"
-            case Op.GREATER:
+        if self.op == Op.GREATER:
                 return f"crate({crate}{feature_str}) > {version_str}{pre_str}"
-            case Op.GREATER_EQ:
+        if self.op == Op.GREATER_EQ:
                 return f"crate({crate}{feature_str}) >= {version_str}{pre_str}"
-            case Op.LESS:
+        if self.op == Op.LESS:
                 return f"crate({crate}{feature_str}) < {version_str}{pre_str_less}"
-            case Op.LESS_EQ:
+        if self.op == Op.LESS_EQ:
                 return f"crate({crate}{feature_str}) <= {version_str}{pre_str}"
-            case _:  # pragma nocover
+        else:  # pragma nocover
                 raise ValueError(f"Unsupported operator for RPM syntax formatting: {self.op}")