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