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