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