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