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