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