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