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