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