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