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