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