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