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