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