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