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