Help! My calculator malfunctions! Introduction

My calculator is behaving weird. Sometimes when I type in an 8 it displays a 2. And sometimes when I type in a 6 it displays a +. Some buttons are mixed up!
Could anyone help me determine which?

Challenge:

Input: List of incorrect equations, with correct results.

Output: The two buttons that are swapped.

For example:
An input could be:

123    = 3
8423   = 252
4+4    = 8
4*7-10 = 417
9/3    = 3
42-9   = -36


For which the expected outputs are: 2 and *.

Why? Because ALL the equations would be correct if we swap the 2's and *'s:

1*3    = 3
84*3   = 252
4+4    = 8
427-10 = 417
9/3    = 3
4*-9   = -36


Challenge rules:


Input can be in any reasonable format. Can be a single string with space delimited; a string-list or -array; a list with equations and another list with the correct results. Your call. Please state which input format you've used!
NOTE: This also means you are allowed to input the test case -5--15 as -5- -15 or -5 - -15. However, a number resulting in -- should either be inputted without spaces or with a space between every digit. So test case 9119 can be inputted like 9119 or 9 1 1 9 (reason 91 19 isn't allowed is because you can then be guided by the space for finding - -). So spaces are (somewhat) optional and allowed.
Output format can be in any reasonable format as well. Can be two characters; a single two-character string; a string-list containing the two characters. Your call. Again, please state which output format you've used!
You are allowed to use any distinct 14 outputs that map to 0123456789+-*/. So you are even allowed to output two distinct integers if you want to (again, please specify the mapping you've used, if any).
You only have to support integers. So there won't be any test cases like 1/8=0.125 or 1/8=0.
Arithmetic operands you'll have to support: addition (+); subtraction (-); multiplication (* or × or ·); division (/ or ÷). (NOTE: Characters between parenthesis are only added as clarification.)
You'll have to support negative numbers. This means - can be interpreted in the equation as both a mathematical operand or a negative indicator.
You can assume the given incorrect equations and supposed correct equations are always valid (so there won't be things like 4-/2 or 9+-+8 for example).
The incorrect input-equations can contain a division by 0, but the corrected and expected equations will never contain division by 0.
The incorrect input-equations can already be correct even if you swap the intended buttons back.
A given input equation can be irrelevant for the buttons  to swap (like the 4+4=8 and 9/3=3 equations, with the swapped buttons 2 and *).
You can assume there will always be only one possible swap that can be made with the given test cases.
Both buttons to swap will always be present in at least one of the incorrect equations.


General rules:


This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code.
Also, please add an explanation if necessary.


Test cases:

Input:
123    = 3
8423   = 252
4+4    = 8
4*7-10 = 417
9/3    = 3
42-9   = -36

Output: 2 *

Input:
4/2   = 6
3/0   = 3
0/8+2 = 4
95-5  = 90
4+2   = 2

Output: + /

Input:
7+4    = 11
5-15   = 46
212-23 = -2121

Output: 1 -

Input:
4+8/2-9*1 = -5
99/3-13   = 20
1+2+3+4   = 10
4-3-2-1   = -6

Output: 2 4

Input:
18/18  = 1
98-8   = 90
55*88  = 4840
-5--15 = 10

Ouput: 5 8

Input:
9119    = 18
5-3     = 513
8*-9    = 152
13116/3 = -1

Output: 1 -
JavaScript (ES7), 159 158 bytes

Edit: new version to comply with the updated rules regarding --
Saved 1 byte thanks to @Shaggy

Takes input in currying syntax (e)(r) where e is the array of equations and r is the array of expected results. Returns an array of characters.

e=&gt;r=&gt;(l=[...2**29+'4+-*/']).filter(x=&gt;l.some(y=&gt;eval("try{eval((S=(s=`[${e}]`).replace(/./g,c=&gt;c==x?y:c==y?x:c)).split`--`.join`+`)+''==r&amp;S!=s}catch(e){}")))


Test cases



let f =

e=&gt;r=&gt;(l=[...2**29+'4+-*/']).filter(x=&gt;l.some(y=&gt;eval("try{eval((S=(s=`[${e}]`).replace(/./g,c=&gt;c==x?y:c==y?x:c)).split`--`.join`+`)+''==r&amp;S!=s}catch(e){}")))

console.log(JSON.stringify(f
  ([ '123', '8423', '4+4', '4*7-10', '9/3', '42-9' ])
  ([ 3, 252, 8, 417, 3, -36 ])
));

console.log(JSON.stringify(f
  ([ '4/2', '3/0', '0/8+2', '95-5', '4+2' ])
  ([ 6, 3, 4, 90, 2 ])
));

console.log(JSON.stringify(f
  ([ '7+4', '5-15', '212-23' ])
  ([ 11, 46, -2121 ])
));

console.log(JSON.stringify(f
  ([ '4+8/2-9*1', '99/3-13', '1+2+3+4', '4-3-2-1' ])
  ([ -5, 20, 10, -6 ])
));

console.log(JSON.stringify(f
  ([ '18/18', '98-8', '55*88', '-5--15' ])
  ([ 1, 90, 4840, 10 ])
));

console.log(JSON.stringify(f
  ([ '9119', '5-3', '8*-9', '13116/3' ])
  ([ 18, 513, 152, -1 ])
));




Formatted and commented

e =&gt; r =&gt;                                  // given e and r
  (l = [...2 ** 29 + '4+-*/'])             // generate l = [...'5368709124+-*/']
  .filter(x =&gt;                             // for each character x of l
    l.some(y =&gt;                            // for each character y of l
      eval("try {                          // we need to 'try', because we don't know
        eval(                              // whether the following expression is valid
          (S = (s = `[${e}]`).             // s = list of equations coerced to a string
            replace(/./g, c =&gt;             // S =
              c == x ? y : c == y ? x : c  //   s with x and y exchanged
            )                              // end of replace()
          ).split`--`.join`+`              // replace '--' with '+'
        ) + '' == r                        // does the resulting list match r?
        &amp; S != s                           // and was at least one character modified?
      } catch(e){}")                       // if we try, we oughta catch
    )                                      // end of some()
  )                                        // end of filter()