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