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