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