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