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