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 |
|:-----------------|:------------|:----------------|:--------------|:--------|--------:|
| ` border grill ' | ' 4th st. ' | ` los angeles ' | 310/451 -1655 | mexican |     116 |

Entity B:
| name              | addr               | city   | phone        | type   |   class |
|:------------------|:-------------------|:-------|:-------------|:-------|--------:|
| ` jackson diner ' | ' 37-03 74th st. ' | queens | 718-672-1232 | indian |     616 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 119
rtable_id: 82
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 |
|:----------------------------|:--------------------|:--------------|:--------------|:------------------------|--------:|
| ` binion \ 's coffee shop ' | ' 128 fremont st. ' | ` las vegas ' | 702/382 -1600 | ` coffee shops/diners ' |     428 |

Entity B:
| name               | addr                   | city          | phone        | type        |   class |
|:-------------------|:-----------------------|:--------------|:-------------|:------------|--------:|
| ` steakhouse the ' | ' 128 e. fremont st. ' | ` las vegas ' | 702-382-1600 | steakhouses |     671 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 428
rtable_id: 137
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 street grille ' | ' 200 e. fremont st. ' | ` las vegas ' | 702/385 -3232 | seafood |      71 |

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: 71
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 |
|:--------|:----------------------|:----------------|:--------------|:------------|--------:|
| eclipse | ' 8800 melrose ave. ' | ` los angeles ' | 310/724 -5959 | californian |     132 |

Entity B:
| name                              | addr                  | city            | phone        | type              |   class |
|:----------------------------------|:----------------------|:----------------|:-------------|:------------------|--------:|
| ` le chardonnay ( los angeles ) ' | ' 8284 melrose ave. ' | ` los angeles ' | 213-655-8880 | ` french bistro ' |      12 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 135
rtable_id: 230
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 |
|:--------------|:----------------------------|:--------------|:-------------|:--------|--------:|
| ` 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: 70
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 |
|:--------------------------|:------------------------|:----------------|:--------------|:----------------|--------:|
| ` jack sprat \ 's grill ' | ' 10668 w. pico blvd. ' | ` los angeles ' | 310/837 -6662 | ` health food ' |     140 |

Entity B:
| name                | addr                    | city            | phone        | type     |   class |
|:--------------------|:------------------------|:----------------|:-------------|:---------|--------:|
| ` main course the ' | ' 10509 w. pico blvd. ' | ` rancho park ' | 310-475-7564 | american |     573 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 143
rtable_id: 39
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 |
|:-------|:---------------------------|:--------------|:--------------|:------------|--------:|
| bistro | ' 3400 las vegas blvd. s ' | ` las vegas ' | 702/791 -7111 | continental |     429 |

Entity B:
| name            | addr                        | city          | phone        | type               |   class |
|:----------------|:----------------------------|:--------------|:-------------|:-------------------|--------:|
| ` monte carlo ' | ' 3145 las vegas blvd. s. ' | ` las vegas ' | 702-733-4524 | ` french ( new ) ' |     665 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 429
rtable_id: 131
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 |
|:---------------------|:---------------------------|:--------------|:--------------|:------------------------|--------:|
| ` bugsy \ 's diner ' | ' 3555 las vegas blvd. s ' | ` las vegas ' | 702/733 -3111 | ` coffee shops/diners ' |     431 |

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: 431
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 |
|:---------|:--------------------|:--------|:--------------|:-------|--------:|
| toulouse | ' b peachtree rd. ' | atlanta | 404/351 -9533 | french |      92 |

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: 92
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 |
|:-------------------------------|:-----------------------|:--------|:--------------|:---------------------------|--------:|
| ` cafe ritz-carlton buckhead ' | ' 3434 peachtree rd. ' | atlanta | 404/237 -2700 | ` ext 6108 international ' |      89 |

Entity B:
| name                       | addr                      | city    | phone        | type   |   class |
|:---------------------------|:--------------------------|:--------|:-------------|:-------|--------:|
| ` white house restaurant ' | ' 3172 peachtree rd. ne ' | atlanta | 404-237-7601 | diners |     719 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 89
rtable_id: 184
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 |
|:----------|:------------------|:-------------|:--------------|:--------|--------:|
| follonico | ' 6 w. 24th st. ' | ` new york ' | 212/691 -6359 | italian |     247 |

Entity B:
| name                        | addr              | city              | phone        | type    |   class |
|:----------------------------|:------------------|:------------------|:-------------|:--------|--------:|
| ` roosevelt tamale parlor ' | ' 2817 24th st. ' | ` san francisco ' | 415-550-9213 | mexican |     742 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 249
rtable_id: 207
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 |
|:-------|:--------------------|:-------------|:--------------|:-------|--------:|
| dawat  | ' 210 e. 58th st. ' | ` new york ' | 212/355 -7555 | asian  |      32 |

Entity B:
| name               | addr                | city              | phone        | type                   |   class |
|:-------------------|:--------------------|:------------------|:-------------|:-----------------------|--------:|
| ` les celebrites ' | ' 155 w. 58th st. ' | ` new york city ' | 212-484-5113 | ` french ( classic ) ' |      42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 32
rtable_id: 260
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 |
|:-------|:------------------|:-------------|:--------------|:--------|--------:|
| oceana | '55 e. 54th st. ' | ` new york ' | 212/759 -5941 | seafood |      50 |

Entity B:
| name                | addr                | city              | phone        | type    |   class |
|:--------------------|:--------------------|:------------------|:-------------|:--------|--------:|
| ` shun lee palace ' | ' 155 e. 55th st. ' | ` new york city ' | 212-371-8844 | chinese |      60 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 50
rtable_id: 278
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 |
|:-----------------|:------------------|:-------------|:--------------|:-------|--------:|
| ` jean lafitte ' | '68 w. 58th st. ' | ` new york ' | 212/751 -2323 | french |     272 |

Entity B:
| name               | addr                | city              | phone        | type                   |   class |
|:-------------------|:--------------------|:------------------|:-------------|:-----------------------|--------:|
| ` les celebrites ' | ' 155 w. 58th st. ' | ` new york city ' | 212-484-5113 | ` french ( classic ) ' |      42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 273
rtable_id: 260
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 dome ' | ' 8720 sunset blvd. ' | ` los angeles ' | 310/659 -6919 | french |     145 |

Entity B:
| name                    | addr                  | city             | phone        | type               |   class |
|:------------------------|:----------------------|:-----------------|:-------------|:-------------------|--------:|
| ` fenix at the argyle ' | ' 8358 sunset blvd. ' | ` w. hollywood ' | 213-848-6677 | ` french ( new ) ' |       7 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 148
rtable_id: 225
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 |
|:---------------|:----------------------|:------------------|:--------------|:--------------|--------:|
| ` moose \ 's ' | ' 1652 stockton st. ' | ` san francisco ' | 415/989 -7800 | mediterranean |     498 |

Entity B:
| name         | addr                | city             | phone        | type   |   class |
|:-------------|:--------------------|:-----------------|:-------------|:-------|--------:|
| ` rae \ 's ' | ' 2901 pico blvd. ' | ` santa monica ' | 310-828-7937 | diners |     589 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 498
rtable_id: 55
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 |
|:--------|:----------------------------------------------------------|:--------|:--------------|:--------|--------:|
| abruzzi | ' 2355 peachtree rd. . peachtree battle shopping center ' | atlanta | 404/261 -8186 | italian |      74 |

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: 1
original: ltable_id: 74
rtable_id: 292
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 |
|:-------|:--------------------|:-------------|:--------------|:---------|--------:|
| march  | ' 405 e. 58th st. ' | ` new york ' | 212/754 -6272 | american |      46 |

Entity B:
| name               | addr                | city              | phone        | type                   |   class |
|:-------------------|:--------------------|:------------------|:-------------|:-----------------------|--------:|
| ` les celebrites ' | ' 155 w. 58th st. ' | ` new york city ' | 212-484-5113 | ` french ( classic ) ' |      42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 46
rtable_id: 260
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 |
|:-------|:------------------------|:-----------------|:--------------|:--------|--------:|
| posto  | ' 14928 ventura blvd. ' | ` sherman oaks ' | 818/784 -4400 | italian |     156 |

Entity B:
| name             | addr                    | city   | phone        | type   |   class |
|:-----------------|:------------------------|:-------|:-------------|:-------|--------:|
| ` mulberry st. ' | ' 17040 ventura blvd. ' | encino | 818-906-8881 | pizza  |     580 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 159
rtable_id: 46
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 |
|:--------------------|:----------------------|:----------------|:--------------|:-------|--------:|
| ` tommy tang \ 's ' | ' 7313 melrose ave. ' | ` los angeles ' | 213/937 -5733 | asian  |     167 |

Entity B:
| name   | addr                  | city            | phone        | type        |   class |
|:-------|:----------------------|:----------------|:-------------|:------------|--------:|
| citrus | ' 6703 melrose ave. ' | ` los angeles ' | 213-857-0034 | californian |       6 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 170
rtable_id: 224
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 |
|:----------------|:-----------------------|:----------------|:--------------|:----------|--------:|
| ` cha cha cha ' | ' 656 n. virgil ave. ' | ` los angeles ' | 213/664 -7723 | caribbean |     124 |

Entity B:
| name                 | addr                | city              | phone        | type      |   class |
|:---------------------|:--------------------|:------------------|:-------------|:----------|--------:|
| ` cha cha cha \ 's ' | ' 1805 haight st. ' | ` san francisco ' | 415-386-5758 | caribbean |     725 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 127
rtable_id: 190
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 |
|:---------------------------|:---------------------------|:--------|:--------------|:---------|--------:|
| ` mary mac \ 's tea room ' | ' 224 ponce de leon ave. ' | atlanta | 404/876 -1800 | southern |      86 |

Entity B:
| name   | addr                       | city    | phone        | type    |   class |
|:-------|:---------------------------|:--------|:-------------|:--------|--------:|
| eats   | ' 600 ponce de leon ave. ' | atlanta | 404-888-9149 | italian |     690 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 86
rtable_id: 156
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 botanica ' | ' 160 central park s ' | ` new york ' | 212/484 -5120 | french |     200 |

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: 0
original: ltable_id: 202
rtable_id: 275
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 |
|:----------------|:---------------------------|:--------------|:--------------|:-----------------|--------:|
| ` steak house ' | ' 2880 las vegas blvd. s ' | ` las vegas ' | 702/734 -0410 | ` steak houses ' |      72 |

Entity B:
| name     | addr                        | city          | phone        | type    |   class |
|:---------|:----------------------------|:--------------|:-------------|:--------|--------:|
| moongate | ' 3400 las vegas blvd. s. ' | ` las vegas ' | 702-791-7352 | chinese |     666 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 72
rtable_id: 132
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 |
|:----------------------|:-----------------------|:--------|:-------------|:------------------|--------:|
| ` brasserie le coze ' | ' 3393 peachtree rd. ' | atlanta | 404-266-1440 | ` french bistro ' |      77 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 405
rtable_id: 295
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 |
|:----------------|:------------------------|:----------------|:----------------|:---------|--------:|
| ` canter \ 's ' | ' 419 n. fairfax ave. ' | ` los angeles ' | 213/651 -2030 . | american |     122 |

Entity B:
| name                                | addr                    | city   | phone        | type     |   class |
|:------------------------------------|:------------------------|:-------|:-------------|:---------|--------:|
| ` mani \ 's bakery & espresso bar ' | ' 519 s. fairfax ave. ' | la     | 213-938-8800 | desserts |     574 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 125
rtable_id: 40
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 |
|:-------|:-------------------|:------------------|:--------------|:-------|--------:|
| bizou  | ' 598 fourth st. ' | ` san francisco ' | 415/543 -2222 | french |     459 |

Entity B:
| name     | addr               | city              | phone        | type              |   class |
|:---------|:-------------------|:------------------|:-------------|:------------------|--------:|
| fringale | ' 570 fourth st. ' | ` san francisco ' | 415-543-0573 | ` french bistro ' |     101 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 459
rtable_id: 319
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 |
|:--------------------|:--------------------|:-------------|:--------------|:---------|--------:|
| ` ben benson \ 's ' | ' 123 w. 52nd st. ' | ` new york ' | 212/581 -8888 | american |     187 |

Entity B:
| name              | addr              | city              | phone        | type                   |   class |
|:------------------|:------------------|:------------------|:-------------|:-----------------------|--------:|
| ` la grenouille ' | ' 3 e. 52nd st. ' | ` new york city ' | 212-752-1495 | ` french ( classic ) ' |     623 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 190
rtable_id: 89
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 |
|:------------------|:-----------------------------------|:------------------|:-------------|:---------------------|--------:|
| ` belvedere the ' | ' 9882 little santa monica blvd. ' | ` beverly hills ' | 310-788-2306 | ` pacific new wave ' |     537 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 131
rtable_id: 3
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 des artistes ' | ' 1 w. 67th st. ' | ` new york ' | 212/877 -3500 | continental |      27 |

Entity B:
| name                  | addr              | city              | phone        | type                   |   class |
|:----------------------|:------------------|:------------------|:-------------|:-----------------------|--------:|
| ` cafe des artistes ' | ' 1 w. 67th st. ' | ` new york city ' | 212-877-3500 | ` french ( classic ) ' |      27 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 27
rtable_id: 245
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 |
|:-----------|:-----------------------|:--------|:--------------|:-------|--------:|
| ciboulette | ' 1529 piedmont ave. ' | atlanta | 404/874 -7600 | french |      79 |

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: 0
original: ltable_id: 79
rtable_id: 301
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 |
|:-------|:-----------------------|:--------|:--------------|:------------|--------:|
| tomtom | ' 3393 peachtree rd. ' | atlanta | 404/264 -1163 | continental |     422 |

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: 422
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 |
|:--------------|:--------------------|:-------------|:--------------|:---------|--------:|
| ` joe allen ' | ' 326 w. 46th st. ' | ` new york ' | 212/581 -6464 | american |     275 |

Entity B:
| name                   | addr                | city              | phone        | type        |   class |
|:-----------------------|:--------------------|:------------------|:-------------|:------------|--------:|
| ` sparks steak house ' | ' 210 e. 46th st. ' | ` new york city ' | 212-687-4855 | steakhouses |     641 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 276
rtable_id: 107
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 roma ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/731 -7547 | ` coffee shops/diners ' |     433 |

Entity B:
| name                | addr                        | city          | phone        | type     |   class |
|:--------------------|:----------------------------|:--------------|:-------------|:---------|--------:|
| ` sterling brunch ' | ' 3645 las vegas blvd. s. ' | ` las vegas ' | 702-739-4651 | eclectic |     673 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 433
rtable_id: 139
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 |
|:-------------------------|:--------------------------|:--------|:-------------|:------------|--------:|
| ` palm the ( atlanta ) ' | ' 3391 peachtree rd. ne ' | atlanta | 404-814-1955 | steakhouses |     709 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 89
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 |
|:--------------------|:------------------|:----------------|:--------------|:------------|--------:|
| ` schatzi on main ' | ' 3110 main st. ' | ` los angeles ' | 310/399 -4800 | continental |     162 |

Entity B:
| name                | addr              | city             | phone        | type                 |   class |
|:--------------------|:------------------|:-----------------|:-------------|:---------------------|--------:|
| ` chinois on main ' | ' 2709 main st. ' | ` santa monica ' | 310-392-9025 | ` pacific new wave ' |       5 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 165
rtable_id: 223
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 |
|:---------|:-----------------------|:--------|:--------------|:--------------|--------:|
| bistango | ' 1100 peachtree st. ' | atlanta | 404/724 -0901 | mediterranean |     386 |

Entity B:
| name                         | addr                  | city    | phone        | type       |   class |
|:-----------------------------|:----------------------|:--------|:-------------|:-----------|--------:|
| ` alon \ 's at the terrace ' | ' 659 peachtree st. ' | atlanta | 404-724-0444 | sandwiches |     676 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 386
rtable_id: 142
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 |
|:-------|:---------------------|:------------------|:--------------|:-------|--------:|
| manora | ' 3226 mission st. ' | ` san francisco ' | 415/861 -6224 | asian  |     494 |

Entity B:
| name           | addr                 | city              | phone        | type   |   class |
|:---------------|:---------------------|:------------------|:-------------|:-------|--------:|
| ` dusit thai ' | ' 3221 mission st. ' | ` san francisco ' | 415-826-4639 | thai   |     728 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 494
rtable_id: 193
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 |
|:--------|:---------------------------|:--------|:-------------|:--------------|--------:|
| riviera | ' 519 e. paces ferry rd. ' | atlanta | 404-262-7112 | mediterranean |     712 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 82
rtable_id: 177
label: 0