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 |
|:--------------------|:----------------------|:----------------|:--------------|:-------|--------:|
| ` tommy tang \ 's ' | ' 7313 melrose ave. ' | ` los angeles ' | 213/937 -5733 | asian  |     167 |

Entity B:
| name                | addr                  | city   | phone        | type     |   class |
|:--------------------|:----------------------|:-------|:-------------|:---------|--------:|
| ` sweet lady jane ' | ' 8360 melrose ave. ' | la     | 213-653-7145 | desserts |     596 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 170
rtable_id: 62
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 |
|:----------------|:------------------------------------|:-----------------|:-------------|:-------------------|--------:|
| ` la cachette ' | ' 10506 little santa monica blvd. ' | ` century city ' | 310-470-4992 | ` french ( new ) ' |     568 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 131
rtable_id: 34
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 |
|:-----------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` buccaneer bay club ' | ' 3300 las vegas blvd. s. ' | ` las vegas ' | 702-894-7350 | continental |     657 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 431
rtable_id: 123
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 |
|:-------------------|:-----------------------|:--------|:-------------|:-------------|--------:|
| ` georgia grille ' | ' 2290 peachtree rd. ' | atlanta | 404-352-3517 | southwestern |      81 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 393
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 |
|:-------------------|:-----------------------|:-------------|:--------------|:-------|--------:|
| ` les celebrites ' | ' 160 central park s ' | ` new york ' | 212/484 -5113 | french |      42 |

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: 42
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 |
|:-------------------|:-------------------------|:--------------|:--------------|:-------|--------:|
| ` mandarin court ' | ' 1510 e. flamingo rd. ' | ` las vegas ' | 702/737 -1234 | asian  |     443 |

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: 443
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 |
|:--------------|:---------------------------|:--------------|:--------------|:-------|--------:|
| ` chin \ 's ' | ' 3200 las vegas blvd. s ' | ` las vegas ' | 702/733 -8899 | asian  |      67 |

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: 67
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 |
|:----------|:------------------|:------------------|:--------------|:---------|--------:|
| boulevard | ' 1 mission st. ' | ` san francisco ' | 415/543 -6084 | american |      96 |

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: 96
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 |
|:---------------------|:---------------------------|:--------------|:--------------|:------------------------|--------:|
| ` 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 |
|:-----------------|:----------------------------|:--------------|:-------------|:-------------------|--------:|
| ` palace court ' | ' 3570 las vegas blvd. s. ' | ` las vegas ' | 702-731-7110 | ` french ( new ) ' |      70 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 431
rtable_id: 288
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 |
|:------------------|:---------------------------|:--------------|:--------------|:-------|--------:|
| 'em press court ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/731 -7888 | asian  |     438 |

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: 438
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 |
|:--------------------|:--------------------|:-------------|:--------------|:---------|--------:|
| ` ben benson \ 's ' | ' 123 w. 52nd st. ' | ` new york ' | 212/581 -8888 | american |     187 |

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



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 190
rtable_id: 241
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 |
|:-------|:----------------------|:----------------|:--------------|:------------|--------:|
| citrus | ' 6703 melrose ave. ' | ` los angeles ' | 213/857 -0034 | californian |       6 |

Entity B:
| name                | addr                  | city   | phone        | type     |   class |
|:--------------------|:----------------------|:-------|:-------------|:---------|--------:|
| ` sweet lady jane ' | ' 8360 melrose ave. ' | la     | 213-653-7145 | desserts |     596 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 6
rtable_id: 62
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 |
|:-----------------|:------------------|:-------------|:--------------|:-------|--------:|
| ` la caravelle ' | '33 w. 55th st. ' | ` new york ' | 212/586 -4252 | french |      39 |

Entity B:
| name                             | addr              | city              | phone        | type   |   class |
|:---------------------------------|:------------------|:------------------|:-------------|:-------|--------:|
| ` lespinasse ( new york city ) ' | ' 2 e. 55th st. ' | ` new york city ' | 212-339-6719 | asian  |      43 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 39
rtable_id: 261
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 |
|:-------------------|:---------------------------|:--------------|:--------------|:--------|--------:|
| ` bertolini \ 's ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/735 -4663 | italian |     427 |

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: 427
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 |
|:----------------|:------------------------|:----------------|:--------------|:--------|--------:|
| ` ca \ ` brea ' | ' 346 s. la brea ave. ' | ` los angeles ' | 213/938 -2863 | italian |     118 |

Entity B:
| name                            | addr                    | city   | phone        | type         |   class |
|:--------------------------------|:------------------------|:-------|:-------------|:-------------|--------:|
| ` pink \ 's famous chili dogs ' | ' 709 n. la brea ave. ' | la     | 213-931-4223 | ` hot dogs ' |     586 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 121
rtable_id: 52
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 |
|:-------------|:----------------------------|:--------------|:-------------|:--------|--------:|
| ` tre visi ' | ' 3799 las vegas blvd. s. ' | ` las vegas ' | 702-891-7331 | italian |     674 |



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

Entity B:
| name                   | addr                        | city          | phone        | type        |   class |
|:-----------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` buccaneer bay club ' | ' 3300 las vegas blvd. s. ' | ` las vegas ' | 702-894-7350 | continental |     657 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 433
rtable_id: 123
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 colonial ' | ' 149 e. 57th st. ' | ` new york ' | ' 212 / 752-0808 ' | asian  |     286 |

Entity B:
| name   | addr                | city              | phone        | type     |   class |
|:-------|:--------------------|:------------------|:-------------|:---------|--------:|
| yama   | ' 122 e. 17th st. ' | ` new york city ' | 212-475-0969 | japanese |     654 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 287
rtable_id: 120
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 |
|:----------|:-----------------------|:--------|:--------------|:------------|--------:|
| palisades | ' 1829 peachtree rd. ' | atlanta | 404/350 -6755 | continental |     410 |

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: 410
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 |
|:--------------------------|:------------------------|:----------------|:--------------|:----------------|--------:|
| ` jack sprat \ 's grill ' | ' 10668 w. pico blvd. ' | ` los angeles ' | 310/837 -6662 | ` health food ' |     140 |

Entity B:
| name              | addr                    | city        | phone        | type     |   class |
|:------------------|:------------------------|:------------|:-------------|:---------|--------:|
| ` apple pan the ' | ' 10801 w. pico blvd. ' | ` west la ' | 310-475-3585 | american |     534 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 143
rtable_id: 0
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 |
|:---------------|:-----------------------|:-------|:-------------|:-----------|--------:|
| ` tommy \ 's ' | ' 2575 beverly blvd. ' | la     | 213-389-9060 | hamburgers |     598 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 170
rtable_id: 64
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 |
|:----------------------------------|:----------------------|:--------|:-------------|:---------------------|--------:|
| ` ritz-carlton cafe ( atlanta ) ' | ' 181 peachtree st. ' | atlanta | 404-659-0400 | ` american ( new ) ' |     711 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 405
rtable_id: 330
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 colonial ' | ' 8783 beverly blvd. ' | ` los angeles ' | 310/289 -0660 | asian  |     144 |

Entity B:
| name            | addr                      | city   | phone        | type    |   class |
|:----------------|:--------------------------|:-------|:-------------|:--------|--------:|
| ` koo koo roo ' | ' 8393 w. beverly blvd. ' | la     | 213-655-9045 | chicken |     567 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 147
rtable_id: 33
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 |
|:----------|:-------------------------|:--------------|:--------------|:--------|--------:|
| tillerman | ' 2245 e. flamingo rd. ' | ` las vegas ' | 702/731 -4036 | seafood |      73 |

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

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: 72
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 |
|:--------|:------------------|:-------------|:-------------------|:---------|--------:|
| aureole | '34 e. 61st st. ' | ` new york ' | ' 212 / 319-1660 ' | american |      25 |

Entity B:
| name     | addr              | city              | phone        | type     |   class |
|:---------|:------------------|:------------------|:-------------|:---------|--------:|
| sushisay | '38 e. 51st st. ' | ` new york city ' | 212-755-1780 | japanese |     643 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 25
rtable_id: 109
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 |
|:------------------------|:-----------------------|:--------------|:--------------|:-------|--------:|
| ` lillie langtry \ 's ' | ' 129 e. fremont st. ' | ` las vegas ' | 702/385 -7111 | asian  |     442 |

Entity B:
| name                    | addr                   | city          | phone        | type            |   class |
|:------------------------|:-----------------------|:--------------|:-------------|:----------------|--------:|
| ` second street grill ' | ' 200 e. fremont st. ' | ` las vegas ' | 702-385-6277 | ` pacific rim ' |      71 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 442
rtable_id: 289
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 |
|:-------------|:-----------------------|:--------------|:--------------|:------------|--------:|
| pamplemousse | ' 400 e. sahara ave. ' | ` las vegas ' | 702/733 -2066 | continental |     447 |

Entity B:
| name                    | addr                    | city          | phone        | type    |   class |
|:------------------------|:------------------------|:--------------|:-------------|:--------|--------:|
| ` mayflower cuisinier ' | ' 4750 w. sahara ave. ' | ` las vegas ' | 702-870-8432 | chinese |     663 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 447
rtable_id: 129
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 |
|:------------------------------------------|:--------------------------|:--------|:-------------|:---------------------|--------:|
| ` ritz-carlton dining room ( buckhead ) ' | ' 3434 peachtree rd. ne ' | atlanta | 404-237-2700 | ` american ( new ) ' |      90 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 92
rtable_id: 308
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 |
|:----------|:-----------------------|:--------|:--------------|:------------|--------:|
| palisades | ' 1829 peachtree rd. ' | atlanta | 404/350 -6755 | continental |     410 |

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: 410
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 |
|:--------|:-----------------|:------------------|:--------------|:-----------------------------|--------:|
| helmand | ' 430 broadway ' | ` san francisco ' | 415/362 -0641 | ` greek and middle eastern ' |     479 |

Entity B:
| name       | addr                | city              | phone        | type              |   class |
|:-----------|:--------------------|:------------------|:-------------|:------------------|--------:|
| montrachet | ' 239 w. broadway ' | ` new york city ' | 212-219-2777 | ` french bistro ' |      49 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 479
rtable_id: 267
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 |
|:-----------------|:------------------|:-------------|:--------------|:-------|--------:|
| ` la caravelle ' | '33 w. 55th st. ' | ` new york ' | 212/586 -4252 | french |      39 |

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: 1
original: ltable_id: 39
rtable_id: 257
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 |
|:-------|:----------------------|:----------------|:--------------|:-------|--------:|
| joss   | ' 9255 sunset blvd. ' | ` los angeles ' | 310/276 -1886 | asian  |     143 |

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: 146
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 |
|:---------------------------------|:----------------------------|:----------------|:--------------|:---------|--------:|
| ` arnie morton \ 's of chicago ' | ' 435 s. la cienega blv . ' | ` los angeles ' | 310/246 -1501 | american |       0 |

Entity B:
| name                                   | addr                     | city    | phone        | type        |   class |
|:---------------------------------------|:-------------------------|:--------|:-------------|:------------|--------:|
| ` morton \ 's of chicago ( atlanta ) ' | ' 303 peachtree st. ne ' | atlanta | 404-577-4366 | steakhouses |     704 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 0
rtable_id: 170
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 |
|:-------------|:----------------------------|:--------------|:-------------|:--------|--------:|
| ` tre visi ' | ' 3799 las vegas blvd. s. ' | ` las vegas ' | 702-891-7331 | italian |     674 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 70
rtable_id: 140
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 |
|:-------|:--------------------|:-------------|:--------------|:--------|--------:|
| bruno  | ' 240 e. 58th st. ' | ` new york ' | 212/688 -4190 | italian |     195 |

Entity B:
| name    | addr                | city              | phone        | type    |   class |
|:--------|:--------------------|:------------------|:-------------|:--------|--------:|
| felidia | ' 243 e. 58th st. ' | ` new york city ' | 212-758-1479 | italian |      33 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 197
rtable_id: 251
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 |
|:--------------------------|:------------------------|:----------------|:--------------|:---------|--------:|
| ` art \ 's delicatessen ' | ' 12224 ventura blvd. ' | ` studio city ' | 818/762 -1221 | american |       1 |

Entity B:
| name             | addr                    | city            | phone        | type     |   class |
|:-----------------|:------------------------|:----------------|:-------------|:---------|--------:|
| ` sushi nozawa ' | ' 11288 ventura blvd. ' | ` studio city ' | 818-508-7017 | japanese |     595 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1
rtable_id: 61
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 |
|:--------------|:-----------------|:------------------|:--------------|:-------|--------:|
| ` des alpes ' | ' 732 broadway ' | ` san francisco ' | 415/788 -9900 | french |     468 |

Entity B:
| name                 | addr              | city              | phone        | type         |   class |
|:---------------------|:------------------|:------------------|:-------------|:-------------|--------:|
| ` gray \ 's papaya ' | ' 2090 broadway ' | ` new york city ' | 212-799-0243 | ` hot dogs ' |     614 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 468
rtable_id: 80
label: 0