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