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