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