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