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