MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                 | addr                       | city          | phone         | type                    |   class |
|:---------------------|:---------------------------|:--------------|:--------------|:------------------------|--------:|
| ` ralph \ 's diner ' | ' 3000 las vegas blvd. s ' | ` las vegas ' | 702/732 -6330 | ` coffee shops/diners ' |     448 |

Entity B:
| name                  | addr                        | city          | phone        | type   |   class |
|:----------------------|:----------------------------|:--------------|:-------------|:-------|--------:|
| ` madame ching \ 's ' | ' 3300 las vegas blvd. s. ' | ` las vegas ' | 702-894-7111 | asian  |     662 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 448
rtable_id: 128
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name              | addr                  | city          | phone         | type   |   class |
|:------------------|:----------------------|:--------------|:--------------|:-------|--------:|
| ` bamboo garden ' | ' 4850 flamingo rd. ' | ` las vegas ' | 702/871 -3262 | asian  |     425 |

Entity B:
| name                          | addr                     | city          | phone        | type    |   class |
|:------------------------------|:-------------------------|:--------------|:-------------|:--------|--------:|
| ` fiore rotisserie & grille ' | ' 3700 w. flamingo rd. ' | ` las vegas ' | 702-252-7702 | italian |     660 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 425
rtable_id: 126
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name              | addr              | city         | phone         | type   |   class |
|:------------------|:------------------|:-------------|:--------------|:-------|--------:|
| ` shun lee west ' | '43 w. 65th st. ' | ` new york ' | 212/371 -8844 | asian  |      60 |

Entity B:
| name             | addr              | city              | phone        | type                   |   class |
|:-----------------|:------------------|:------------------|:-------------|:-----------------------|--------:|
| ` la caravelle ' | '33 w. 55th st. ' | ` new york city ' | 212-586-4252 | ` french ( classic ) ' |      39 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 60
rtable_id: 257
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name               | addr                                    | city    | phone         | type   |   class |
|:-------------------|:----------------------------------------|:--------|:--------------|:-------|--------:|
| ` heera of india ' | ' 595 piedmont ave. rio shopping mall ' | atlanta | 404/876 -4408 | asian  |      83 |

Entity B:
| name               | addr                  | city    | phone        | type   |   class |
|:-------------------|:----------------------|:--------|:-------------|:-------|--------:|
| ` heera of india ' | ' 595 piedmont ave. ' | atlanta | 404-876-4408 | indian |      83 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 83
rtable_id: 301
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                       | city    | phone         | type          |   class |
|:-------|:---------------------------|:--------|:--------------|:--------------|--------:|
| abbey  | ' 163 ponce de leon ave. ' | atlanta | 404/876 -8532 | international |     379 |

Entity B:
| name                       | addr                       | city    | phone        | type          |   class |
|:---------------------------|:---------------------------|:--------|:-------------|:--------------|--------:|
| ` mary mac \ 's tea room ' | ' 224 ponce de leon ave. ' | atlanta | 404-876-1800 | southern/soul |      86 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 379
rtable_id: 304
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                 | addr                       | city          | phone         | type                    |   class |
|:---------------------|:---------------------------|:--------------|:--------------|:------------------------|--------:|
| ` ralph \ 's diner ' | ' 3000 las vegas blvd. s ' | ` las vegas ' | 702/732 -6330 | ` coffee shops/diners ' |     448 |

Entity B:
| name                                     | addr                        | city          | phone        | type        |   class |
|:-----------------------------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` morton \ 's of chicago ( las vegas ) ' | ' 3200 las vegas blvd. s. ' | ` las vegas ' | 702-893-0703 | steakhouses |     667 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 448
rtable_id: 133
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                      | addr                       | city    | phone         | type          |   class |
|:--------------------------|:---------------------------|:--------|:--------------|:--------------|--------:|
| ` hedgerose heights inn ' | ' 490 e. paces ferry rd. ' | atlanta | 404/233 -7673 | international |      82 |

Entity B:
| name                          | addr                          | city    | phone        | type        |   class |
|:------------------------------|:------------------------------|:--------|:-------------|:------------|--------:|
| ` hedgerose heights inn the ' | ' 490 e. paces ferry rd. ne ' | atlanta | 404-233-7673 | continental |      82 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 82
rtable_id: 300
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                                  | addr                   | city    | phone         | type          |   class |
|:--------------------------------------|:-----------------------|:--------|:--------------|:--------------|--------:|
| ` dining room ritz-carlton buckhead ' | ' 3434 peachtree rd. ' | atlanta | 404/237 -2700 | international |      90 |

Entity B:
| name                | addr                   | city    | phone        | type       |   class |
|:--------------------|:-----------------------|:--------|:-------------|:-----------|--------:|
| ` brookhaven cafe ' | ' 4274 peachtree rd. ' | atlanta | 404-231-5907 | vegetarian |     682 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 90
rtable_id: 148
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name              | addr                       | city          | phone         | type                  |   class |
|:------------------|:---------------------------|:--------------|:--------------|:----------------------|--------:|
| ` the bacchanal ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/731 -7525 | ` only in las vegas ' |     449 |

Entity B:
| name          | addr                        | city          | phone        | type    |   class |
|:--------------|:----------------------------|:--------------|:-------------|:--------|--------:|
| ` chin \ 's ' | ' 3200 las vegas blvd. s. ' | ` las vegas ' | 702-733-8899 | chinese |      67 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 449
rtable_id: 285
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                | addr                  | city            | phone         | type     |   class |
|:--------------------|:----------------------|:----------------|:--------------|:---------|--------:|
| ` ed debevic \ 's ' | ' 134 n. la cienega ' | ` los angeles ' | 310/659 -1952 | american |     133 |

Entity B:
| name      | addr                        | city              | phone        | type    |   class |
|:----------|:----------------------------|:------------------|:-------------|:--------|--------:|
| matsuhisa | ' 129 n. la cienega blvd. ' | ` beverly hills ' | 310-659-9639 | seafood |      14 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 136
rtable_id: 232
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                       | city      | phone         | type     |   class |
|:-------|:---------------------------|:----------|:--------------|:---------|--------:|
| fenix  | ' 8358 sunset blvd. west ' | hollywood | 213/848 -6677 | american |       7 |

Entity B:
| name                      | addr                  | city             | phone        | type        |   class |
|:--------------------------|:----------------------|:-----------------|:-------------|:------------|--------:|
| ` spago ( los angeles ) ' | ' 8795 sunset blvd. ' | ` w. hollywood ' | 310-652-4025 | californian |      20 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 7
rtable_id: 238
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                         | city            | phone     | type              |   class |
|:-------|:-----------------------------|:----------------|:----------|:------------------|--------:|
| dive ! | ' 10250 santa monica blvd. ' | ` los angeles ' | 310/788 - | ` dive american ' |     128 |

Entity B:
| name                         | addr                        | city             | phone        | type        |   class |
|:-----------------------------|:----------------------------|:-----------------|:-------------|:------------|--------:|
| ` palm the ( los angeles ) ' | ' 9001 santa monica blvd. ' | ` w. hollywood ' | 310-550-8811 | steakhouses |      15 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 131
rtable_id: 233
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                   | addr                         | city         | phone         | type         |   class |
|:-----------------------|:-----------------------------|:-------------|:--------------|:-------------|--------:|
| ` second avenue deli ' | ' 156 2nd ave. at 10th st. ' | ` new york ' | 212/677 -0606 | delicatessen |      58 |

Entity B:
| name                   | addr                | city              | phone        | type   |   class |
|:-----------------------|:--------------------|:------------------|:-------------|:-------|--------:|
| ` second avenue deli ' | ' 156 second ave. ' | ` new york city ' | 212-677-0606 | delis  |      58 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 58
rtable_id: 276
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr                | city         | phone         | type              |   class |
|:-----------------|:--------------------|:-------------|:--------------|:------------------|--------:|
| ` island spice ' | ' 402 w. 44th st. ' | ` new york ' | 212/765 -1737 | ` tel caribbean ' |      37 |

Entity B:
| name             | addr                | city              | phone        | type      |   class |
|:-----------------|:--------------------|:------------------|:-------------|:----------|--------:|
| ` island spice ' | ' 402 w. 44th st. ' | ` new york city ' | 212-765-1737 | caribbean |      37 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 37
rtable_id: 255
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name              | addr                       | city          | phone         | type    |   class |
|:------------------|:---------------------------|:--------------|:--------------|:--------|--------:|
| ` circus circus ' | ' 2880 las vegas blvd. s ' | ` las vegas ' | 702/734 -0410 | buffets |     437 |

Entity B:
| name                           | addr                        | city          | phone        | type        |   class |
|:-------------------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` michael \ 's ( las vegas ) ' | ' 3595 las vegas blvd. s. ' | ` las vegas ' | 702-737-7111 | continental |     664 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 437
rtable_id: 130
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                                   | addr                   | city    | phone         | type        |   class |
|:---------------------------------------|:-----------------------|:--------|:--------------|:------------|--------:|
| ` dante \ 's down the hatch buckhead ' | ' 3380 peachtree rd. ' | atlanta | 404/266 -1600 | continental |     393 |

Entity B:
| name     | addr                    | city    | phone        | type               |   class |
|:---------|:------------------------|:--------|:-------------|:-------------------|--------:|
| toulouse | ' 293-b peachtree rd. ' | atlanta | 404-351-9533 | ` french ( new ) ' |      92 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 393
rtable_id: 310
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr                   | city              | phone         | type    |   class |
|:-----------------|:-----------------------|:------------------|:--------------|:--------|--------:|
| ` tadich grill ' | ' 240 california st. ' | ` san francisco ' | 415/391 -2373 | seafood |     519 |

Entity B:
| name                          | addr                    | city              | phone        | type       |   class |
|:------------------------------|:------------------------|:------------------|:-------------|:-----------|--------:|
| 'em erald garden restaurant ' | ' 1550 california st. ' | ` san francisco ' | 415-673-1155 | vietnamese |     730 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 519
rtable_id: 195
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                     | addr                      | city    | phone         | type      |   class |
|:-------------------------|:--------------------------|:--------|:--------------|:----------|--------:|
| ` indigo coastal grill ' | ' 1397 n. highland ave. ' | atlanta | 404/876 -0676 | caribbean |      84 |

Entity B:
| name                     | addr                      | city    | phone        | type     |   class |
|:-------------------------|:--------------------------|:--------|:-------------|:---------|--------:|
| ` indigo coastal grill ' | ' 1397 n. highland ave. ' | atlanta | 404-876-0676 | eclectic |      84 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 84
rtable_id: 302
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                       | addr                       | city          | phone         | type    |   class |
|:---------------------------|:---------------------------|:--------------|:--------------|:--------|--------:|
| ` bally \ 's big kitchen ' | ' 3645 las vegas blvd. s ' | ` las vegas ' | 702/739 -4111 | buffets |     424 |

Entity B:
| name                                   | addr                        | city          | phone        | type    |   class |
|:---------------------------------------|:----------------------------|:--------------|:-------------|:--------|--------:|
| 'em eril \ 's new orleans fish house ' | ' 3799 las vegas blvd. s. ' | ` las vegas ' | 702-891-7374 | seafood |     659 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 424
rtable_id: 125
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                                   | addr                   | city    | phone         | type        |   class |
|:---------------------------------------|:-----------------------|:--------|:--------------|:------------|--------:|
| ` dante \ 's down the hatch buckhead ' | ' 3380 peachtree rd. ' | atlanta | 404/266 -1600 | continental |     393 |

Entity B:
| name                     | addr                      | city    | phone        | type        |   class |
|:-------------------------|:--------------------------|:--------|:-------------|:------------|--------:|
| ` palm the ( atlanta ) ' | ' 3391 peachtree rd. ne ' | atlanta | 404-814-1955 | steakhouses |     709 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 393
rtable_id: 175
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr                       | city          | phone         | type        |   class |
|:-----------------|:---------------------------|:--------------|:--------------|:------------|--------:|
| ` palace court ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/731 -7547 | continental |      70 |

Entity B:
| name                           | addr                        | city          | phone        | type        |   class |
|:-------------------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` michael \ 's ( las vegas ) ' | ' 3595 las vegas blvd. s. ' | ` las vegas ' | 702-737-7111 | continental |     664 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 70
rtable_id: 130
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                    | addr                   | city          | phone         | type    |   class |
|:------------------------|:-----------------------|:--------------|:--------------|:--------|--------:|
| ` golden nugget hotel ' | ' 129 e. fremont st. ' | ` las vegas ' | 702/385 -7111 | buffets |     440 |

Entity B:
| name                 | addr                   | city          | phone        | type        |   class |
|:---------------------|:-----------------------|:--------------|:-------------|:------------|--------:|
| ` hugo \ 's cellar ' | ' 202 e. fremont st. ' | ` las vegas ' | 702-385-4011 | continental |     661 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 440
rtable_id: 127
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name            | addr                       | city          | phone         | type         |   class |
|:----------------|:---------------------------|:--------------|:--------------|:-------------|--------:|
| ` coyote cafe ' | ' 3799 las vegas blvd. s ' | ` las vegas ' | 702/891 -7349 | southwestern |      68 |

Entity B:
| name                    | addr                        | city          | phone        | type        |   class |
|:------------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` spago ( las vegas ) ' | ' 3500 las vegas blvd. s. ' | ` las vegas ' | 702-369-6300 | californian |     670 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 68
rtable_id: 136
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                          | addr             | city              | phone         | type   |   class |
|:------------------------------|:-----------------|:------------------|:--------------|:-------|--------:|
| ` pacific pan pacific hotel ' | ' 500 post st. ' | ` san francisco ' | 415/929 -2087 | french |     502 |

Entity B:
| name   | addr              | city              | phone        | type     |   class |
|:-------|:------------------|:------------------|:-------------|:---------|--------:|
| mifune | ' 1737 post st. ' | ` san francisco ' | 415-922-0337 | japanese |     107 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 502
rtable_id: 325
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr                                          | city         | phone         | type    |   class |
|:-----------------|:----------------------------------------------|:-------------|:--------------|:--------|--------:|
| ` carmine \ 's ' | ' 2450 broadway between 90th and 91st sts . ' | ` new york ' | 212/362 -2200 | italian |      28 |

Entity B:
| name             | addr              | city              | phone        | type    |   class |
|:-----------------|:------------------|:------------------|:-------------|:--------|--------:|
| ` carmine \ 's ' | ' 2450 broadway ' | ` new york city ' | 212-362-2200 | italian |      28 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 28
rtable_id: 246
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name          | addr                   | city    | phone         | type     |   class |
|:--------------|:-----------------------|:--------|:--------------|:---------|--------:|
| ` bone \ 's ' | ' 3130 piedmont road ' | atlanta | 404/237 -2663 | american |      76 |

Entity B:
| name         | addr                        | city   | phone        | type                 |   class |
|:-------------|:----------------------------|:-------|:-------------|:---------------------|--------:|
| ` joe \ 's ' | ' 1023 abbot kinney blvd. ' | venice | 310-399-5811 | ` american ( new ) ' |     560 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 76
rtable_id: 26
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                           | addr                   | city    | phone         | type                       |   class |
|:-------------------------------|:-----------------------|:--------|:--------------|:---------------------------|--------:|
| ` cafe ritz-carlton buckhead ' | ' 3434 peachtree rd. ' | atlanta | 404/237 -2700 | ` ext 6108 international ' |      89 |

Entity B:
| name    | addr                      | city    | phone        | type    |   class |
|:--------|:--------------------------|:--------|:-------------|:--------|--------:|
| abruzzi | ' 2355 peachtree rd. ne ' | atlanta | 404-261-8186 | italian |      74 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 89
rtable_id: 292
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name           | addr                    | city             | phone         | type   |   class |
|:---------------|:------------------------|:-----------------|:--------------|:-------|--------:|
| ` cafe bizou ' | ' 14016 ventura blvd. ' | ` sherman oaks ' | 818/788 -3536 | french |       3 |

Entity B:
| name             | addr                    | city            | phone        | type              |   class |
|:-----------------|:------------------------|:----------------|:-------------|:------------------|--------:|
| ` pinot bistro ' | ' 12969 ventura blvd. ' | ` studio city ' | 818-990-0500 | ` french bistro ' |      18 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 3
rtable_id: 236
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name     | addr                  | city              | phone         | type    |   class |
|:---------|:----------------------|:------------------|:--------------|:--------|--------:|
| oritalia | ' 1915 fillmore st. ' | ` san francisco ' | 415/346 -1333 | italian |     501 |

Entity B:
| name          | addr                  | city              | phone        | type     |   class |
|:--------------|:----------------------|:------------------|:-------------|:---------|--------:|
| ` trio cafe ' | ' 1870 fillmore st. ' | ` san francisco ' | 415-563-2248 | american |     749 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 501
rtable_id: 214
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name       | addr              | city         | phone         | type     |   class |
|:-----------|:------------------|:-------------|:--------------|:---------|--------:|
| '21 club ' | '21 w. 52nd st. ' | ` new york ' | 212/582 -7200 | american |      23 |

Entity B:
| name             | addr              | city              | phone        | type                 |   class |
|:-----------------|:------------------|:------------------|:-------------|:---------------------|--------:|
| ` four seasons ' | '99 e. 52nd st. ' | ` new york city ' | 212-754-9494 | ` american ( new ) ' |      34 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 23
rtable_id: 252
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name        | addr                   | city    | phone         | type        |   class |
|:------------|:-----------------------|:--------|:--------------|:------------|--------:|
| ` luna si ' | ' 1931 peachtree rd. ' | atlanta | 404/355 -5993 | continental |     405 |

Entity B:
| name               | addr                   | city    | phone        | type         |   class |
|:-------------------|:-----------------------|:--------|:-------------|:-------------|--------:|
| ` georgia grille ' | ' 2290 peachtree rd. ' | atlanta | 404-352-3517 | southwestern |      81 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 405
rtable_id: 299
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name           | addr              | city         | phone         | type     |   class |
|:---------------|:------------------|:-------------|:--------------|:---------|--------:|
| ` monkey bar ' | '60 e. 54th st. ' | ` new york ' | 212/838 -2600 | american |     308 |

Entity B:
| name      | addr                | city              | phone        | type              |   class |
|:----------|:--------------------|:------------------|:-------------|:------------------|--------:|
| ` jo jo ' | ' 160 e. 64th st. ' | ` new york city ' | 212-223-5656 | ` french bistro ' |      38 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 309
rtable_id: 256
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name              | addr                     | city          | phone         | type     |   class |
|:------------------|:-------------------------|:--------------|:--------------|:---------|--------:|
| ` cafe michelle ' | ' 1350 e. flamingo rd. ' | ` las vegas ' | 702/735 -8686 | american |     432 |

Entity B:
| name              | addr                     | city          | phone        | type        |   class |
|:------------------|:-------------------------|:--------------|:-------------|:------------|--------:|
| 'till erman the ' | ' 2245 e. flamingo rd. ' | ` las vegas ' | 702-731-4036 | steakhouses |      73 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 432
rtable_id: 291
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr               | city              | phone         | type   |   class |
|:-----------------|:-------------------|:------------------|:--------------|:-------|--------:|
| ` fleur de lys ' | ' 777 sutter st. ' | ` san francisco ' | 415/673 -7779 | french |     100 |

Entity B:
| name             | addr               | city              | phone        | type               |   class |
|:-----------------|:-------------------|:------------------|:-------------|:-------------------|--------:|
| ` fleur de lys ' | ' 777 sutter st. ' | ` san francisco ' | 415-673-7779 | ` french ( new ) ' |     100 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 100
rtable_id: 318
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr                   | city         | phone         | type    |   class |
|:-----------------|:-----------------------|:-------------|:--------------|:--------|--------:|
| ` san domenico ' | ' 240 central park s ' | ` new york ' | 212/265 -5959 | italian |      57 |

Entity B:
| name             | addr                    | city              | phone        | type    |   class |
|:-----------------|:------------------------|:------------------|:-------------|:--------|--------:|
| ` san domenico ' | ' 240 central park s. ' | ` new york city ' | 212-265-5959 | italian |      57 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 57
rtable_id: 275
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name               | addr              | city         | phone         | type   |   class |
|:-------------------|:------------------|:-------------|:--------------|:-------|--------:|
| ` jewel of india ' | '15 w. 44th st. ' | ` new york ' | 212/869 -5544 | asian  |     273 |

Entity B:
| name      | addr              | city              | phone        | type          |   class |
|:----------|:------------------|:------------------|:-------------|:--------------|--------:|
| picholine | '35 w. 64th st. ' | ` new york city ' | 212-724-8585 | mediterranean |      53 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 274
rtable_id: 271
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name          | addr                        | city            | phone         | type   |   class |
|:--------------|:----------------------------|:----------------|:--------------|:-------|--------:|
| ` drai \ 's ' | ' 730 n. la cienega blvd. ' | ` los angeles ' | 310/358 -8585 | french |     130 |

Entity B:
| name                | addr                        | city             | phone        | type                   |   class |
|:--------------------|:----------------------------|:-----------------|:-------------|:-----------------------|--------:|
| ` l \ ` orangerie ' | ' 903 n. la cienega blvd. ' | ` w. hollywood ' | 310-652-9770 | ` french ( classic ) ' |      11 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 133
rtable_id: 229
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name          | addr                | city              | phone         | type   |   class |
|:--------------|:--------------------|:------------------|:--------------|:-------|--------:|
| ` le soleil ' | ' 133 clement st. ' | ` san francisco ' | 415/668 -4848 | asian  |     492 |

Entity B:
| name               | addr                | city              | phone        | type               |   class |
|:-------------------|:--------------------|:------------------|:-------------|:-------------------|--------:|
| ` alain rondelli ' | ' 126 clement st. ' | ` san francisco ' | 415-387-0408 | ` french ( new ) ' |      94 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 492
rtable_id: 312
label: 0