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