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