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