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