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